app/models.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 import enum, datetime
  19
  20 from app import app, gravatar
  21 from urllib.parse import urlparse
  22
  23 from flask import Flask, url_for
  24 from flask_sqlalchemy import SQLAlchemy, BaseQuery
  25 from flask_migrate import Migrate
  26 from flask_user import login_required, UserManager, UserMixin, SQLAlchemyAdapter
  27 from sqlalchemy import func
  28 from sqlalchemy.orm import validates
  29 from sqlalchemy_searchable import SearchQueryMixin
  30 from sqlalchemy_utils.types import TSVectorType
  31 from sqlalchemy_searchable import make_searchable
  32
  33
  34 # Initialise database
  35 db = SQLAlchemy(app)
  36 migrate = Migrate(app, db)
  37 make_searchable(db.metadata)
  38
  39
  40 class ArticleQuery(BaseQuery, SearchQueryMixin):
  41         pass
  42
  43
  44 class UserRank(enum.Enum):
  45         BANNED         = 0
  46         NOT_JOINED     = 1
  47         NEW_MEMBER     = 2
  48         MEMBER         = 3
  49         TRUSTED_MEMBER = 4
  50         EDITOR         = 5
  51         MODERATOR      = 6
  52         ADMIN          = 7
  53
  54         def atLeast(self, min):
  55                 return self.value >= min.value
  56
  57         def getTitle(self):
  58                 return self.name.replace("_", " ").title()
  59
  60         def toName(self):
  61                 return self.name.lower()
  62
  63         def __str__(self):
  64                 return self.name
  65
  66         @classmethod
  67         def choices(cls):
  68                 return [(choice, choice.getTitle()) for choice in cls]
  69
  70         @classmethod
  71         def coerce(cls, item):
  72                 return item if type(item) == UserRank else UserRank[item]
  73
  74
  75 class Permission(enum.Enum):
  76         EDIT_PACKAGE       = "EDIT_PACKAGE"
  77         APPROVE_CHANGES    = "APPROVE_CHANGES"
  78         DELETE_PACKAGE     = "DELETE_PACKAGE"
  79         CHANGE_AUTHOR      = "CHANGE_AUTHOR"
  80         CHANGE_NAME        = "CHANGE_NAME"
  81         MAKE_RELEASE       = "MAKE_RELEASE"
  82         ADD_SCREENSHOTS    = "ADD_SCREENSHOTS"
  83         APPROVE_SCREENSHOT = "APPROVE_SCREENSHOT"
  84         APPROVE_RELEASE    = "APPROVE_RELEASE"
  85         APPROVE_NEW        = "APPROVE_NEW"
  86         CHANGE_RELEASE_URL = "CHANGE_RELEASE_URL"
  87         CHANGE_DNAME       = "CHANGE_DNAME"
  88         CHANGE_RANK        = "CHANGE_RANK"
  89         CHANGE_EMAIL       = "CHANGE_EMAIL"
  90         EDIT_EDITREQUEST   = "EDIT_EDITREQUEST"
  91         SEE_THREAD         = "SEE_THREAD"
  92         CREATE_THREAD      = "CREATE_THREAD"
  93         UNAPPROVE_PACKAGE  = "UNAPPROVE_PACKAGE"
  94         TOPIC_DISCARD      = "TOPIC_DISCARD"
  95         CREATE_TOKEN       = "CREATE_TOKEN"
  96
  97         # Only return true if the permission is valid for *all* contexts
  98         # See Package.checkPerm for package-specific contexts
  99         def check(self, user):
 100                 if not user.is_authenticated:
 101                         return False
 102
 103                 if self == Permission.APPROVE_NEW or \
 104                                 self == Permission.APPROVE_CHANGES    or \
 105                                 self == Permission.APPROVE_RELEASE    or \
 106                                 self == Permission.APPROVE_SCREENSHOT or \
 107                                 self == Permission.SEE_THREAD:
 108                         return user.rank.atLeast(UserRank.EDITOR)
 109                 else:
 110                         raise Exception("Non-global permission checked globally. Use Package.checkPerm or User.checkPerm instead.")
 111
 112 class User(db.Model, UserMixin):
 113         id           = db.Column(db.Integer, primary_key=True)
 114
 115         # User authentication information
 116         username     = db.Column(db.String(50, collation="NOCASE"), nullable=False, unique=True, index=True)
 117         password     = db.Column(db.String(255), nullable=True)
 118         reset_password_token = db.Column(db.String(100), nullable=False, server_default="")
 119
 120         rank         = db.Column(db.Enum(UserRank))
 121
 122         # Account linking
 123         github_username = db.Column(db.String(50, collation="NOCASE"), nullable=True, unique=True)
 124         forums_username = db.Column(db.String(50, collation="NOCASE"), nullable=True, unique=True)
 125
 126         # User email information
 127         email         = db.Column(db.String(255), nullable=True, unique=True)
 128         confirmed_at  = db.Column(db.DateTime())
 129
 130         # User information
 131         profile_pic   = db.Column(db.String(255), nullable=True, server_default=None)
 132         active        = db.Column("is_active", db.Boolean, nullable=False, server_default="0")
 133         display_name  = db.Column(db.String(100), nullable=False, server_default="")
 134
 135         # Links
 136         website_url   = db.Column(db.String(255), nullable=True, default=None)
 137         donate_url    = db.Column(db.String(255), nullable=True, default=None)
 138
 139         # Content
 140         notifications = db.relationship("Notification", primaryjoin="User.id==Notification.user_id")
 141
 142         # causednotifs  = db.relationship("Notification", backref="causer", lazy="dynamic")
 143         packages      = db.relationship("Package", backref="author", lazy="dynamic")
 144         requests      = db.relationship("EditRequest", backref="author", lazy="dynamic")
 145         threads       = db.relationship("Thread", backref="author", lazy="dynamic")
 146         tokens        = db.relationship("APIToken", backref="owner", lazy="dynamic")
 147         replies       = db.relationship("ThreadReply", backref="author", lazy="dynamic")
 148
 149         def __init__(self, username, active=False, email=None, password=None):
 150                 self.username = username
 151                 self.confirmed_at = datetime.datetime.now() - datetime.timedelta(days=6000)
 152                 self.display_name = username
 153                 self.active = active
 154                 self.email = email
 155                 self.password = password
 156                 self.rank = UserRank.NOT_JOINED
 157
 158         def canAccessTodoList(self):
 159                 return Permission.APPROVE_NEW.check(self) or \
 160                                 Permission.APPROVE_RELEASE.check(self) or \
 161                                 Permission.APPROVE_CHANGES.check(self)
 162
 163         def isClaimed(self):
 164                 return self.rank.atLeast(UserRank.NEW_MEMBER)
 165
 166         def getProfilePicURL(self):
 167                 if self.profile_pic:
 168                         return self.profile_pic
 169                 else:
 170                         return gravatar(self.email or "")
 171
 172         def checkPerm(self, user, perm):
 173                 if not user.is_authenticated:
 174                         return False
 175
 176                 if type(perm) == str:
 177                         perm = Permission[perm]
 178                 elif type(perm) != Permission:
 179                         raise Exception("Unknown permission given to User.checkPerm()")
 180
 181                 # Members can edit their own packages, and editors can edit any packages
 182                 if perm == Permission.CHANGE_AUTHOR:
 183                         return user.rank.atLeast(UserRank.EDITOR)
 184                 elif perm == Permission.CHANGE_RANK or perm == Permission.CHANGE_DNAME:
 185                         return user.rank.atLeast(UserRank.MODERATOR)
 186                 elif perm == Permission.CHANGE_EMAIL:
 187                         return user == self or (user.rank.atLeast(UserRank.MODERATOR) and user.rank.atLeast(self.rank))
 188                 elif perm == Permission.CREATE_TOKEN:
 189                         if user == self:
 190                                 return user.rank.atLeast(UserRank.MEMBER)
 191                         else:
 192                                 return user.rank.atLeast(UserRank.MODERATOR) and user.rank.atLeast(self.rank)
 193                 else:
 194                         raise Exception("Permission {} is not related to users".format(perm.name))
 195
 196         def canCommentRL(self):
 197                 hour_ago = datetime.datetime.utcnow() - datetime.timedelta(hours=1)
 198                 return ThreadReply.query.filter_by(author=self) \
 199                         .filter(ThreadReply.created_at > hour_ago).count() < 4
 200
 201         def canOpenThreadRL(self):
 202                 hour_ago = datetime.datetime.utcnow() - datetime.timedelta(hours=1)
 203                 return Thread.query.filter_by(author=self) \
 204                         .filter(Thread.created_at > hour_ago).count() < 2
 205
 206 class UserEmailVerification(db.Model):
 207         id      = db.Column(db.Integer, primary_key=True)
 208         user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
 209         email   = db.Column(db.String(100))
 210         token   = db.Column(db.String(32))
 211         user    = db.relationship("User", foreign_keys=[user_id])
 212
 213 class Notification(db.Model):
 214         id        = db.Column(db.Integer, primary_key=True)
 215         user_id   = db.Column(db.Integer, db.ForeignKey("user.id"))
 216         causer_id = db.Column(db.Integer, db.ForeignKey("user.id"))
 217         user      = db.relationship("User", foreign_keys=[user_id])
 218         causer    = db.relationship("User", foreign_keys=[causer_id])
 219
 220         title     = db.Column(db.String(100), nullable=False)
 221         url       = db.Column(db.String(200), nullable=True)
 222
 223         def __init__(self, us, cau, titl, ur):
 224                 if len(titl) > 100:
 225                         title = title[:99] + "…"
 226
 227                 self.user   = us
 228                 self.causer = cau
 229                 self.title  = titl
 230                 self.url    = ur
 231
 232
 233 class License(db.Model):
 234         id      = db.Column(db.Integer, primary_key=True)
 235         name    = db.Column(db.String(50), nullable=False, unique=True)
 236         is_foss = db.Column(db.Boolean,    nullable=False, default=True)
 237
 238         def __init__(self, v, is_foss=True):
 239                 self.name = v
 240                 self.is_foss = is_foss
 241
 242         def __str__(self):
 243                 return self.name
 244
 245
 246 class PackageType(enum.Enum):
 247         MOD  = "Mod"
 248         GAME = "Game"
 249         TXP  = "Texture Pack"
 250
 251         def toName(self):
 252                 return self.name.lower()
 253
 254         def __str__(self):
 255                 return self.name
 256
 257         @classmethod
 258         def get(cls, name):
 259                 try:
 260                         return PackageType[name.upper()]
 261                 except KeyError:
 262                         return None
 263
 264         @classmethod
 265         def choices(cls):
 266                 return [(choice, choice.value) for choice in cls]
 267
 268         @classmethod
 269         def coerce(cls, item):
 270                 return item if type(item) == PackageType else PackageType[item]
 271
 272
 273 class PackagePropertyKey(enum.Enum):
 274         name          = "Name"
 275         title         = "Title"
 276         short_desc     = "Short Description"
 277         desc          = "Description"
 278         type          = "Type"
 279         license       = "License"
 280         media_license = "Media License"
 281         tags          = "Tags"
 282         provides      = "Provides"
 283         repo          = "Repository"
 284         website       = "Website"
 285         issueTracker  = "Issue Tracker"
 286         forums        = "Forum Topic ID"
 287
 288         def convert(self, value):
 289                 if self == PackagePropertyKey.tags:
 290                         return ",".join([t.title for t in value])
 291                 elif self == PackagePropertyKey.provides:
 292                         return ",".join([t.name for t in value])
 293                 else:
 294                         return str(value)
 295
 296 provides = db.Table("provides",
 297         db.Column("package_id",    db.Integer, db.ForeignKey("package.id"), primary_key=True),
 298     db.Column("metapackage_id", db.Integer, db.ForeignKey("meta_package.id"), primary_key=True)
 299 )
 300
 301 tags = db.Table("tags",
 302     db.Column("tag_id", db.Integer, db.ForeignKey("tag.id"), primary_key=True),
 303     db.Column("package_id", db.Integer, db.ForeignKey("package.id"), primary_key=True)
 304 )
 305
 306 class Dependency(db.Model):
 307         id              = db.Column(db.Integer, primary_key=True)
 308         depender_id     = db.Column(db.Integer, db.ForeignKey("package.id"),     nullable=True)
 309         package_id      = db.Column(db.Integer, db.ForeignKey("package.id"),     nullable=True)
 310         package         = db.relationship("Package", foreign_keys=[package_id])
 311         meta_package_id = db.Column(db.Integer, db.ForeignKey("meta_package.id"), nullable=True)
 312         optional        = db.Column(db.Boolean, nullable=False, default=False)
 313         __table_args__  = (db.UniqueConstraint('depender_id', 'package_id', 'meta_package_id', name='_dependency_uc'), )
 314
 315         def __init__(self, depender=None, package=None, meta=None):
 316                 if depender is None:
 317                         return
 318
 319                 self.depender = depender
 320
 321                 packageProvided = package is not None
 322                 metaProvided = meta is not None
 323
 324                 if packageProvided and not metaProvided:
 325                         self.package = package
 326                 elif metaProvided and not packageProvided:
 327                         self.meta_package = meta
 328                 else:
 329                         raise Exception("Either meta or package must be given, but not both!")
 330
 331         def __str__(self):
 332                 if self.package is not None:
 333                         return self.package.author.username + "/" + self.package.name
 334                 elif self.meta_package is not None:
 335                         return self.meta_package.name
 336                 else:
 337                         raise Exception("Meta and package are both none!")
 338
 339         @staticmethod
 340         def SpecToList(depender, spec, cache={}):
 341                 retval = []
 342                 arr = spec.split(",")
 343
 344                 import re
 345                 pattern1 = re.compile("^([a-z0-9_]+)$")
 346                 pattern2 = re.compile("^([A-Za-z0-9_]+)/([a-z0-9_]+)$")
 347
 348                 for x in arr:
 349                         x = x.strip()
 350                         if x == "":
 351                                 continue
 352
 353                         if pattern1.match(x):
 354                                 meta = MetaPackage.GetOrCreate(x, cache)
 355                                 retval.append(Dependency(depender, meta=meta))
 356                         else:
 357                                 m = pattern2.match(x)
 358                                 username = m.group(1)
 359                                 name     = m.group(2)
 360                                 user = User.query.filter_by(username=username).first()
 361                                 if user is None:
 362                                         raise Exception("Unable to find user " + username)
 363
 364                                 package = Package.query.filter_by(author=user, name=name).first()
 365                                 if package is None:
 366                                         raise Exception("Unable to find package " + name + " by " + username)
 367
 368                                 retval.append(Dependency(depender, package=package))
 369
 370                 return retval
 371
 372
 373 class Package(db.Model):
 374         query_class  = ArticleQuery
 375
 376         id           = db.Column(db.Integer, primary_key=True)
 377
 378         # Basic details
 379         author_id    = db.Column(db.Integer, db.ForeignKey("user.id"))
 380         name         = db.Column(db.String(100), nullable=False)
 381         title        = db.Column(db.Unicode(100), nullable=False)
 382         short_desc   = db.Column(db.Unicode(200), nullable=False)
 383         desc         = db.Column(db.UnicodeText, nullable=True)
 384         type         = db.Column(db.Enum(PackageType))
 385         created_at   = db.Column(db.DateTime, nullable=False, default=datetime.datetime.utcnow)
 386
 387         search_vector = db.Column(TSVectorType("title", "short_desc", "desc"))
 388
 389         license_id   = db.Column(db.Integer, db.ForeignKey("license.id"), nullable=False, default=1)
 390         license      = db.relationship("License", foreign_keys=[license_id])
 391         media_license_id = db.Column(db.Integer, db.ForeignKey("license.id"), nullable=False, default=1)
 392         media_license    = db.relationship("License", foreign_keys=[media_license_id])
 393
 394         approved     = db.Column(db.Boolean, nullable=False, default=False)
 395         soft_deleted = db.Column(db.Boolean, nullable=False, default=False)
 396
 397         score        = db.Column(db.Float, nullable=False, default=0)
 398
 399         review_thread_id = db.Column(db.Integer, db.ForeignKey("thread.id"), nullable=True, default=None)
 400         review_thread    = db.relationship("Thread", foreign_keys=[review_thread_id])
 401
 402         # Downloads
 403         repo         = db.Column(db.String(200), nullable=True)
 404         website      = db.Column(db.String(200), nullable=True)
 405         issueTracker = db.Column(db.String(200), nullable=True)
 406         forums       = db.Column(db.Integer,     nullable=True)
 407
 408         provides = db.relationship("MetaPackage", secondary=provides, lazy="subquery",
 409                         backref=db.backref("packages", lazy="dynamic", order_by=db.desc("score")))
 410
 411         dependencies = db.relationship("Dependency", backref="depender", lazy="dynamic", foreign_keys=[Dependency.depender_id])
 412
 413         tags = db.relationship("Tag", secondary=tags, lazy="subquery",
 414                         backref=db.backref("packages", lazy=True))
 415
 416         releases = db.relationship("PackageRelease", backref="package",
 417                         lazy="dynamic", order_by=db.desc("package_release_releaseDate"))
 418
 419         screenshots = db.relationship("PackageScreenshot", backref="package",
 420                         lazy="dynamic", order_by=db.asc("package_screenshot_id"))
 421
 422         requests = db.relationship("EditRequest", backref="package",
 423                         lazy="dynamic")
 424
 425         def __init__(self, package=None):
 426                 if package is None:
 427                         return
 428
 429                 self.author_id = package.author_id
 430                 self.created_at = package.created_at
 431                 self.approved = package.approved
 432
 433                 for e in PackagePropertyKey:
 434                         setattr(self, e.name, getattr(package, e.name))
 435
 436         def getIsFOSS(self):
 437                 return self.license.is_foss and self.media_license.is_foss
 438
 439         def getState(self):
 440                 if self.approved:
 441                         return "approved"
 442                 elif self.review_thread_id:
 443                         return "thread"
 444                 elif (self.type == PackageType.GAME or \
 445                                         self.type == PackageType.TXP) and \
 446                                 self.screenshots.count() == 0:
 447                         return "wip"
 448                 elif not self.getDownloadRelease():
 449                         return "wip"
 450                 elif "Other" in self.license.name or "Other" in self.media_license.name:
 451                         return "license"
 452                 else:
 453                         return "ready"
 454
 455         def getAsDictionaryKey(self):
 456                 return {
 457                         "name": self.name,
 458                         "author": self.author.display_name,
 459                         "type": self.type.toName(),
 460                 }
 461
 462         def getAsDictionaryShort(self, base_url, version=None, protonum=None):
 463                 tnurl = self.getThumbnailURL(1)
 464                 release = self.getDownloadRelease(version=version, protonum=protonum)
 465                 return {
 466                         "name": self.name,
 467                         "title": self.title,
 468                         "author": self.author.display_name,
 469                         "short_description": self.short_desc,
 470                         "type": self.type.toName(),
 471                         "release": release and release.id,
 472                         "thumbnail": (base_url + tnurl) if tnurl is not None else None,
 473                         "score": round(self.score * 10) / 10
 474                 }
 475
 476         def getAsDictionary(self, base_url, version=None, protonum=None):
 477                 tnurl = self.getThumbnailURL(1)
 478                 release = self.getDownloadRelease(version=version, protonum=protonum)
 479                 return {
 480                         "author": self.author.display_name,
 481                         "name": self.name,
 482                         "title": self.title,
 483                         "short_description": self.short_desc,
 484                         "desc": self.desc,
 485                         "type": self.type.toName(),
 486                         "created_at": self.created_at,
 487
 488                         "license": self.license.name,
 489                         "media_license": self.media_license.name,
 490
 491                         "repo": self.repo,
 492                         "website": self.website,
 493                         "issue_tracker": self.issueTracker,
 494                         "forums": self.forums,
 495
 496                         "provides": [x.name for x in self.provides],
 497                         "thumbnail": (base_url + tnurl) if tnurl is not None else None,
 498                         "screenshots": [base_url + ss.url for ss in self.screenshots],
 499
 500                         "url": base_url + self.getDownloadURL(),
 501                         "release": release and release.id,
 502
 503                         "score": round(self.score * 10) / 10
 504                 }
 505
 506         def getThumbnailURL(self, level=2):
 507                 screenshot = self.screenshots.filter_by(approved=True).order_by(db.asc(PackageScreenshot.id)).first()
 508                 return screenshot.getThumbnailURL(level) if screenshot is not None else None
 509
 510         def getMainScreenshotURL(self):
 511                 screenshot = self.screenshots.filter_by(approved=True).order_by(db.asc(PackageScreenshot.id)).first()
 512                 return screenshot.url if screenshot is not None else None
 513
 514         def getDetailsURL(self):
 515                 return url_for("packages.view",
 516                                 author=self.author.username, name=self.name)
 517
 518         def getEditURL(self):
 519                 return url_for("packages.create_edit",
 520                                 author=self.author.username, name=self.name)
 521
 522         def getApproveURL(self):
 523                 return url_for("packages.approve",
 524                                 author=self.author.username, name=self.name)
 525
 526         def getRemoveURL(self):
 527                 return url_for("packages.remove",
 528                                 author=self.author.username, name=self.name)
 529
 530         def getNewScreenshotURL(self):
 531                 return url_for("packages.create_screenshot",
 532                                 author=self.author.username, name=self.name)
 533
 534         def getCreateReleaseURL(self):
 535                 return url_for("packages.create_release",
 536                                 author=self.author.username, name=self.name)
 537
 538         def getCreateEditRequestURL(self):
 539                 return url_for("create_edit_editrequest_page",
 540                                 author=self.author.username, name=self.name)
 541
 542         def getBulkReleaseURL(self):
 543                 return url_for("packages.bulk_change_release",
 544                         author=self.author.username, name=self.name)
 545
 546         def getDownloadURL(self):
 547                 return url_for("packages.download",
 548                                 author=self.author.username, name=self.name)
 549
 550         def getDownloadRelease(self, version=None, protonum=None):
 551                 if version is None and protonum is not None:
 552                         version = MinetestRelease.query.filter(MinetestRelease.protocol >= int(protonum)).first()
 553                         if version is not None:
 554                                 version = version.id
 555                         else:
 556                                 version = 10000000
 557
 558
 559                 for rel in self.releases:
 560                         if rel.approved and (version is None or
 561                                         ((rel.min_rel is None or rel.min_rel_id <= version) and \
 562                                         (rel.max_rel is None or rel.max_rel_id >= version))):
 563                                 return rel
 564
 565                 return None
 566
 567         def getDownloadCount(self):
 568                 counter = 0
 569                 for release in self.releases:
 570                         counter += release.downloads
 571                 return counter
 572
 573         def checkPerm(self, user, perm):
 574                 if not user.is_authenticated:
 575                         return False
 576
 577                 if type(perm) == str:
 578                         perm = Permission[perm]
 579                 elif type(perm) != Permission:
 580                         raise Exception("Unknown permission given to Package.checkPerm()")
 581
 582                 isOwner = user == self.author
 583
 584                 if perm == Permission.CREATE_THREAD:
 585                         return user.rank.atLeast(UserRank.MEMBER)
 586
 587                 # Members can edit their own packages, and editors can edit any packages
 588                 if perm == Permission.MAKE_RELEASE or perm == Permission.ADD_SCREENSHOTS:
 589                         return isOwner or user.rank.atLeast(UserRank.EDITOR)
 590
 591                 if perm == Permission.EDIT_PACKAGE or perm == Permission.APPROVE_CHANGES:
 592                         if isOwner:
 593                                 return user.rank.atLeast(UserRank.MEMBER if self.approved else UserRank.NEW_MEMBER)
 594                         else:
 595                                 return user.rank.atLeast(UserRank.EDITOR)
 596
 597                 # Anyone can change the package name when not approved, but only editors when approved
 598                 elif perm == Permission.CHANGE_NAME:
 599                         return not self.approved or user.rank.atLeast(UserRank.EDITOR)
 600
 601                 # Editors can change authors and approve new packages
 602                 elif perm == Permission.APPROVE_NEW or perm == Permission.CHANGE_AUTHOR:
 603                         return user.rank.atLeast(UserRank.EDITOR)
 604
 605                 elif perm == Permission.APPROVE_RELEASE or perm == Permission.APPROVE_SCREENSHOT:
 606                         return user.rank.atLeast(UserRank.TRUSTED_MEMBER if isOwner else UserRank.EDITOR)
 607
 608                 # Moderators can delete packages
 609                 elif perm == Permission.DELETE_PACKAGE or perm == Permission.UNAPPROVE_PACKAGE \
 610                                 or perm == Permission.CHANGE_RELEASE_URL:
 611                         return user.rank.atLeast(UserRank.MODERATOR)
 612
 613                 else:
 614                         raise Exception("Permission {} is not related to packages".format(perm.name))
 615
 616         def setStartScore(self):
 617                 downloads = db.session.query(func.sum(PackageRelease.downloads)). \
 618                                 filter(PackageRelease.package_id == self.id).scalar() or 0
 619
 620                 forum_score = 0
 621                 forum_bonus = 0
 622                 topic = self.forums and ForumTopic.query.get(self.forums)
 623                 if topic:
 624                         months = (datetime.datetime.now() - topic.created_at).days / 30
 625                         years  = months / 12
 626                         forum_score = topic.views / max(years, 0.0416) + 80*min(max(months, 0.5), 6)
 627                         forum_bonus = topic.views + topic.posts
 628
 629                 self.score = max(downloads, forum_score * 0.6) + forum_bonus
 630
 631                 if self.getMainScreenshotURL() is None:
 632                         self.score *= 0.8
 633
 634                 if not self.license.is_foss or not self.media_license.is_foss:
 635                         self.score *= 0.1
 636
 637
 638 class MetaPackage(db.Model):
 639         id           = db.Column(db.Integer, primary_key=True)
 640         name         = db.Column(db.String(100), unique=True, nullable=False)
 641         dependencies = db.relationship("Dependency", backref="meta_package", lazy="dynamic")
 642
 643         def __init__(self, name=None):
 644                 self.name = name
 645
 646         def __str__(self):
 647                 return self.name
 648
 649         @staticmethod
 650         def ListToSpec(list):
 651                 return ",".join([str(x) for x in list])
 652
 653         @staticmethod
 654         def GetOrCreate(name, cache={}):
 655                 mp = cache.get(name)
 656                 if mp is None:
 657                         mp = MetaPackage.query.filter_by(name=name).first()
 658
 659                 if mp is None:
 660                         mp = MetaPackage(name)
 661                         db.session.add(mp)
 662
 663                 cache[name] = mp
 664                 return mp
 665
 666         @staticmethod
 667         def SpecToList(spec, cache={}):
 668                 retval = []
 669                 arr = spec.split(",")
 670
 671                 import re
 672                 pattern = re.compile("^([a-z0-9_]+)$")
 673
 674                 for x in arr:
 675                         x = x.strip()
 676                         if x == "":
 677                                 continue
 678
 679                         if not pattern.match(x):
 680                                 continue
 681
 682                         retval.append(MetaPackage.GetOrCreate(x, cache))
 683
 684                 return retval
 685
 686 class Tag(db.Model):
 687         id              = db.Column(db.Integer,    primary_key=True)
 688         name            = db.Column(db.String(100), unique=True, nullable=False)
 689         title           = db.Column(db.String(100), nullable=False)
 690         backgroundColor = db.Column(db.String(6),   nullable=False)
 691         textColor       = db.Column(db.String(6),   nullable=False)
 692
 693         def __init__(self, title, backgroundColor="000000", textColor="ffffff"):
 694                 self.title           = title
 695                 self.backgroundColor = backgroundColor
 696                 self.textColor       = textColor
 697
 698                 import re
 699                 regex = re.compile("[^a-z_]")
 700                 self.name = regex.sub("", self.title.lower().replace(" ", "_"))
 701
 702
 703 class MinetestRelease(db.Model):
 704         id       = db.Column(db.Integer, primary_key=True)
 705         name     = db.Column(db.String(100), unique=True, nullable=False)
 706         protocol = db.Column(db.Integer, nullable=False, default=0)
 707
 708         def __init__(self, name=None):
 709                 self.name = name
 710
 711         def getActual(self):
 712                 return None if self.name == "None" else self
 713
 714
 715 class PackageRelease(db.Model):
 716         id           = db.Column(db.Integer, primary_key=True)
 717
 718         package_id   = db.Column(db.Integer, db.ForeignKey("package.id"))
 719         title        = db.Column(db.String(100), nullable=False)
 720         releaseDate  = db.Column(db.DateTime,    nullable=False)
 721         url          = db.Column(db.String(200), nullable=False)
 722         approved     = db.Column(db.Boolean, nullable=False, default=False)
 723         task_id      = db.Column(db.String(37), nullable=True)
 724         commit_hash  = db.Column(db.String(41), nullable=True, default=None)
 725         downloads    = db.Column(db.Integer, nullable=False, default=0)
 726
 727         min_rel_id = db.Column(db.Integer, db.ForeignKey("minetest_release.id"), nullable=True, server_default=None)
 728         min_rel    = db.relationship("MinetestRelease", foreign_keys=[min_rel_id])
 729
 730         max_rel_id = db.Column(db.Integer, db.ForeignKey("minetest_release.id"), nullable=True, server_default=None)
 731         max_rel    = db.relationship("MinetestRelease", foreign_keys=[max_rel_id])
 732
 733
 734         def getEditURL(self):
 735                 return url_for("packages.edit_release",
 736                                 author=self.package.author.username,
 737                                 name=self.package.name,
 738                                 id=self.id)
 739
 740         def getDownloadURL(self):
 741                 return url_for("packages.download_release",
 742                                 author=self.package.author.username,
 743                                 name=self.package.name,
 744                                 id=self.id)
 745
 746
 747         def __init__(self):
 748                 self.releaseDate = datetime.datetime.now()
 749
 750         def approve(self, user):
 751                 if self.package.approved and \
 752                                 not self.package.checkPerm(user, Permission.APPROVE_RELEASE):
 753                         return False
 754
 755                 assert self.task_id is None and self.url is not None and self.url != ""
 756
 757                 self.approved = True
 758                 return True
 759
 760
 761 class PackageReview(db.Model):
 762         id         = db.Column(db.Integer, primary_key=True)
 763         package_id = db.Column(db.Integer, db.ForeignKey("package.id"))
 764         thread_id  = db.Column(db.Integer, db.ForeignKey("thread.id"), nullable=False)
 765         recommend  = db.Column(db.Boolean, nullable=False, default=True)
 766
 767
 768 class PackageScreenshot(db.Model):
 769         id         = db.Column(db.Integer, primary_key=True)
 770         package_id = db.Column(db.Integer, db.ForeignKey("package.id"))
 771         title      = db.Column(db.String(100), nullable=False)
 772         url        = db.Column(db.String(100), nullable=False)
 773         approved   = db.Column(db.Boolean, nullable=False, default=False)
 774
 775
 776         def getEditURL(self):
 777                 return url_for("packages.edit_screenshot",
 778                                 author=self.package.author.username,
 779                                 name=self.package.name,
 780                                 id=self.id)
 781
 782         def getThumbnailURL(self, level=2):
 783                 return self.url.replace("/uploads/", ("/thumbnails/{:d}/").format(level))
 784
 785
 786 class APIToken(db.Model):
 787         id           = db.Column(db.Integer, primary_key=True)
 788         access_token = db.Column(db.String(34), unique=True)
 789         name         = db.Column(db.String(100), nullable=False)
 790         owner_id     = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
 791         created_at   = db.Column(db.DateTime, nullable=False, default=datetime.datetime.utcnow)
 792
 793         def canOperateOnPackage(self, package):
 794                 return packages.count() == 0 or package in packages
 795
 796
 797 class EditRequest(db.Model):
 798         id           = db.Column(db.Integer, primary_key=True)
 799
 800         package_id   = db.Column(db.Integer, db.ForeignKey("package.id"))
 801         author_id    = db.Column(db.Integer, db.ForeignKey("user.id"))
 802
 803         title        = db.Column(db.String(100), nullable=False)
 804         desc         = db.Column(db.String(1000), nullable=True)
 805
 806         # 0 - open
 807         # 1 - merged
 808         # 2 - rejected
 809         status       = db.Column(db.Integer, nullable=False, default=0)
 810
 811         changes = db.relationship("EditRequestChange", backref="request",
 812                         lazy="dynamic")
 813
 814         def getURL(self):
 815                 return url_for("view_editrequest_page",
 816                                 author=self.package.author.username,
 817                                 name=self.package.name,
 818                                 id=self.id)
 819
 820         def getApproveURL(self):
 821                 return url_for("approve_editrequest_page",
 822                                 author=self.package.author.username,
 823                                 name=self.package.name,
 824                                 id=self.id)
 825
 826         def getRejectURL(self):
 827                 return url_for("reject_editrequest_page",
 828                                 author=self.package.author.username,
 829                                 name=self.package.name,
 830                                 id=self.id)
 831
 832         def getEditURL(self):
 833                 return url_for("create_edit_editrequest_page",
 834                                 author=self.package.author.username,
 835                                 name=self.package.name,
 836                                 id=self.id)
 837
 838         def applyAll(self, package):
 839                 for change in self.changes:
 840                         change.apply(package)
 841
 842
 843         def checkPerm(self, user, perm):
 844                 if not user.is_authenticated:
 845                         return False
 846
 847                 if type(perm) == str:
 848                         perm = Permission[perm]
 849                 elif type(perm) != Permission:
 850                         raise Exception("Unknown permission given to EditRequest.checkPerm()")
 851
 852                 isOwner = user == self.author
 853
 854                 # Members can edit their own packages, and editors can edit any packages
 855                 if perm == Permission.EDIT_EDITREQUEST:
 856                         return isOwner or user.rank.atLeast(UserRank.EDITOR)
 857
 858                 else:
 859                         raise Exception("Permission {} is not related to packages".format(perm.name))
 860
 861
 862
 863
 864 class EditRequestChange(db.Model):
 865         id           = db.Column(db.Integer, primary_key=True)
 866
 867         request_id   = db.Column(db.Integer, db.ForeignKey("edit_request.id"))
 868         key          = db.Column(db.Enum(PackagePropertyKey), nullable=False)
 869
 870         # TODO: make diff instead
 871         oldValue     = db.Column(db.Text, nullable=True)
 872         newValue     = db.Column(db.Text, nullable=True)
 873
 874         def apply(self, package):
 875                 if self.key == PackagePropertyKey.tags:
 876                         package.tags.clear()
 877                         for tagTitle in self.newValue.split(","):
 878                                 tag = Tag.query.filter_by(title=tagTitle.strip()).first()
 879                                 package.tags.append(tag)
 880
 881                 else:
 882                         setattr(package, self.key.name, self.newValue)
 883
 884
 885 watchers = db.Table("watchers",
 886     db.Column("user_id", db.Integer, db.ForeignKey("user.id"), primary_key=True),
 887     db.Column("thread_id", db.Integer, db.ForeignKey("thread.id"), primary_key=True)
 888 )
 889
 890 class Thread(db.Model):
 891         id         = db.Column(db.Integer, primary_key=True)
 892
 893         package_id = db.Column(db.Integer, db.ForeignKey("package.id"), nullable=True)
 894         package    = db.relationship("Package", foreign_keys=[package_id])
 895
 896         author_id  = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
 897         title      = db.Column(db.String(100), nullable=False)
 898         private    = db.Column(db.Boolean, server_default="0")
 899
 900         created_at = db.Column(db.DateTime, nullable=False, default=datetime.datetime.utcnow)
 901
 902         replies    = db.relationship("ThreadReply", backref="thread", lazy="dynamic")
 903
 904         watchers   = db.relationship("User", secondary=watchers, lazy="subquery", \
 905                                                 backref=db.backref("watching", lazy=True))
 906
 907
 908         def getSubscribeURL(self):
 909                 return url_for("threads.subscribe",
 910                                 id=self.id)
 911
 912         def getUnsubscribeURL(self):
 913                 return url_for("threads.unsubscribe",
 914                                 id=self.id)
 915
 916         def checkPerm(self, user, perm):
 917                 if not user.is_authenticated:
 918                         return not self.private
 919
 920                 if type(perm) == str:
 921                         perm = Permission[perm]
 922                 elif type(perm) != Permission:
 923                         raise Exception("Unknown permission given to Thread.checkPerm()")
 924
 925                 isOwner = user == self.author or (self.package is not None and self.package.author == user)
 926
 927                 if perm == Permission.SEE_THREAD:
 928                         return not self.private or isOwner or user.rank.atLeast(UserRank.EDITOR)
 929
 930                 else:
 931                         raise Exception("Permission {} is not related to threads".format(perm.name))
 932
 933 class ThreadReply(db.Model):
 934         id         = db.Column(db.Integer, primary_key=True)
 935         thread_id  = db.Column(db.Integer, db.ForeignKey("thread.id"), nullable=False)
 936         comment    = db.Column(db.String(500), nullable=False)
 937         author_id  = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
 938         created_at = db.Column(db.DateTime, nullable=False, default=datetime.datetime.utcnow)
 939
 940
 941 REPO_BLACKLIST = [".zip", "mediafire.com", "dropbox.com", "weebly.com", \
 942                 "minetest.net", "dropboxusercontent.com", "4shared.com", \
 943                 "digitalaudioconcepts.com", "hg.intevation.org", "www.wtfpl.net", \
 944                 "imageshack.com", "imgur.com"]
 945
 946 class ForumTopic(db.Model):
 947         topic_id  = db.Column(db.Integer, primary_key=True, autoincrement=False)
 948         author_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
 949         author    = db.relationship("User")
 950
 951         wip       = db.Column(db.Boolean, server_default="0")
 952         discarded = db.Column(db.Boolean, server_default="0")
 953
 954         type      = db.Column(db.Enum(PackageType), nullable=False)
 955         title     = db.Column(db.String(200), nullable=False)
 956         name      = db.Column(db.String(30), nullable=True)
 957         link      = db.Column(db.String(200), nullable=True)
 958
 959         posts     = db.Column(db.Integer, nullable=False)
 960         views     = db.Column(db.Integer, nullable=False)
 961
 962         created_at = db.Column(db.DateTime, nullable=False, default=datetime.datetime.utcnow)
 963
 964         def getRepoURL(self):
 965                 if self.link is None:
 966                         return None
 967
 968                 for item in REPO_BLACKLIST:
 969                         if item in self.link:
 970                                 return None
 971
 972                 return self.link.replace("repo.or.cz/w/", "repo.or.cz/")
 973
 974         def getAsDictionary(self):
 975                 return {
 976                         "author": self.author.username,
 977                         "name":   self.name,
 978                         "type":   self.type.toName(),
 979                         "title":  self.title,
 980                         "id":     self.topic_id,
 981                         "link":   self.link,
 982                         "posts":  self.posts,
 983                         "views":  self.views,
 984                         "is_wip": self.wip,
 985                         "discarded":  self.discarded,
 986                         "created_at": self.created_at.isoformat(),
 987                 }
 988
 989         def checkPerm(self, user, perm):
 990                 if not user.is_authenticated:
 991                         return False
 992
 993                 if type(perm) == str:
 994                         perm = Permission[perm]
 995                 elif type(perm) != Permission:
 996                         raise Exception("Unknown permission given to ForumTopic.checkPerm()")
 997
 998                 if perm == Permission.TOPIC_DISCARD:
 999                         return self.author == user or user.rank.atLeast(UserRank.EDITOR)
1000
1001                 else:
1002                         raise Exception("Permission {} is not related to topics".format(perm.name))
1003
1004
1005 # Setup Flask-User
1006 db_adapter = SQLAlchemyAdapter(db, User)        # Register the User model
1007 user_manager = UserManager(db_adapter, app)     # Initialize Flask-User