app/querybuilder.py

   1 from .models import db, PackageType, Package, ForumTopic, License, MinetestRelease, PackageRelease, User, Tag, Tags, ContentWarning
   2 from .utils import isNo, isYes, get_int_or_abort
   3 from sqlalchemy.sql.expression import func
   4 from flask import abort
   5 from sqlalchemy import or_
   6
   7 class QueryBuilder:
   8         title  = None
   9         types  = None
  10         search = None
  11
  12         def __init__(self, args):
  13                 title = "Packages"
  14
  15                 # Get request types
  16                 types = args.getlist("type")
  17                 types = [PackageType.get(tname) for tname in types]
  18                 types = [type for type in types if type is not None]
  19                 if len(types) > 0:
  20                         title = ", ".join([type.value + "s" for type in types])
  21
  22                 # Get tags types
  23                 tags = args.getlist("tag")
  24                 tags = [Tag.query.filter_by(name=tname).first() for tname in tags]
  25                 tags = [tag for tag in tags if tag is not None]
  26
  27                 # Hide
  28                 hide_flags = args.getlist("hide")
  29
  30
  31                 self.title  = title
  32                 self.types  = types
  33                 self.tags   = tags
  34
  35                 self.random = "random" in args
  36                 self.lucky  = "lucky" in args
  37                 self.limit  = 1 if self.lucky else None
  38                 self.order_by  = args.get("sort")
  39                 self.order_dir = args.get("order") or "desc"
  40
  41                 self.hide_nonfree = "nonfree" in hide_flags
  42                 self.hide_flags = set(hide_flags)
  43                 self.hide_flags.discard("nonfree")
  44
  45                 # Filters
  46
  47                 self.search = args.get("q")
  48                 self.minetest_version = args.get("engine_version")
  49                 self.protocol_version = get_int_or_abort(args.get("protocol_version"))
  50                 self.author = args.get("author")
  51
  52                 self.show_discarded = isYes(args.get("show_discarded"))
  53                 self.show_added = args.get("show_added")
  54                 if self.show_added is not None:
  55                         self.show_added = isYes(self.show_added)
  56
  57                 if self.search is not None and self.search.strip() == "":
  58                         self.search = None
  59
  60         def setSortIfNone(self, name, dir="desc"):
  61                 if self.order_by is None:
  62                         self.order_by = name
  63                         self.order_dir = dir
  64
  65         def getMinetestVersion(self):
  66                 if not self.protocol_version and not self.minetest_version:
  67                         return None
  68
  69                 return MinetestRelease.get(self.minetest_version, self.protocol_version)
  70
  71         def buildPackageQuery(self):
  72                 query = None
  73                 if self.order_by == "last_release":
  74                         query = db.session.query(Package).select_from(PackageRelease).join(Package) \
  75                                 .filter_by(state=PackageState.APPROVED)
  76                 else:
  77                         query = Package.query.filter_by(state=PackageState.APPROVED)
  78
  79                 return self.filterPackageQuery(self.orderPackageQuery(query))
  80
  81         def filterPackageQuery(self, query):
  82                 if len(self.types) > 0:
  83                         query = query.filter(Package.type.in_(self.types))
  84
  85                 if self.author:
  86                         author = User.query.filter_by(username=self.author).first()
  87                         if not author:
  88                                 abort(404)
  89
  90                         query = query.filter_by(author=author)
  91
  92                 for tag in self.tags:
  93                         query = query.filter(Package.tags.any(Tag.id == tag.id))
  94
  95                 if "android_default" in self.hide_flags:
  96                         query = query.filter(~ Package.content_warnings.any())
  97                 else:
  98                         for flag in self.hide_flags:
  99                                 warning = ContentWarning.query.filter_by(name=flag).first()
 100                                 if warning:
 101                                         query = query.filter(~ Package.content_warnings.any(ContentWarning.id == warning.id))
 102
 103                 if self.hide_nonfree:
 104                         query = query.filter(Package.license.has(License.is_foss == True))
 105                         query = query.filter(Package.media_license.has(License.is_foss == True))
 106
 107                 if self.protocol_version or self.minetest_version:
 108                         version = self.getMinetestVersion()
 109                         if version:
 110                                 query = query.join(Package.releases) \
 111                                         .filter(PackageRelease.approved==True) \
 112                                         .filter(or_(PackageRelease.min_rel_id==None, PackageRelease.min_rel_id<=version.id)) \
 113                                         .filter(or_(PackageRelease.max_rel_id==None, PackageRelease.max_rel_id>=version.id))
 114
 115                 if self.limit:
 116                         query = query.limit(self.limit)
 117
 118                 return query
 119
 120         def orderPackageQuery(self, query):
 121                 if self.search:
 122                         query = query.search(self.search, sort=self.order_by is None)
 123
 124                 if self.random:
 125                         query = query.order_by(func.random())
 126                         return query
 127
 128                 to_order = None
 129                 if self.order_by is None and self.search:
 130                         pass
 131                 elif self.order_by is None or self.order_by == "score":
 132                         to_order = Package.score
 133                 elif self.order_by == "name":
 134                         to_order = Package.name
 135                 elif self.order_by == "title":
 136                         to_order = Package.title
 137                 elif self.order_by == "downloads":
 138                         to_order = Package.downloads
 139                 elif self.order_by == "created_at" or self.order_by == "date":
 140                         to_order = Package.created_at
 141                 elif self.order_by == "approved_at" or self.order_by == "date":
 142                         to_order = Package.approved_at
 143                 elif self.order_by == "last_release":
 144                         to_order = PackageRelease.releaseDate
 145                 else:
 146                         abort(400)
 147
 148                 if to_order:
 149                         if self.order_dir == "asc":
 150                                 to_order = db.asc(to_order)
 151                         elif self.order_dir == "desc":
 152                                 to_order = db.desc(to_order)
 153                         else:
 154                                 abort(400)
 155
 156                         query = query.order_by(to_order)
 157
 158                 return query
 159
 160         def buildTopicQuery(self, show_added=False):
 161                 query = ForumTopic.query
 162
 163                 if not self.show_discarded:
 164                         query = query.filter_by(discarded=False)
 165
 166                 show_added = self.show_added == True or (self.show_added is None and show_added)
 167                 if not show_added:
 168                         query = query.filter(~ db.exists().where(Package.forums==ForumTopic.topic_id))
 169
 170                 if self.order_by is None or self.order_by == "name":
 171                         query = query.order_by(db.asc(ForumTopic.wip), db.asc(ForumTopic.name), db.asc(ForumTopic.title))
 172                 elif self.order_by == "views":
 173                         query = query.order_by(db.desc(ForumTopic.views))
 174                 elif self.order_by == "created_at" or self.order_by == "date":
 175                         query = query.order_by(db.asc(ForumTopic.created_at))
 176
 177                 if self.search:
 178                         query = query.filter(ForumTopic.title.ilike('%' + self.search + '%'))
 179
 180                 if len(self.types) > 0:
 181                         query = query.filter(ForumTopic.type.in_(self.types))
 182
 183                 if self.limit:
 184                         query = query.limit(self.limit)
 185
 186                 return query