app/views/packages.py

   1 # Content DB
   2 # Copyright (C) 2018  rubenwardy
   3 #
   4 # This program is free software: you can redistribute it and/or modify
   5 # it under the terms of the GNU General Public License as published by
   6 # the Free Software Foundation, either version 3 of the License, or
   7 # (at your option) any later version.
   8 #
   9 # This program is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 # GNU General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU General Public License
  15 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
  16
  17
  18 from flask import *
  19 from flask_user import *
  20 from flask.ext import menu
  21 from app import app
  22 from app.models import *
  23 from app.tasks.importtasks import importRepoScreenshot, makeVCSRelease
  24
  25 from app.utils import *
  26
  27 from celery import uuid
  28 from flask_wtf import FlaskForm
  29 from wtforms import *
  30 from wtforms.validators import *
  31 from wtforms.ext.sqlalchemy.fields import QuerySelectField, QuerySelectMultipleField
  32
  33
  34 # TODO: the following could be made into one route, except I"m not sure how
  35 # to do the menu
  36
  37 @menu.register_menu(app, ".mods", "Mods", order=11, endpoint_arguments_constructor=lambda: { 'type': 'mod' })
  38 @menu.register_menu(app, ".games", "Games", order=12, endpoint_arguments_constructor=lambda: { 'type': 'game' })
  39 @menu.register_menu(app, ".txp", "Texture Packs", order=13, endpoint_arguments_constructor=lambda: { 'type': 'txp' })
  40 @app.route("/packages/")
  41 def packages_page():
  42         type = request.args.get("type")
  43         if type is not None:
  44                 type = PackageType[type.upper()]
  45
  46         title = "Packages"
  47         query = Package.query
  48
  49         if type is not None:
  50                 title = type.value + "s"
  51                 query = query.filter_by(type=type, approved=True)
  52
  53         search = request.args.get("q")
  54         if search is not None:
  55                 query = query.filter(Package.title.contains(search))
  56
  57         if shouldReturnJson():
  58                 pkgs = [package.getAsDictionary(app.config["BASE_URL"]) \
  59                                 for package in query.all() if package.getDownloadRelease() is not None]
  60                 return jsonify(pkgs)
  61         else:
  62                 tags = Tag.query.all()
  63                 return render_template("packages/list.html", title=title, packages=query.all(), \
  64                                 query=search, tags=tags, type=None if type is None else type.toName())
  65
  66 @app.route("/todo/")
  67 @login_required
  68 def todo_page():
  69         canApproveNew = Permission.APPROVE_NEW.check(current_user)
  70         canApproveRel = Permission.APPROVE_RELEASE.check(current_user)
  71
  72         packages = None
  73         if canApproveNew:
  74                 packages = Package.query.filter_by(approved=False).all()
  75
  76         releases = None
  77         if canApproveRel:
  78                 releases = PackageRelease.query.filter_by(approved=False).all()
  79
  80         return render_template("todo.html", title="Reports and Work Queue",
  81                 approve_new=packages, releases=releases,
  82                 canApproveNew=canApproveNew, canApproveRel=canApproveRel)
  83
  84 def getReleases(package):
  85         if package.checkPerm(current_user, Permission.MAKE_RELEASE):
  86                 return package.releases
  87         else:
  88                 return [rel for rel in package.releases if rel.approved]
  89
  90
  91 @app.route("/packages/<author>/<name>/")
  92 @is_package_page
  93 def package_page(package):
  94         if shouldReturnJson():
  95                 return jsonify(package.getAsDictionary(app.config["BASE_URL"]))
  96         else:
  97                 clearNotifications(package.getDetailsURL())
  98
  99                 releases = getReleases(package)
 100                 requests = [r for r in package.requests if r.status == 0]
 101                 return render_template("packages/view.html", package=package, releases=releases, requests=requests)
 102
 103
 104 @app.route("/packages/<author>/<name>/download/")
 105 @is_package_page
 106 def package_download_page(package):
 107         release = package.getDownloadRelease()
 108
 109         if release is None:
 110                 if "application/zip" in request.accept_mimetypes and \
 111                                 not "text/html" in request.accept_mimetypes:
 112                         return "", 204
 113                 else:
 114                         flash("No download available.", "error")
 115                         return redirect(package.getDetailsURL())
 116         else:
 117                 return redirect(release.url, code=302)
 118
 119
 120 class PackageForm(FlaskForm):
 121         name          = StringField("Name", [InputRequired(), Length(1, 20), Regexp("^[a-z0-9_]", 0, "Lower case letters (a-z), digits (0-9), and underscores (_) only")])
 122         title         = StringField("Title", [InputRequired(), Length(3, 50)])
 123         shortDesc     = StringField("Short Description", [InputRequired(), Length(1,200)])
 124         desc          = TextAreaField("Long Description", [Optional(), Length(0,10000)])
 125         type          = SelectField("Type", [InputRequired()], choices=PackageType.choices(), coerce=PackageType.coerce, default=PackageType.MOD)
 126         license       = QuerySelectField("License", [InputRequired()], query_factory=lambda: License.query, get_pk=lambda a: a.id, get_label=lambda a: a.name)
 127         tags          = QuerySelectMultipleField('Tags', query_factory=lambda: Tag.query.order_by(db.asc(Tag.name)), get_pk=lambda a: a.id, get_label=lambda a: a.title)
 128         harddeps      = QuerySelectMultipleField('Dependencies', query_factory=lambda: Package.query.join(User).order_by(db.asc(Package.title), db.asc(User.display_name)), get_pk=lambda a: a.id, get_label=lambda a: a.title + " by " + a.author.display_name)
 129         softdeps      = QuerySelectMultipleField('Soft Dependencies', query_factory=lambda: Package.query.join(User).order_by(db.asc(Package.title), db.asc(User.display_name)), get_pk=lambda a: a.id, get_label=lambda a: a.title + " by " + a.author.display_name)
 130         repo          = StringField("Repo URL", [Optional(), URL()])
 131         website       = StringField("Website URL", [Optional(), URL()])
 132         issueTracker  = StringField("Issue Tracker URL", [Optional(), URL()])
 133         forums        = IntegerField("Forum Topic ID", [Optional(), NumberRange(0,999999)])
 134         submit        = SubmitField("Save")
 135
 136 @app.route("/packages/new/", methods=["GET", "POST"])
 137 @app.route("/packages/<author>/<name>/edit/", methods=["GET", "POST"])
 138 @login_required
 139 def create_edit_package_page(author=None, name=None):
 140         package = None
 141         form = None
 142         if author is None:
 143                 form = PackageForm(formdata=request.form)
 144                 author = request.args.get("author")
 145                 if author is None or author == current_user.username:
 146                         author = current_user
 147                 else:
 148                         author = User.query.filter_by(username=author).first()
 149                         if author is None:
 150                                 flash("Unable to find that user", "error")
 151                                 return redirect(url_for("create_edit_package_page"))
 152
 153                         if not author.checkPerm(current_user, Permission.CHANGE_AUTHOR):
 154                                 flash("Permission denied", "error")
 155                                 return redirect(url_for("create_edit_package_page"))
 156
 157         else:
 158                 package = getPackageByInfo(author, name)
 159                 if not package.checkPerm(current_user, Permission.EDIT_PACKAGE):
 160                         return redirect(package.getDetailsURL())
 161
 162                 author = package.author
 163
 164                 form = PackageForm(formdata=request.form, obj=package)
 165
 166         # Initial form class from post data and default data
 167         if request.method == "POST" and form.validate():
 168                 wasNew = False
 169                 if not package:
 170                         package = Package.query.filter_by(name=form["name"].data, author_id=author.id).first()
 171                         if package is not None:
 172                                 flash("Package already exists!", "error")
 173                                 return redirect(url_for("create_edit_package_page"))
 174
 175                         package = Package()
 176                         package.author = author
 177                         wasNew = True
 178                 else:
 179                         triggerNotif(package.author, current_user,
 180                                         "{} edited".format(package.title), package.getDetailsURL())
 181
 182                 form.populate_obj(package) # copy to row
 183
 184                 package.tags.clear()
 185                 for tag in form.tags.raw_data:
 186                         package.tags.append(Tag.query.get(tag))
 187
 188                 db.session.commit() # save
 189
 190                 if wasNew and package.canImportScreenshot():
 191                         task = importRepoScreenshot.delay(package.id)
 192                         return redirect(url_for("check_task", id=task.id, r=package.getDetailsURL()))
 193
 194                 return redirect(package.getDetailsURL())
 195
 196         enableWizard = name is None and request.method != "POST"
 197         return render_template("packages/create_edit.html", package=package, \
 198                         form=form, author=author, enable_wizard=enableWizard)
 199
 200 @app.route("/packages/<author>/<name>/approve/", methods=["POST"])
 201 @login_required
 202 @is_package_page
 203 def approve_package_page(package):
 204         if not package.checkPerm(current_user, Permission.APPROVE_NEW):
 205                 flash("You don't have permission to do that.", "error")
 206
 207         elif package.approved:
 208                 flash("Package has already been approved", "error")
 209
 210         else:
 211                 package.approved = True
 212
 213                 triggerNotif(package.author, current_user,
 214                                 "{} approved".format(package.title), package.getDetailsURL())
 215                 db.session.commit()
 216
 217         return redirect(package.getDetailsURL())
 218
 219 class CreateScreenshotForm(FlaskForm):
 220         title      = StringField("Title/Caption", [Optional()])
 221         fileUpload = FileField("File Upload", [InputRequired()])
 222         submit     = SubmitField("Save")
 223
 224 @app.route("/packages/<author>/<name>/screenshots/new/", methods=["GET", "POST"])
 225 @login_required
 226 @is_package_page
 227 def create_screenshot_page(package):
 228         if not package.checkPerm(current_user, Permission.MAKE_RELEASE):
 229                 return redirect(package.getDetailsURL())
 230
 231         # Initial form class from post data and default data
 232         form = CreateScreenshotForm()
 233         if request.method == "POST" and form.validate():
 234                 uploadedPath = doFileUpload(form.fileUpload.data, ["png", "jpg", "jpeg"],
 235                                 "a PNG or JPG image file")
 236                 if uploadedPath is not None:
 237                         ss = PackageScreenshot()
 238                         ss.package = package
 239                         ss.title   = form["title"].data
 240                         ss.url     = uploadedPath
 241                         db.session.add(ss)
 242
 243                         msg = "{}: Screenshot added {}" \
 244                                         .format(package.title, ss.title)
 245                         triggerNotif(package.author, current_user, msg, package.getDetailsURL())
 246                         db.session.commit()
 247                         return redirect(package.getDetailsURL())
 248
 249         return render_template("packages/screenshot_new.html", package=package, form=form)
 250
 251
 252 class EditRequestForm(PackageForm):
 253         edit_title = StringField("Edit Title", [InputRequired(), Length(1, 100)])
 254         edit_desc  = TextField("Edit Description", [Optional()])
 255
 256 @app.route("/packages/<author>/<name>/requests/new/", methods=["GET","POST"])
 257 @app.route("/packages/<author>/<name>/requests/<id>/edit/", methods=["GET","POST"])
 258 @login_required
 259 @is_package_page
 260 def create_edit_editrequest_page(package, id=None):
 261         edited_package = package
 262
 263         erequest = None
 264         if id is not None:
 265                 erequest = EditRequest.query.get(id)
 266                 if erequest.package != package:
 267                         abort(404)
 268
 269                 if not erequest.checkPerm(current_user, Permission.EDIT_EDITREQUEST):
 270                         abort(403)
 271
 272                 if erequest.status != 0:
 273                         flash("Can't edit EditRequest, it has already been merged or rejected", "error")
 274                         return redirect(erequest.getURL())
 275
 276                 edited_package = Package(package)
 277                 erequest.applyAll(edited_package)
 278
 279
 280         form = EditRequestForm(request.form, obj=edited_package)
 281         if request.method == "POST" and form.validate():
 282                 if erequest is None:
 283                         erequest = EditRequest()
 284                         erequest.package = package
 285                         erequest.author  = current_user
 286
 287                 erequest.title   = form["edit_title"].data
 288                 erequest.desc    = form["edit_desc"].data
 289                 db.session.add(erequest)
 290
 291                 EditRequestChange.query.filter_by(request=erequest).delete()
 292
 293                 wasChangeMade = False
 294                 for e in PackagePropertyKey:
 295                         newValue = form[e.name].data
 296                         oldValue = getattr(package, e.name)
 297
 298                         newValueComp = newValue
 299                         oldValueComp = oldValue
 300                         if type(newValue) is str:
 301                                 newValue = newValue.replace("\r\n", "\n")
 302                                 newValueComp = newValue.strip()
 303                                 oldValueComp = "" if oldValue is None else oldValue.strip()
 304
 305                         if newValueComp != oldValueComp:
 306                                 change = EditRequestChange()
 307                                 change.request = erequest
 308                                 change.key = e
 309                                 change.oldValue = e.convert(oldValue)
 310                                 change.newValue = e.convert(newValue)
 311                                 db.session.add(change)
 312                                 wasChangeMade = True
 313
 314                 if wasChangeMade:
 315                         msg = "{}: Edit request #{} {}" \
 316                                         .format(package.title, erequest.id, "created" if id is None else "edited")
 317                         triggerNotif(package.author, current_user, msg, erequest.getURL())
 318                         triggerNotif(erequest.author, current_user, msg, erequest.getURL())
 319                         db.session.commit()
 320                         return redirect(erequest.getURL())
 321                 else:
 322                         flash("No changes detected", "warning")
 323         elif erequest is not None:
 324                 form["edit_title"].data = erequest.title
 325                 form["edit_desc"].data  = erequest.desc
 326
 327         return render_template("packages/editrequest_create_edit.html", package=package, form=form)
 328
 329
 330 @app.route("/packages/<author>/<name>/requests/<id>/")
 331 @is_package_page
 332 def view_editrequest_page(package, id):
 333         erequest = EditRequest.query.get(id)
 334         if erequest is None or erequest.package != package:
 335                 abort(404)
 336
 337         clearNotifications(erequest.getURL())
 338         return render_template("packages/editrequest_view.html", package=package, request=erequest)
 339
 340
 341 @app.route("/packages/<author>/<name>/requests/<id>/approve/", methods=["POST"])
 342 @is_package_page
 343 def approve_editrequest_page(package, id):
 344         if not package.checkPerm(current_user, Permission.APPROVE_CHANGES):
 345                 flash("You don't have permission to do that.", "error")
 346                 return redirect(package.getDetailsURL())
 347
 348         erequest = EditRequest.query.get(id)
 349         if erequest is None or erequest.package != package:
 350                 abort(404)
 351
 352         if erequest.status != 0:
 353                 flash("Edit request has already been resolved", "error")
 354
 355         else:
 356                 erequest.status = 1
 357                 erequest.applyAll(package)
 358
 359                 msg = "{}: Edit request #{} merged".format(package.title, erequest.id)
 360                 triggerNotif(erequest.author, current_user, msg, erequest.getURL())
 361                 triggerNotif(package.author, current_user, msg, erequest.getURL())
 362                 db.session.commit()
 363
 364         return redirect(package.getDetailsURL())
 365
 366 @app.route("/packages/<author>/<name>/requests/<id>/reject/", methods=["POST"])
 367 @is_package_page
 368 def reject_editrequest_page(package, id):
 369         if not package.checkPerm(current_user, Permission.APPROVE_CHANGES):
 370                 flash("You don't have permission to do that.", "error")
 371                 return redirect(package.getDetailsURL())
 372
 373         erequest = EditRequest.query.get(id)
 374         if erequest is None or erequest.package != package:
 375                 abort(404)
 376
 377         if erequest.status != 0:
 378                 flash("Edit request has already been resolved", "error")
 379
 380         else:
 381                 erequest.status = 2
 382
 383                 msg = "{}: Edit request #{} rejected".format(package.title, erequest.id)
 384                 triggerNotif(erequest.author, current_user, msg, erequest.getURL())
 385                 triggerNotif(package.author, current_user, msg, erequest.getURL())
 386                 db.session.commit()
 387
 388         return redirect(package.getDetailsURL())
 389
 390
 391 class CreatePackageReleaseForm(FlaskForm):
 392         name       = StringField("Name")
 393         title      = StringField("Title")
 394         uploadOpt  = RadioField ("Method", choices=[("upload", "File Upload")], default="upload")
 395         vcsLabel   = StringField("VCS Commit or Branch", default="master")
 396         fileUpload = FileField("File Upload")
 397         submit     = SubmitField("Save")
 398
 399 class EditPackageReleaseForm(FlaskForm):
 400         name     = StringField("Name")
 401         title    = StringField("Title")
 402         url      = StringField("URL", [URL])
 403         task_id  = StringField("Task ID")
 404         approved = BooleanField("Is Approved")
 405         submit   = SubmitField("Save")
 406
 407 @app.route("/packages/<author>/<name>/releases/new/", methods=["GET", "POST"])
 408 @login_required
 409 @is_package_page
 410 def create_release_page(package):
 411         if not package.checkPerm(current_user, Permission.MAKE_RELEASE):
 412                 return redirect(package.getDetailsURL())
 413
 414         # Initial form class from post data and default data
 415         form = CreatePackageReleaseForm()
 416         if package.canMakeReleaseFromVCS():
 417                 form["uploadOpt"].choices = [("vcs", "From VCS Commit or Branch"), ("upload", "File Upload")]
 418                 if request.method != "POST":
 419                         form["uploadOpt"].data = "vcs"
 420
 421         if request.method == "POST" and form.validate():
 422                 if form["uploadOpt"].data == "vcs":
 423                         rel = PackageRelease()
 424                         rel.package = package
 425                         rel.title   = form["title"].data
 426                         rel.url     = ""
 427                         rel.task_id = uuid()
 428                         db.session.add(rel)
 429                         db.session.commit()
 430
 431                         makeVCSRelease.apply_async((rel.id, form["vcsLabel"].data), task_id=rel.task_id)
 432
 433                         msg = "{}: Release {} created".format(package.title, rel.title)
 434                         triggerNotif(package.author, current_user, msg, rel.getEditURL())
 435                         db.session.commit()
 436
 437                         return redirect(url_for("check_task", id=rel.task_id, r=rel.getEditURL()))
 438                 else:
 439                         uploadedPath = doFileUpload(form.fileUpload.data, ["zip"], "a zip file")
 440                         if uploadedPath is not None:
 441                                 rel = PackageRelease()
 442                                 rel.package = package
 443                                 rel.title = form["title"].data
 444                                 rel.url = uploadedPath
 445                                 db.session.add(rel)
 446                                 db.session.commit()
 447
 448                                 msg = "{}: Release {} created".format(package.title, rel.title)
 449                                 triggerNotif(package.author, current_user, msg, rel.getEditURL())
 450                                 db.session.commit()
 451                                 return redirect(package.getDetailsURL())
 452
 453         return render_template("packages/release_new.html", package=package, form=form)
 454
 455 @app.route("/packages/<author>/<name>/releases/<id>/", methods=["GET", "POST"])
 456 @login_required
 457 @is_package_page
 458 def edit_release_page(package, id):
 459         release = PackageRelease.query.get(id)
 460         if release is None or release.package != package:
 461                 abort(404)
 462
 463         clearNotifications(release.getEditURL())
 464
 465         canEdit = package.checkPerm(current_user, Permission.MAKE_RELEASE)
 466         canApprove = package.checkPerm(current_user, Permission.APPROVE_RELEASE)
 467         if not (canEdit or canApprove):
 468                 return redirect(package.getDetailsURL())
 469
 470         # Initial form class from post data and default data
 471         form = EditPackageReleaseForm(formdata=request.form, obj=release)
 472         if request.method == "POST" and form.validate():
 473                 wasApproved = release.approved
 474                 if canEdit:
 475                         release.title = form["title"].data
 476
 477                 if package.checkPerm(current_user, Permission.CHANGE_RELEASE_URL):
 478                         release.url = form["url"].data
 479                         release.task_id = form["task_id"].data
 480                         if release.task_id.strip() == "":
 481                                 release.task_id = None
 482
 483                 if canApprove:
 484                         release.approved = form["approved"].data
 485                 else:
 486                         release.approved = wasApproved
 487
 488                 db.session.commit()
 489                 return redirect(package.getDetailsURL())
 490
 491         return render_template("packages/release_edit.html", package=package, release=release, form=form)