app/models.py

   1 # ContentDB
   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         REIMPORT_META      = "REIMPORT_META"
  84         APPROVE_SCREENSHOT = "APPROVE_SCREENSHOT"
  85         APPROVE_RELEASE    = "APPROVE_RELEASE"
  86         APPROVE_NEW        = "APPROVE_NEW"
  87         EDIT_TAGS          = "EDIT_TAGS"
  88         CREATE_TAG         = "CREATE_TAG"
  89         CHANGE_RELEASE_URL = "CHANGE_RELEASE_URL"
  90         CHANGE_USERNAMES   = "CHANGE_USERNAMES"
  91         CHANGE_RANK        = "CHANGE_RANK"
  92         CHANGE_EMAIL       = "CHANGE_EMAIL"
  93         EDIT_EDITREQUEST   = "EDIT_EDITREQUEST"
  94         SEE_THREAD         = "SEE_THREAD"
  95         CREATE_THREAD      = "CREATE_THREAD"
  96         COMMENT_THREAD     = "COMMENT_THREAD"
  97         LOCK_THREAD        = "LOCK_THREAD"
  98         DELETE_REPLY       = "DELETE_REPLY"
  99         EDIT_REPLY         = "EDIT_REPLY"
 100         UNAPPROVE_PACKAGE  = "UNAPPROVE_PACKAGE"
 101         TOPIC_DISCARD      = "TOPIC_DISCARD"
 102         CREATE_TOKEN       = "CREATE_TOKEN"
 103         EDIT_MAINTAINERS   = "EDIT_MAINTAINERS"
 104         CHANGE_PROFILE_URLS = "CHANGE_PROFILE_URLS"
 105
 106         # Only return true if the permission is valid for *all* contexts
 107         # See Package.checkPerm for package-specific contexts
 108         def check(self, user):
 109                 if not user.is_authenticated:
 110                         return False
 111
 112                 if self == Permission.APPROVE_NEW or \
 113                                 self == Permission.APPROVE_CHANGES    or \
 114                                 self == Permission.APPROVE_RELEASE    or \
 115                                 self == Permission.APPROVE_SCREENSHOT or \
 116                                 self == Permission.EDIT_TAGS or \
 117                                 self == Permission.CREATE_TAG or \
 118                                 self == Permission.SEE_THREAD:
 119                         return user.rank.atLeast(UserRank.EDITOR)
 120                 else:
 121                         raise Exception("Non-global permission checked globally. Use Package.checkPerm or User.checkPerm instead.")
 122
 123         @staticmethod
 124         def checkPerm(user, perm):
 125                 if type(perm) == str:
 126                         perm = Permission[perm]
 127                 elif type(perm) != Permission:
 128                         raise Exception("Unknown permission given to Permission.check")
 129
 130                 return perm.check(user)
 131
 132 def display_name_default(context):
 133     return context.get_current_parameters()["username"]
 134
 135 class User(db.Model, UserMixin):
 136         id           = db.Column(db.Integer, primary_key=True)
 137
 138         # User authentication information
 139         username     = db.Column(db.String(50, collation="NOCASE"), nullable=False, unique=True, index=True)
 140         password     = db.Column(db.String(255), nullable=False, server_default="")
 141         reset_password_token = db.Column(db.String(100), nullable=False, server_default="")
 142
 143         rank         = db.Column(db.Enum(UserRank))
 144
 145         # Account linking
 146         github_username = db.Column(db.String(50, collation="NOCASE"), nullable=True, unique=True)
 147         forums_username = db.Column(db.String(50, collation="NOCASE"), nullable=True, unique=True)
 148
 149         # Access token for webhook setup
 150         github_access_token = db.Column(db.String(50), nullable=True, server_default=None)
 151
 152         # User email information
 153         email         = db.Column(db.String(255), nullable=True, unique=True)
 154         email_confirmed_at  = db.Column(db.DateTime())
 155
 156         # User information
 157         profile_pic   = db.Column(db.String(255), nullable=True, server_default=None)
 158         active        = db.Column("is_active", db.Boolean, nullable=False, server_default="0")
 159         display_name  = db.Column(db.String(100), nullable=False, default=display_name_default)
 160
 161         # Links
 162         website_url   = db.Column(db.String(255), nullable=True, default=None)
 163         donate_url    = db.Column(db.String(255), nullable=True, default=None)
 164
 165         # Content
 166         notifications = db.relationship("Notification", primaryjoin="User.id==Notification.user_id")
 167
 168         # causednotifs  = db.relationship("Notification", backref="causer", lazy="dynamic")
 169         packages      = db.relationship("Package", backref=db.backref("author", lazy="joined"), lazy="dynamic")
 170         requests      = db.relationship("EditRequest", backref="author", lazy="dynamic")
 171         threads       = db.relationship("Thread", backref="author", lazy="dynamic")
 172         tokens        = db.relationship("APIToken", backref="owner", lazy="dynamic")
 173         replies       = db.relationship("ThreadReply", backref="author", lazy="dynamic")
 174
 175         def __init__(self, username=None, active=False, email=None, password=""):
 176                 self.username = username
 177                 self.email_confirmed_at = datetime.datetime.now() - datetime.timedelta(days=6000)
 178                 self.display_name = username
 179                 self.active = active
 180                 self.email = email
 181                 self.password = password
 182                 self.rank = UserRank.NOT_JOINED
 183
 184         def hasPassword(self):
 185                 return self.password != ""
 186
 187         def canAccessTodoList(self):
 188                 return Permission.APPROVE_NEW.check(self) or \
 189                                 Permission.APPROVE_RELEASE.check(self) or \
 190                                 Permission.APPROVE_CHANGES.check(self)
 191
 192         def isClaimed(self):
 193                 return self.rank.atLeast(UserRank.NEW_MEMBER)
 194
 195         def getProfilePicURL(self):
 196                 if self.profile_pic:
 197                         return self.profile_pic
 198                 else:
 199                         return gravatar(self.email or "")
 200
 201         def checkPerm(self, user, perm):
 202                 if not user.is_authenticated:
 203                         return False
 204
 205                 if type(perm) == str:
 206                         perm = Permission[perm]
 207                 elif type(perm) != Permission:
 208                         raise Exception("Unknown permission given to User.checkPerm()")
 209
 210                 # Members can edit their own packages, and editors can edit any packages
 211                 if perm == Permission.CHANGE_AUTHOR:
 212                         return user.rank.atLeast(UserRank.EDITOR)
 213                 elif perm == Permission.CHANGE_RANK or perm == Permission.CHANGE_USERNAMES:
 214                         return user.rank.atLeast(UserRank.MODERATOR)
 215                 elif perm == Permission.CHANGE_EMAIL or perm == Permission.CHANGE_PROFILE_URLS:
 216                         return user == self or user.rank.atLeast(UserRank.ADMIN)
 217                 elif perm == Permission.CREATE_TOKEN:
 218                         if user == self:
 219                                 return user.rank.atLeast(UserRank.MEMBER)
 220                         else:
 221                                 return user.rank.atLeast(UserRank.MODERATOR) and user.rank.atLeast(self.rank)
 222                 else:
 223                         raise Exception("Permission {} is not related to users".format(perm.name))
 224
 225         def canCommentRL(self):
 226                 one_min_ago = datetime.datetime.utcnow() - datetime.timedelta(minutes=1)
 227                 if ThreadReply.query.filter_by(author=self) \
 228                                 .filter(ThreadReply.created_at > one_min_ago).count() >= 3:
 229                         return False
 230
 231                 hour_ago = datetime.datetime.utcnow() - datetime.timedelta(hours=1)
 232                 if ThreadReply.query.filter_by(author=self) \
 233                                 .filter(ThreadReply.created_at > hour_ago).count() >= 20:
 234                         return False
 235
 236                 return True
 237
 238         def canOpenThreadRL(self):
 239                 hour_ago = datetime.datetime.utcnow() - datetime.timedelta(hours=1)
 240                 return Thread.query.filter_by(author=self) \
 241                         .filter(Thread.created_at > hour_ago).count() < 2
 242
 243         def __eq__(self, other):
 244                 if other is None:
 245                         return False
 246
 247                 if not self.is_authenticated or not other.is_authenticated:
 248                         return False
 249
 250                 assert self.id > 0
 251                 return self.id == other.id
 252
 253 class UserEmailVerification(db.Model):
 254         id      = db.Column(db.Integer, primary_key=True)
 255         user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
 256         email   = db.Column(db.String(100))
 257         token   = db.Column(db.String(32))
 258         user    = db.relationship("User", foreign_keys=[user_id])
 259
 260 class Notification(db.Model):
 261         id         = db.Column(db.Integer, primary_key=True)
 262
 263         user_id    = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
 264         user       = db.relationship("User", foreign_keys=[user_id])
 265
 266         causer_id  = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
 267         causer     = db.relationship("User", foreign_keys=[causer_id])
 268
 269         title      = db.Column(db.String(100), nullable=False)
 270         url        = db.Column(db.String(200), nullable=True)
 271
 272         package_id = db.Column(db.Integer, db.ForeignKey("package.id"), nullable=True)
 273         package    = db.relationship("Package", foreign_keys=[package_id])
 274
 275         created_at = db.Column(db.DateTime, nullable=True, default=datetime.datetime.utcnow)
 276
 277         def __init__(self, user, causer, title, url, package=None):
 278                 if len(title) > 100:
 279                         title = title[:99] + "…"
 280
 281                 self.user    = user
 282                 self.causer  = causer
 283                 self.title   = title
 284                 self.url     = url
 285                 self.package = package
 286
 287
 288 class License(db.Model):
 289         id      = db.Column(db.Integer, primary_key=True)
 290         name    = db.Column(db.String(50), nullable=False, unique=True)
 291         is_foss = db.Column(db.Boolean,    nullable=False, default=True)
 292
 293         def __init__(self, v, is_foss=True):
 294                 self.name = v
 295                 self.is_foss = is_foss
 296
 297         def __str__(self):
 298                 return self.name
 299
 300
 301 class PackageType(enum.Enum):
 302         MOD  = "Mod"
 303         GAME = "Game"
 304         TXP  = "Texture Pack"
 305
 306         def toName(self):
 307                 return self.name.lower()
 308
 309         def __str__(self):
 310                 return self.name
 311
 312         @classmethod
 313         def get(cls, name):
 314                 try:
 315                         return PackageType[name.upper()]
 316                 except KeyError:
 317                         return None
 318
 319         @classmethod
 320         def choices(cls):
 321                 return [(choice, choice.value) for choice in cls]
 322
 323         @classmethod
 324         def coerce(cls, item):
 325                 return item if type(item) == PackageType else PackageType[item]
 326
 327
 328 class PackagePropertyKey(enum.Enum):
 329         name          = "Name"
 330         title         = "Title"
 331         short_desc     = "Short Description"
 332         desc          = "Description"
 333         type          = "Type"
 334         license       = "License"
 335         media_license = "Media License"
 336         tags          = "Tags"
 337         provides      = "Provides"
 338         repo          = "Repository"
 339         website       = "Website"
 340         issueTracker  = "Issue Tracker"
 341         forums        = "Forum Topic ID"
 342
 343         def convert(self, value):
 344                 if self == PackagePropertyKey.tags:
 345                         return ",".join([t.title for t in value])
 346                 elif self == PackagePropertyKey.provides:
 347                         return ",".join([t.name for t in value])
 348                 else:
 349                         return str(value)
 350
 351 provides = db.Table("provides",
 352         db.Column("package_id",    db.Integer, db.ForeignKey("package.id"), primary_key=True),
 353     db.Column("metapackage_id", db.Integer, db.ForeignKey("meta_package.id"), primary_key=True)
 354 )
 355
 356 Tags = db.Table("tags",
 357     db.Column("tag_id", db.Integer, db.ForeignKey("tag.id"), primary_key=True),
 358     db.Column("package_id", db.Integer, db.ForeignKey("package.id"), primary_key=True)
 359 )
 360
 361 ContentWarnings = db.Table("content_warnings",
 362     db.Column("content_warning_id", db.Integer, db.ForeignKey("content_warning.id"), primary_key=True),
 363     db.Column("package_id", db.Integer, db.ForeignKey("package.id"), primary_key=True)
 364 )
 365
 366 maintainers = db.Table("maintainers",
 367     db.Column("user_id", db.Integer, db.ForeignKey("user.id"), primary_key=True),
 368     db.Column("package_id", db.Integer, db.ForeignKey("package.id"), primary_key=True)
 369 )
 370
 371 class Dependency(db.Model):
 372         id              = db.Column(db.Integer, primary_key=True)
 373         depender_id     = db.Column(db.Integer, db.ForeignKey("package.id"),     nullable=True)
 374         package_id      = db.Column(db.Integer, db.ForeignKey("package.id"),     nullable=True)
 375         package         = db.relationship("Package", foreign_keys=[package_id])
 376         meta_package_id = db.Column(db.Integer, db.ForeignKey("meta_package.id"), nullable=True)
 377         optional        = db.Column(db.Boolean, nullable=False, default=False)
 378         __table_args__  = (db.UniqueConstraint("depender_id", "package_id", "meta_package_id", name="_dependency_uc"), )
 379
 380         def __init__(self, depender=None, package=None, meta=None, optional=False):
 381                 if depender is None:
 382                         return
 383
 384                 self.depender = depender
 385                 self.optional = optional
 386
 387                 packageProvided = package is not None
 388                 metaProvided = meta is not None
 389
 390                 if packageProvided and not metaProvided:
 391                         self.package = package
 392                 elif metaProvided and not packageProvided:
 393                         self.meta_package = meta
 394                 else:
 395                         raise Exception("Either meta or package must be given, but not both!")
 396
 397         def getName(self):
 398                 if self.meta_package:
 399                         return self.meta_package.name
 400                 elif self.package:
 401                         return self.package.name
 402                 else:
 403                         assert False
 404
 405         def __str__(self):
 406                 if self.package is not None:
 407                         return self.package.author.username + "/" + self.package.name
 408                 elif self.meta_package is not None:
 409                         return self.meta_package.name
 410                 else:
 411                         raise Exception("Meta and package are both none!")
 412
 413         @staticmethod
 414         def SpecToList(depender, spec, cache={}):
 415                 retval = []
 416                 arr = spec.split(",")
 417
 418                 import re
 419                 pattern1 = re.compile("^([a-z0-9_]+)$")
 420                 pattern2 = re.compile("^([A-Za-z0-9_]+)/([a-z0-9_]+)$")
 421
 422                 for x in arr:
 423                         x = x.strip()
 424                         if x == "":
 425                                 continue
 426
 427                         if pattern1.match(x):
 428                                 meta = MetaPackage.GetOrCreate(x, cache)
 429                                 retval.append(Dependency(depender, meta=meta))
 430                         else:
 431                                 m = pattern2.match(x)
 432                                 username = m.group(1)
 433                                 name     = m.group(2)
 434                                 user = User.query.filter_by(username=username).first()
 435                                 if user is None:
 436                                         raise Exception("Unable to find user " + username)
 437
 438                                 package = Package.query.filter_by(author=user, name=name).first()
 439                                 if package is None:
 440                                         raise Exception("Unable to find package " + name + " by " + username)
 441
 442                                 retval.append(Dependency(depender, package=package))
 443
 444                 return retval
 445
 446
 447 class Package(db.Model):
 448         query_class  = ArticleQuery
 449
 450         id           = db.Column(db.Integer, primary_key=True)
 451
 452         # Basic details
 453         author_id    = db.Column(db.Integer, db.ForeignKey("user.id"))
 454         name         = db.Column(db.Unicode(100), nullable=False)
 455         title        = db.Column(db.Unicode(100), nullable=False)
 456         short_desc   = db.Column(db.Unicode(200), nullable=False)
 457         desc         = db.Column(db.UnicodeText, nullable=True)
 458         type         = db.Column(db.Enum(PackageType))
 459         created_at   = db.Column(db.DateTime, nullable=False, default=datetime.datetime.utcnow)
 460         approved_at  = db.Column(db.DateTime, nullable=True, default=None)
 461
 462         name_valid = db.CheckConstraint("name ~* '^[a-z0-9_]+$'")
 463
 464         search_vector = db.Column(TSVectorType("name", "title", "short_desc", "desc", \
 465                         weights={ "name": "A", "title": "B", "short_desc": "C", "desc": "D" }))
 466
 467         license_id   = db.Column(db.Integer, db.ForeignKey("license.id"), nullable=False, default=1)
 468         license      = db.relationship("License", foreign_keys=[license_id])
 469         media_license_id = db.Column(db.Integer, db.ForeignKey("license.id"), nullable=False, default=1)
 470         media_license    = db.relationship("License", foreign_keys=[media_license_id])
 471
 472         approved     = db.Column(db.Boolean, nullable=False, default=False)
 473         soft_deleted = db.Column(db.Boolean, nullable=False, default=False)
 474
 475         score        = db.Column(db.Float, nullable=False, default=0)
 476         score_downloads = db.Column(db.Float, nullable=False, default=0)
 477         downloads     = db.Column(db.Integer, nullable=False, default=0)
 478
 479         review_thread_id = db.Column(db.Integer, db.ForeignKey("thread.id"), nullable=True, default=None)
 480         review_thread    = db.relationship("Thread", foreign_keys=[review_thread_id])
 481
 482         # Downloads
 483         repo         = db.Column(db.String(200), nullable=True)
 484         website      = db.Column(db.String(200), nullable=True)
 485         issueTracker = db.Column(db.String(200), nullable=True)
 486         forums       = db.Column(db.Integer,     nullable=True)
 487
 488         provides = db.relationship("MetaPackage", \
 489                         secondary=provides, lazy="select", order_by=db.asc("name"), \
 490                         backref=db.backref("packages", lazy="dynamic", order_by=db.desc("score")))
 491
 492         dependencies = db.relationship("Dependency", backref="depender", lazy="dynamic", foreign_keys=[Dependency.depender_id])
 493
 494         tags = db.relationship("Tag", secondary=Tags, lazy="select",
 495                         backref=db.backref("packages", lazy=True))
 496
 497         content_warnings = db.relationship("ContentWarning", secondary=ContentWarnings, lazy="select",
 498                         backref=db.backref("packages", lazy=True))
 499
 500         releases = db.relationship("PackageRelease", backref="package",
 501                         lazy="dynamic", order_by=db.desc("package_release_releaseDate"))
 502
 503         screenshots = db.relationship("PackageScreenshot", backref="package",
 504                         lazy="dynamic", order_by=db.asc("package_screenshot_id"))
 505
 506         requests = db.relationship("EditRequest", backref="package",
 507                         lazy="dynamic")
 508
 509         maintainers = db.relationship("User", secondary=maintainers, lazy="subquery")
 510
 511         def __init__(self, package=None):
 512                 if package is None:
 513                         return
 514
 515                 self.author_id = package.author_id
 516                 self.created_at = package.created_at
 517                 self.approved = package.approved
 518
 519                 self.maintainers.append(self.author)
 520
 521                 for e in PackagePropertyKey:
 522                         setattr(self, e.name, getattr(package, e.name))
 523
 524         def getId(self):
 525                 return "{}/{}".format(self.author.username, self.name)
 526
 527         def getIsFOSS(self):
 528                 return self.license.is_foss and self.media_license.is_foss
 529
 530         def getIsOnGitHub(self):
 531                 if self.repo is None:
 532                         return False
 533
 534                 url = urlparse(self.repo)
 535                 return url.netloc == "github.com"
 536
 537         def getGitHubFullName(self):
 538                 if self.repo is None:
 539                         return None
 540
 541                 url = urlparse(self.repo)
 542                 if url.netloc != "github.com":
 543                         return None
 544
 545                 import re
 546                 m = re.search(r"^\/([^\/]+)\/([^\/]+)\/?$", url.path)
 547                 if m is None:
 548                         return
 549
 550                 user = m.group(1)
 551                 repo = m.group(2).replace(".git", "")
 552
 553                 return (user,repo)
 554
 555         def getSortedDependencies(self, is_hard=None):
 556                 query = self.dependencies
 557                 if is_hard is not None:
 558                         query = query.filter_by(optional=not is_hard)
 559
 560                 deps = query.all()
 561                 deps.sort(key = lambda x: x.getName())
 562                 return deps
 563
 564         def getSortedHardDependencies(self):
 565                 return self.getSortedDependencies(True)
 566
 567         def getSortedOptionalDependencies(self):
 568                 return self.getSortedDependencies(False)
 569
 570         def getState(self):
 571                 if self.approved:
 572                         return "approved"
 573                 elif self.review_thread_id:
 574                         return "thread"
 575                 elif (self.type == PackageType.GAME or \
 576                                         self.type == PackageType.TXP) and \
 577                                 self.screenshots.count() == 0:
 578                         return "wip"
 579                 elif not self.getDownloadRelease():
 580                         return "wip"
 581                 elif "Other" in self.license.name or "Other" in self.media_license.name:
 582                         return "license"
 583                 else:
 584                         return "ready"
 585
 586         def getAsDictionaryKey(self):
 587                 return {
 588                         "name": self.name,
 589                         "author": self.author.display_name,
 590                         "type": self.type.toName(),
 591                 }
 592
 593         def getAsDictionaryShort(self, base_url, version=None):
 594                 tnurl = self.getThumbnailURL(1)
 595                 release = self.getDownloadRelease(version=version)
 596                 return {
 597                         "name": self.name,
 598                         "title": self.title,
 599                         "author": self.author.username,
 600                         "short_description": self.short_desc,
 601                         "type": self.type.toName(),
 602                         "release": release and release.id,
 603                         "thumbnail": (base_url + tnurl) if tnurl is not None else None
 604                 }
 605
 606         def getAsDictionary(self, base_url, version=None):
 607                 tnurl = self.getThumbnailURL(1)
 608                 release = self.getDownloadRelease(version=version)
 609                 return {
 610                         "author": self.author.username,
 611                         "name": self.name,
 612                         "title": self.title,
 613                         "short_description": self.short_desc,
 614                         "desc": self.desc,
 615                         "type": self.type.toName(),
 616                         "created_at": self.created_at.isoformat(),
 617
 618                         "license": self.license.name,
 619                         "media_license": self.media_license.name,
 620
 621                         "repo": self.repo,
 622                         "website": self.website,
 623                         "issue_tracker": self.issueTracker,
 624                         "forums": self.forums,
 625
 626                         "provides": [x.name for x in self.provides],
 627                         "thumbnail": (base_url + tnurl) if tnurl is not None else None,
 628                         "screenshots": [base_url + ss.url for ss in self.screenshots],
 629
 630                         "url": base_url + self.getDownloadURL(),
 631                         "release": release and release.id,
 632
 633                         "score": round(self.score * 10) / 10
 634                 }
 635
 636         def getThumbnailURL(self, level=2):
 637                 screenshot = self.screenshots.filter_by(approved=True).order_by(db.asc(PackageScreenshot.id)).first()
 638                 return screenshot.getThumbnailURL(level) if screenshot is not None else None
 639
 640         def getMainScreenshotURL(self, absolute=False):
 641                 screenshot = self.screenshots.filter_by(approved=True).order_by(db.asc(PackageScreenshot.id)).first()
 642                 if screenshot is None:
 643                         return None
 644
 645                 if absolute:
 646                         from app.utils import abs_url
 647                         return abs_url(screenshot.url)
 648                 else:
 649                         return screenshot.url
 650
 651         def getDetailsURL(self, absolute=False):
 652                 if absolute:
 653                         from app.utils import abs_url_for
 654                         return abs_url_for("packages.view",
 655                                         author=self.author.username, name=self.name)
 656                 else:
 657                         return url_for("packages.view",
 658                                         author=self.author.username, name=self.name)
 659
 660         def getEditURL(self):
 661                 return url_for("packages.create_edit",
 662                                 author=self.author.username, name=self.name)
 663
 664         def getApproveURL(self):
 665                 return url_for("packages.approve",
 666                                 author=self.author.username, name=self.name)
 667
 668         def getRemoveURL(self):
 669                 return url_for("packages.remove",
 670                                 author=self.author.username, name=self.name)
 671
 672         def getNewScreenshotURL(self):
 673                 return url_for("packages.create_screenshot",
 674                                 author=self.author.username, name=self.name)
 675
 676         def getCreateReleaseURL(self):
 677                 return url_for("packages.create_release",
 678                                 author=self.author.username, name=self.name)
 679
 680         def getCreateEditRequestURL(self):
 681                 return url_for("create_edit_editrequest_page",
 682                                 author=self.author.username, name=self.name)
 683
 684         def getBulkReleaseURL(self):
 685                 return url_for("packages.bulk_change_release",
 686                         author=self.author.username, name=self.name)
 687
 688         def getDownloadURL(self):
 689                 return url_for("packages.download",
 690                                 author=self.author.username, name=self.name)
 691
 692         def getEditMaintainersURL(self):
 693                 return url_for("packages.edit_maintainers",
 694                                 author=self.author.username, name=self.name)
 695
 696         def getRemoveSelfMaintainerURL(self):
 697                 return url_for("packages.remove_self_maintainers",
 698                                 author=self.author.username, name=self.name)
 699
 700         def getUpdateFromReleaseURL(self):
 701                 return url_for("packages.update_from_release",
 702                                 author=self.author.username, name=self.name)
 703
 704         def getReviewURL(self):
 705                 return url_for('packages.review',
 706                                 author=self.author.username, name=self.name)
 707
 708         def getDownloadRelease(self, version=None):
 709                 for rel in self.releases:
 710                         if rel.approved and (version is None or
 711                                         ((rel.min_rel is None or rel.min_rel_id <= version.id) and \
 712                                         (rel.max_rel is None or rel.max_rel_id >= version.id))):
 713                                 return rel
 714
 715                 return None
 716
 717         def checkPerm(self, user, perm):
 718                 if not user.is_authenticated:
 719                         return False
 720
 721                 if type(perm) == str:
 722                         perm = Permission[perm]
 723                 elif type(perm) != Permission:
 724                         raise Exception("Unknown permission given to Package.checkPerm()")
 725
 726                 isOwner = user == self.author
 727                 isMaintainer = isOwner or user.rank.atLeast(UserRank.EDITOR) or user in self.maintainers
 728
 729                 if perm == Permission.CREATE_THREAD:
 730                         return user.rank.atLeast(UserRank.MEMBER)
 731
 732                 # Members can edit their own packages, and editors can edit any packages
 733                 elif perm == Permission.MAKE_RELEASE or perm == Permission.ADD_SCREENSHOTS:
 734                         return isMaintainer
 735
 736                 elif perm == Permission.EDIT_PACKAGE or perm == Permission.REIMPORT_META or \
 737                                 perm == Permission.APPROVE_CHANGES or perm == Permission.APPROVE_RELEASE:
 738                         return isMaintainer and user.rank.atLeast(UserRank.MEMBER if self.approved else UserRank.NEW_MEMBER)
 739
 740                 # Anyone can change the package name when not approved, but only editors when approved
 741                 elif perm == Permission.CHANGE_NAME:
 742                         return not self.approved or user.rank.atLeast(UserRank.EDITOR)
 743
 744                 # Editors can change authors and approve new packages
 745                 elif perm == Permission.APPROVE_NEW or perm == Permission.CHANGE_AUTHOR:
 746                         return user.rank.atLeast(UserRank.EDITOR)
 747
 748                 elif perm == Permission.APPROVE_SCREENSHOT:
 749                         return isMaintainer and user.rank.atLeast(UserRank.TRUSTED_MEMBER if self.approved else UserRank.NEW_MEMBER)
 750
 751                 elif perm == Permission.EDIT_MAINTAINERS:
 752                         return isOwner or user.rank.atLeast(UserRank.MODERATOR)
 753
 754                 elif perm == Permission.UNAPPROVE_PACKAGE or perm == Permission.DELETE_PACKAGE:
 755                         return user.rank.atLeast(UserRank.EDITOR)
 756
 757                 elif perm == Permission.CHANGE_RELEASE_URL:
 758                         return user.rank.atLeast(UserRank.MODERATOR)
 759
 760                 else:
 761                         raise Exception("Permission {} is not related to packages".format(perm.name))
 762
 763         def getScoreDict(self):
 764                 return {
 765                         "author": self.author.username,
 766                         "name": self.name,
 767                         "score": self.score,
 768                         "score_downloads": self.score_downloads,
 769                         "score_reviews": self.score - self.score_downloads,
 770                         "downloads": self.downloads
 771                 }
 772
 773         def recalcScore(self):
 774                 review_scores = [ 100 * r.asSign() for r in self.reviews ]
 775                 self.score = self.score_downloads + sum(review_scores)
 776
 777
 778 class MetaPackage(db.Model):
 779         id           = db.Column(db.Integer, primary_key=True)
 780         name         = db.Column(db.String(100), unique=True, nullable=False)
 781         dependencies = db.relationship("Dependency", backref="meta_package", lazy="dynamic")
 782
 783         mp_name_valid = db.CheckConstraint("name ~* '^[a-z0-9_]+$'")
 784
 785         def __init__(self, name=None):
 786                 self.name = name
 787
 788         def __str__(self):
 789                 return self.name
 790
 791         @staticmethod
 792         def ListToSpec(list):
 793                 return ",".join([str(x) for x in list])
 794
 795         @staticmethod
 796         def GetOrCreate(name, cache={}):
 797                 mp = cache.get(name)
 798                 if mp is None:
 799                         mp = MetaPackage.query.filter_by(name=name).first()
 800
 801                 if mp is None:
 802                         mp = MetaPackage(name)
 803                         db.session.add(mp)
 804
 805                 cache[name] = mp
 806                 return mp
 807
 808         @staticmethod
 809         def SpecToList(spec, cache={}):
 810                 retval = []
 811                 arr = spec.split(",")
 812
 813                 import re
 814                 pattern = re.compile("^([a-z0-9_]+)$")
 815
 816                 for x in arr:
 817                         x = x.strip()
 818                         if x == "":
 819                                 continue
 820
 821                         if not pattern.match(x):
 822                                 continue
 823
 824                         retval.append(MetaPackage.GetOrCreate(x, cache))
 825
 826                 return retval
 827
 828
 829 class ContentWarning(db.Model):
 830         id              = db.Column(db.Integer, primary_key=True)
 831         name            = db.Column(db.String(100), unique=True, nullable=False)
 832         title           = db.Column(db.String(100), nullable=False)
 833         description     = db.Column(db.String(500), nullable=False)
 834
 835         def __init__(self, title, description=""):
 836                 self.title       = title
 837                 self.description = description
 838
 839                 import re
 840                 regex = re.compile("[^a-z_]")
 841                 self.name = regex.sub("", self.title.lower().replace(" ", "_"))
 842
 843
 844 class Tag(db.Model):
 845         id              = db.Column(db.Integer, primary_key=True)
 846         name            = db.Column(db.String(100), unique=True, nullable=False)
 847         title           = db.Column(db.String(100), nullable=False)
 848         description     = db.Column(db.String(500), nullable=True, default=None)
 849         backgroundColor = db.Column(db.String(6), nullable=False)
 850         textColor       = db.Column(db.String(6), nullable=False)
 851         views           = db.Column(db.Integer, nullable=False, default=0)
 852
 853         def __init__(self, title, backgroundColor="000000", textColor="ffffff"):
 854                 self.title           = title
 855                 self.backgroundColor = backgroundColor
 856                 self.textColor       = textColor
 857
 858                 import re
 859                 regex = re.compile("[^a-z_]")
 860                 self.name = regex.sub("", self.title.lower().replace(" ", "_"))
 861
 862
 863 class MinetestRelease(db.Model):
 864         id       = db.Column(db.Integer, primary_key=True)
 865         name     = db.Column(db.String(100), unique=True, nullable=False)
 866         protocol = db.Column(db.Integer, nullable=False, default=0)
 867
 868         def __init__(self, name=None, protocol=0):
 869                 self.name = name
 870                 self.protocol = protocol
 871
 872         def getActual(self):
 873                 return None if self.name == "None" else self
 874
 875         @classmethod
 876         def get(cls, version, protocol_num):
 877                 if version:
 878                         parts = version.strip().split(".")
 879                         if len(parts) >= 2:
 880                                 major_minor = parts[0] + "." + parts[1]
 881                                 query = MinetestRelease.query.filter(MinetestRelease.name.like("{}%".format(major_minor)))
 882                                 if protocol_num:
 883                                         query = query.filter_by(protocol=protocol_num)
 884
 885                                 release = query.one_or_none()
 886                                 if release:
 887                                         return release
 888
 889                 if protocol_num:
 890                         return MinetestRelease.query.filter_by(protocol=protocol_num).first()
 891
 892                 return None
 893
 894
 895 class PackageRelease(db.Model):
 896         id           = db.Column(db.Integer, primary_key=True)
 897
 898         package_id   = db.Column(db.Integer, db.ForeignKey("package.id"))
 899         title        = db.Column(db.String(100), nullable=False)
 900         releaseDate  = db.Column(db.DateTime,    nullable=False)
 901         url          = db.Column(db.String(200), nullable=False)
 902         approved     = db.Column(db.Boolean, nullable=False, default=False)
 903         task_id      = db.Column(db.String(37), nullable=True)
 904         commit_hash  = db.Column(db.String(41), nullable=True, default=None)
 905         downloads    = db.Column(db.Integer, nullable=False, default=0)
 906
 907         min_rel_id = db.Column(db.Integer, db.ForeignKey("minetest_release.id"), nullable=True, server_default=None)
 908         min_rel    = db.relationship("MinetestRelease", foreign_keys=[min_rel_id])
 909
 910         max_rel_id = db.Column(db.Integer, db.ForeignKey("minetest_release.id"), nullable=True, server_default=None)
 911         max_rel    = db.relationship("MinetestRelease", foreign_keys=[max_rel_id])
 912
 913         # If the release is approved, then the task_id must be null and the url must be present
 914         CK_approval_valid = db.CheckConstraint("not approved OR (task_id IS NULL AND (url = '') IS NOT FALSE)")
 915
 916         def getAsDictionary(self):
 917                 return {
 918                         "id": self.id,
 919                         "title": self.title,
 920                         "url": self.url if self.url != "" else None,
 921                         "release_date": self.releaseDate.isoformat(),
 922                         "commit": self.commit_hash,
 923                         "downloads": self.downloads,
 924                         "min_protocol": self.min_rel and self.min_rel.protocol,
 925                         "max_protocol": self.max_rel and self.max_rel.protocol
 926                 }
 927
 928         def getEditURL(self):
 929                 return url_for("packages.edit_release",
 930                                 author=self.package.author.username,
 931                                 name=self.package.name,
 932                                 id=self.id)
 933
 934         def getDeleteURL(self):
 935                 return url_for("packages.delete_release",
 936                                 author=self.package.author.username,
 937                                 name=self.package.name,
 938                                 id=self.id)
 939
 940         def getDownloadURL(self):
 941                 return url_for("packages.download_release",
 942                                 author=self.package.author.username,
 943                                 name=self.package.name,
 944                                 id=self.id)
 945
 946         def __init__(self):
 947                 self.releaseDate = datetime.datetime.now()
 948
 949         def approve(self, user):
 950                 if not self.package.checkPerm(user, Permission.APPROVE_RELEASE):
 951                         return False
 952
 953                 assert self.task_id is None and self.url is not None and self.url != ""
 954
 955                 self.approved = True
 956                 return True
 957
 958         def checkPerm(self, user, perm):
 959                 if not user.is_authenticated:
 960                         return False
 961
 962                 if type(perm) == str:
 963                         perm = Permission[perm]
 964                 elif type(perm) != Permission:
 965                         raise Exception("Unknown permission given to PackageRelease.checkPerm()")
 966
 967                 isOwner = user == self.package.author
 968
 969                 if perm == Permission.DELETE_RELEASE:
 970                         if user.rank.atLeast(UserRank.ADMIN):
 971                                 return True
 972
 973                         if not (isOwner or user.rank.atLeast(UserRank.EDITOR)):
 974                                 return False
 975
 976                         if not self.package.approved or self.task_id is not None:
 977                                 return True
 978
 979                         count = PackageRelease.query \
 980                                         .filter_by(package_id=self.package_id) \
 981                                         .filter(PackageRelease.id > self.id) \
 982                                         .count()
 983
 984                         return count > 0
 985                 else:
 986                         raise Exception("Permission {} is not related to releases".format(perm.name))
 987
 988
 989 # class PackageReview(db.Model):
 990 #       id         = db.Column(db.Integer, primary_key=True)
 991 #       package_id = db.Column(db.Integer, db.ForeignKey("package.id"))
 992 #       thread_id  = db.Column(db.Integer, db.ForeignKey("thread.id"), nullable=False)
 993 #       recommend  = db.Column(db.Boolean, nullable=False, default=True)
 994
 995
 996 class PackageScreenshot(db.Model):
 997         id         = db.Column(db.Integer, primary_key=True)
 998         package_id = db.Column(db.Integer, db.ForeignKey("package.id"))
 999         title      = db.Column(db.String(100), nullable=False)
1000         url        = db.Column(db.String(100), nullable=False)
1001         approved   = db.Column(db.Boolean, nullable=False, default=False)
1002
1003
1004         def getEditURL(self):
1005                 return url_for("packages.edit_screenshot",
1006                                 author=self.package.author.username,
1007                                 name=self.package.name,
1008                                 id=self.id)
1009
1010         def getThumbnailURL(self, level=2):
1011                 return self.url.replace("/uploads/", ("/thumbnails/{:d}/").format(level))
1012
1013
1014 class APIToken(db.Model):
1015         id           = db.Column(db.Integer, primary_key=True)
1016         access_token = db.Column(db.String(34), unique=True)
1017
1018         name         = db.Column(db.String(100), nullable=False)
1019         owner_id     = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
1020         # owner is created using backref
1021
1022         created_at   = db.Column(db.DateTime, nullable=False, default=datetime.datetime.utcnow)
1023
1024         package_id = db.Column(db.Integer, db.ForeignKey("package.id"), nullable=True)
1025         package    = db.relationship("Package", foreign_keys=[package_id])
1026
1027         def canOperateOnPackage(self, package):
1028                 if self.package and self.package != package:
1029                         return False
1030
1031                 return package.author == self.owner
1032
1033
1034 class EditRequest(db.Model):
1035         id           = db.Column(db.Integer, primary_key=True)
1036
1037         package_id   = db.Column(db.Integer, db.ForeignKey("package.id"))
1038         author_id    = db.Column(db.Integer, db.ForeignKey("user.id"))
1039
1040         title        = db.Column(db.String(100), nullable=False)
1041         desc         = db.Column(db.String(1000), nullable=True)
1042
1043         # 0 - open
1044         # 1 - merged
1045         # 2 - rejected
1046         status       = db.Column(db.Integer, nullable=False, default=0)
1047
1048         changes = db.relationship("EditRequestChange", backref="request",
1049                         lazy="dynamic")
1050
1051         def getURL(self):
1052                 return url_for("view_editrequest_page",
1053                                 author=self.package.author.username,
1054                                 name=self.package.name,
1055                                 id=self.id)
1056
1057         def getApproveURL(self):
1058                 return url_for("approve_editrequest_page",
1059                                 author=self.package.author.username,
1060                                 name=self.package.name,
1061                                 id=self.id)
1062
1063         def getRejectURL(self):
1064                 return url_for("reject_editrequest_page",
1065                                 author=self.package.author.username,
1066                                 name=self.package.name,
1067                                 id=self.id)
1068
1069         def getEditURL(self):
1070                 return url_for("create_edit_editrequest_page",
1071                                 author=self.package.author.username,
1072                                 name=self.package.name,
1073                                 id=self.id)
1074
1075         def applyAll(self, package):
1076                 for change in self.changes:
1077                         change.apply(package)
1078
1079
1080         def checkPerm(self, user, perm):
1081                 if not user.is_authenticated:
1082                         return False
1083
1084                 if type(perm) == str:
1085                         perm = Permission[perm]
1086                 elif type(perm) != Permission:
1087                         raise Exception("Unknown permission given to EditRequest.checkPerm()")
1088
1089                 isOwner = user == self.author
1090
1091                 # Members can edit their own packages, and editors can edit any packages
1092                 if perm == Permission.EDIT_EDITREQUEST:
1093                         return isOwner or user.rank.atLeast(UserRank.EDITOR)
1094
1095                 else:
1096                         raise Exception("Permission {} is not related to packages".format(perm.name))
1097
1098
1099
1100
1101 class EditRequestChange(db.Model):
1102         id           = db.Column(db.Integer, primary_key=True)
1103
1104         request_id   = db.Column(db.Integer, db.ForeignKey("edit_request.id"))
1105         key          = db.Column(db.Enum(PackagePropertyKey), nullable=False)
1106
1107         # TODO: make diff instead
1108         oldValue     = db.Column(db.Text, nullable=True)
1109         newValue     = db.Column(db.Text, nullable=True)
1110
1111         def apply(self, package):
1112                 if self.key == PackagePropertyKey.tags:
1113                         package.tags.clear()
1114                         for tagTitle in self.newValue.split(","):
1115                                 tag = Tag.query.filter_by(title=tagTitle.strip()).first()
1116                                 package.tags.append(tag)
1117
1118                 else:
1119                         setattr(package, self.key.name, self.newValue)
1120
1121
1122 watchers = db.Table("watchers",
1123     db.Column("user_id", db.Integer, db.ForeignKey("user.id"), primary_key=True),
1124     db.Column("thread_id", db.Integer, db.ForeignKey("thread.id"), primary_key=True)
1125 )
1126
1127 class Thread(db.Model):
1128         id         = db.Column(db.Integer, primary_key=True)
1129
1130         package_id = db.Column(db.Integer, db.ForeignKey("package.id"), nullable=True)
1131         package    = db.relationship("Package", foreign_keys=[package_id])
1132
1133         review_id  = db.Column(db.Integer, db.ForeignKey("package_review.id"), nullable=True)
1134         review     = db.relationship("PackageReview", foreign_keys=[review_id])
1135
1136         author_id  = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
1137         title      = db.Column(db.String(100), nullable=False)
1138         private    = db.Column(db.Boolean, server_default="0", nullable=False)
1139
1140         locked     = db.Column(db.Boolean, server_default="0", nullable=False)
1141
1142         created_at = db.Column(db.DateTime, nullable=False, default=datetime.datetime.utcnow)
1143
1144         replies    = db.relationship("ThreadReply", backref="thread", lazy="dynamic", \
1145                         order_by=db.asc("thread_reply_id"))
1146
1147         watchers   = db.relationship("User", secondary=watchers, lazy="subquery", \
1148                         backref=db.backref("watching", lazy=True))
1149
1150         def getViewURL(self):
1151                 return url_for("threads.view", id=self.id)
1152
1153         def getSubscribeURL(self):
1154                 return url_for("threads.subscribe", id=self.id)
1155
1156         def getUnsubscribeURL(self):
1157                 return url_for("threads.unsubscribe", id=self.id)
1158
1159         def checkPerm(self, user, perm):
1160                 if not user.is_authenticated:
1161                         return perm == Permission.SEE_THREAD and not self.private
1162
1163                 if type(perm) == str:
1164                         perm = Permission[perm]
1165                 elif type(perm) != Permission:
1166                         raise Exception("Unknown permission given to Thread.checkPerm()")
1167
1168                 isMaintainer = user == self.author or (self.package is not None and self.package.author == user)
1169                 if self.package:
1170                         isMaintainer = isMaintainer or user in self.package.maintainers
1171
1172                 canSee = not self.private or isMaintainer or user.rank.atLeast(UserRank.EDITOR)
1173
1174                 if perm == Permission.SEE_THREAD:
1175                         return canSee
1176
1177                 elif perm == Permission.COMMENT_THREAD:
1178                         return canSee and (not self.locked or user.rank.atLeast(UserRank.MODERATOR))
1179
1180                 elif perm == Permission.LOCK_THREAD:
1181                         return user.rank.atLeast(UserRank.MODERATOR)
1182
1183                 else:
1184                         raise Exception("Permission {} is not related to threads".format(perm.name))
1185
1186 class ThreadReply(db.Model):
1187         id         = db.Column(db.Integer, primary_key=True)
1188         thread_id  = db.Column(db.Integer, db.ForeignKey("thread.id"), nullable=False)
1189         comment    = db.Column(db.String(2000), nullable=False)
1190         author_id  = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
1191         created_at = db.Column(db.DateTime, nullable=False, default=datetime.datetime.utcnow)
1192
1193         def checkPerm(self, user, perm):
1194                 if not user.is_authenticated:
1195                         return False
1196
1197                 if type(perm) == str:
1198                         perm = Permission[perm]
1199                 elif type(perm) != Permission:
1200                         raise Exception("Unknown permission given to ThreadReply.checkPerm()")
1201
1202                 if perm == Permission.EDIT_REPLY:
1203                         return user == self.author and user.rank.atLeast(UserRank.MEMBER) and not self.thread.locked
1204
1205                 elif perm == Permission.DELETE_REPLY:
1206                         return user.rank.atLeast(UserRank.MODERATOR) and self.thread.replies[0] != self
1207
1208                 else:
1209                         raise Exception("Permission {} is not related to threads".format(perm.name))
1210
1211
1212 class PackageReview(db.Model):
1213         id         = db.Column(db.Integer, primary_key=True)
1214
1215         package_id = db.Column(db.Integer, db.ForeignKey("package.id"), nullable=True)
1216         package    = db.relationship("Package", foreign_keys=[package_id], backref=db.backref("reviews", lazy=True))
1217
1218         created_at = db.Column(db.DateTime, nullable=False, default=datetime.datetime.utcnow)
1219
1220         author_id  = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
1221         author     = db.relationship("User", foreign_keys=[author_id], backref=db.backref("reviews", lazy=True))
1222
1223         recommends = db.Column(db.Boolean, nullable=False)
1224
1225         thread     = db.relationship("Thread", uselist=False, back_populates="review")
1226
1227         def asSign(self):
1228                 return 1 if self.recommends else -1
1229
1230         def getEditURL(self):
1231                 return self.package.getReviewURL()
1232
1233         def getDeleteURL(self):
1234                 return url_for("packages.delete_review",
1235                                 author=self.package.author.username,
1236                                 name=self.package.name)
1237
1238
1239 class AuditSeverity(enum.Enum):
1240         NORMAL = 0 # Normal user changes
1241         EDITOR = 1 # Editor changes
1242         MODERATION = 2 # Destructive / moderator changes
1243
1244         def __str__(self):
1245                 return self.name
1246
1247         def getTitle(self):
1248                 return self.name.replace("_", " ").title()
1249
1250         @classmethod
1251         def choices(cls):
1252                 return [(choice, choice.getTitle()) for choice in cls]
1253
1254         @classmethod
1255         def coerce(cls, item):
1256                 return item if type(item) == AuditSeverity else AuditSeverity[item]
1257
1258
1259
1260 class AuditLogEntry(db.Model):
1261         id         = db.Column(db.Integer, primary_key=True)
1262
1263         created_at = db.Column(db.DateTime, nullable=False, default=datetime.datetime.utcnow)
1264
1265         causer_id  = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
1266         causer     = db.relationship("User", foreign_keys=[causer_id])
1267
1268         severity   = db.Column(db.Enum(AuditSeverity), nullable=False)
1269
1270         title      = db.Column(db.String(100), nullable=False)
1271         url        = db.Column(db.String(200), nullable=True)
1272
1273         package_id = db.Column(db.Integer, db.ForeignKey("package.id"), nullable=True)
1274         package    = db.relationship("Package", foreign_keys=[package_id])
1275
1276         description = db.Column(db.Text, nullable=True, default=None)
1277
1278         def __init__(self, causer, severity, title, url, package=None, description=None):
1279                 if len(title) > 100:
1280                         title = title[:99] + "…"
1281
1282                 self.causer   = causer
1283                 self.severity = severity
1284                 self.title    = title
1285                 self.url      = url
1286                 self.package  = package
1287                 self.description = description
1288
1289
1290
1291
1292 REPO_BLACKLIST = [".zip", "mediafire.com", "dropbox.com", "weebly.com", \
1293                 "minetest.net", "dropboxusercontent.com", "4shared.com", \
1294                 "digitalaudioconcepts.com", "hg.intevation.org", "www.wtfpl.net", \
1295                 "imageshack.com", "imgur.com"]
1296
1297 class ForumTopic(db.Model):
1298         topic_id  = db.Column(db.Integer, primary_key=True, autoincrement=False)
1299         author_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
1300         author    = db.relationship("User")
1301
1302         wip       = db.Column(db.Boolean, server_default="0")
1303         discarded = db.Column(db.Boolean, server_default="0")
1304
1305         type      = db.Column(db.Enum(PackageType), nullable=False)
1306         title     = db.Column(db.String(200), nullable=False)
1307         name      = db.Column(db.String(30), nullable=True)
1308         link      = db.Column(db.String(200), nullable=True)
1309
1310         posts     = db.Column(db.Integer, nullable=False)
1311         views     = db.Column(db.Integer, nullable=False)
1312
1313         created_at = db.Column(db.DateTime, nullable=False, default=datetime.datetime.utcnow)
1314
1315         def getRepoURL(self):
1316                 if self.link is None:
1317                         return None
1318
1319                 for item in REPO_BLACKLIST:
1320                         if item in self.link:
1321                                 return None
1322
1323                 return self.link.replace("repo.or.cz/w/", "repo.or.cz/")
1324
1325         def getAsDictionary(self):
1326                 return {
1327                         "author": self.author.username,
1328                         "name":   self.name,
1329                         "type":   self.type.toName(),
1330                         "title":  self.title,
1331                         "id":     self.topic_id,
1332                         "link":   self.link,
1333                         "posts":  self.posts,
1334                         "views":  self.views,
1335                         "is_wip": self.wip,
1336                         "discarded":  self.discarded,
1337                         "created_at": self.created_at.isoformat(),
1338                 }
1339
1340         def checkPerm(self, user, perm):
1341                 if not user.is_authenticated:
1342                         return False
1343
1344                 if type(perm) == str:
1345                         perm = Permission[perm]
1346                 elif type(perm) != Permission:
1347                         raise Exception("Unknown permission given to ForumTopic.checkPerm()")
1348
1349                 if perm == Permission.TOPIC_DISCARD:
1350                         return self.author == user or user.rank.atLeast(UserRank.EDITOR)
1351
1352                 else:
1353                         raise Exception("Permission {} is not related to topics".format(perm.name))
1354
1355
1356 # Setup Flask-User
1357 user_manager = UserManager(app, db, User)
1358
1359 if app.config.get("LOG_SQL"):
1360         import logging
1361         logging.basicConfig()
1362         logging.getLogger('sqlalchemy.engine').setLevel(logging.INFO)