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