gcivil-nyu-org / fall24-monday-team4 / 383

Committed 08 Dec 2024 09:22PM UTC coverage: 97.367% (-2.2%) from 99.538%

Build # 383

Build Type

push

travis-pro

Committed by

web-flow

Commit Message

Merge pull request #157 from gcivil-nyu-org/all_branch_merge

Develop V4

Run Details

226 of 290 new or added lines in 12 files covered. (77.93%)

4 existing lines in 1 file now uncovered.

2995 of 3076 relevant lines covered (97.37%)

1.95 hits per line

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

91.34

/admin_user/views.py

from django.shortcuts import render, get_object_or_404
from django.contrib.auth.decorators import login_required
from django.contrib.admin.views.decorators import staff_member_required
from django.contrib.auth.models import User
from django.db.models import Count, Case, When, IntegerField
from accounts.models import UserReports, UserDocument
from utils.s3_utils import generate_presigned_url
from django.http import JsonResponse
from user_profile.models import UserProfile
from django.template.loader import render_to_string
from django.urls import reverse
from django.views.decorators.http import require_http_methods
from django.core.mail import EmailMessage
from django.conf import settings
import json
from user_profile.decorators import verification_required


@login_required
@verification_required
@staff_member_required
def admin_view(request):
    users = User.objects.select_related("userprofile").all()
    active_users = (
        User.objects.select_related("userprofile")
        .filter(documents__s3_key__isnull=False)
        .distinct()
    )

    user_documents = []
    for user in active_users:
        documents = user.documents.all()
        pending_count = documents.filter(status=1).count()
        document_data = [
            {
                "filename": document.filename,
                "file_type": document.file_type,
                "created_at": document.created_at,
                "status": dict(UserDocument.STATUS_CHOICES)[document.status],
                "description": document.description,
                "document_url": generate_presigned_url(document.s3_key),
            }
            for document in documents
        ]
        if document_data:
            user_documents.append(
                {
                    "user": user,
                    "documents": document_data,
                    "pending_count": pending_count,
                }
            )

    return render(
        request,
        "admin/admin_tabs.html",
        {"users": users, "user_documents": user_documents},
    )


@login_required
@verification_required
@staff_member_required
@require_http_methods(["GET"])
def reported_users_list(request):
    reported_active_users = (
        User.objects.filter(is_active=True, reports_received__isnull=False)
        .annotate(
            total_report_count=Count("reports_received"),
            pending_report_count=Count(
                Case(
                    When(reports_received__is_acknowledged=False, then=1),
                    output_field=IntegerField(),
                )
            ),
        )
        .values(
            "id",
            "first_name",
            "last_name",
            "username",
            "email",
            "pending_report_count",
            "total_report_count",
        )
    )

    return JsonResponse({"success": True, "reports": list(reported_active_users)})


@login_required
@verification_required
@staff_member_required
@require_http_methods(["GET"])
def get_user_documents(request, user_id):
    documents = UserDocument.objects.filter(user_id=user_id)
    user = get_object_or_404(User, id=user_id)
    pending_count = documents.filter(status=1).count()

    document_data = [
        {
            "id": document.id,
            "filename": document.filename,
            "file_type": document.file_type,
            "created_at": document.created_at,
            "status_name": document.get_status_display(),
            "status_id": document.status,
            "description": document.description,
            "document_url": generate_presigned_url(document.s3_key),
        }
        for document in documents
    ]

    return JsonResponse(
        {
            "success": True,
            "documents": document_data,
            "username": user.username,
            "pending_count": pending_count,
        },
        status=200,
    )


@login_required
@verification_required
@staff_member_required
@require_http_methods(["POST"])
def accept_document(request, user_id, document_id):
    document = get_object_or_404(UserDocument, id=document_id, user_id=user_id)
    document.status = 2
    document.save()

    document_data = {
        "id": document.id,
        "filename": document.filename,
        "file_type": document.file_type,
        "created_at": document.created_at,
        "status_name": document.get_status_display(),
        "status_id": document.status,
        "description": document.description,
        "document_url": generate_presigned_url(document.s3_key),
    }

    return JsonResponse({"success": True, "document": document_data})


@login_required
@verification_required
@staff_member_required
@require_http_methods(["POST"])
def reject_document(request, user_id, document_id):
    document = get_object_or_404(UserDocument, id=document_id, user_id=user_id)
    document.status = 3
    document.save()

    document_data = {
        "id": document.id,
        "filename": document.filename,
        "file_type": document.file_type,
        "created_at": document.created_at,
        "status_name": document.get_status_display(),
        "status_id": document.status,
        "description": document.description,
        "document_url": generate_presigned_url(document.s3_key),
    }

    return JsonResponse({"success": True, "document": document_data})


@login_required
@verification_required
@staff_member_required
@require_http_methods(["GET"])
def get_user_reports(request):
    user_id = request.GET.get("user_id")
    user = get_object_or_404(User, id=user_id)
    reports = user.reports_received.all().order_by("-created_at")

    return JsonResponse(
        {
            "user": {
                "first_name": user.first_name,
                "last_name": user.last_name,
                "username": user.username,
                "id": user.id,
            },
            "reports": [
                {
                    "id": report.id,
                    "subject": report.subject,
                    "description": report.description,
                    "is_acknowledged": report.is_acknowledged,
                    "reporter_username": report.reporter.username,
                    "created_at": report.created_at.isoformat(),
                }
                for report in reports
            ],
        }
    )


@login_required
@verification_required
@staff_member_required
@require_http_methods(["POST"])
def acknowledge_report(request):
    try:
        data = json.loads(request.body)
        report_id = data.get("report_id")
        report = get_object_or_404(UserReports, id=report_id)
        report.is_acknowledged = True
        report.save()

        return JsonResponse({"success": True})
    except json.JSONDecodeError as e:
        return JsonResponse(
            {"success": False, "error": "Invalid JSON data", "errorMessage": str(e)},
            status=400,
        )
    except Exception as e:
        return JsonResponse({"success": False, "error": str(e)}, status=500)


def deactivate_account_email(user):
    subject = "Your Account Has Been Deactivated"
    html_message = render_to_string(
        "emails/deactivate_account_email.html",
        {"first_name": user.first_name},
    )
    email = EmailMessage(
        subject, html_message, settings.DEFAULT_FROM_EMAIL, [user.email]
    )
    email.content_subtype = "html"
    email.send()


@login_required
@verification_required
@staff_member_required
@require_http_methods(["POST"])
def deactivate_account(request):
    try:
        data = json.loads(request.body)
        user_id = data.get("user_id")

        if user_id is None:
            return JsonResponse(
                {"success": False, "error": "User ID is required."}, status=400
            )

        user = get_object_or_404(User, id=user_id)
        user.is_active = False
        user.save()
        deactivate_account_email(user)
        return JsonResponse(
            {"success": True, "message": "User account deactivated successfully."}
        )
    except Exception as e:
        return JsonResponse({"success": False, "error": str(e)}, status=500)


def activate_account_email(user):
    subject = "Your Account Has Been Activated"
    website_link = settings.SITE_URL + reverse("home")
    html_message = render_to_string(
        "emails/activate_account_email.html",
        {"website_link": website_link, "first_name": user.first_name},
    )
    email = EmailMessage(
        subject, html_message, settings.DEFAULT_FROM_EMAIL, [user.email]
    )
    email.content_subtype = "html"
    email.send()


@login_required
@verification_required
@staff_member_required
@require_http_methods(["POST"])
def activate_account(request):
    try:
        data = json.loads(request.body)
        user_id = data.get("user_id")

        if user_id is None:
            return JsonResponse(
                {"success": False, "error": "User ID is required."}, status=400
            )

        user = get_object_or_404(User, id=user_id)
        user.is_active = True
        user.save()
        activate_account_email(user)
        return JsonResponse(
            {"success": True, "message": "User account activated successfully."}
        )
    except Exception as e:
        return JsonResponse({"success": False, "error": str(e)}, status=500)


def verify_account_email(user):
    subject = "Your Account Has Been Successfully Verified"
    website_link = settings.SITE_URL + reverse("home")
    html_message = render_to_string(
        "emails/verify_account_email.html",
        {"website_link": website_link, "first_name": user.first_name},
    )
    email = EmailMessage(
        subject, html_message, settings.DEFAULT_FROM_EMAIL, [user.email]
    )
    email.content_subtype = "html"
    email.send()


@login_required
@verification_required
@staff_member_required
@require_http_methods(["POST"])
def verify_account(request):
    try:
        data = json.loads(request.body)
        user_id = data.get("user_id")

        if user_id is None:
            return JsonResponse(
                {"success": False, "error": "User ID is required."}, status=400
            )

        user = get_object_or_404(User, id=user_id)
        user_profile = get_object_or_404(UserProfile, user=user)

        user_profile.is_verified = True
        user_profile.save()

        verify_account_email(user)
        return JsonResponse(
            {"success": True, "message": "User account has been successfully verified."}
        )
    except Exception as e:
        return JsonResponse({"success": False, "error": str(e)}, status=500)


def unverify_account_email(user):
    subject = "Your Account Has Been Unauthenticated"
    html_message = render_to_string(
        "emails/unverify_account_email.html",
        {"first_name": user.first_name},
    )
    email = EmailMessage(
        subject, html_message, settings.DEFAULT_FROM_EMAIL, [user.email]
    )
    email.content_subtype = "html"
    email.send()


@login_required
@verification_required
@staff_member_required
@require_http_methods(["POST"])
def unverify_account(request):
    try:
        data = json.loads(request.body)
        user_id = data.get("user_id")

        if user_id is None:
            return JsonResponse(
                {"success": False, "error": "User ID is required."}, status=400
            )
        user = get_object_or_404(User, id=user_id)
        user_profile = get_object_or_404(UserProfile, user=user)

        user_profile.is_verified = False
        user_profile.save()

        unverify_account_email(user)
        return JsonResponse(
            {
                "success": True,
                "message": "User account has been successfully unauthenticated.",
            }
        )
    except Exception as e:
        return JsonResponse({"success": False, "error": str(e)}, status=500)


@login_required
@verification_required
@staff_member_required
@require_http_methods(["POST"])
def set_emergency_support(request):
    try:
        data = json.loads(request.body)
        user_id = data.get("user_id")

        if user_id is None:
            return JsonResponse(
                {"success": False, "error": "User ID is required."}, status=400
            )

        user = get_object_or_404(User, id=user_id)
        user_profile = get_object_or_404(UserProfile, user=user)

        user_profile.is_emergency_support = True
        user_profile.save()

        return JsonResponse(
            {
                "success": True,
                "message": "User account has been successfully set as Emergency Support.",
            }
        )
    except Exception as e:
        return JsonResponse({"success": False, "error": str(e)}, status=500)


@login_required
@verification_required
@staff_member_required
@require_http_methods(["POST"])
def unset_emergency_support(request):
    try:
        data = json.loads(request.body)
        user_id = data.get("user_id")

        if user_id is None:
            return JsonResponse(
                {"success": False, "error": "User ID is required."}, status=400
            )
        user = get_object_or_404(User, id=user_id)
        user_profile = get_object_or_404(UserProfile, user=user)

        user_profile.is_emergency_support = False
        user_profile.save()

        return JsonResponse(
            {
                "success": True,
                "message": "User account has been successfully unset as Emergency Support.",
            }
        )
    except Exception as e:
        return JsonResponse({"success": False, "error": str(e)}, status=500)


@login_required
@verification_required
@staff_member_required
@require_http_methods(["POST"])
def set_admin(request):
    try:
        data = json.loads(request.body)
        user_id = data.get("user_id")

        if user_id is None:
            return JsonResponse(
                {"success": False, "error": "User ID is required."}, status=400
            )

        user = get_object_or_404(User, id=user_id)

        user.is_staff = True
        user.save()

        return JsonResponse(
            {
                "success": True,
                "message": "User account has been successfully set as administrator.",
            }
        )
    except Exception as e:
        return JsonResponse({"success": False, "error": str(e)}, status=500)


@login_required
@verification_required
@staff_member_required
@require_http_methods(["POST"])
def unset_admin(request):
    try:
        data = json.loads(request.body)
        user_id = data.get("user_id")

        if user_id is None:
            return JsonResponse(
                {"success": False, "error": "User ID is required."}, status=400
            )
        user = get_object_or_404(User, id=user_id)

        user.is_staff = False
        user.save()

        return JsonResponse(
            {
                "success": True,
                "message": "User account has been successfully unset as administrator.",
            }
        )
    except Exception as e:
        return JsonResponse({"success": False, "error": str(e)}, status=500)

1	from django.shortcuts import render, get_object_or_404	2✔
2	from django.contrib.auth.decorators import login_required	2✔
3	from django.contrib.admin.views.decorators import staff_member_required	2✔
4	from django.contrib.auth.models import User	2✔
5	from django.db.models import Count, Case, When, IntegerField	2✔
6	from accounts.models import UserReports, UserDocument	2✔
7	from utils.s3_utils import generate_presigned_url	2✔
8	from django.http import JsonResponse	2✔
9	from user_profile.models import UserProfile	2✔
10	from django.template.loader import render_to_string	2✔
11	from django.urls import reverse	2✔
12	from django.views.decorators.http import require_http_methods	2✔
13	from django.core.mail import EmailMessage	2✔
14	from django.conf import settings	2✔
15	import json	2✔
16	from user_profile.decorators import verification_required	2✔
17
18
19	@login_required	2✔
20	@verification_required	2✔
21	@staff_member_required	2✔
22	def admin_view(request):	2✔
23	users = User.objects.select_related("userprofile").all()	2✔
24	active_users = (	2✔
25	User.objects.select_related("userprofile")
26	.filter(documents__s3_key__isnull=False)
27	.distinct()
28	)
29
30	user_documents = []	2✔
31	for user in active_users:	2✔
32	documents = user.documents.all()	2✔
33	pending_count = documents.filter(status=1).count()	2✔
34	document_data = [	2✔
35	{
36	"filename": document.filename,
37	"file_type": document.file_type,
38	"created_at": document.created_at,
39	"status": dict(UserDocument.STATUS_CHOICES)[document.status],
40	"description": document.description,
41	"document_url": generate_presigned_url(document.s3_key),
42	}
43	for document in documents
44	]
45	if document_data:	2✔
46	user_documents.append(	2✔
47	{
48	"user": user,
49	"documents": document_data,
50	"pending_count": pending_count,
51	}
52	)
53
54	return render(	2✔
55	request,
56	"admin/admin_tabs.html",
57	{"users": users, "user_documents": user_documents},
58	)
59
60
61	@login_required	2✔
62	@verification_required	2✔
63	@staff_member_required	2✔
64	@require_http_methods(["GET"])	2✔
65	def reported_users_list(request):	2✔
66	reported_active_users = (	2✔
67	User.objects.filter(is_active=True, reports_received__isnull=False)
68	.annotate(
69	total_report_count=Count("reports_received"),
70	pending_report_count=Count(
71	Case(
72	When(reports_received__is_acknowledged=False, then=1),
73	output_field=IntegerField(),
74	)
75	),
76	)
77	.values(
78	"id",
79	"first_name",
80	"last_name",
81	"username",
82	"email",
83	"pending_report_count",
84	"total_report_count",
85	)
86	)
87
88	return JsonResponse({"success": True, "reports": list(reported_active_users)})	2✔
89
90
91	@login_required	2✔
92	@verification_required	2✔
93	@staff_member_required	2✔
94	@require_http_methods(["GET"])	2✔
95	def get_user_documents(request, user_id):	2✔
96	documents = UserDocument.objects.filter(user_id=user_id)	2✔
97	user = get_object_or_404(User, id=user_id)	2✔
98	pending_count = documents.filter(status=1).count()	2✔
99
100	document_data = [	2✔
101	{
102	"id": document.id,
103	"filename": document.filename,
104	"file_type": document.file_type,
105	"created_at": document.created_at,
106	"status_name": document.get_status_display(),
107	"status_id": document.status,
108	"description": document.description,
109	"document_url": generate_presigned_url(document.s3_key),
110	}
111	for document in documents
112	]
113
114	return JsonResponse(	2✔
115	{
116	"success": True,
117	"documents": document_data,
118	"username": user.username,
119	"pending_count": pending_count,
120	},
121	status=200,
122	)
123
124
125	@login_required	2✔
126	@verification_required	2✔
127	@staff_member_required	2✔
128	@require_http_methods(["POST"])	2✔
129	def accept_document(request, user_id, document_id):	2✔
130	document = get_object_or_404(UserDocument, id=document_id, user_id=user_id)	2✔
131	document.status = 2	2✔
132	document.save()	2✔
133
134	document_data = {	2✔
135	"id": document.id,
136	"filename": document.filename,
137	"file_type": document.file_type,
138	"created_at": document.created_at,
139	"status_name": document.get_status_display(),
140	"status_id": document.status,
141	"description": document.description,
142	"document_url": generate_presigned_url(document.s3_key),
143	}
144
145	return JsonResponse({"success": True, "document": document_data})	2✔
146
147
148	@login_required	2✔
149	@verification_required	2✔
150	@staff_member_required	2✔
151	@require_http_methods(["POST"])	2✔
152	def reject_document(request, user_id, document_id):	2✔
153	document = get_object_or_404(UserDocument, id=document_id, user_id=user_id)	2✔
154	document.status = 3	2✔
155	document.save()	2✔
156
157	document_data = {	2✔
158	"id": document.id,
159	"filename": document.filename,
160	"file_type": document.file_type,
161	"created_at": document.created_at,
162	"status_name": document.get_status_display(),
163	"status_id": document.status,
164	"description": document.description,
165	"document_url": generate_presigned_url(document.s3_key),
166	}
167
168	return JsonResponse({"success": True, "document": document_data})	2✔
169
170
171	@login_required	2✔
172	@verification_required	2✔
173	@staff_member_required	2✔
174	@require_http_methods(["GET"])	2✔
175	def get_user_reports(request):	2✔
176	user_id = request.GET.get("user_id")	2✔
177	user = get_object_or_404(User, id=user_id)	2✔
178	reports = user.reports_received.all().order_by("-created_at")	2✔
179
180	return JsonResponse(	2✔
181	{
182	"user": {
183	"first_name": user.first_name,
184	"last_name": user.last_name,
185	"username": user.username,
186	"id": user.id,
187	},
188	"reports": [
189	{
190	"id": report.id,
191	"subject": report.subject,
192	"description": report.description,
193	"is_acknowledged": report.is_acknowledged,
194	"reporter_username": report.reporter.username,
195	"created_at": report.created_at.isoformat(),
196	}
197	for report in reports
198	],
199	}
200	)
201
202
203	@login_required	2✔
204	@verification_required	2✔
205	@staff_member_required	2✔
206	@require_http_methods(["POST"])	2✔
207	def acknowledge_report(request):	2✔
208	try:	2✔
209	data = json.loads(request.body)	2✔
210	report_id = data.get("report_id")	2✔
211	report = get_object_or_404(UserReports, id=report_id)	2✔
212	report.is_acknowledged = True	2✔
213	report.save()	2✔
214
215	return JsonResponse({"success": True})	2✔
216	except json.JSONDecodeError as e:	2✔
217	return JsonResponse(	2✔
218	{"success": False, "error": "Invalid JSON data", "errorMessage": str(e)},
219	status=400,
220	)
221	except Exception as e:	2✔
222	return JsonResponse({"success": False, "error": str(e)}, status=500)	2✔
223
224
225	def deactivate_account_email(user):	2✔
UNCOV 226	subject = "Your Account Has Been Deactivated"	×
NEW 227	html_message = render_to_string(	×
228	"emails/deactivate_account_email.html",
229	{"first_name": user.first_name},
230	)
NEW 231	email = EmailMessage(	×
232	subject, html_message, settings.DEFAULT_FROM_EMAIL, [user.email]
233	)
NEW 234	email.content_subtype = "html"	×
NEW 235	email.send()	×
236
237
238	@login_required	2✔
239	@verification_required	2✔
240	@staff_member_required	2✔
241	@require_http_methods(["POST"])	2✔
242	def deactivate_account(request):	2✔
243	try:	2✔
244	data = json.loads(request.body)	2✔
245	user_id = data.get("user_id")	2✔
246
247	if user_id is None:	2✔
248	return JsonResponse(	2✔
249	{"success": False, "error": "User ID is required."}, status=400
250	)
251
252	user = get_object_or_404(User, id=user_id)	2✔
253	user.is_active = False	2✔
254	user.save()	2✔
255	deactivate_account_email(user)	2✔
256	return JsonResponse(	2✔
257	{"success": True, "message": "User account deactivated successfully."}
258	)
259	except Exception as e:	2✔
260	return JsonResponse({"success": False, "error": str(e)}, status=500)	2✔
261
262
263	def activate_account_email(user):	2✔
UNCOV 264	subject = "Your Account Has Been Activated"	×
NEW 265	website_link = settings.SITE_URL + reverse("home")	×
NEW 266	html_message = render_to_string(	×
267	"emails/activate_account_email.html",
268	{"website_link": website_link, "first_name": user.first_name},
269	)
NEW 270	email = EmailMessage(	×
271	subject, html_message, settings.DEFAULT_FROM_EMAIL, [user.email]
272	)
NEW 273	email.content_subtype = "html"	×
NEW 274	email.send()	×
275
276
277	@login_required	2✔
278	@verification_required	2✔
279	@staff_member_required	2✔
280	@require_http_methods(["POST"])	2✔
281	def activate_account(request):	2✔
282	try:	2✔
283	data = json.loads(request.body)	2✔
284	user_id = data.get("user_id")	2✔
285
286	if user_id is None:	2✔
287	return JsonResponse(	2✔
288	{"success": False, "error": "User ID is required."}, status=400
289	)
290
291	user = get_object_or_404(User, id=user_id)	2✔
292	user.is_active = True	2✔
293	user.save()	2✔
294	activate_account_email(user)	2✔
295	return JsonResponse(	2✔
296	{"success": True, "message": "User account activated successfully."}
297	)
298	except Exception as e:	2✔
299	return JsonResponse({"success": False, "error": str(e)}, status=500)	2✔
300
301
302	def verify_account_email(user):	2✔
UNCOV 303	subject = "Your Account Has Been Successfully Verified"	×
NEW 304	website_link = settings.SITE_URL + reverse("home")	×
NEW 305	html_message = render_to_string(	×
306	"emails/verify_account_email.html",
307	{"website_link": website_link, "first_name": user.first_name},
308	)
NEW 309	email = EmailMessage(	×
310	subject, html_message, settings.DEFAULT_FROM_EMAIL, [user.email]
311	)
NEW 312	email.content_subtype = "html"	×
NEW 313	email.send()	×
314
315
316	@login_required	2✔
317	@verification_required	2✔
318	@staff_member_required	2✔
319	@require_http_methods(["POST"])	2✔
320	def verify_account(request):	2✔
321	try:	2✔
322	data = json.loads(request.body)	2✔
323	user_id = data.get("user_id")	2✔
324
325	if user_id is None:	2✔
326	return JsonResponse(	2✔
327	{"success": False, "error": "User ID is required."}, status=400
328	)
329
330	user = get_object_or_404(User, id=user_id)	2✔
331	user_profile = get_object_or_404(UserProfile, user=user)	2✔
332
333	user_profile.is_verified = True	2✔
334	user_profile.save()	2✔
335
336	verify_account_email(user)	2✔
337	return JsonResponse(	2✔
338	{"success": True, "message": "User account has been successfully verified."}
339	)
340	except Exception as e:	2✔
341	return JsonResponse({"success": False, "error": str(e)}, status=500)	2✔
342
343
344	def unverify_account_email(user):	2✔
UNCOV 345	subject = "Your Account Has Been Unauthenticated"	×
NEW 346	html_message = render_to_string(	×
347	"emails/unverify_account_email.html",
348	{"first_name": user.first_name},
349	)
NEW 350	email = EmailMessage(	×
351	subject, html_message, settings.DEFAULT_FROM_EMAIL, [user.email]
352	)
NEW 353	email.content_subtype = "html"	×
NEW 354	email.send()	×
355
356
357	@login_required	2✔
358	@verification_required	2✔
359	@staff_member_required	2✔
360	@require_http_methods(["POST"])	2✔
361	def unverify_account(request):	2✔
362	try:	2✔
363	data = json.loads(request.body)	2✔
364	user_id = data.get("user_id")	2✔
365
366	if user_id is None:	2✔
367	return JsonResponse(	2✔
368	{"success": False, "error": "User ID is required."}, status=400
369	)
370	user = get_object_or_404(User, id=user_id)	2✔
371	user_profile = get_object_or_404(UserProfile, user=user)	2✔
372
373	user_profile.is_verified = False	2✔
374	user_profile.save()	2✔
375
376	unverify_account_email(user)	2✔
377	return JsonResponse(	2✔
378	{
379	"success": True,
380	"message": "User account has been successfully unauthenticated.",
381	}
382	)
383	except Exception as e:	2✔
384	return JsonResponse({"success": False, "error": str(e)}, status=500)	2✔
385
386
387	@login_required	2✔
388	@verification_required	2✔
389	@staff_member_required	2✔
390	@require_http_methods(["POST"])	2✔
391	def set_emergency_support(request):	2✔
392	try:	2✔
393	data = json.loads(request.body)	2✔
394	user_id = data.get("user_id")	2✔
395
396	if user_id is None:	2✔
397	return JsonResponse(	2✔
398	{"success": False, "error": "User ID is required."}, status=400
399	)
400
401	user = get_object_or_404(User, id=user_id)	2✔
402	user_profile = get_object_or_404(UserProfile, user=user)	2✔
403
404	user_profile.is_emergency_support = True	2✔
405	user_profile.save()	2✔
406
407	return JsonResponse(	2✔
408	{
409	"success": True,
410	"message": "User account has been successfully set as Emergency Support.",
411	}
412	)
413	except Exception as e:	2✔
414	return JsonResponse({"success": False, "error": str(e)}, status=500)	2✔
415
416
417	@login_required	2✔
418	@verification_required	2✔
419	@staff_member_required	2✔
420	@require_http_methods(["POST"])	2✔
421	def unset_emergency_support(request):	2✔
422	try:	2✔
423	data = json.loads(request.body)	2✔
424	user_id = data.get("user_id")	2✔
425
426	if user_id is None:	2✔
427	return JsonResponse(	2✔
428	{"success": False, "error": "User ID is required."}, status=400
429	)
430	user = get_object_or_404(User, id=user_id)	2✔
431	user_profile = get_object_or_404(UserProfile, user=user)	2✔
432
433	user_profile.is_emergency_support = False	2✔
434	user_profile.save()	2✔
435
436	return JsonResponse(	2✔
437	{
438	"success": True,
439	"message": "User account has been successfully unset as Emergency Support.",
440	}
441	)
442	except Exception as e:	2✔
443	return JsonResponse({"success": False, "error": str(e)}, status=500)	2✔
444
445
446	@login_required	2✔
447	@verification_required	2✔
448	@staff_member_required	2✔
449	@require_http_methods(["POST"])	2✔
450	def set_admin(request):	2✔
451	try:	2✔
452	data = json.loads(request.body)	2✔
453	user_id = data.get("user_id")	2✔
454
455	if user_id is None:	2✔
456	return JsonResponse(	2✔
457	{"success": False, "error": "User ID is required."}, status=400
458	)
459
460	user = get_object_or_404(User, id=user_id)	2✔
461
462	user.is_staff = True	2✔
463	user.save()	2✔
464
465	return JsonResponse(	2✔
466	{
467	"success": True,
468	"message": "User account has been successfully set as administrator.",
469	}
470	)
471	except Exception as e:	2✔
472	return JsonResponse({"success": False, "error": str(e)}, status=500)	2✔
473
474
475	@login_required	2✔
476	@verification_required	2✔
477	@staff_member_required	2✔
478	@require_http_methods(["POST"])	2✔
479	def unset_admin(request):	2✔
480	try:	2✔
481	data = json.loads(request.body)	2✔
482	user_id = data.get("user_id")	2✔
483
484	if user_id is None:	2✔
485	return JsonResponse(	2✔
486	{"success": False, "error": "User ID is required."}, status=400
487	)
488	user = get_object_or_404(User, id=user_id)	2✔
489
490	user.is_staff = False	2✔
491	user.save()	2✔
492
493	return JsonResponse(	2✔
494	{
495	"success": True,
496	"message": "User account has been successfully unset as administrator.",
497	}
498	)
499	except Exception as e:	2✔
500	return JsonResponse({"success": False, "error": str(e)}, status=500)	2✔

gcivil-nyu-org / fall24-monday-team4 / 383

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