Fakultas Ilmu Komputer UI

views.py 29.3 KB
Newer Older
1
2
import mimetypes
import os
3
from io import BytesIO
4

5
import django
6
from decouple import config
7
import pandas as pd
8
from django.conf import settings
9
from django.contrib import messages
10
11
12
from django.contrib.auth.views import PasswordChangeForm
from django.contrib.auth.views import PasswordChangeView
from django.core.exceptions import PermissionDenied, FieldError
13
from django.core.mail import send_mail
14
from django.core.paginator import Paginator
15
from django.db.models import Q, Avg
16
17
from django.http import (Http404, HttpResponse, HttpResponseRedirect,
                         JsonResponse)
18
from django.shortcuts import get_object_or_404, redirect
19
from django.shortcuts import render
20
from django.template import loader
21
from django.urls import reverse
22
from django.urls import reverse_lazy
23
from django.views import defaults
24
from django.views.generic import TemplateView
25

26
from app.forms import SuntingProfilForm, UploadMateriForm, RatingContributorForm
27
28
29
from app.models import (
    Category,
    Comment,
30
    Review,
31
32
    Materi,
    ReqMaterial,
33
    Rating, RatingContributor,
insan ramadhan's avatar
insan ramadhan committed
34
    SubmitVisitor
35
)
36
from authentication.models import User
37
38
39
40
from .services import DafterKatalogService, DetailMateriService, LikeDislikeService, MateriFieldValidationHelperService, \
    DownloadViewMateriHelperService, UploadMateriService, EditProfileService, RevisiMateriService, \
    DownloadHistoryService, GoogleDriveUploadService

41

42
def permission_denied(request, exception, template_name="error_403.html"):
43
44
    return defaults.permission_denied(request, exception, template_name)

45

46
class DaftarKatalog(TemplateView):
igor lestin sianipar's avatar
igor lestin sianipar committed
47
    paginate_by = 2
48
49
50
51
52
53
54
    template_name = "app/katalog_materi.html"

    def get_context_data(self, **kwargs):
        return super().get_context_data(**kwargs)

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)
55
        context["kategori_list"] = Category.objects.all()
56

Mika dabelza abi's avatar
Mika dabelza abi committed
57
        lstMateri = Materi.objects.filter(status="APPROVE").order_by("date_modified")
Mika dabelza abi's avatar
Mika dabelza abi committed
58
59
        url = ""

60
        lstMateri, url = DafterKatalogService.apply_options(lstMateri, request, url)
Saul Andre's avatar
Saul Andre committed
61

62

Mika dabelza abi's avatar
Mika dabelza abi committed
63
        context["materi_list"] = lstMateri
Mika dabelza abi's avatar
Mika dabelza abi committed
64
        paginator = Paginator(context["materi_list"], 15)
65
        page_number = request.GET.get("page")
Mika dabelza abi's avatar
Mika dabelza abi committed
66
67
68
69
        page_obj = paginator.get_page(page_number)
        context["materi_list"] = page_obj

        context["url"] = url
70
71
        return self.render_to_response(context=context)

72

73
74
class KatalogPerKontributorView(TemplateView):
    template_name = "app/katalog_kontri.html"
75

76
77
78
79
80
81
82
83
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        contributor = get_object_or_404(User, email=kwargs["email"])
        context["contributor"] = contributor
        return context

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)
84
85
86
87
88

        materi_list = Materi.objects.filter(status="APPROVE", uploader=context["contributor"]).order_by(
            "date_modified"
        )

89
        paginator = Paginator(materi_list, 15)
90
        page_number = request.GET.get("page")
91
92
        materi_list_by_page = paginator.get_page(page_number)
        context["materi_list"] = materi_list_by_page
93
94
95
96
97
        contributor = context["contributor"]
        context["form_rating"] = RatingContributorForm(initial={
            "contributor": contributor,
            "user":request.user
        })
98
        context["avg_rating"] = User.objects.filter(email=kwargs["email"]) \
99
100
101
102
103
104
105
            .annotate(avg_rating=Avg("contributor__score"))[0]
        context["count_rating"] = RatingContributor.objects.filter(contributor=contributor).count()

        if request.user.is_authenticated:
            has_rated = RatingContributor.objects.filter(user=request.user, contributor=contributor).exists()
            context["has_rated"] = has_rated

106
        return self.render_to_response(context=context)
107

108
    def post(self, request, *args, **kwargs):
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
        context = self.get_context_data(**kwargs)
        if not request.user.is_authenticated:
            raise PermissionDenied(request)

        is_delete = request.POST.get('delete', None)
        is_update = request.POST.get('update', None)
        if is_delete:
            rating_contributor = get_object_or_404(
                RatingContributor, 
                user=request.user,
                contributor=context["contributor"]
            )
            rating_contributor.delete()
        elif is_update:
            score = request.POST.get('score', None)
            rating = RatingContributor.objects.filter(
                user=request.user,
                contributor=context["contributor"]
            ).first()
            
            if rating and score:
                rating.score = int(score)
                rating.save()
        else:
            data = RatingContributorForm(request.POST)
            if data.is_valid():
                data.save()
                
137
138
        return redirect("katalog-per-kontributor", email=kwargs["email"])

139
140
141
142
class DetailMateri(TemplateView):
    template_name = "app/detail_materi.html"

    def get_context_data(self, **kwargs):
143
144
145
146
        context = super(DetailMateri, self).get_context_data(**kwargs)
        if not self.request.session or not self.request.session.session_key:
            self.request.session.save()
        materi = get_object_or_404(Materi, pk=kwargs["pk"])
147
148
149
        DetailMateriService.init_context_data(context, materi, self.request.session)
        published_date = DetailMateriService.set_published_date(materi)
        DetailMateriService.init_citation_and_materi_rating(context, materi, published_date, self.request)
150
        DetailMateriService.init_materi_download_count(context, materi)
151
152
153
154

        if self.request.user.is_authenticated:
            materi_rating = Rating.objects.filter(materi=materi, user=self.request.user).first()
            if materi_rating is not None:
155
                context['materi_rating_score'] = materi_rating.score
156

157
        context['is_authenticated'] = self.request.user.is_authenticated
158

159
        return context
160

161

162
163
    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)
164
        query_set_for_comment = Comment.objects.filter(materi=context["materi_data"])
165
        query_set_for_review = Review.objects.filter(materi=context["materi_data"])
166
        has_disliked, has_liked = DetailMateriService.find_comment_like_dislike(query_set_for_comment, self.request.session)
167
        context["comment_data"] = query_set_for_comment
168
        context["review_data"] = query_set_for_review
169
170
        context["has_liked_comment"] = has_liked
        context["has_disliked_comment"] = has_disliked
171
172
        return self.render_to_response(context=context)

173

174

175
    def post(self, request, *args, **kwargs):
176
177
178
        comment_text = request.POST.get("comment", None)
        review_text  = request.POST.get("review", None)
        if ((comment_text == None or comment_text == "" )and (review_text == None or review_text == "")):
179
180
            context = self.get_context_data(*args, **kwargs)
            context["error_message"] = "Anda belum menuliskan komentar"
181
            context["materi_data"] = get_object_or_404(Materi, pk=kwargs["pk"])
182
            query_set_for_comment = Comment.objects.filter(materi=context["materi_data"])
183
            context["comment_data"] = query_set_for_comment
184
185
            query_set_for_review = Review.objects.filter(materi=context["materi_data"])
            context["review_data"] = query_set_for_review
186
            return self.render_to_response(context=context)
187

188
        materi = get_object_or_404(Materi, pk=kwargs["pk"])
189
        user_obj = request.user if request.user.is_authenticated else None
190
        if user_obj:
191
            if (comment_text != None ):
192
                comment = Comment.objects.create(
193
                    comment=comment_text, username=DetailMateriService.get_user_name(request), materi=materi, user=user_obj
194
195
                )
                comment.save()
196
197
198
199
200
201
202
203
204
205
206
207
208
                materi_uploader = materi.uploader
                if materi_uploader.is_subscribing_to_material_comments and user_obj.email != materi_uploader.email:
                    email_content =  f'User dengan email {user_obj.email} ' + \
                        f'menambahkan komentar pada materi Anda dengan judul "{materi.title}".' + \
                        f'\nKomentar: "{comment.comment}".\n' + \
                        f'Silahkan akses halaman detail materi untuk berinteraksi lebih lanjut.'
                    send_mail(
                        subject = 'DIGIPUS: Komentar Baru pada Materi Anda',
                        message = email_content,
                        from_email = getattr(settings, 'EMAIL_HOST_USER'),
                        recipient_list = [materi_uploader.email,],
                        fail_silently = False,
                    ) 
209
            elif (review_text != None):
210
                review = Review.objects.create(
211
                    review=review_text, username=DetailMateriService.get_user_name(request), materi=materi, user=user_obj
212
213
                )
                review.save()
214
215
        return HttpResponseRedirect(request.path)

216

217
def toggle_like(request):
218
219
220
    if request.method == "POST":
        materi_id = request.POST.get("materi_id", None)
        session_id = request.POST.get("session_id", None)
221
222
        if materi_id is None or session_id is None:
            return JsonResponse({"success": False, "msg": "Missing parameter"})
223
        return JsonResponse(LikeDislikeService.apply_like_materi(materi_id, session_id))
224
225
226
227
    else:
        return JsonResponse({"success": False, "msg": "Unsuported method"})


228
def delete_comment(request, pk_materi, pk_comment):
229
230
    if not request.user.is_authenticated or not request.user.is_admin:
        raise PermissionDenied(request)
231
    comment = get_object_or_404(Comment, pk=pk_comment)
232
    url = "/materi/" + str(pk_materi) + "/"
233
234
235
    comment.delete()
    return HttpResponseRedirect(url)

236
def toggle_like_comment(request):
237
    comment_id = 0
238
239
240
241
242
    if request.method == "POST":
        comment_id = request.POST.get("comment_id", None)
        session_id = request.POST.get("session_id", None)
        if comment_id is None or session_id is None:
            return JsonResponse({"success": False, "msg": "Missing parameter", "comment_id": comment_id})
243
        return JsonResponse(LikeDislikeService.apply_comment_like(comment_id, session_id))
244
245
246
    else:
        return JsonResponse({"success": False, "msg": "Unsuported method", "comment_id": comment_id})

247

248
def toggle_dislike_comment(request):
249
    comment_id = 0
250
251
252
253
254
    if request.method == "POST":
        comment_id = request.POST.get("comment_id", None)
        session_id = request.POST.get("session_id", None)
        if comment_id is None or session_id is None:
            return JsonResponse({"success": False, "msg": "Missing parameter", "comment_id": comment_id})
255
        return JsonResponse(LikeDislikeService.apply_comment_dislike(comment_id, session_id))
256
257
    else:
        return JsonResponse({"success": False, "msg": "Unsuported method", "comment_id": comment_id})
258
259


260
def add_rating_materi(request):
261
    if request.method == "POST" and request.user.is_authenticated:
262

263
264
        materi_id = request.POST.get("materi_id", None)
        rating_score = request.POST.get("rating_score", None)
265
266


267
268
269
270
        is_valid_params, materi_id, \
        rating_score, response, \
        status_code = MateriFieldValidationHelperService.\
            validate_materi_rating_params(materi_id,rating_score)
271

272
273
        if not is_valid_params:
            return JsonResponse(response, status=status_code)
274

275
276
277
        is_valid_rating, materi, \
        response, status_code = MateriFieldValidationHelperService.\
            validate_materi_rating(materi_id, request.user)
278

279
280
        if not is_valid_rating:
            return JsonResponse(response, status=status_code)
281
282

        Rating(materi=materi, user=request.user, score=rating_score).save()
283
284
285
        return JsonResponse(
            {"success": True, "msg": "Rating successfully created", "rating_score": rating_score}, status=201
        )
286
287
288
    return JsonResponse({"success": False, "msg": "Forbidden"}, status=403)


289

290
291
292
293
294
def download_materi(request, pk):
    materi = get_object_or_404(Materi, pk=pk)
    path = materi.content.path
    file_path = os.path.join(settings.MEDIA_ROOT, path)
    if os.path.exists(file_path):
295
296
297
        try:
            mimetype = mimetypes.guess_type(file_path)
            with open(file_path, "rb") as fh:
298
299
300
                return DownloadViewMateriHelperService.build_materi_response(fh, file_path,
                                                                             materi, mimetype, request,
                                                                             HttpResponse(fh.read(), content_type=mimetype[0]))
301
302
        except Exception as e:
            raise Http404("File tidak dapat ditemukan.")
303
304
305
    else:
        raise Http404("File tidak dapat ditemukan.")

igor lestin sianipar's avatar
igor lestin sianipar committed
306

307
308
309
310
311
312
def view_materi(request, pk):
    materi = get_object_or_404(Materi, pk=pk)
    path = materi.content.path
    file_path = os.path.join(settings.MEDIA_ROOT, path)
    if os.path.exists(file_path):
        mimetype = mimetypes.guess_type(file_path)
313
314
315
        try:
            with open(file_path, "rb") as fh:
                response = HttpResponse(fh.read(), content_type=mimetype[0])
316
                DownloadViewMateriHelperService.build_view_materi_response(file_path, materi, response)
317
318
319
                return response
        except Exception as e:
            raise Http404("File tidak dapat ditemukan.")
320
321
    else:
        raise Http404("File tidak dapat ditemukan.")
igor lestin sianipar's avatar
igor lestin sianipar committed
322

igor lestin sianipar's avatar
igor lestin sianipar committed
323

Selvy Fitriani's avatar
Selvy Fitriani committed
324
325
def delete_materi(request, pk):
    materi = get_object_or_404(Materi, pk=pk)
326
327
328
    if request.user.is_superuser or request.user.is_admin:
        materi.soft_delete()
        return HttpResponseRedirect("/administration/")
Selvy Fitriani's avatar
Selvy Fitriani committed
329
330
331
    materi.delete()
    return HttpResponseRedirect("/dashboard/")

igor lestin sianipar's avatar
igor lestin sianipar committed
332
class UploadMateriView(TemplateView):
333
    template_name = "unggah.html"
igor lestin sianipar's avatar
igor lestin sianipar committed
334
335
336
337
338
339
    context = {}

    def get_context_data(self, **kwargs):
        context = super(UploadMateriView, self).get_context_data(**kwargs)
        return context

Saul Andre's avatar
Saul Andre committed
340
    def post(self, request, *args, **kwargs):
Steven Kusuman's avatar
Steven Kusuman committed
341
        if request.user.is_authenticated == False or not request.user.is_contributor:
igor lestin sianipar's avatar
igor lestin sianipar committed
342
            raise PermissionDenied(request)
343
        form = UploadMateriForm(request.POST, request.FILES)
igor lestin sianipar's avatar
igor lestin sianipar committed
344
345
346
        if form.is_valid():
            materi = form.save(commit=False)
            materi.uploader = request.user
347
            konten = form.cleaned_data["content"]
348
349
            yt_url_id = form.cleaned_data['yt_video_id']
            if not UploadMateriService.validate_file_extension(konten, request, yt_url_id):
350
                return HttpResponseRedirect("/unggah/")
351
            UploadMateriService.upload_materi(form, materi)
352
            messages.success(request, "Materi berhasil diunggah, periksa riwayat unggah anda")
353
            return HttpResponseRedirect("/unggah/")
Saul Andre's avatar
Saul Andre committed
354
        else:
igor lestin sianipar's avatar
igor lestin sianipar committed
355
            context = self.get_context_data(**kwargs)
356
            context["form"] = form
357
            messages.error(request, "Terjadi kesalahan pada pengisian data")
igor lestin sianipar's avatar
igor lestin sianipar committed
358
359
            return self.render_to_response(context)

360
361


igor lestin sianipar's avatar
igor lestin sianipar committed
362
    def get(self, request, *args, **kwargs):
Steven Kusuman's avatar
Steven Kusuman committed
363
        if request.user.is_authenticated == False or not request.user.is_contributor:
igor lestin sianipar's avatar
igor lestin sianipar committed
364
            raise PermissionDenied(request)
365

igor lestin sianipar's avatar
igor lestin sianipar committed
366
        context = self.get_context_data(**kwargs)
367
        context["form"] = UploadMateriForm
igor lestin sianipar's avatar
igor lestin sianipar committed
368
        return self.render_to_response(context)
369

370

371
372
373
class UploadMateriHTML(TemplateView):
    template_name = "unggah.html"
    context = {}
igor lestin sianipar's avatar
igor lestin sianipar committed
374

375
376
377
378
379
380
    def get_template_names(self):
        if self.request.path == "/unggah/":
            template_name = "unggah.html"
        return template_name


381
382
383
384
385
386
387
388
389
390
391
class UploadMateriExcelView(TemplateView):
    template_name = "unggah_excel.html"
    context = {}

    def get_template_names(self):
        if self.request.path == "/unggah_excel/":
            template_name = "unggah_excel.html"
        return template_name

    def get(self, request, *args, **kwargs):

392
        if "template" in self.request.GET:
393

394
395
396
            data_frame = pd.DataFrame(
                {"Title": [], "Author": [], "Publisher": [], "Categories": [], "Description": [],}
            )
397
398

            with BytesIO() as b:
399
                writer = pd.ExcelWriter(b, engine="xlsxwriter")  # pylint: disable=abstract-class-instantiated
400
401
402
                data_frame.to_excel(writer, index=0)
                writer.save()
                response = HttpResponse(
403
404
                    b.getvalue(), content_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
                )
405
406
407
408
409
410
411
412
413
414

                response["Content-Disposition"] = "attachment; filename=template.xlsx"

                return response

        else:
            context = self.get_context_data(**kwargs)
            return self.render_to_response(context)

    def post(self, request, *args, **kwargs):
415
416
        excel_file = request.FILES["excel"]
        excel = pd.read_excel(excel_file)
417

418
        row, lines = excel.shape
419
        categories = Category.objects.all()
420

421
        field_length = {
422
423
424
            "title": 50,
            "author": 30,
            "publisher": 30,
425
426
427
428
429
430
        }

        message = None

        # First pass, validate input
        for i in range(row):
431

432
            # Validate Categories
433
            message = UploadMateriService.validate_excel_categories(categories, excel, i, message)
434

435
            message = UploadMateriService.validate_excel_field_length(excel, field_length, i, message)
436
437
438

            if message != None:
                break
439

440
441
        if message != None:
            messages.error(request, message)
442
            return HttpResponseRedirect("/unggah_excel/")
443
444
445

        # Second pass, save data
        with django.db.transaction.atomic():
446
            UploadMateriService.upload_materi_excel(categories, excel, request, row)
447

448
        messages.success(request, "Materi berhasil diunggah")
449

450
        return HttpResponseRedirect("/unggah_excel/")
451
452


453
454


455
class DashboardKontributorView(TemplateView):
456
    template_name = "dashboard.html"
457
458
459
460
461
462
463

    def dispatch(self, request, *args, **kwargs):
        if not request.user.is_authenticated or not request.user.is_contributor:
            raise PermissionDenied(request)
        return super(DashboardKontributorView, self).dispatch(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
464
        context = super(DashboardKontributorView, self).get_context_data(**kwargs)
465
466
467
468
        return context

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)
469
470
471
        current_user = self.request.user
        materi_list = current_user.materi_set.all()
        context["materi_list"] = materi_list
472
        return self.render_to_response(context)
473

474

475
class ProfilView(TemplateView):
476
477
478
    template_name = "profil.html"

    def dispatch(self, request, *args, **kwargs):
479
        if not request.user.is_authenticated:
480
            raise PermissionDenied(request)
481
        return super(ProfilView, self).dispatch(request, *args, **kwargs)
482
483
484

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)
485
        current_user = request.user
486
487
488
        context["user"] = current_user
        return self.render_to_response(context)

489

490
491
492
493
class SuntingProfilView(TemplateView):
    template_name = "sunting.html"

    def dispatch(self, request, *args, **kwargs):
494
        if not request.user.is_authenticated:
495
496
497
498
            raise PermissionDenied(request)
        return super(SuntingProfilView, self).dispatch(request, *args, **kwargs)

    def get(self, request, *args, **kwargs):
Samuel Dimas Partogi's avatar
Samuel Dimas Partogi committed
499
        current_user = self.request.user
500
501
502
503
504
505
506
507
508
509
        context = self.get_context_data(**kwargs)
        context["user"] = current_user
        context["form"] = SuntingProfilForm(instance=current_user)
        return self.render_to_response(context)

    def post(self, request, *args, **kwargs):
        if request.user.is_authenticated == False:
            raise PermissionDenied(request)

        current_user = self.request.user
510

511
        form = SuntingProfilForm(request.POST, request.FILES, instance=current_user)
512
513
        if form.is_valid():
            current_user.default_profile_picture = True
514
515
516

            # Removing exifdata from profile picture on upload
            if request.FILES:
517
                EditProfileService.update_profile_picture(current_user, request)
518
            else:
519
                form.save()
520
            return HttpResponseRedirect("/profil/")
521
522
        else:
            context = self.get_context_data(**kwargs)
523
524
            context["form"] = form
            return self.render_to_response(context)
525

526

527
528
529
530
531
532
533
534
535
class ReqMateriView(TemplateView):
    template_name = "req_materi.html"

    def dispatch(self, request, *args, **kwargs):
        if request.user.is_authenticated == False:
            return HttpResponseRedirect("/login/")
        return super(ReqMateriView, self).dispatch(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
536
        context = super(ReqMateriView, self).get_context_data(**kwargs)
537
538
539
540
        return context

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)
541
        context['requested_material'] = ReqMaterial.objects.all()
542
543
544
        return self.render_to_response(context)

    def post(self, request, *args, **kwargs):
545
        title = request.POST.get("title", None)
546
547
548
549
550
        if title is None:
            return JsonResponse({"success": False, "msg": "Missing parameter"})
        ReqMaterial(title=title).save()
        return JsonResponse({"success": True, "msg": "Permintaan materi berhasil dikirimkan"})

551

552
553
554
555
556
557
558
class SuksesLoginKontributorView(TemplateView):
    template_name = "sukses_kontri.html"

    def dispatch(self, request, *args, **kwargs):
        if not request.user.is_contributor:
            raise PermissionDenied(request)
        return super(SuksesLoginKontributorView, self).dispatch(request, *args, **kwargs)
559

560
    def get_context_data(self, **kwargs):
561
        context = super(SuksesLoginKontributorView, self).get_context_data(**kwargs)
562
563
564
565
566
567
568
569
570
571
        return context

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)

        current_user = self.request.user
        context["user"] = current_user

        return self.render_to_response(context)

572

573
574
575
576
577
578
579
class SuksesLoginAdminView(TemplateView):
    template_name = "sukses_admin.html"

    def dispatch(self, request, *args, **kwargs):
        if not request.user.is_admin:
            raise PermissionDenied(request)
        return super(SuksesLoginAdminView, self).dispatch(request, *args, **kwargs)
580

581
582
583
584
585
586
587
588
589
590
591
592
    def get_context_data(self, **kwargs):
        context = super(SuksesLoginAdminView, self).get_context_data(**kwargs)
        return context

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)

        current_user = self.request.user
        context["user"] = current_user

        return self.render_to_response(context)

igor lestin sianipar's avatar
igor lestin sianipar committed
593

594
595
596
class PostsView(TemplateView):

    template_name = "user_uploaded_posts.html"
597
598

    def dispatch(self, request, *args, **kwargs):
599
        if not request.user.is_authenticated:
600
            raise PermissionDenied(request)
601
        return super(PostsView, self).dispatch(request, *args, **kwargs)
602
603

    def get(self, request, *args, **kwargs):
604
605
606
607
        context = super().get_context_data(**kwargs)
        user = self.request.user

        posts = Materi.objects.filter(uploader=user).order_by("-date_created")
608
        posts_data = {post.id: {"data": post, "comments": []} for post in posts}
609

610
        comments = Comment.objects.filter(materi__id__in=posts_data.keys()).order_by("-timestamp")
611
612
613
614
615
616
617

        for comment in comments:
            posts_data[comment.materi.id]["comments"].append(comment)

        context["user"] = user
        context["posts"] = posts_data

618
        return self.render_to_response(context=context)
619

620

621
622
623
class RevisiMateriView(TemplateView):
    template_name = "revisi.html"

624
    def dispatch(self, request, *args, **kwargs):
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
        if not request.user.is_contributor:
            raise PermissionDenied(request)
        return super(RevisiMateriView, self).dispatch(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super(RevisiMateriView, self).get_context_data(**kwargs)
        current_materi = get_object_or_404(Materi, pk=kwargs["pk"])
        context["materi"] = current_materi
        context["revisi_form"] = UploadMateriForm(instance=current_materi)
        return context

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)
        return self.render_to_response(context)

640
    def post(self, request, *args, **kwargs):
641
642
643
644
        if request.user.is_authenticated == False:
            raise PermissionDenied(request)

        current_materi = get_object_or_404(Materi, pk=kwargs["pk"])
645
        form = UploadMateriForm(request.POST, request.FILES, instance=current_materi)
646
        if form.is_valid():
647
            RevisiMateriService.revisi_materi(form, request)
648
649
650
651
652
653
            return HttpResponseRedirect("/dashboard/")
        else:
            context = self.get_context_data(**kwargs)
            context["form_revisi"] = form
            return self.render_to_response(context)

654

Samuel Dimas's avatar
Samuel Dimas committed
655
656
657
658
659
660
def pages(request):
    context = {}
    # All resource paths end in .html.
    # Pick out the html file name from the url. And load that template.
    try:

661
        load_template = request.path.split("/")[-1]
Samuel Dimas's avatar
Samuel Dimas committed
662
663
664
        template = loader.get_template(load_template)
        return HttpResponse(template.render(context, request))

665
    except Exception as e:
Samuel Dimas's avatar
Samuel Dimas committed
666

667
        template = loader.get_template("error-404.html")
Samuel Dimas's avatar
Samuel Dimas committed
668
        return HttpResponse(template.render(context, request))
669
670


671
672
673
674
class DownloadHistoryView(TemplateView):
    template_name = "download_history.html"

    def get_context_data(self, **kwargs):
675
        context = super(DownloadHistoryView, self).get_context_data(**kwargs)
676
677
678
679
680
681
        return context

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)
        if request.user.is_authenticated:
            current_user = self.request.user
682
            DownloadHistoryService.init_data_authenticated_user(context, current_user)
683
        else:
684
            DownloadHistoryService.init_data_guest_user(context, request)
685
        return self.render_to_response(context)
686

687

688
689
690
691
692
def save_to_gdrive(request, pk):
    materi = get_object_or_404(Materi, pk=pk)
    path = materi.content.path
    file_path = os.path.join(settings.MEDIA_ROOT, path)
    if os.path.exists(file_path):
693
        GoogleDriveUploadService.upload_to_gdrive(file_path, materi.title)
694
695
696
    else:
        raise Http404("File tidak dapat ditemukan.")

Yaumi's avatar
Yaumi committed
697
698
    return HttpResponseRedirect(reverse('detail-materi', kwargs={'pk': pk}))

699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
class MateriFavorite(TemplateView):

    template_name = "user_favorite_materi.html"

    def dispatch(self, request, *args, **kwargs):
        if not request.user.is_authenticated:
            raise PermissionDenied(request)
        return super(MateriFavorite, self).dispatch(request, *args, **kwargs)

    def get(self, request, *args, **kwargs):
        context = super().get_context_data(**kwargs)
        user = self.request.user

        materi = Materi.objects.filter(like=True)
        likes_data = { mat.id: { "data": mat, "comments": [] } for mat in materi }

        comments = Comment.objects \
            .filter(materi__id__in=likes_data.keys()) \
            .order_by("-timestamp")

        for comment in comments:
            likes_data[comment.materi.id]["comments"].append(comment)

        context["user"] = user
        context["likes"] = likes_data

        return self.render_to_response(context=context)

Yaumi's avatar
Yaumi committed
727
class PasswordChangeViews(PasswordChangeView):
728

Yaumi's avatar
Yaumi committed
729
730
    from_class = PasswordChangeForm
    success_url = reverse_lazy('password_success')
Yaumi's avatar
Yaumi committed
731

Yaumi's avatar
Yaumi committed
732
def password_success(request):
733
    return render(request, 'password_success.html', {})
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757


def see_given_rating(request):
    if request.user.is_authenticated:
        order_by_key = request.GET.get('order_by_key', 'timestamp')

        if request.GET.get('order', '').lower() == 'asc':
            order_by = 'asc'
            query_order = ''
        else:
            order_by = 'dsc'
            query_order = '-'

        try:
            if order_by_key[0] == '-':
                order_by_key = order_by_key[1:]
            rating_list = Rating.objects.filter(user=request.user).order_by(query_order + order_by_key)
        except FieldError:
            order_by_key = 'timestamp'
            rating_list = Rating.objects.filter(user=request.user).order_by(query_order + order_by_key)

        return render(request, 'given-rating.html',
                      context={'rating_list': rating_list, 'order_by_key': order_by_key, 'order_by': order_by})
    return permission_denied(request, exception=None)
insan ramadhan's avatar
insan ramadhan committed
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782

class SubmitVisitorView(TemplateView):
    template_name = "submit_visitor.html"

    def dispatch(self, request, *args, **kwargs):
        if request.user.is_authenticated == False:
            return HttpResponseRedirect("/login/")
        return super(SubmitVisitorView, self).dispatch(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super(SubmitVisitorView, self).get_context_data(**kwargs)
        return context

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)
        return self.render_to_response(context)

    def post(self, request, *args, **kwargs):
        title = request.POST.get("title", None)
        email = request.POST.get("email", None)
        user_id = request.POST.get("user_id", None)
        if title is None:
            return JsonResponse({"success": False, "msg": "Missing parameter"})
        SubmitVisitor(msg=title, user_id=user_id, email=email).save()
        return JsonResponse({"success": True, "msg": "Buku tamu berhasil ditambahkan"})