added ajax

1 files changed, 530 insertions, 0 deletions

diff --git a/website/ajax.py b/website/ajax.py
new file mode 100755
index 0000000..ecd040a
--- /dev/null
+++ b/website/ajax.py
@@ -0,0 +1,530 @@
+from django.forms.models import model_to_dict
+import json as simplejson
+from django.http import HttpResponse
+from django.shortcuts import render, redirect
+from django.core import serializers
+
+# from django.http import HttpResponse, HttpResponseRedirect
+# from django.shortcuts import render, redirect
+from django.core.mail import EmailMultiAlternatives
+from django.template.context_processors import csrf
+# from django.utils.html import strip_tags
+from django.template.loader import render_to_string, get_template
+from django.views.decorators.csrf import csrf_exempt, csrf_protect
+
+# from django.db.models import Q
+from textwrap import dedent
+from R_on_Cloud.config import FROM_EMAIL, TO_EMAIL, CC_EMAIL, BCC_EMAIL
+from R_on_Cloud.config import UPLOADS_PATH
+from website.views import catg
+from website.models import *
+from website.forms import BugForm, RevisionForm, issues
+
+from . import utils
+from .query import *
+
+import base64
+from django.db import connections
+
+
+def remove_from_session(request, keys):
+    for key in keys:
+        request.session.pop(key, None)
+
+
+def subcategories(request):
+    context = {}
+    response_dict = []
+    if request.is_ajax():
+        maincategory_id = int(request.GET.get('maincat_id'))
+        if maincategory_id:
+            request.session['maincat_id'] = maincategory_id
+            with connections['r'].cursor() as cursor:
+                cursor.execute(GET_SUBCATEGORY_SQL, params=[maincategory_id])
+                subcategory = cursor.fetchall()
+            for obj in subcategory:
+                response = {
+                    'subcategory_id': obj[1],
+                    'subcategory': obj[2],
+                }
+                response_dict.append(response)
+            return HttpResponse(simplejson.dumps(response_dict),
+                                content_type='application/json')
+
+
+def books(request):
+    context = {}
+    response_dict = []
+    if request.is_ajax():
+        main_category_id = int(request.GET.get('maincat_id'))
+        category_id = int(request.GET.get('cat_id'))
+
+        if category_id:
+            # store category_id in cookie/session
+            request.session['subcategory_id'] = category_id
+            request.session['maincat_id'] = main_category_id
+            remove_from_session(request, [
+                'book_id',
+                'chapter_id',
+                'example_id',
+                'commit_sha',
+                'example_file_id',
+                'filepath',
+                'code',
+            ])
+
+            with connections['r'].cursor() as cursor:
+                cursor.execute(GET_TBC_PREFERENCE_SQL,
+                               params=[main_category_id, category_id])
+                books = cursor.fetchall()
+            for obj in books:
+                response = {
+                    'id': obj[1],
+                    'book': obj[4],
+                    'author': obj[5]
+                }
+
+                response_dict.append(response)
+            return HttpResponse(simplejson.dumps(response_dict),
+                                content_type='application/json')
+
+
+def chapters(request):
+    context = {}
+    response_dict = []
+    if request.is_ajax():
+        book_id = int(request.GET.get('book_id'))
+        if book_id:
+            request.session['book_id'] = book_id
+            remove_from_session(request, [
+                'chapter_id',
+                'example_id',
+                'commit_sha',
+                'example_file_id',
+                'filepath',
+                'code',
+            ])
+
+            with connections['r'].cursor() as cursor:
+                cursor.execute(GET_TBC_CHAPTER_SQL, params=[book_id])
+                chapters = cursor.fetchall()
+            for obj in chapters:
+                response = {
+                    'id': obj[0],
+                    'number': obj[1],
+                    'chapter': obj[2],
+
+                }
+                print(obj.name)
+                response_dict.append(response)
+            return HttpResponse(simplejson.dumps(response_dict),
+                                content_type='application/json')
+
+
+def examples(request):
+    context = {}
+    response_dict = []
+    if request.is_ajax():
+        chapter_id = int(request.GET.get('chapter_id'))
+        if chapter_id:
+            request.session['chapter_id'] = chapter_id
+            remove_from_session(request, [
+                'example_id',
+                'commit_sha',
+                'example_file_id',
+                'filepath',
+                'code',
+            ])
+
+            with connections['r'].cursor() as cursor:
+                cursor.execute(GET_TBC_EXAMPLE_SQL, params=[chapter_id])
+                examples = cursor.fetchall()
+            for obj in examples:
+                response = {
+                    'id': obj[0],
+                    'number': obj[1],
+                    'caption': obj[2],
+                }
+                response_dict.append(response)
+            return HttpResponse(simplejson.dumps(response_dict),
+                                content_type='application/json')
+
+
+def revisions(request):
+    commits = {}
+    response_dict = []
+    if request.is_ajax():
+        example_id = int(request.GET.get('example_id'))
+        request.session['example_id'] = example_id
+        remove_from_session(request, [
+            'commit_sha',
+            'example_file_id',
+            'filepath',
+            'code',
+        ])
+
+        with connections['r'].cursor() as cursor:
+            cursor.execute(GET_TBC_EXAMPLE_FILE_SQL, params=[example_id])
+            example_file = cursor.fetchone()
+        example_file_filepath = example_file[4] + '/' + example_file[5]
+        request.session['example_file_id'] = example_file[3]
+        request.session['filepath'] = example_file_filepath
+        commits = utils.get_commits(file_path=example_file_filepath)
+        response = {
+            'commits': commits,
+        }
+        response_dict.append(response)
+        return HttpResponse(simplejson.dumps(response),
+                            content_type='application/json')
+
+
+def code(request):
+    commits = {}
+    response_dict = []
+    if request.is_ajax():
+        commit_sha = request.GET.get('commit_sha')
+        request.session['commit_sha'] = commit_sha
+        remove_from_session(request, [
+            'code',
+        ])
+        code = ''
+        review = ''
+        review_url = ''
+        example_id = request.session['example_id']
+        if not example_id:
+            example_id = int(request.GET.get('example_id'))
+        file_path = request.session['filepath']
+        review = ScilabCloudComment.objects.using('r')\
+            .filter(example=example_id).count()
+        with connections['r'].cursor() as cursor:
+            cursor.execute(GET_TBC_EXAMPLE_FILE_VIEW_SQL, params=[example_id])
+            exmple = cursor.fetchone()
+        review_url = "https://scilab.in/cloud_comments/" + str(example_id)
+        # example_path = UPLOADS_PATH + '/' + file_path
+
+        file = utils.get_file(file_path, commit_sha, main_repo=True)
+        code = base64.b64decode(file['content'])
+        response = {
+            'code': code.decode('UTF-8'),
+            'review': review,
+            'review_url': review_url,
+            'exmple': exmple[1]
+        }
+        # response_dict.append(response)
+        return HttpResponse(simplejson.dumps(response),
+                            content_type='application/json')
+
+
+def contributor(request):
+    context = {}
+    contributor = {}
+    response_dict = []
+    if request.is_ajax():
+        book_id = int(request.GET.get('book_id'))
+
+        with connections['r'].cursor() as cursor:
+            cursor.execute(GET_TBC_CONTRIBUTOR_DETAILS_SQL, params=[book_id])
+            contributor = cursor.fetchone()
+
+        for obj in contributor:
+            response = {
+                "contributor_name": obj[1],
+                "proposal_faculty": obj[2],
+                "proposal_reviewer": obj[3],
+                "proposal_university": obj[4],
+            }
+            response_dict.append(response)
+    return HttpResponse(simplejson.dumps(response),
+                        content_type='application/json')
+
+
+def node(request):
+    context = {}
+    response_dict = []
+    if request.is_ajax():
+        key = request.GET.get('key')
+        response = render_to_string(
+            "node-{0}.html".format(key))
+        return HttpResponse(simplejson.dumps(response),
+                            content_type='application/json')
+
+
+def bug_form(request):
+    context = {}
+    response_dict = []
+    if request.is_ajax():
+        bug_form = request.GET.get('bug_form')
+        form = BugForm()
+        context['form'] = BugForm()
+        context.update(csrf(request))
+        response = render_to_string('bug-form.html', context)
+        return HttpResponse(simplejson.dumps(response),
+                            content_type='application/json')
+
+
+def bug_form_submit(request):
+    context = {}
+    response_dict = []
+    if request.is_ajax():
+        form = request.GET.get('form')
+        cat_id = request.GET.get('cat_id')
+        book_id = request.GET.get('book_id')
+        chapter_id = request.GET.get('chapter_id')
+        ex_id = request.GET.get('ex_id')
+        form = BugForm(deserialize_form(form))
+        print(form)
+        if form.is_valid():
+            comment = form.cleaned_data['description']
+            error = form.cleaned_data['issue']
+            email = form.cleaned_data['email']
+            print(comment)
+            comment_data = TextbookCompanionPreference.objects\
+                .db_manager('r').raw(dedent("""\
+                    SELECT 1 as id, tcp.book as book, tcp.author as author,
+                    tcp.publisher as publisher, tcp.year as year,
+                    tcp.category as category, tce.chapter_id,
+                    tcc.number AS chapter_no, tcc.name AS chapter_name,
+                    tce.number AS example_no, tce.caption AS example_caption
+                    FROM textbook_companion_preference tcp
+                    LEFT JOIN textbook_companion_chapter tcc ON
+                    tcp.id = tcc.preference_id 
+                    LEFT JOIN textbook_companion_example
+                    tce ON tce.chapter_id = tcc.id WHERE tce.id = %s"""),
+                                     [ex_id])
+            book_name = comment_data[0].book
+            book_author = comment_data[0].author
+            book_publisher = comment_data[0].publisher
+            chapter_number = comment_data[0].chapter_no
+            chapter_name = comment_data[0].chapter_name
+            example_number = comment_data[0].example_no
+            example_caption = comment_data[0].example_caption
+            all_cat = False
+            category = catg(comment_data[0].category, all_cat)
+            subcategory = 0
+            error_int = int(error)
+            error = issues[error_int][1]
+            context = {
+                'category': category,
+                'subcategory': subcategory,
+                'error': error,
+                'book': book_name,
+                'author':  book_author,
+                'publisher': book_publisher,
+                'chapter_name': chapter_name,
+                'chapter_no': chapter_number,
+                'example_id': ex_id,
+                'example_caption': example_caption,
+                'example_no': example_number,
+                'comment': comment,
+            }
+            scilab_comment = ScilabCloudComment()
+            scilab_comment.type = error_int
+            scilab_comment.comment = comment
+            scilab_comment.email = email
+            scilab_comment.category = comment_data[0].category
+            scilab_comment.books = book_id
+            scilab_comment.chapter = chapter_id
+            scilab_comment.example = ex_id
+            scilab_comment.save(using='r')
+            subject = "New Cloud Comment"
+            message = render_to_string('email.html', context)
+            from_email = FROM_EMAIL
+            to_email = TO_EMAIL
+            cc_email = CC_EMAIL
+            bcc_email = BCC_EMAIL
+            # Send Emails to, cc, bcc
+            msg = EmailMultiAlternatives(
+                subject,
+                message,
+                from_email,
+                [to_email],
+                bcc=[bcc_email],
+                cc=[cc_email]
+            )
+            msg.content_subtype = "html"
+            msg.send()
+            response = "Thank you for your feedback"
+            return HttpResponse(simplejson.dumps(response),
+                                content_type='application/json')
+# submit revision
+
+
+def revision_form(request):
+
+    context = {}
+    response_dict = []
+    if request.is_ajax():
+        code = request.GET.get('code')
+        code = code.decode('UTF-8')
+        initial_code = request.GET.get('initial_code')
+        request.session['code'] = code.decode('UTF-8')
+
+        if code == initial_code:
+            response = "You have not made any changes"
+            return HttpResponse(simplejson.dumps(response),
+                                content_type='application/json')
+
+        if not request.user.is_anonymous():
+            if 'commit_sha' not in request.session:
+                response = "Please select a revision"
+                return HttpResponse(simplejson.dumps(response),
+                                    content_type='application/json')
+
+            form = RevisionForm()
+            context = {'form': form}
+            context.update(csrf(request))
+            response = render_to_string(
+                'submit-revision.html', context)
+            return HttpResponse(simplejson.dumps(response),
+                                content_type='application/json')
+        else:
+            response = render_to_string(
+                'revision-login.html', {})
+        return HttpResponse(simplejson.dumps(response),
+                            content_type='application/json')
+
+
+# @dajaxice_register
+def revision_error(request):
+    context = {
+        'error_message': 'You have not made any changes',
+    }
+    response = render_to_string(
+        'submit-revision-error.html', context)
+    return HttpResponse(simplejson.dumps(response),
+                        content_type='application/json')
+
+
+def revision_form_submit(request):
+    if request.is_ajax():
+        form = request.GET.get('form')
+        code = request.GET.get('code')
+        code = code.decode('UTF-8')
+
+        form = RevisionForm(deserialize_form(form))
+
+        if form.is_valid():
+
+            commit_message = form.cleaned_data['commit_message']
+            username, email = request.user.username, request.user.email
+
+            # push changes to temp repo
+            # update_file returns True if the push is success.
+            commit_sha = utils.update_file(
+                request.session['filepath'],
+                commit_message,
+                base64.b64encode(code),
+                [username, email],
+                main_repo=False,
+            )
+
+            if commit_sha is not None:
+                # everything is fine
+
+                # save the revision info in database
+                rev = TextbookCompanionRevision(
+                    example_file_id=request.session['example_file_id'],
+                    commit_sha=commit_sha,
+                    commit_message=commit_message,
+                    committer_name=username,
+                    committer_email=email,
+                )
+                rev.save(using='r')
+
+                response = 'submitted successfully! \nYour changes will be'
+                'visible after review.'
+                return HttpResponse(simplejson.dumps(response),
+                                    content_type='application/json')
+        else:
+            response = 'Some error occures.'
+            return HttpResponse(simplejson.dumps(response),
+                                content_type='application/json')
+
+
+def diff(request):
+    if request.is_ajax():
+        diff_commit_sha = request.GET.get('diff_commit_sha')
+        editor_code = request.GET.get('editor_code')
+    context = {}
+    file_path = request.session['filepath']
+    file = utils.get_file(file_path, diff_commit_sha, main_repo=True)
+    code = base64.b64decode(file['content'])
+    response = {
+        'code2': code.decode('UTF-8'),
+    }
+    return HttpResponse(simplejson.dumps(response),
+                        content_type='application/json')
+
+# ------------------------------------------------------------
+# review interface functions
+
+
+def review_revision(request):
+    if request.is_ajax():
+        revision_id = request.GET.get('revision_id')
+        print(revision_id)
+        revision = TextbookCompanionRevision.objects.using(
+            'r').get(id=revision_id)
+        file = utils.get_file(revision.example_file.filepath,
+                              revision.commit_sha, main_repo=False)
+        code = base64.b64decode(file['content'])
+
+        request.session['revision_id'] = revision_id
+
+        example = revision.example_file.example
+        chapter = example.chapter
+        book = chapter.preference
+        category = utils.get_category(book.category)
+
+        response = {
+            'code': code.decode('UTF-8'),
+            'revision': model_to_dict(revision),
+            'example': model_to_dict(example),
+            'chapter': model_to_dict(chapter),
+            'book': model_to_dict(book),
+            'category': category,
+            'createdAt': str(revision.timestamp),
+        }
+        return HttpResponse(simplejson.dumps(response),
+                            content_type='application/json')
+
+
+def push_revision(request):
+    """
+    code: from code editor on review interface
+    """
+    if request.is_ajax():
+        code = request.GET.get('code')
+        code = code.decode('UTF-8')
+        revision = TextbookCompanionRevision.objects.using(
+            'r').get(id=request.session['revision_id'])
+
+        print('pushing to repo')
+        utils.update_file(
+            revision.example_file.filepath,
+            revision.commit_message,
+            base64.b64encode(code.decode('UTF-8')),
+            [revision.committer_name, revision.committer_email],
+            branch='master',
+            main_repo=True)
+
+        print('update push_status')
+        revision.push_status = True
+        revision.save()
+
+        response = 'pushed successfully!'
+
+        return HttpResponse(simplejson.dumps(response),
+                            content_type='application/json')
+
+
+def remove_revision(request):
+    """
+    remove revision from revision database
+    """
+    TextbookCompanionRevision.objects.using('r').get(
+        id=request.session['revision_id']).delete()
+
+    response = 'removed successfully!'
+    return HttpResponse(simplejson.dumps(response),
+                        content_type='application/json')