Debian Codegraph @

src/webswview/lkswview/portal/views.py

raw
1 # -*- coding: utf-8 -*-
2 #
3 # Copyright (C) 2018-2022 Matthias Klumpp <[email protected]>
4 #
5 # SPDX-License-Identifier: LGPL-3.0+
6
7 import math
8
9 import gi
10 from flask import Blueprint, abort, flash, request, url_for, redirect, render_template
11 from sqlalchemy import String, and_, cast, func
12 from sqlalchemy.orm import joinedload
13 from sqlalchemy.dialects.postgresql import ARRAY
14
15 import laniakea.typing as T
16 from laniakea.db import (
17 ArchiveSuite,
18 ArchiveConfig,
19 BinaryPackage,
20 SourcePackage,
21 ArchiveSection,
22 PackageOverride,
23 ArchiveRepository,
24 SoftwareComponent,
25 session_scope,
26 )
27 from laniakea.archive import repo_suite_settings_for
28
29 from ..extensions import cache
30
31 gi.require_version('AppStream', '1.0')
32 from gi.repository import AppStream
33
34 portal = Blueprint('portal', __name__)
35
36
37 @portal.route('/')
38 def index():
39 return render_template('index.html')
40
41
42 @portal.route('/search_pkg', methods=['GET', 'POST'])
43 def search_pkg():
44 term = request.args.get('term')
45 if not term:
46 flash('The search term was invalid.')
47 return redirect(url_for('portal.index'))
48
49 with session_scope() as session:
50 spkg_filters = [SourcePackage.time_deleted.is_(None), SourcePackage.name.like('%' + term + '%')]
51
52 spkg_filter_sq = session.query(SourcePackage).filter(*spkg_filters).subquery()
53 smv_sq = (
54 session.query(spkg_filter_sq.c.name, func.max(spkg_filter_sq.c.version).label('max_version'))
55 .group_by(spkg_filter_sq.c.name)
56 .subquery('smv_sq')
57 )
58 src_packages = (
59 session.query(SourcePackage)
60 .options(joinedload(SourcePackage.repo), joinedload(SourcePackage.suites))
61 .filter(*spkg_filters)
62 .join(
63 smv_sq,
64 and_(
65 SourcePackage.name == smv_sq.c.name,
66 SourcePackage.version == smv_sq.c.max_version,
67 ),
68 )
69 .order_by(SourcePackage.name)
70 .all()
71 )
72
73 bin_packages = (
74 session.query(BinaryPackage)
75 .options(joinedload(BinaryPackage.repo), joinedload(BinaryPackage.suites))
76 .filter(
77 BinaryPackage.time_deleted.is_(None), BinaryPackage.__ts_vector__.op('@@')(func.plainto_tsquery(term))
78 )
79 .distinct(BinaryPackage.name, BinaryPackage.version)
80 ).all()
81
82 results_count = len(bin_packages) + len(src_packages)
83
84 results_per_page = results_count
85 page_count = math.ceil(results_count / results_per_page) if results_per_page > 0 else 1
86
87 return render_template(
88 'pkg_search_results.html',
89 term=term,
90 results_count=results_count,
91 results_per_page=results_per_page,
92 page_count=page_count,
93 src_packages=src_packages,
94 bin_packages=bin_packages,
95 )
96
97
98 @portal.route('/search_sw', methods=['GET', 'POST'])
99 def search_software():
100 term = request.args.get('term')
101 if not term:
102 flash('The search term was invalid.')
103 return redirect(url_for('portal.index'))
104
105 with session_scope() as session:
106 q = (
107 session.query(SoftwareComponent)
108 .join(SoftwareComponent.pkgs_binary)
109 .filter(SoftwareComponent.__ts_vector__.op('@@')(func.plainto_tsquery(term)))
110 .order_by(SoftwareComponent.cid, BinaryPackage.version.desc())
111 .distinct(SoftwareComponent.cid)
112 )
113
114 results_count = q.count()
115 software = q.all()
116
117 results_per_page = results_count
118 page_count = math.ceil(results_count / results_per_page) if results_per_page > 0 else 1
119
120 return render_template(
121 'software_search_results.html',
122 term=term,
123 results_count=results_count,
124 results_per_page=results_per_page,
125 page_count=page_count,
126 software=software,
127 )
128
129
130 @portal.route('/repos', defaults={'repo_name': None})
131 @portal.route('/repo/<repo_name>')
132 @cache.cached(timeout=8400)
133 def repo_index(repo_name: T.Optional[str] = None):
134 with session_scope() as session:
135 if not repo_name:
136 selected_repo = session.query(ArchiveRepository).join(ArchiveConfig.primary_repo).one()
137 else:
138 selected_repo = session.query(ArchiveRepository).filter(ArchiveRepository.name == repo_name).one_or_none()
139 if not selected_repo:
140 abort(404)
141 repos = session.query(ArchiveRepository).order_by(ArchiveRepository.name).all()
142
143 return render_template('repo_index.html', repos=repos, selected_repo=selected_repo)
144
145
146 @portal.route('/<repo_name>/<suite_name>/sections')
147 @cache.cached(timeout=8400)
148 def sections_index(repo_name, suite_name):
149 with session_scope() as session:
150 rss = repo_suite_settings_for(session, repo_name, suite_name, fail_if_missing=False)
151 if not rss:
152 abort(404)
153
154 sections = session.query(ArchiveSection).order_by(ArchiveSection.name).all()
155 return render_template('sections_index.html', repo_suite=rss, sections=sections)
156
157
158 @portal.route('/<repo_name>/<suite_name>/<section_name>/<int:page>')
159 @cache.cached(timeout=3600)
160 def section_view(repo_name, suite_name, section_name, page):
161 with session_scope() as session:
162 rss = repo_suite_settings_for(session, repo_name, suite_name, fail_if_missing=False)
163 if not rss:
164 abort(404)
165 section = session.query(ArchiveSection).filter(ArchiveSection.name == section_name).one_or_none()
166 if not section:
167 abort(404)
168
169 pkgs_per_page = 50
170 pkg_query = (
171 session.query(BinaryPackage)
172 .join(
173 PackageOverride,
174 and_(
175 PackageOverride.repo_id == rss.repo_id,
176 PackageOverride.suite_id == rss.suite_id,
177 PackageOverride.pkg_name == BinaryPackage.name,
178 ),
179 )
180 .filter(BinaryPackage.repo_id == rss.repo_id)
181 .filter(BinaryPackage.suites.any(ArchiveSuite.id == rss.suite_id))
182 .filter(PackageOverride.section.has(id=section.id))
183 .order_by(BinaryPackage.name.asc(), BinaryPackage.version.desc())
184 .distinct(BinaryPackage.name)
185 )
186 pkgs_total = pkg_query.count()
187 page_count = math.ceil(pkgs_total / pkgs_per_page)
188
189 packages = (
190 pkg_query.options(joinedload(BinaryPackage.component))
191 .slice((page - 1) * pkgs_per_page, page * pkgs_per_page)
192 .all()
193 )
194
195 return render_template(
196 'section_view.html',
197 section=section,
198 repo_suite=rss,
199 packages=packages,
200 pkgs_per_page=pkgs_per_page,
201 pkgs_total=pkgs_total,
202 current_page=page,
203 page_count=page_count,
204 )
205
206
207 # cached app category dictionary
208 _app_categories = None
209
210
211 def get_app_categories():
212 '''
213 Retrieve a cached dict of software categories.
214 '''
215 global _app_categories
216 if _app_categories:
217 return _app_categories
218
219 cats = {}
220 ascats = AppStream.get_default_categories(False)
221 for c in ascats:
222 cats[c.get_id()] = c
223 _app_categories = cats
224 return cats
225
226
227 @portal.route('/categories')
228 @cache.cached(timeout=8400)
229 def categories_index():
230 categories = get_app_categories()
231 return render_template('categories_index.html', categories=categories.values())
232
233
234 @portal.route('/category/<cat_id>/<subcat_id>/<int:page>')
235 @portal.route('/category/<cat_id>/<int:page>', defaults={'subcat_id': None})
236 @cache.cached(timeout=8400)
237 def category_view(cat_id, subcat_id, page):
238 categories = get_app_categories()
239 category = categories.get(cat_id)
240 if not category:
241 abort(404)
242
243 parent_category = category
244 if subcat_id:
245 category = None
246 for c in parent_category.get_children():
247 if c.get_id() == subcat_id:
248 category = c
249 break
250 if not category:
251 abort(404)
252
253 sw_per_page = 25
254
255 with session_scope() as session:
256 # TODO: Do this inefficient filtering in advance
257 dcats = []
258 for c in category.get_desktop_groups():
259 parts = c.split('::')
260 if len(parts) <= 1:
261 dcats.append(c)
262 else:
263 dcats.append(parts[-1])
264
265 sw_query = (
266 session.query(SoftwareComponent)
267 .join(SoftwareComponent.pkgs_binary)
268 .filter(SoftwareComponent.categories.overlap(cast(dcats, ARRAY(String()))))
269 .order_by(SoftwareComponent.cid, BinaryPackage.version.desc())
270 .distinct(SoftwareComponent.cid)
271 )
272 software = sw_query.slice((page - 1) * sw_per_page, page * sw_per_page).all()
273
274 sw_total = sw_query.count()
275 page_count = math.ceil(sw_total / sw_per_page)
276
277 return render_template(
278 'category_view.html',
279 parent_category=parent_category,
280 category=category,
281 subcat_id=subcat_id,
282 software=software,
283 sw_per_page=sw_per_page,
284 sw_total=sw_total,
285 current_page=page,
286 page_count=page_count,
287 )