contentdb/app/views/packages.py

415 lines
13 KiB
Python
Raw Normal View History

2018-03-19 19:08:41 +01:00
from flask import *
from flask_user import *
from flask.ext import menu
from app import app
from app.models import *
2018-03-23 18:33:34 +01:00
from .utils import *
2018-03-20 03:58:31 +01:00
from flask_wtf import FlaskForm
from wtforms import *
2018-03-21 18:42:43 +01:00
from wtforms.validators import *
2018-03-20 03:58:31 +01:00
2018-03-23 18:05:07 +01:00
# TODO: the following could be made into one route, except I"m not sure how
2018-03-20 02:19:19 +01:00
# to do the menu
2018-03-21 21:02:53 +01:00
def doPackageList(type):
2018-03-21 21:10:11 +01:00
title = "Packages"
query = Package.query
2018-03-21 21:02:53 +01:00
2018-03-21 21:10:11 +01:00
if type is not None:
title = type.value + "s"
query = query.filter_by(type=type, approved=True)
2018-03-21 21:02:53 +01:00
2018-03-21 21:10:11 +01:00
search = request.args.get("q")
if search is not None:
query = query.filter(Package.title.contains(search))
2018-03-23 18:33:34 +01:00
if shouldReturnJson():
return jsonify([package.getAsDictionary(app.config["BASE_URL"]) for package in query.all()])
2018-03-23 18:33:34 +01:00
else:
return render_template("packages/list.html", title=title, packages=query.all(), query=search)
2018-03-21 21:10:11 +01:00
2018-03-21 23:03:37 +01:00
@app.route("/packages/")
2018-03-21 21:10:11 +01:00
def packages_page():
2018-03-23 18:33:34 +01:00
type = None
typeStr = request.args.get("type")
if typeStr is not None:
type = PackageType[typeStr.upper()]
return doPackageList(type)
2018-03-21 21:02:53 +01:00
2018-03-21 23:03:37 +01:00
@app.route("/mods/")
@menu.register_menu(app, ".mods", "Mods", order=11)
2018-03-19 19:08:41 +01:00
def mods_page():
2018-03-21 21:02:53 +01:00
return doPackageList(PackageType.MOD)
2018-03-19 19:08:41 +01:00
2018-03-21 23:03:37 +01:00
@app.route("/games/")
@menu.register_menu(app, ".games", "Games", order=12)
2018-03-20 01:44:47 +01:00
def games_page():
2018-03-21 21:02:53 +01:00
return doPackageList(PackageType.GAME)
2018-03-20 01:44:47 +01:00
2018-03-21 23:03:37 +01:00
@app.route("/texturepacks/")
@menu.register_menu(app, ".txp", "Texture Packs", order=13)
2018-03-20 01:44:47 +01:00
def txp_page():
2018-03-21 21:02:53 +01:00
return doPackageList(PackageType.TXP)
2018-03-20 01:44:47 +01:00
2018-03-21 20:24:45 +01:00
def canSeeWorkQueue():
return Permission.APPROVE_NEW.check(current_user) or \
Permission.APPROVE_RELEASE.check(current_user) or \
Permission.APPROVE_CHANGES.check(current_user)
2018-03-21 20:24:45 +01:00
2018-03-21 23:03:37 +01:00
@menu.register_menu(app, ".todo", "Work Queue", order=20, visible_when=canSeeWorkQueue)
2018-03-21 20:24:45 +01:00
@app.route("/todo/")
@login_required
def todo_page():
canApproveNew = Permission.APPROVE_NEW.check(current_user)
canApproveRel = Permission.APPROVE_RELEASE.check(current_user)
packages = None
if canApproveNew:
packages = Package.query.filter_by(approved=False).all()
releases = None
if canApproveRel:
releases = PackageRelease.query.filter_by(approved=False).all()
2018-03-21 23:03:37 +01:00
return render_template("todo.html", title="Reports and Work Queue",
approve_new=packages, releases=releases,
canApproveNew=canApproveNew, canApproveRel=canApproveRel)
2018-03-21 20:24:45 +01:00
2018-03-20 02:19:19 +01:00
2018-03-20 03:58:31 +01:00
def getPageByInfo(type, author, name):
user = User.query.filter_by(username=author).first()
if user is None:
abort(404)
package = Package.query.filter_by(name=name, author_id=user.id,
2018-03-20 05:11:50 +01:00
type=PackageType[type.upper()]).first()
2018-03-19 19:08:41 +01:00
if package is None:
abort(404)
2018-03-20 03:58:31 +01:00
return package
2018-03-20 19:20:30 +01:00
def getReleases(package):
if package.checkPerm(current_user, Permission.MAKE_RELEASE):
return package.releases
else:
return [rel for rel in package.releases if rel.approved]
2018-03-20 03:58:31 +01:00
@app.route("/<type>s/<author>/<name>/")
def package_page(type, author, name):
package = getPageByInfo(type, author, name)
2018-03-20 19:20:30 +01:00
2018-03-23 18:33:34 +01:00
if shouldReturnJson():
return jsonify(package.getAsDictionary(app.config["BASE_URL"]))
2018-03-23 18:33:34 +01:00
else:
releases = getReleases(package)
2018-03-23 20:49:57 +01:00
requests = [r for r in package.requests if r.status == 0]
return render_template("packages/view.html", package=package, releases=releases, requests=requests)
2018-03-23 18:33:34 +01:00
2018-03-20 03:58:31 +01:00
2018-03-23 17:20:56 +01:00
@app.route("/<type>s/<author>/<name>/download/")
def package_download_page(type, author, name):
package = getPageByInfo(type, author, name)
release = package.getDownloadRelease()
if release is None:
2018-03-23 18:33:34 +01:00
if "application/zip" in request.accept_mimetypes and \
not "text/html" in request.accept_mimetypes:
2018-03-23 17:20:56 +01:00
return "", 204
else:
flash("No download available.", "error")
return redirect(package.getDetailsURL())
else:
return redirect(release.url, code=302)
2018-03-20 03:58:31 +01:00
class PackageForm(FlaskForm):
2018-03-23 20:08:55 +01:00
name = StringField("Name", [InputRequired(), Length(1, 20), Regexp("^[a-z0-9_]", 0, "Lower case letters (a-z), digits (0-9), and underscores (_) only")])
title = StringField("Title", [InputRequired(), Length(3, 50)])
shortDesc = StringField("Short Description", [InputRequired(), Length(1,200)])
desc = TextAreaField("Long Description", [Optional(), Length(0,10000)])
type = SelectField("Type", [InputRequired()], choices=PackageType.choices(), coerce=PackageType.coerce, default=PackageType.MOD)
repo = StringField("Repo URL", [Optional(), URL()])
website = StringField("Website URL", [Optional(), URL()])
2018-03-21 18:42:43 +01:00
issueTracker = StringField("Issue Tracker URL", [Optional(), URL()])
2018-03-23 20:08:55 +01:00
forums = IntegerField("Forum Topic ID", [InputRequired(), NumberRange(0,999999)])
submit = SubmitField("Save")
2018-03-20 03:58:31 +01:00
2018-03-21 23:03:37 +01:00
@menu.register_menu(app, ".new", "Create", order=21, visible_when=lambda: current_user.is_authenticated)
@app.route("/new/", methods=["GET", "POST"])
@app.route("/<type>s/<author>/<name>/edit/", methods=["GET", "POST"])
2018-03-20 03:58:31 +01:00
@login_required
2018-03-21 18:03:14 +01:00
def create_edit_package_page(type=None, author=None, name=None):
package = None
form = None
if type is None:
form = PackageForm(formdata=request.form)
else:
package = getPageByInfo(type, author, name)
if not package.checkPerm(current_user, Permission.EDIT_PACKAGE):
return redirect(package.getDetailsURL())
form = PackageForm(formdata=request.form, obj=package)
2018-03-20 03:58:31 +01:00
# Initial form class from post data and default data
if request.method == "POST" and form.validate():
# Successfully submitted!
2018-03-21 18:03:14 +01:00
if not package:
package = Package()
package.author = current_user
2018-03-21 20:03:14 +01:00
# package.approved = package.checkPerm(current_user, Permission.APPROVE_NEW)
2018-03-21 18:03:14 +01:00
2018-03-20 03:58:31 +01:00
form.populate_obj(package) # copy to row
db.session.commit() # save
return redirect(package.getDetailsURL()) # redirect
2018-03-23 15:07:13 +01:00
return render_template("packages/create_edit.html", package=package, form=form)
2018-03-20 19:40:19 +01:00
2018-03-21 20:03:14 +01:00
@app.route("/<type>s/<author>/<name>/approve/")
@login_required
def approve_package_page(type=None, author=None, name=None):
package = getPageByInfo(type, author, name)
if not package.checkPerm(current_user, Permission.APPROVE_NEW):
flash("You don't have permission to do that.", "error")
elif package.approved:
flash("Package has already been approved", "error")
else:
package.approved = True
db.session.commit()
return redirect(package.getDetailsURL())
2018-03-20 19:40:19 +01:00
2018-03-26 11:52:25 +02:00
class CreateScreenshotForm(FlaskForm):
title = StringField("Title/Caption", [Optional()])
fileUpload = FileField("File Upload", [InputRequired()])
submit = SubmitField("Save")
@app.route("/<type>s/<author>/<name>/screenshots/new/", methods=["GET", "POST"])
@login_required
def create_screenshot_page(type, author, name):
package = getPageByInfo(type, author, name)
if not package.checkPerm(current_user, Permission.MAKE_RELEASE):
return redirect(package.getDetailsURL())
# Initial form class from post data and default data
form = CreateScreenshotForm()
if request.method == "POST" and form.validate():
uploadedPath = doFileUpload(form.fileUpload.data, ["png", "jpg", "jpeg"],
"a PNG or JPG image file")
if uploadedPath is not None:
ss = PackageScreenshot()
ss.package = package
ss.title = form["title"].data
ss.url = uploadedPath
db.session.add(ss)
db.session.commit()
return redirect(package.getDetailsURL())
return render_template("packages/screenshot_new.html", package=package, form=form)
2018-03-23 20:08:55 +01:00
class EditRequestForm(PackageForm):
edit_title = StringField("Edit Title", [InputRequired(), Length(1, 100)])
edit_desc = TextField("Edit Description", [Optional()])
class UnresolvedPackage(Package):
edit_title = ""
edit_desc = ""
@app.route("/<ptype>s/<author>/<name>/requests/new/", methods=["GET","POST"])
@login_required
2018-03-23 20:25:48 +01:00
def create_editrequest_page(ptype, author, name):
2018-03-23 20:08:55 +01:00
package = getPageByInfo(ptype, author, name)
form = EditRequestForm(request.form, obj=package)
if request.method == "POST" and form.validate():
editedPackage = UnresolvedPackage()
form.populate_obj(editedPackage)
erequest = EditRequest()
erequest.package = package
erequest.author = current_user
erequest.title = editedPackage.edit_title
erequest.desc = editedPackage.edit_desc
db.session.add(erequest)
wasChangeMade = False
for e in PackagePropertyKey:
newValue = getattr(editedPackage, e.name)
oldValue = getattr(package, e.name)
newValueComp = newValue
oldValueComp = oldValue
if type(newValue) is str:
newValue = newValue.replace("\r\n", "\n")
newValueComp = newValue.strip()
2018-03-23 20:49:57 +01:00
oldValueComp = "" if oldValue is None else oldValue.strip()
2018-03-23 20:08:55 +01:00
if newValueComp != oldValueComp:
change = EditRequestChange()
change.request = erequest
change.key = e
2018-03-23 20:49:57 +01:00
change.oldValue = str(oldValue)
change.newValue = str(newValue)
2018-03-23 20:08:55 +01:00
db.session.add(change)
wasChangeMade = True
if wasChangeMade:
db.session.commit()
2018-03-23 20:49:57 +01:00
return redirect(erequest.getURL())
2018-03-23 20:08:55 +01:00
else:
flash("No changes detected", "warning")
2018-03-23 20:25:48 +01:00
return render_template("packages/editrequest_create.html", package=package, form=form)
@app.route("/<ptype>s/<author>/<name>/requests/<id>/")
def view_editrequest_page(ptype, author, name, id):
package = getPageByInfo(ptype, author, name)
erequest = EditRequest.query.filter_by(id=id).first()
if erequest is None:
abort(404)
return render_template("packages/editrequest_view.html", package=package, request=erequest)
2018-03-23 20:08:55 +01:00
2018-03-23 20:49:57 +01:00
@app.route("/<ptype>s/<author>/<name>/requests/<id>/approve/")
def approve_editrequest_page(ptype, author, name, id):
package = getPageByInfo(ptype, author, name)
if not package.checkPerm(current_user, Permission.APPROVE_CHANGES):
flash("You don't have permission to do that.", "error")
return redirect(package.getDetailsURL())
erequest = EditRequest.query.filter_by(id=id).first()
if erequest is None:
abort(404)
if erequest.status != 0:
flash("Edit request has already been resolved", "error")
else:
erequest.status = 1
erequest.applyAll(package)
db.session.commit()
return redirect(package.getDetailsURL())
@app.route("/<ptype>s/<author>/<name>/requests/<id>/reject/")
def reject_editrequest_page(ptype, author, name, id):
package = getPageByInfo(ptype, author, name)
if not package.checkPerm(current_user, Permission.APPROVE_CHANGES):
flash("You don't have permission to do that.", "error")
return redirect(package.getDetailsURL())
erequest = EditRequest.query.filter_by(id=id).first()
if erequest is None:
abort(404)
if erequest.status != 0:
flash("Edit request has already been resolved", "error")
else:
erequest.status = 2
db.session.commit()
return redirect(package.getDetailsURL())
class CreatePackageReleaseForm(FlaskForm):
2018-03-23 20:08:55 +01:00
name = StringField("Name")
title = StringField("Title")
uploadOpt = RadioField ("File", choices=[("vcs", "From VCS Commit or Branch"), ("upload", "File Upload")])
vcsLabel = StringField("VCS Commit or Branch", default="master")
fileUpload = FileField("File Upload")
2018-03-23 18:05:07 +01:00
submit = SubmitField("Save")
2018-03-20 19:40:19 +01:00
class EditPackageReleaseForm(FlaskForm):
2018-03-23 20:08:55 +01:00
name = StringField("Name")
title = StringField("Title")
url = StringField("URL", [URL])
approved = BooleanField("Is Approved")
submit = SubmitField("Save")
2018-03-21 23:03:37 +01:00
@app.route("/<type>s/<author>/<name>/releases/new/", methods=["GET", "POST"])
2018-03-20 19:40:19 +01:00
@login_required
def create_release_page(type, author, name):
package = getPageByInfo(type, author, name)
if not package.checkPerm(current_user, Permission.MAKE_RELEASE):
return redirect(package.getDetailsURL())
# Initial form class from post data and default data
2018-03-23 18:05:07 +01:00
form = CreatePackageReleaseForm()
2018-03-20 19:40:19 +01:00
if request.method == "POST" and form.validate():
2018-03-23 18:05:07 +01:00
for key, value in request.files.items() :
print (key, value)
2018-03-20 19:40:19 +01:00
if form["uploadOpt"].data == "vcs":
rel = PackageRelease()
rel.package = package
rel.title = form["title"].data
rel.url = form["vcsLabel"].data
# TODO: get URL to commit from branch name
db.session.commit()
2018-03-23 18:05:07 +01:00
return redirect(package.getDetailsURL())
2018-03-20 19:40:19 +01:00
else:
2018-03-26 11:52:25 +02:00
uploadedPath = doFileUpload(form.fileUpload.data, ["zip"], "a zip file")
if uploadedPath is not None:
2018-03-23 18:05:07 +01:00
rel = PackageRelease()
rel.package = package
rel.title = form["title"].data
2018-03-26 11:52:25 +02:00
rel.url = uploadedPath
db.session.add(rel)
2018-03-23 18:05:07 +01:00
db.session.commit()
return redirect(package.getDetailsURL())
2018-03-20 19:40:19 +01:00
2018-03-23 15:07:13 +01:00
return render_template("packages/release_new.html", package=package, form=form)
2018-03-21 23:03:37 +01:00
@app.route("/<type>s/<author>/<name>/releases/<id>/", methods=["GET", "POST"])
@login_required
def edit_release_page(type, author, name, id):
user = User.query.filter_by(username=author).first()
if user is None:
abort(404)
release = PackageRelease.query.filter_by(id=id).first()
if release is None:
abort(404)
package = release.package
if package.name != name or package.type != PackageType[type.upper()]:
abort(404)
2018-03-23 18:05:07 +01:00
canEdit = package.checkPerm(current_user, Permission.MAKE_RELEASE)
canApprove = package.checkPerm(current_user, Permission.APPROVE_RELEASE)
if not (canEdit or canApprove):
return redirect(package.getDetailsURL())
# Initial form class from post data and default data
form = EditPackageReleaseForm(formdata=request.form, obj=release)
if request.method == "POST" and form.validate():
wasApproved = release.approved
if canEdit:
release.title = form["title"].data
if package.checkPerm(current_user, Permission.CHANGE_RELEASE_URL):
release.url = form["url"].data
if canApprove:
release.approved = form["approved"].data
else:
release.approved = wasApproved
db.session.commit()
return redirect(package.getDetailsURL())
2018-03-23 15:07:13 +01:00
return render_template("packages/release_edit.html", package=package, release=release, form=form)