path: root/routes/uploads.py

# Copyright (c) 2018, George Tokmaji

# Permission to use, copy, modify, and/or distribute this software for any
# purpose with or without fee is hereby granted, provided that the above
# copyright notice and this permission notice appear in all copies.

# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

from ..helpers import *
from .media import *
from .media import _upload_file, _delete_file
from bottle import delete, put
from itertools import chain
import string

_vote_dummy = {
    "voting" : {
        "sum" : 0,
        "count" : 0,
        "votes" : None
        }
    }

def _add_upload(entry : Upload, session : DBSession):
    e = entry.json()
    
    #e.update(_vote_dummy)
    
    e["comments"] = [{**(comment.json()), **_vote_dummy} for comment in session.query(Comment).filter_by(upload=entry)]
    e["files"] = [file.json() for file in session.query(File).filter_by(upload=entry)]
    e["dependencies"] = [] #TODO
    
    votes = session.query(Vote).filter_by(upload=entry)
    e["voting"] = {
        "sum" : sum(i.impact for i in votes),
        "count" : votes.count()
        }
    
    return e

@get("/api/uploads")
def get_uploads():
    ret = {
        "pagination" : {
            "total" : 0,
            "limit" : 50,
            "page" : 1,
            "pages" : 1
            },
        "uploads" : []
        }
    
    session = DBSession()
    for entry in session.query(Upload).order_by(Upload.updated_at.desc()):
        ret["uploads"].append(_add_upload(entry, session))
    
    ret["pagination"]["total"] = ret["pagination"]["limit"] = len(ret["uploads"])
    
    return ret

@post("/api/uploads")
@put("/api/uploads/<id>")
@jwt_auth_required
def post_upload(id=None):
    try:
        session = DBSession()
        if id is not None:
            entry = session.query(Upload).get(id)
            if not entry:
                raise ParryHTTPResponse(status=404)
        else:
            if session.query(Upload).filter_by(title=request_data()["title"]).count():
                raise ParryHTTPResponse("An entry with the specified title already exists", 410)
            
            entry = Upload()
        
        entry.title = request_data()["title"]
        entry.version = request_data()["version"]
        entry.description=request_data()["description"]
        entry.slug = "".join(i for i in request_data()["title"].lower() if i in string.ascii_letters)
        entry.tags = request_data().get("tags", [])
        entry.author = get_user(session)
        
        session.add(entry)
        
        try:
            os.mkdir(os.path.join(os.getcwd(), "media"))
        except FileExistsError:
            pass
        
        file_ids = []
        if "files" in request_data():
            for f in request_data()["files"]:
                try:
                    f = f["id"]
                except TypeError:
                    pass
                if ObjectId.is_valid(f):
                    file_ids.append(ObjectId(f))
                    file = session.query(File).get(ObjectId(f))
                    file.upload = entry
                    session.add(file)
        
        else:
            for file in request.files.values():
                f = _upload_file(file, entry)
                session.add(f)
                file_ids.append(f.id)
        
        for file in session.query(File).filter(File.upload_id == entry.id, ~File.id.in_(file_ids)): # we change the upload above, so we can't use Filter.upload
            session.delete(file)
        
    except KeyError as e:
        session.rollback()
        raise ParryHTTPResponse(f"Missing form value: {e.args[0]}", 400)
    
    session.commit()
    return _add_upload(entry, session)


@get("/api/uploads/<id>")
def get_upload(id):
    session = DBSession()
    entry = session.query(Upload).get(id)
    if entry is not None:
        return _add_upload(entry, session)
    
    raise ParryHTTPResponse(status=404)

@delete("/api/uploads/<id>")
@jwt_auth_required
def delete_upload(id):
    session = DBSession()
    author = get_user(session)
    try:
        entry = session.query(Upload).filter_by(id=id, author=author).one()
    except db.orm.exc.NoResultFound:
        raise ParryHTTPResponse(status=404)
    
    if entry.readonly:
        raise ParryHTTPResponse("Resource is read-only", 403)
    
    session.delete(entry)
    for i in [Comment, Vote]:
        for e in session.query(i).filter_by(upload=entry):
            session.delete(e)
    
    for f in session.query(File).filter_by(upload=entry):
        session.delete(f)
        _delete_file(f)
    
    #TODO: Dependencies
    session.commit()
    session.flush()
    return ParryHTTPResponse(status=204)
        

@get("/api/uploads/<id>/comments")
def get_comments(id):
    session = DBSession()
    upload = session.query(Upload).get(id)
    if upload is None:
        raise ParryHTTPResponse("Invalid upload id", 404)
    
    return {
        "comments" : [{**(comment.json()), **_vote_dummy} for comment in session.query(Comment).filter_by(upload=upload)]
        }

@post("/api/uploads/<id>/comments")
@jwt_auth_required
def post_comments(id):
    session = DBSession()
    upload = session.query(Upload).get(id)
    if upload is None:
        raise ParryHTTPResponse("Invalid upload id", 404)
    
    try:
        
        comment = Comment(
            body=request_data()["body"],
            author=get_user(session),
            upload=upload
            )
    except KeyError as e:
        raise ParryHTTPResponse(f"Missing json value: {e.args[0]}", 400)
    
    session.add(comment)
    session.commit()
    return comment.json()

@delete("/api/uploads/<id>/comments/<comment_id>")
@jwt_auth_required
def delete_comments(id, comment_id):
    session = DBSession()
    try:
        comment = session.query(Comment).filter_by(id=comment_id, author=get_user(session), upload=session.query(Upload).get(id)).one()
    except db.orm.exc.NoResultFound:
        raise ParryHTTPResponse(status=404)
    
    session.delete(comment)
    session.commit()
    return ParryHTTPResponse(status=204)

@get("/api/uploads/<id>/vote")
@jwt_auth_required
def get_vote(id):
    session = DBSession()
    upload = session.query(Upload).get(id)
    if upload is None:
        raise ParryHTTPResponse("Invalid upload id", 404)
    
    try:
        return session.query(Vote).filter_by(upload=upload, author=get_user(session)).one().json()
    except db.orm.exc.NoResultFound:
        raise ParryHTTPResponse(status=404)

@post("/api/uploads/<id>/vote")
@jwt_auth_required
def post_vote(id):
    session = DBSession()
    upload = session.query(Upload).get(id)
    if upload is None:
        raise ParryHTTPResponse("Invalid upload id", 404)
    
    author = get_user(session)
    try:
        vote = session.query(Vote).filter_by(upload=upload, author=author).one()
    except db.orm.exc.NoResultFound:
        vote = Vote(author=author, upload=upload)
    
    vote.impact = request_data()["impact"]
    session.add(vote)
    session.commit()
    return vote.json()