app/querybuilder.py

   1 from .models import db, PackageType, Package, ForumTopic, License, MinetestRelease, PackageRelease
   2 from .utils import isNo, isYes
   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                 hide_flags = args.getlist("hide")
  23
  24                 self.title  = title
  25                 self.types  = types
  26                 self.search = args.get("q")
  27                 self.random = "random" in args
  28                 self.lucky  = "lucky" in args
  29                 self.hide_nonfree = "nonfree" in hide_flags
  30                 self.limit  = 1 if self.lucky else None
  31                 self.order_by  = args.get("sort")
  32                 self.order_dir = args.get("order") or "desc"
  33                 self.protocol_version = args.get("protocol_version")
  34
  35                 self.show_discarded = isYes(args.get("show_discarded"))
  36                 self.show_added = args.get("show_added")
  37                 if self.show_added is not None:
  38                         self.show_added = isYes(self.show_added)
  39
  40                 if self.search is not None and self.search.strip() == "":
  41                         self.search = None
  42
  43         def setSortIfNone(self, name):
  44                 if self.order_by is None:
  45                         self.order_by = name
  46
  47         def getMinetestVersion(self):
  48                 if not self.protocol_version:
  49                         return None
  50
  51                 self.protocol_version = int(self.protocol_version)
  52                 version = MinetestRelease.query.filter(MinetestRelease.protocol>=self.protocol_version).first()
  53                 if version is not None:
  54                         return version.id
  55                 else:
  56                         return 10000000
  57
  58         def buildPackageQuery(self):
  59                 query = Package.query.filter_by(soft_deleted=False, approved=True)
  60
  61                 if len(self.types) > 0:
  62                         query = query.filter(Package.type.in_(self.types))
  63
  64                 if self.search:
  65                         query = query.search(self.search)
  66
  67                 if self.random:
  68                         query = query.order_by(func.random())
  69                 else:
  70                         to_order = None
  71                         if self.order_by is None or self.order_by == "score":
  72                                 to_order = Package.score
  73                         elif self.order_by == "created_at":
  74                                 to_order = Package.created_at
  75                         else:
  76                                 abort(400)
  77
  78                         if self.order_dir == "asc":
  79                                 to_order = db.asc(to_order)
  80                         elif self.order_dir == "desc":
  81                                 to_order = db.desc(to_order)
  82                         else:
  83                                 abort(400)
  84
  85                         query = query.order_by(to_order)
  86
  87                 if self.hide_nonfree:
  88                         query = query.filter(Package.license.has(License.is_foss == True))
  89                         query = query.filter(Package.media_license.has(License.is_foss == True))
  90
  91                 if self.protocol_version:
  92                         version = self.getMinetestVersion()
  93                         query = query.join(Package.releases) \
  94                                 .filter(PackageRelease.approved==True) \
  95                                 .filter(or_(PackageRelease.min_rel_id==None, PackageRelease.min_rel_id<=version)) \
  96                                 .filter(or_(PackageRelease.max_rel_id==None, PackageRelease.max_rel_id>=version))
  97
  98                 if self.limit:
  99                         query = query.limit(self.limit)
 100
 101                 return query
 102
 103         def buildTopicQuery(self, show_added=False):
 104                 query = ForumTopic.query
 105
 106                 if not self.show_discarded:
 107                         query = query.filter_by(discarded=False)
 108
 109                 show_added = self.show_added == True or (self.show_added is None and show_added)
 110                 if not show_added:
 111                         query = query.filter(~ db.exists().where(Package.forums==ForumTopic.topic_id))
 112
 113                 if self.order_by is None or self.order_by == "name":
 114                         query = query.order_by(db.asc(ForumTopic.wip), db.asc(ForumTopic.name), db.asc(ForumTopic.title))
 115                 elif self.order_by == "views":
 116                         query = query.order_by(db.desc(ForumTopic.views))
 117                 elif self.order_by == "date":
 118                         query = query.order_by(db.asc(ForumTopic.created_at))
 119                         sort_by = "date"
 120
 121                 if self.search:
 122                         query = query.filter(ForumTopic.title.ilike('%' + self.search + '%'))
 123
 124                 if len(self.types) > 0:
 125                         query = query.filter(ForumTopic.type.in_(self.types))
 126
 127                 if self.limit:
 128                         query = query.limit(self.limit)
 129
 130                 return query