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