[IMP] runbot: implement public model mixin for bundle

Implements the public model mixin for `runbot.bundle` and make enough
fields public to be able to render the runbot homepage.

Author: Williambraecky

runbot/models/batch.py

@@ -12,16 +12,17 @@
 class Batch(models.Model):
     _name = 'runbot.batch'
     _description = "Bundle batch"
+    _inherit = ['runbot.public.model.mixin']
 
-    last_update = fields.Datetime('Last ref update')
+    last_update = fields.Datetime('Last ref update', public=True)
     bundle_id = fields.Many2one('runbot.bundle', required=True, index=True, ondelete='cascade')
-    commit_link_ids = fields.Many2many('runbot.commit.link')
+    commit_link_ids = fields.Many2many('runbot.commit.link', public=True)
     commit_ids = fields.Many2many('runbot.commit', compute='_compute_commit_ids')
-    slot_ids = fields.One2many('runbot.batch.slot', 'batch_id')
+    slot_ids = fields.One2many('runbot.batch.slot', 'batch_id', public=True)
     all_build_ids = fields.Many2many('runbot.build', compute='_compute_all_build_ids', help="Recursive builds")
-    state = fields.Selection([('preparing', 'Preparing'), ('ready', 'Ready'), ('done', 'Done'), ('skipped', 'Skipped')])
+    state = fields.Selection([('preparing', 'Preparing'), ('ready', 'Ready'), ('done', 'Done'), ('skipped', 'Skipped')], public=True)
     hidden = fields.Boolean('Hidden', default=False)
-    age = fields.Integer(compute='_compute_age', string='Build age')
+    age = fields.Integer(compute='_compute_age', string='Build age', public=True)
     category_id = fields.Many2one('runbot.category', index=True, default=lambda self: self.env.ref('runbot.default_category', raise_if_not_found=False))
     log_ids = fields.One2many('runbot.batch.log', 'batch_id')
     has_warning = fields.Boolean("Has warning")
@@ -34,6 +35,10 @@ class Batch(models.Model):
         column2='referenced_batch_id',
     )
 
+    @api.model
+    def _api_project_id_field_path(self):
+        return 'bundle_id.project_id'
+
     @api.depends('slot_ids.build_id')
     def _compute_all_build_ids(self):
         all_builds = self.env['runbot.build'].search([('id', 'child_of', self.slot_ids.build_id.ids)])
@@ -522,20 +527,25 @@ class BatchSlot(models.Model):
     _name = 'runbot.batch.slot'
     _description = 'Link between a bundle batch and a build'
     _order = 'trigger_id,id'
+    _inherit = ['runbot.public.model.mixin']
 
-    batch_id = fields.Many2one('runbot.batch', index=True)
-    trigger_id = fields.Many2one('runbot.trigger', index=True)
-    build_id = fields.Many2one('runbot.build', index=True)
-    all_build_ids = fields.Many2many('runbot.build', compute='_compute_all_build_ids')
+    batch_id = fields.Many2one('runbot.batch', index=True, public=True)
+    trigger_id = fields.Many2one('runbot.trigger', index=True, public=True)
+    build_id = fields.Many2one('runbot.build', index=True, public=True)
+    all_build_ids = fields.Many2many('runbot.build', compute='_compute_all_build_ids', public=True)
     params_id = fields.Many2one('runbot.build.params', index=True, required=True)
-    link_type = fields.Selection([('created', 'Build created'), ('matched', 'Existing build matched'), ('rebuild', 'Rebuild')], required=True)  # rebuild type?
-    active = fields.Boolean('Attached', default=True)
+    link_type = fields.Selection([('created', 'Build created'), ('matched', 'Existing build matched'), ('rebuild', 'Rebuild')], required=True, public=True)  # rebuild type?
+    active = fields.Boolean('Attached', default=True, public=True)
     skipped = fields.Boolean('Skipped', default=False)
     # rebuild, what to do: since build can be in multiple batch:
     # - replace for all batch?
     # - only available on batch and replace for batch only?
     # - create a new bundle batch will new linked build?
 
+    @api.model
+    def _api_request_allow_direct_access(self):
+        return False
+
     @api.depends('build_id')
     def _compute_all_build_ids(self):
         all_builds = self.env['runbot.build'].search([('id', 'child_of', self.build_id.ids)])

runbot/models/branch.py

@@ -13,10 +13,11 @@ class Branch(models.Model):
     _description = "Branch"
     _order = 'name'
     _rec_name = 'dname'
+    _inherit = ['runbot.public.model.mixin']
 
     _sql_constraints = [('branch_repo_uniq', 'unique (name,remote_id)', 'The branch must be unique per repository !')]
 
-    name = fields.Char('Name', required=True)
+    name = fields.Char('Name', required=True, public=True)
     remote_id = fields.Many2one('runbot.remote', 'Remote', required=True, ondelete='cascade', index=True)
 
     head = fields.Many2one('runbot.commit', 'Head Commit', index=True)
@@ -25,7 +26,7 @@ class Branch(models.Model):
     reference_name = fields.Char(compute='_compute_reference_name', string='Bundle name', store=True)
     bundle_id = fields.Many2one('runbot.bundle', 'Bundle', ondelete='cascade', index=True)
 
-    is_pr = fields.Boolean('IS a pr', required=True)
+    is_pr = fields.Boolean('IS a pr', required=True, public=True)
     pr_title = fields.Char('Pr Title')
     pr_body = fields.Char('Pr Body')
     pr_author = fields.Char('Pr Author')
@@ -37,12 +38,16 @@ class Branch(models.Model):
 
     reflog_ids = fields.One2many('runbot.ref.log', 'branch_id')
 
-    branch_url = fields.Char(compute='_compute_branch_url', string='Branch url', readonly=True)
-    dname = fields.Char('Display name', compute='_compute_dname', search='_search_dname')
+    branch_url = fields.Char(compute='_compute_branch_url', string='Branch url', readonly=True, public=True)
+    dname = fields.Char('Display name', compute='_compute_dname', search='_search_dname', public=True)
 
     alive = fields.Boolean('Alive', default=True)
     draft = fields.Boolean('Draft', store=True)
 
+    @api.model
+    def _api_project_id_field_path(self):
+        return 'bundle_id.project_id'
+
     @api.depends('name', 'remote_id.short_name')
     def _compute_dname(self):
         for branch in self:

runbot/models/build.py

@@ -49,24 +49,25 @@ def make_selection(array):
 class BuildParameters(models.Model):
     _name = 'runbot.build.params'
     _description = "All information used by a build to run, should be unique and set on create only"
+    _inherit = ['runbot.public.model.mixin']
 
     # on param or on build?
     # execution parametter
     commit_link_ids = fields.Many2many('runbot.commit.link', copy=True)
     commit_ids = fields.Many2many('runbot.commit', compute='_compute_commit_ids')
     version_id = fields.Many2one('runbot.version', required=True, index=True)
     project_id = fields.Many2one('runbot.project', required=True, index=True)  # for access rights
-    trigger_id = fields.Many2one('runbot.trigger', index=True)  # for access rights
-    create_batch_id = fields.Many2one('runbot.batch', index=True)
-    category = fields.Char('Category', index=True)  # normal vs nightly vs weekly, ...
+    trigger_id = fields.Many2one('runbot.trigger', index=True, public=True)  # for access rights
+    create_batch_id = fields.Many2one('runbot.batch', index=True, public=True)
+    category = fields.Char('Category', index=True, public=True)  # normal vs nightly vs weekly, ...
     dockerfile_id = fields.Many2one('runbot.dockerfile', index=True, default=lambda self: self.env.ref('runbot.docker_default', raise_if_not_found=False))
     skip_requirements = fields.Boolean('Skip requirements.txt auto install')
     # other informations
     extra_params = fields.Char('Extra cmd args')
-    config_id = fields.Many2one('runbot.build.config', 'Run Config', required=True,
+    config_id = fields.Many2one('runbot.build.config', 'Run Config', required=True, public=True,
                                 default=lambda self: self.env.ref('runbot.runbot_build_config_default', raise_if_not_found=False), index=True)
-    config_data = JsonDictField('Config Data')
-    used_custom_trigger = fields.Boolean('Custom trigger was used to generate this build')
+    config_data = JsonDictField('Config Data', public=True)
+    used_custom_trigger = fields.Boolean('Custom trigger was used to generate this build', public=True)
 
     build_ids = fields.One2many('runbot.build', 'params_id')
     builds_reference_ids = fields.Many2many('runbot.build', relation='runbot_build_params_references', copy=True)
@@ -84,6 +85,10 @@ class BuildParameters(models.Model):
         ('unique_fingerprint', 'unique (fingerprint)', 'avoid duplicate params'),
     ]
 
+    @api.model
+    def _api_request_allow_direct_access(self):
+        return False
+
     # @api.depends('version_id', 'project_id', 'extra_params', 'config_id', 'config_data', 'modules', 'commit_link_ids', 'builds_reference_ids')
     def _compute_fingerprint(self):
         for param in self:
@@ -141,6 +146,7 @@ class BuildResult(models.Model):
 
     _name = 'runbot.build'
     _description = "Build"
+    _inherit = ['runbot.public.model.mixin']
 
     _parent_store = True
     _order = 'id desc'
@@ -154,26 +160,26 @@ class BuildResult(models.Model):
     no_auto_run = fields.Boolean('No run')
     # could be a default value, but possible to change it to allow duplicate accros branches
 
-    description = fields.Char('Description', help='Informative description')
-    md_description = fields.Html(compute='_compute_md_description', string='MD Parsed Description', help='Informative description markdown parsed', sanitize=False)
-    display_name = fields.Char(compute='_compute_display_name')
+    description = fields.Char('Description', help='Informative description', public=True)
+    md_description = fields.Html(compute='_compute_md_description', string='MD Parsed Description', help='Informative description markdown parsed', sanitize=False, public=True)
+    display_name = fields.Char(compute='_compute_display_name', public=True)
 
     # Related fields for convenience
-    version_id = fields.Many2one('runbot.version', related='params_id.version_id', store=True, index=True)
-    config_id = fields.Many2one('runbot.build.config', related='params_id.config_id', store=True, index=True)
-    trigger_id = fields.Many2one('runbot.trigger', related='params_id.trigger_id', store=True, index=True)
-    create_batch_id = fields.Many2one('runbot.batch', related='params_id.create_batch_id', store=True, index=True)
+    version_id = fields.Many2one('runbot.version', related='params_id.version_id', store=True, index=True, public=True)
+    config_id = fields.Many2one('runbot.build.config', related='params_id.config_id', store=True, index=True, public=True)
+    trigger_id = fields.Many2one('runbot.trigger', related='params_id.trigger_id', store=True, index=True, public=True)
+    create_batch_id = fields.Many2one('runbot.batch', related='params_id.create_batch_id', store=True, index=True, public=True)
 
     # state machine
-    global_state = fields.Selection(make_selection(state_order), string='Status', compute='_compute_global_state', store=True, recursive=True)
-    local_state = fields.Selection(make_selection(state_order), string='Build Status', default='pending', required=True, index=True)
-    global_result = fields.Selection(make_selection(result_order), string='Result', compute='_compute_global_result', store=True, recursive=True)
-    local_result = fields.Selection(make_selection(result_order), string='Build Result', default='ok')
+    global_state = fields.Selection(make_selection(state_order), string='Status', compute='_compute_global_state', store=True, recursive=True, public=True)
+    local_state = fields.Selection(make_selection(state_order), string='Build Status', default='pending', required=True, index=True, public=True)
+    global_result = fields.Selection(make_selection(result_order), string='Result', compute='_compute_global_result', store=True, recursive=True, public=True)
+    local_result = fields.Selection(make_selection(result_order), string='Build Result', default='ok', public=True)
 
-    requested_action = fields.Selection([('wake_up', 'To wake up'), ('deathrow', 'To kill')], string='Action requested', index=True)
+    requested_action = fields.Selection([('wake_up', 'To wake up'), ('deathrow', 'To kill')], string='Action requested', index=True, public=True)
     # web infos
-    host = fields.Char('Host name')
-    host_id = fields.Many2one('runbot.host', string="Host", compute='_compute_host_id')
+    host = fields.Char('Host name', public=True)
+    host_id = fields.Many2one('runbot.host', string="Host", compute='_compute_host_id', public=True)
     keep_host = fields.Boolean('Keep host on rebuild and for children')
 
     port = fields.Integer('Port')
@@ -183,7 +189,7 @@ class BuildResult(models.Model):
     log_ids = fields.One2many('ir.logging', 'build_id', string='Logs')
     error_log_ids = fields.One2many('ir.logging', 'build_id', domain=[('level', 'in', ['WARNING', 'ERROR', 'CRITICAL'])], string='Error Logs')
     stat_ids = fields.One2many('runbot.build.stat', 'build_id', string='Statistics values')
-    log_list = fields.Char('Comma separted list of step_ids names with logs')
+    log_list = fields.Char('Comma separted list of step_ids names with logs', public=True)
 
     active_step = fields.Many2one('runbot.build.config.step', 'Active step')
     job = fields.Char('Active step display name', compute='_compute_job')
@@ -234,13 +240,17 @@ class BuildResult(models.Model):
     slot_ids = fields.One2many('runbot.batch.slot', 'build_id')
     killable = fields.Boolean('Killable')
 
-    database_ids = fields.One2many('runbot.database', 'build_id')
+    database_ids = fields.One2many('runbot.database', 'build_id', public=True)
     commit_export_ids = fields.One2many('runbot.commit.export', 'build_id')
 
     static_run = fields.Char('Static run URL')
 
     access_token = fields.Char('Token', default=lambda self: uuid.uuid4().hex)
 
+    @api.model
+    def _api_project_id_field_path(self):
+        return 'params_id.project_id'
+
     @api.depends('description', 'params_id.config_id')
     def _compute_display_name(self):
         for build in self:

runbot/models/bundle.py

@@ -1,44 +1,47 @@
+from werkzeug.exceptions import BadRequest
+
 import time
 import logging
 import datetime
 import subprocess
 
 from collections import defaultdict
 from odoo import models, fields, api, tools
+from odoo.osv import expression
 from ..common import dt2time, s2human_long
 
 
 class Bundle(models.Model):
     _name = 'runbot.bundle'
     _description = "Bundle"
-    _inherit = 'mail.thread'
+    _inherit = ['mail.thread', 'runbot.public.model.mixin']
 
-    name = fields.Char('Bundle name', required=True, help="Name of the base branch")
-    project_id = fields.Many2one('runbot.project', required=True, index=True)
-    branch_ids = fields.One2many('runbot.branch', 'bundle_id')
+    name = fields.Char('Bundle name', required=True, help="Name of the base branch", public=True)
+    project_id = fields.Many2one('runbot.project', required=True, index=True, public=True)
+    branch_ids = fields.One2many('runbot.branch', 'bundle_id', public=True)
 
     # custom behaviour
-    no_build = fields.Boolean('No build')
+    no_build = fields.Boolean('No build', public=True)
     no_auto_run = fields.Boolean('No run')
     build_all = fields.Boolean('Force all triggers')
     always_use_foreign = fields.Boolean('Use foreign bundle', help='By default, check for the same bundle name in another project to fill missing commits.', default=lambda self: self.project_id.always_use_foreign)
     modules = fields.Char("Modules to install", help="Comma-separated list of modules to install and test.")
 
     batch_ids = fields.One2many('runbot.batch', 'bundle_id')
-    last_batch = fields.Many2one('runbot.batch', index=True, domain=lambda self: [('category_id', '=', self.env.ref('runbot.default_category').id)])
-    last_batchs = fields.Many2many('runbot.batch', 'Last batchs', compute='_compute_last_batchs')
+    last_batch = fields.Many2one('runbot.batch', index=True, domain=lambda self: [('category_id', '=', self.env.ref('runbot.default_category').id)], public=True)
+    last_batchs = fields.Many2many('runbot.batch', 'Last batchs', compute='_compute_last_batchs', public=True)
     last_done_batch = fields.Many2many('runbot.batch', 'Last batchs', compute='_compute_last_done_batch')
 
-    sticky = fields.Boolean('Sticky', compute='_compute_sticky', store=True, index=True)
-    is_base = fields.Boolean('Is base', index=True)
+    sticky = fields.Boolean('Sticky', compute='_compute_sticky', store=True, index=True, public=True)
+    is_base = fields.Boolean('Is base', index=True, public=True)
     defined_base_id = fields.Many2one('runbot.bundle', 'Forced base bundle', domain="[('project_id', '=', project_id), ('is_base', '=', True)]")
     base_id = fields.Many2one('runbot.bundle', 'Base bundle', compute='_compute_base_id', store=True)
     to_upgrade = fields.Boolean('To upgrade To', compute='_compute_to_upgrade', store=True, index=False)
     to_upgrade_from = fields.Boolean('To upgrade From', compute='_compute_to_upgrade_from', store=True, index=False)
 
-    has_pr = fields.Boolean('Has PR', compute='_compute_has_pr', store=True)
+    has_pr = fields.Boolean('Has PR', compute='_compute_has_pr', store=True, public=True)
 
-    version_id = fields.Many2one('runbot.version', 'Version', compute='_compute_version_id', store=True, recursive=True)
+    version_id = fields.Many2one('runbot.version', 'Version', compute='_compute_version_id', store=True, recursive=True, public=True)
     version_number = fields.Char(related='version_id.number', store=True, index=True)
 
     previous_major_version_base_id = fields.Many2one('runbot.bundle', 'Previous base bundle', compute='_compute_relations_base_id')
@@ -56,7 +59,36 @@ class Bundle(models.Model):
     disable_codeowner = fields.Boolean("Disable codeowners", tracking=True)
 
     # extra_info
-    for_next_freeze = fields.Boolean('Should be in next freeze')
+    for_next_freeze = fields.Boolean('Should be in next freeze', public=True)
+
+    @api.model
+    def _api_request_allowed_keys(self):
+        return super()._api_request_allowed_keys() | {'category_id'}
+    
+    @api.model
+    def _api_project_id_field_path(self):
+        return 'project_id'
+
+    @api.model
+    def _api_request_read_get_records(self, request_data):
+        if 'category_id' in request_data:
+            if not isinstance(request_data['category_id'], int):
+                raise BadRequest('Invalid category_id')
+            category_id = request_data['category_id']
+        else:
+            category_id = self.env['ir.model.data']._xmlid_to_res_id('runbot.default_category')
+        self = self.with_context(category_id=category_id)
+        limit, offset = self._api_request_read_get_offset_limit(request_data)
+        e = expression.expression(request_data['domain'], self)
+        query = e.query
+        query.order = """
+        (case when "runbot_bundle".sticky then 1 when "runbot_bundle".sticky is null then 2 else 2 end),
+            case when "runbot_bundle".sticky then "runbot_bundle".version_number end collate "C" desc,
+            "runbot_bundle".last_batch desc
+        """
+        query.limit = limit
+        query.offset = offset
+        return self.browse(query)
 
     @api.depends('name')
     def _compute_host_id(self):