コード例 #1
0
ファイル: __init__.py プロジェクト: drulang/foxleaf
def signup(request):
    if request.method == "POST":
        email = request.POST.get("email")
        if email:
            validate_email(email)
            signup = models.UserSignup(email=email)
            signup.save()
            return json_response({"status": OK})
    else:
        return HttpResponseNotAllowed('Method not allowed')
コード例 #2
0
ファイル: bookviews.py プロジェクト: drulang/foxleaf
def scenefavorite(request, sceneid):
    """
    NOTE: Needs to be in API
    """
    # Not using login_required decorator because this is primarly used in an
    # API manner and I want a 403 returned instead of a redirect
    if not request.user.is_authenticated():
        return HttpResponseForbidden()

    if request.method == "POST":
        scene = get_object_or_404(models.Scene, pk=sceneid)
        request.user.scenefavorites.add(scene)
        request.user.save() 
        return json_response({"status": "OK"})
    elif request.method == "DELETE":
        scene = get_object_or_404(models.Scene, pk=sceneid)
        request.user.scenefavorites.remove(scene)
        request.user.save() 
        return json_response({"status": "OK"})
    else:
        return HttpResponse("User scene favorites")
コード例 #3
0
ファイル: bookviews.py プロジェクト: drulang/foxleaf
 def _delete():
     if art.user != request.user:
         return HttpResponseForbidden("User does not own art")
     else:
         try:
             fq_filename = os.path.join(ART_IMAGE_PATH, art.image.filename)
             os.remove(fq_filename)
         except Exception as e:
             # This is ok. There will be a batch job to remove files no longer
             # associated with anything
             print("Error deleting image file: %s" % e)
         art.delete()
         return json_response({"status": "OK"})
コード例 #4
0
ファイル: bookviews.py プロジェクト: drulang/foxleaf
def artcommentedit(request, commentid):
    if not request.user.is_authenticated():
        resp_data = {
            "status": "ERR",
            "message": "User not logged in",
        }
        return json_response(resp_data)
    elif request.method != "POST":
        return HttpResponseNotAllowed("Method not allowed")

    comment = get_object_or_404(models.Comment, pk=commentid)

    if comment.user != request.user:
        raise HttpResponseForbidden("User is not associated with comment")

    comment_text = request.POST.get("comment") 
    if not comment_text:
        raise ValueError("Comment cannot be empty")

    comment.comment = comment_text
    comment.save()

    return json_response({"status": "OK"})
コード例 #5
0
ファイル: bookviews.py プロジェクト: drulang/foxleaf
def comment(request, commentid):
    if not request.user.is_authenticated():
        return HttpResponseForbidden()
    elif request.method != "DELETE":
        return HttpResponseNotAllowed("Method not allowed")

    comment = get_object_or_404(models.Comment, pk=commentid)

    if comment.user != request.user:
        raise HttpResponseForbidden("User is not associated with comment")

    comment.datedeleted = timezone.now()
    comment.save()

    return json_response({"status": "OK"})
コード例 #6
0
ファイル: bookviews.py プロジェクト: drulang/foxleaf
def commentvote(request, commentid):
    if not request.user.is_authenticated():
        return HttpResponseForbidden()
    elif request.method != "POST":
        return HttpResponseNotAllowed("Method not allowed")

    comment = get_object_or_404(models.Comment, pk=commentid)

    # See if user has commented on art already
    vote = models.CommentVote.objects.filter(
        user_id=request.user.id
    ).filter(
        comment_id=comment.id
    ).first()

    if vote is None:
        vote = models.CommentVote()
        vote.user = request.user
        vote.comment = comment

    vote.votetype_id = request.POST['upvotetype']
    vote.save()

    return json_response({"status": "OK"})
コード例 #7
0
ファイル: bookviews.py プロジェクト: drulang/foxleaf
def scene(request, booktitle):
    if request.method == "POST":
        book = models.Book.objects.filter(title_url=booktitle).first()

        title = request.POST['title'].strip()
        startpage = request.POST['startPage'].strip()
        endpage = request.POST['endPage'].strip()
        text = request.POST['text'].strip()
        nsfw = True if request.POST["nsfw"] == 'true' else False
        scene_type = get_object_or_404(models.SceneType, scenetypcd=request.POST['sceneType'])
        if bool(startpage) != bool(endpage):
            raise ValueError("If one page is passed so must the other")
        else:
            if startpage == "":
                startpage = None
            else:
                startpage = int(startpage)
            if endpage == "":
                endpage = None
            else:
                endpage = int(endpage)

        # Validate
        # Title required for all
        if not title:
            raise ValueError("Title cannot be null or empty")

        if scene_type.scenetypcd == "gnrc":
            if not text:
                raise ValueError("Text is required")
            elif not startpage:
                raise ValueError("StartPage is required")
            elif not endpage:
                raise ValueError("EndPage is required")
            
        # Since other scene types might have start/end pages check 
        if startpage and endpage and (startpage > endpage):
            raise ValueError("Start page must come before end page")

        new_scene = models.Scene(
            user=request.user,
            book=book,
            scenetype=scene_type,
            title=title,
            title_url=string_to_url(title),
            startpage=startpage,
            endpage=endpage,
            text=text,
            nsfw=nsfw,
        )
        new_scene.save()

        # Give user some points
        usertasks.add_point_to_user.delay(request.user.id, "adscn")

        new_scene_url = request.path + "/" + new_scene.title_url
        resp_data = {
            "status": OK,
            "newSceneUrl": new_scene_url,
            "sceneid": new_scene.id,
        }
        return json_response(resp_data)

    if request.method == "GET" and request.META.get("CONTENT_TYPE") == "application/json":
        book = models.Book.objects.filter(title_url=booktitle).first()
        if not book:
            resp_data = err_resp("Book not found")
        else:
            scenes = []
            scenetypcd = request.GET.get("scenetypcd")
            book_scenes = book.scene.filter(scenetype_id=scenetypcd).all()
            for scene in book_scenes:
                scenes.append(scene.dict)

            resp_data = { 
                "scenes": scenes, 
                "status": OK,
            }

        return json_response(resp_data)

    # Default
    return HttpResponse("Scene Page")
コード例 #8
0
ファイル: bookviews.py プロジェクト: drulang/foxleaf
 def _delete():
     if scene.user != request.user:
         return HttpResponseForbidden("User does not own scene")
     else:
         scene.delete()
         return json_response({"status": "OK"})
コード例 #9
0
ファイル: bookviews.py プロジェクト: drulang/foxleaf
def art(request, booktitle):
    if request.method == "POST":
        book = models.Book.objects.filter(title_url=booktitle).first()
        if not book:
            raise ValueError("Unable to find book with title: %s" % booktitle)
        request_file = request.FILES['art-image']
        art_title = request.POST.get("artTitle", "").strip()
        # Validate data
        if not image_type_valid(request_file.content_type):
            raise ValueError("Unsupported content type")
        elif len(art_title) == 0:
            raise ValueError("Title cannot be empty")
        elif request_file.size > MAX_FILE_SIZE:
            raise ValueError("File cannot be greater than 25MB")

        # Create art
        title_url = string_to_url(request.POST['artTitle'])
        filename, ext = os.path.splitext(request_file.name)
        for _ in range(50):
            # Try 50 times to find a filename
            filename = "art_image__" + random_string(length=80) + ext
            fq_filename = os.path.join(ART_IMAGE_PATH, filename)

            if os.path.exists(fq_filename):
                if _ == 49:
                    raise ValueError("Error saving image")
                else:
                    continue
            else:
                break

        # Save file to disk
        handle_uploaded_image(request_file, fq_filename)

        # If successful then create an Image and assign to user
        art_image = models.Image()
        art_image.imagetype = ART_IMAGE_TYPE
        art_image.relativepath = fq_filename
        art_image.filename = filename
        art_image.save()

        # Create Art model
        art = models.Art()
        art.user = request.user
        art.arttype_id = request.POST['artType']
        art.scene_id = request.POST.get("sceneid")
        art.book = book
        art.image = art_image
        art.title = art_title
        art.title_url = title_url
        art.description = request.POST['artText']
        art.nsfw = request.POST.get('nsfw', "f")[0]
        art.save() 

        #
        # TODO: Need to resize and standardize the iamge with a job
        #

        usertasks.add_point_to_user.delay(request.user.id, "adart")

        art_url = "/book/" + book.title_url + "/art/" + art.title_url;
        data = {
           "status": OK,
           "artURL": art_url,
        }
        return json_response(data)
    else:
        return HttpResponse("Art Page")