+ """

+ Provide index for Build: id.desc() + copr_dir_id

+ 

+ Revision ID: d5990bd4aa46

+ Revises: 45d0515bdc3f

+ Create Date: 2021-08-31 14:43:28.534127

+ """

+ 

+ import sqlalchemy as sa

+ from alembic import op

+ 

+ 

+ revision = 'd5990bd4aa46'

+ down_revision = '45d0515bdc3f'

+ 

+ def upgrade():

+     op.create_index('build_id_desc_per_copr_dir', 'build',

+                     [sa.text('id DESC'), 'copr_dir_id'], unique=False)

+ 

+ def downgrade():

+     op.drop_index('build_id_desc_per_copr_dir', table_name='build')

+ from coprs.views.coprs_ns import pagination_redirect

+ import coprs.context_processors

+ from coprs import app

+ from coprs.helpers import current_url

+ 

+ 

+ 

+ 

+ @app.context_processor

+ def current_url_processor():

+     """ Provide 'current_url()' method in templates """

+     return dict(current_url=current_url)

+ from werkzeug.urls import url_encode

+ 

+ 

+ 

+ def current_url(**kwargs):

+     """

+     Generate the same url as is currently processed, but define (or replace) the

+     arguments in kwargs.

+     """

+     new_args = {}

+     new_args.update(flask.request.args)

+     new_args.update(kwargs)

+     if not new_args:

+         return flask.request.path

+     return '{}?{}'.format(flask.request.path, url_encode(new_args))

+     def get_monitor_data(cls, copr, per_page=50, page=1,

+                          paginate_if_more_than=1000):

+         """

+         Return Package objects with corresponding latest BuildChroots in active

+         CoprChroots in given COPR.  We try to hold all packages on one page,

+         though if there are more than PAGINATE_IF_MORE_THAN packages, we return

+         only a slice of the results (in this case PAGE is used to return an

+         appropriate slice, and PER_PAGE to control how many pieces are returned

+         in one slice).

+         We return only the pagination object:

+             pagination.items => list of returned packages

+             pagination.serverside_pagination => if the pagination is in effect

+             pagination.item[N].latest_build_chroots => list of the latest

+                 BuildChroots (can span multiple Builds!) for the given package

+         """

+ 

+         packages_query = PackagesLogic.get_all_ordered(copr.main_dir.id)

+         packages_count = packages_query.count()

+ 

+         if packages_count > paginate_if_more_than:

+             pagination = packages_query.paginate(per_page=per_page,

+                                                  page=page)

+             pagination.serverside_pagination = True

+         else:

+             pagination = packages_query.paginate(per_page=paginate_if_more_than,

+                                                  page=1)

+             pagination.serverside_pagination = False

+ 

+         pkg_ids = [package.id for package in pagination.items]

+         mock_chroot_ids = [mch.id for mch in copr.active_chroots]

+ 

+         builds_ids = (

+             models.Build.query.join(models.BuildChroot)

+                   .filter(models.Build.package_id.in_(pkg_ids))

+                   .filter(models.BuildChroot.mock_chroot_id.in_(mock_chroot_ids))

+                   .with_entities(

+                       models.Build.package_id.label('package_id'),

+                       func.max(models.Build.id).label('build_id').label("build_id"),

+                       models.BuildChroot.mock_chroot_id,

+                   )

+                   .group_by(

+                       models.Build.package_id,

+                       models.BuildChroot.mock_chroot_id,

+                   )

+                   .subquery()

+         )

+ 

+         query = (models.BuildChroot.query

+             .join(

+                 builds_ids,

+                 and_(builds_ids.c.build_id == models.BuildChroot.build_id,

+                      builds_ids.c.mock_chroot_id == models.BuildChroot.mock_chroot_id))

+             .add_columns(

+                 builds_ids.c.package_id.label("package_id"),

+             )

+         )

+ 

+         mapper = {}

+         for package in pagination.items:

+             mapper[package.id] = {}

+ 

+         for build_chroot, package_id in query:

+             mapper[package_id][build_chroot.mock_chroot.name] = build_chroot

+ 

+         for package in pagination.items:

+             package.latest_build_chroots = []

+             for chroot in copr.active_chroots_sorted:

+                 package.latest_build_chroots.append(

+                     mapper[package.id].get(chroot.name))

+ 

+         return pagination

+                 models.Build.submitted_on

+             .order_by(desc(models.Build.id))

+             .limit(1)

+         """

+         Get all packages assigned to 'copr_dir_id'

+         """

+     def get_all_ordered(cls, copr_dir_id):

+         """

+         Get all packages in 'copr_dir_id' ordered by package name

+         """

+         return cls.get_all(copr_dir_id).order_by(models.Package.name)

+ 

+     @classmethod

+     def get_packages_with_latest_builds_for_dir(

+             cls, copr_dir_id, small_build=True, packages=None):

+         """

+         Obtain the list of package objects for given copr_dir_id, with the

+         latest build assigned.

+         Parameters:

+ 

+         :param copr_dir_id: CoprDir ID (int)

+         :param small_build: Don't assign full Build objects, but only a limited

+             objects with necessary info.

+         :param packages: Don't query the list of Package objects from DB, but

+             use the given 'packages' array.

+         :return: array of Package objects, with assigned latest Build object

+         """

+         if not packages:

+             packages = cls.get_all_ordered(copr_dir_id).all()

+ 

+     __table_args__ = (

+         db.Index('build_canceled', "canceled"),

+         db.Index('build_order', "is_background", "id"),

+         db.Index('build_filter', "source_type", "canceled"),

+         db.Index('build_canceled_is_background_source_status_id_idx',

+                  'canceled', "is_background", "source_status", "id"),

+         db.Index('build_copr_id_package_id', "copr_id", "package_id"),

+         db.Index("build_id_desc_per_copr_dir", id.desc(), "copr_dir_id"),

+     )

+ 

+ {% macro render_monitor_table(copr, pagination, oses, archs, simple=True) %}

+ <table class="table table-striped table-bordered dataTable">

+     {# This table should be sorted by package name #}

+     </tr>

+     {% for package in pagination.items %}

+     <tr>

+           <b><a href="{{ copr_url('coprs_ns.copr_package', copr, package_name=package.name) }}">

+             {{ package.name }}

+         {% for buildchroot in package.latest_build_chroots %}

+         <td>

+             {% if buildchroot %}

+                 <a href="{{ copr_url("coprs_ns.copr_build", copr, build_id=buildchroot.build_id) }}">

+                 {% if simple %}

+                     {{ build_state_text(buildchroot.status|state_from_num) }}

+                 {% else %}

+                     <small> {{ buildchroot.build_id }} </small> <br>

+                     {{ build_state_text(buildchroot.status|state_from_num) }}<br>

+                     <small class="text-muted"> {{ buildchroot.build.pkg_version }} </small>

+                 {% endif %}

+                 </a>

+             {% else %}

+                 -

+             {% endif %}

+         </td>

+         {% endfor %}

+     </tr>

+ 

+ {% if pagination.serverside_pagination %}

+ {{ pagination_form(pagination) }}

+ {% endif %}

+ 

+ 

+ {% macro pagination_form(pagination) %}

+ <form class="content-view-pf-pagination table-view-pf-pagination clearfix"

+       id="pagination" method="post" action="{{ current_url() }}">

+   <div class="form-group">

+     <span>

+       <span class="pagination-pf-items-current">

+           {{ pagination.per_page*(pagination.page -1) + 1}} -

+           {{ pagination.per_page*(pagination.page) }}

+       </span>

+       of

+       <span class="pagination-pf-items-total">{{ pagination.total }}</span></span>

+     <ul class="pagination pagination-pf-back">

+       <li {% if not pagination.has_prev %}class="disabled"{% endif %}><a href="{{ current_url(page=1) }}" title="First Page"><span class="i fa fa-angle-double-left"></span></a></li>

+       <li {% if not pagination.has_prev %}class="disabled"{% endif %}><a href="{{ current_url(page=pagination.page - 1) }}"  title="Previous Page"><span class="i fa fa-angle-left"></span></a></li>

+     </ul>

+     <label for="pagination1-page" class="sr-only">Current Page</label>

+     <input class="pagination-pf-page" name="go_to_page"  type="text" value="{{ pagination.page }}" id="go_to_page" style="width: 3.5em;" />

+     <span>of <span class="pagination-pf-pages">{{ pagination.pages }}</span></span>

+     <ul class="pagination pagination-pf-forward">

+         <li {% if not pagination.has_next %}class="disabled"{% endif %}><a href="{{ current_url(page=pagination.page + 1) }}" title="Next Page"><span class="i fa fa-angle-right"></span></a></li>

+         <li {% if not pagination.has_next %}class="disabled"{% endif %}><a href="{{ current_url(page=pagination.pages) }}" title="Last Page"><span class="i fa fa-angle-double-right"></span></a></li>

+     </ul>

+   </div>

+ </form>

+ 

+ {% endmacro %}

+ 

+ {% macro serverside_pagination_warning() %}

+ <p> Warning!

+     This is a large project with many packages and/or builds - we can not hold all

+     the requested data on one page (as we usually do), please use the pagination

+     buttons below the table.

+ </p>

+ {% endmacro %}

+ {% from "_helpers.html" import pagination_form with context %}

+ {% macro builds_table(builds, print_possible_states=True, serverside_pagination=None) %}

+     {% if not serverside_pagination %}

+     {% endif %}

+     <table class="datatable dataTable table table-striped table-bordered">

+     {% if not serverside_pagination %}

+         {{ initialize_datatables() }}

+     {% else %}

+         {{ pagination_form(serverside_pagination) }}

+     {% endif %}

+ {% from "_helpers.html" import copr_url, build_state, initialize_datatables, serverside_pagination_warning %}

+ {% from "_helpers.html" import pagination_form with context %}

+ {% from "coprs/detail/_build_states.html" import build_states %}

+ {% macro packages_table(packages, serverside_pagination=None) %}

+ {% if not serverside_pagination %}

+ <noscript><p>WARNING!! This page is using JavaScript to filter, sort and delete builds from the table.</p></noscript>

+ {% else %}

+ {{ serverside_pagination_warning() }}

+ {% endif %}

+   <table class="datatable dataTable table table-striped table-bordered">

+ {% if not serverside_pagination %}

+ {% else %}

+ {{ pagination_form(serverside_pagination) }}

+ {% endif %}

+ {{ build_states() }}

+ {% from "_helpers.html" import render_pagination, serverside_pagination_warning %}

+   {% if builds.items %}

+   {{ serverside_pagination_warning() }}

+   {{ builds_table(builds.items, serverside_pagination=builds) }}

+   {% else %}

+   {% endif %}

+ {% from "_helpers.html" import copr_url, copr_name, serverside_pagination_warning  %}

+ {% if pagination.serverside_pagination %}

+ {{ serverside_pagination_warning() }}

+ {% endif %}

+ 

+ {% from "_helpers.html" import package_href, build_href, build_state_text %}

+ {% from "_helpers.html" import render_monitor_table with context %}

+ {{ render_monitor_table(copr, pagination, oses, archs, simple=False) }}

+ {% from "_helpers.html" import package_href, build_href, build_state_text %}

+ {% from "_helpers.html" import render_monitor_table with context %}

+ {{ render_monitor_table(copr, pagination, oses, archs, simple=True) }}

+   {{ packages_table(packages, serverside_pagination=serverside_pagination) }}

+ from sqlalchemy import desc

+ from coprs import models

+ from coprs.views.misc import (

+     login_required,

+     req_with_copr,

+     req_with_pagination,

+     send_build_icon,

+ )

+ @req_with_pagination

+ def copr_builds(copr, page=1):

+ 

+ 

+     one_js_page_limit = 10000

+     if builds_query.count() > one_js_page_limit:

+         # we currently don't support filtering with server-side pagination,

+         # so order the query so the newest builds are shown first

+         builds_query = builds_query.order_by(desc(models.Build.id))

+         builds = builds_query.paginate(

+             page=page,

+             per_page=50,

+         )

+     else:

+         builds = builds_query.yield_per(1000)

+ 

+ from coprs.views.misc import (

+     generic_error,

+     login_required,

+     page_not_found,

+     req_with_copr,

+     req_with_copr_dir,

+     req_with_pagination,

+ )

+ @coprs_ns.route("/<username>/<coprname>/monitor/")

+ @coprs_ns.route("/<username>/<coprname>/monitor/<detailed>")

+ @coprs_ns.route("/g/<group_name>/<coprname>/monitor/")

+ @coprs_ns.route("/g/<group_name>/<coprname>/monitor/<detailed>")

+ @req_with_copr

+ @req_with_pagination

+ def copr_build_monitor(copr, detailed=False, page=1):

+     """

+     The monitor page (overview of the build status in each chroot for all the

+     packages built in given project).

+     """

+     detailed = detailed == "detailed"

+     pagination = builds_logic.BuildsMonitorLogic.get_monitor_data(

+             copr, page=page)

+ 

+     chroot_indexer = {}

+     for index, chroot in enumerate(copr.active_chroots_sorted):

+         chroot_indexer[chroot] = index

+ 

+                                  pagination=pagination,

+ from coprs.views.misc import (

+     login_required,

+     req_with_copr,

+     req_with_pagination,

+     send_build_icon

+ )

+ 

+ @req_with_pagination

+ def copr_packages(copr, page=1):

+ 

+     copr_dir_id = copr.main_dir.id

+     query_packages = PackagesLogic.get_all_ordered(copr_dir_id)

+ 

+     pagination = None

+     if query_packages.count() > 1000:

+         pagination = query_packages.paginate(page=page, per_page=50)

+         packages = pagination.items

+     else:

+         packages = query_packages.all()

+ 

+     # Assign the latest builds to the package array set.

+         copr.main_dir.id, packages=packages)

+ 

+             serverside_pagination=pagination,

+ """

+ Several Copr WebUI pages require the server-side pagination, and the way the

+ pagination html tool works requires us to provide additional redirect routes for

+ the pages.

+ """

+ 

+ import flask

+ from coprs.views.coprs_ns import coprs_ns

+ from coprs import helpers

+ 

+ 

+ @coprs_ns.route("/<username>/<coprname>/builds/", methods=["POST"])

+ @coprs_ns.route("/g/<group_name>/<coprname>/builds/", methods=["POST"])

+ @coprs_ns.route("/<username>/<coprname>/packages/", methods=["POST"])

+ @coprs_ns.route("/g/<group_name>/<coprname>/packages/", methods=["POST"])

+ @coprs_ns.route("/<username>/<coprname>/monitor/", methods=["POST"])

+ @coprs_ns.route("/<username>/<coprname>/monitor/<detailed>", methods=["POST"])

+ @coprs_ns.route("/g/<group_name>/<coprname>/monitor/", methods=["POST"])

+ @coprs_ns.route("/g/<group_name>/<coprname>/monitor/<detailed>", methods=["POST"])

+ def copr_pagination_redirect(**_kwargs):

+     """

+     Redirect the current page to the very same page, with just the '?page=<N>'

+     argument changed.

+     """

+     to_page = flask.request.form.get('go_to_page', 1)

+     return flask.redirect(helpers.current_url(page=to_page))

+ from coprs.exceptions import ObjectNotFound

+ 

+ 

+ 

+ def req_with_pagination(f):

+     """

+     Parse 'page=' option from GET url, and place it as the argument

+     """

+     @wraps(f)

+     def wrapper(*args, **kwargs):

+         try:

+             page = flask.request.args.get('page', 1)

+             page = int(page)

+         except ValueError as err:

+             raise ObjectNotFound("Invalid pagination format") from err

+         return f(*args, page=page, **kwargs)

+     return wrapper