WebSVN – Moodle – Diff – /reportbuilder/classes/local/report/column.php

 declare(strict_types=1);
 namespace core_reportbuilder\local\report;
-use coding_exception;
+use core\exception\coding_exception;
-use lang_string;
+use core\lang_string;
-use core_reportbuilder\local\helpers\aggregation;
+use core\output\help_icon;
-use core_reportbuilder\local\helpers\database;
+use core_reportbuilder\local\helpers\{aggregation, database, join_trait};
 use core_reportbuilder\local\aggregation\base;
  * @copyright   2020 Paul Holden <paulh@moodle.com>
  * @license     http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  */
 final class column {
+    use join_trait;
     /** @var int Column type is integer */
     public const TYPE_INTEGER = 1;
     public const TYPE_LONGTEXT = 6;
     /** @var int $index Column index within a report */
-    private $index;
-    /** @var string $columnname Internal reference to name of column */
-    private $columnname;
-    /** @var lang_string $columntitle Used as a title for the column in reports */
-    private $columntitle;
+    private $index;
-    /** @var bool $hascustomcolumntitle Used to store if the column has been given a custom title */
-    private $hascustomcolumntitle = false;
-    /** @var string $entityname Name of the entity this column belongs to */
+    /** @var bool $hascustomcolumntitle Used to store if the column has been given a custom title */
-    private $entityname;
+    private $hascustomcolumntitle = false;
-    /** @var int $type Column data type (one of the TYPE_* class constants) */
-    private $type = self::TYPE_TEXT;
-    /** @var string[] $joins List of SQL joins for this column */
+    /** @var int $type Column data type (one of the TYPE_* class constants) */
-    private $joins = [];
+    private $type = self::TYPE_TEXT;
     /** @var array[] $callbacks Array of [callable, additionalarguments] */
     private $callbacks = [];
+    /** @var base|null $aggregation Aggregation type to apply to column */
+    private base|null $aggregation = null;
-    /** @var base|null $aggregation Aggregation type to apply to column */
+    /** @var array[] $aggregationoptions Aggregation type options */
-    private $aggregation = null;
+    private array $aggregationoptions = [];
     private $sortfields = [];
     /** @var array $attributes */
+    private $attributes = [];
+    /** @var help_icon|null $helpicon */
-    private $attributes = [];
+    private $helpicon = null;
     /** @var bool $available Used to know if column is available to the current user or not */
-    protected $available = true;
+    private $available = true;
     /** @var bool $deprecated */
-    protected $deprecated = false;
+    private $deprecated = false;
     /** @var string $deprecatedmessage */
-    protected $deprecatedmessage;
+    private $deprecatedmessage;
     /** @var column_model $persistent */
      * @param lang_string|null $title Title of the column used in reports (null for blank)
      * @param string $entityname Name of the entity this column belongs to. Typically when creating columns within entities
      *      this value should be the result of calling {@see get_entity_name}, however if creating columns inside reports directly
      *      it should be the name of the entity as passed to {@see \core_reportbuilder\local\report\base::annotate_entity}
      */
+    public function __construct(
-    public function __construct(string $name, ?lang_string $title, string $entityname) {
+        /** @var string Internal name of the column */
-        $this->columnname = $name;
+        private string $name,
+        /** @var lang_string|null Title of the column used in reports */
-        $this->columntitle = $title;
+        private ?lang_string $title,
+        /** @var string Name of the entity this column belongs to */
-        $this->entityname = $entityname;
+        private readonly string $entityname,
+    ) {
+    }
     /**
      * Set column name
+     *
      * @param string $name
      * @return self
      */
     public function set_name(string $name): self {
-        $this->columnname = $name;
+        $this->name = $name;
         return $this;
+    }
     /**
      * Return column name
+     *
      * @return mixed
      */
     public function get_name(): string {
-        return $this->columnname;
+        return $this->name;
+    }
     /**
      * Set column title
+     *
      * @param lang_string|null $title
      * @return self
      */
     public function set_title(?lang_string $title): self {
-        $this->columntitle = $title;
+        $this->title = $title;
         $this->hascustomcolumntitle = true;
         return $this;
+    }
     /**
      * Return column title
      *
      * @return string
      */
     public function get_title(): string {
-        return $this->columntitle ? (string) $this->columntitle : '';
+        return $this->title ? (string) $this->title : '';
     /**
      * Set the column type, if not called then the type will be assumed to be {@see TYPE_TEXT}
+     *
      * The type of a column is used to cast the first column field passed to any callbacks {@see add_callback} as well as the
+     * aggregation options available for the column. It should represent how the column content is returned from callbacks
      * aggregation options available for the column
+     *
      * @param int $type
      * @return self
      * @throws coding_exception
     public function get_type(): int {
         return $this->type;
+    }
-    /**
-     * Add join clause required for this column to join to existing tables/entities
-     *
-     * This is necessary in the case where {@see add_field} is selecting data from a table that isn't otherwise queried
-     *
-     * @param string $join
-     * @return self
-     */
-    public function add_join(string $join): self {
-        $this->joins[trim($join)] = trim($join);
-        return $this;
-    }
-    /**
-     * Add multiple join clauses required for this column, passing each to {@see add_join}
-     *
-     * Typically when defining columns in entities, you should pass {@see \core_reportbuilder\local\report\base::get_joins} to
-     * this method, so that all entity joins are included in the report when your column is added to it
-     *
-     * @param string[] $joins
-     * @return self
-     */
-    public function add_joins(array $joins): self {
-        foreach ($joins as $join) {
-            $this->add_join($join);
-        }
-        return $this;
-    }
-    /**
-     * Return column joins
-     *
-     * @return string[]
-     */
-    public function get_joins(): array {
-        return array_values($this->joins);
-    }
     /**
      * Adds a field to be queried from the database that is necessary for this column
+     *
      * Multiple fields can be added per column, this method may be called several times. Field aliases must be unique inside
      * any given column, but there will be no conflicts if the same aliases are used in other columns in the same report
      * @return array
      */
     public function get_fields(): array {
         $fieldsalias = $this->get_fields_sql_alias();
-        if (!empty($this->aggregation)) {
+        if ($this->aggregation !== null) {
             $fieldsaliassql = array_column($fieldsalias, 'sql');
             $field = reset($fieldsalias);
-            // If aggregating the column, generate SQL from column fields and use it to generate aggregation SQL.
-            $columnfieldsql = $this->aggregation::get_column_field_sql($fieldsaliassql);
+            // If aggregating the column, generate SQL from column fields and use it to generate aggregation SQL.
-            $aggregationfieldsql = $this->aggregation::get_field_sql($columnfieldsql, $this->get_type());
+            $aggregationfieldsql = $this->get_field_aggregation_sql($fieldsaliassql);
             $fields = ["{$aggregationfieldsql} AS {$field['alias']}"];
         return array_values($fields);
+    }
+    /**
+     * Return aggregated field SQL for the column
+     *
+     * @param string[] $sqlfields
+     * @return string
+     * @throws coding_exception
+     */
+    private function get_field_aggregation_sql(array $sqlfields): string {
+        if ($this->aggregation === null) {
+            throw new coding_exception('Column aggregation is undefined');
+        }
+        $columnfieldsql = $this->aggregation::get_column_field_sql($sqlfields);
+        return $this->aggregation::get_field_sql($columnfieldsql, $this->get_type());
+    }
     /**
      * Return column parameters, prefixed by the current index to allow the column to be added multiple times to a report
+     *
      * @return array
      * @return array
      */
     public function get_groupby_sql(): array {
         global $DB;
+        // We can reference field aliases in GROUP BY only in MySQL/Postgres (MDL-78783).
+        $usealias = in_array($DB->get_dbfamily(), ['mysql', 'postgres']);
+        $fieldsalias = $this->get_fields_sql_alias();
+        // To ensure cross-platform support for column aggregation, where the aggregation should also be grouped, we need
+        // to generate SQL from column fields and use it to generate aggregation SQL.
+        if ($this->aggregation !== null && $this->aggregation::column_groupby()) {
+            if ($usealias) {
+                $this->set_groupby_sql($this->get_column_alias());
+            } else {
+                $fieldsaliassql = array_column($fieldsalias, 'sql');
+                $this->set_groupby_sql($this->get_field_aggregation_sql($fieldsaliassql));
+            }
+        }
-        // Return defined value if it's already been set during column definition.
+        // Return defined value if it's been set.
         if (!empty($this->groupbysql)) {
             return [$this->groupbysql];
-        }
-        $fieldsalias = $this->get_fields_sql_alias();
         // Note that we can reference field aliases in GROUP BY only in MySQL/Postgres.
-        $usealias = in_array($DB->get_dbfamily(), ['mysql', 'postgres']);
         $columnname = $usealias ? 'alias' : 'sql';
         $columnname = $usealias ? 'alias' : 'sql';
         return array_column($fieldsalias, $columnname);
+    }
     /**
      * Set column aggregation type
+     *
+     * @param string|null $aggregation Type of aggregation, e.g. 'sum', 'count', etc
-     * @param string|null $aggregation Type of aggregation, e.g. 'sum', 'count', etc
+     * @param array|null $options Aggregation type options
      * @return self
      * @throws coding_exception For invalid aggregation type, or one that is incompatible with column type
      */
-    public function set_aggregation(?string $aggregation): self {
+    public function set_aggregation(?string $aggregation, ?array $options = null): self {
+        if ((string) $aggregation !== '') {
-        if (!empty($aggregation)) {
+            // Convert aggregation to full class instance for internal storage.
-            $aggregation = aggregation::get_full_classpath($aggregation);
+            $aggregationclasspath = aggregation::get_full_classpath($aggregation);
-            if (!aggregation::valid($aggregation) || !$aggregation::compatible($this->get_type())) {
+            if (!aggregation::valid($aggregationclasspath) || !$aggregationclasspath::compatible($this->get_type())) {
                 throw new coding_exception('Invalid column aggregation', $aggregation);
+            }
+            $options ??= $this->get_aggregation_options($aggregation);
+            $this->aggregation = new $aggregationclasspath($options);
+        } else {
             $this->aggregation = null;
-        }
+        }
         $this->aggregation = $aggregation;
         return $this;
+    }
     /**
      * Get column aggregation type
      *
      * @return base|null
      */
-    public function get_aggregation(): ?string {
+    public function get_aggregation(): ?base {
+        return $this->aggregation;
+    }
+    /**
+     * Set options for the given aggregation type
+     *
+     * @param string $aggregation Type of aggregation, e.g. 'sum', 'count', etc
+     * @param array $options Aggregation type options
+     * @return self
+     */
+    public function set_aggregation_options(string $aggregation, array $options): self {
+        $this->aggregationoptions[$aggregation] = $options;
+        return $this;
+    }
+    /**
+     * Get options for the given aggregation type
+     *
+     * @param string|null $aggregation Type of aggregation, e.g. 'sum', 'count', etc
+     * @return array
+     */
+    public function get_aggregation_options(?string $aggregation): array {
-        return $this->aggregation;
+        return $this->aggregationoptions[$aggregation] ?? [];
+    }
     /**
      * Set disabled aggregation methods for the column. Typically only those methods suitable for the current column type are
     /**
      * Sets the column as sortable
+     *
      * @param bool $issortable
-     * @param array $sortfields Define the fields that should be used when the column is sorted, typically a subset of the fields
+     * @param array $sortfields Define the fields that should be used when the column is sorted. Must be a subset of the fields
      *      selected for the column, via {@see add_field}. If omitted then the first selected field is used
      * @return self
      */
     public function set_is_sortable(bool $issortable, array $sortfields = []): self {
      * @return bool
      */
     public function get_is_sortable(): bool {
         // Defer sortable status to aggregation type if column is being aggregated.
-        if (!empty($this->aggregation)) {
+        if ($this->aggregation !== null) {
             return $this->aggregation::sortable($this->issortable);
+        }
             if (array_key_exists($sortfield, $fieldsalias)) {
                 return $fieldsalias[$sortfield]['alias'];
+            }
             // Check whether sortfield refers to field SQL.
-            foreach ($fieldsalias as $field) {
+            return str_ireplace(
-                if (strcasecmp($sortfield, $field['sql']) === 0) {
+                array_column($fieldsalias, 'sql'),
-                    $sortfield = $field['alias'];
+                array_column($fieldsalias, 'alias'),
-                    break;
-                }
+                $sortfield,
-            }
-            return $sortfield;
+            );
         }, $this->sortfields);
+    }
      * @param array $row
      * @return mixed
      */
     public function format_value(array $row) {
         $values = $this->get_values($row);
-        $value = self::get_default_value($values, $this->type);
         // If column is being aggregated then defer formatting to them, otherwise loop through all column callbacks.
+        if ($this->aggregation !== null) {
-        if (!empty($this->aggregation)) {
+            $value = self::get_default_value($values, $this->aggregation::get_column_type($this->get_type()));
-            $value = $this->aggregation::format_value($value, $values, $this->callbacks, $this->type);
+            $value = $this->aggregation->format_value($value, $values, $this->callbacks, $this->get_type());
+        } else {
-        } else {
+            $value = self::get_default_value($values, $this->get_type());
             foreach ($this->callbacks as $callback) {
                 [$callable, $arguments] = $callback;
                 $value = ($callable)($value, (object) $values, $arguments, null);
+            }
     public function get_attributes(): array {
         return $this->attributes;
+    }
+    /**
+     * Set column help icon
+     *
+     * @param help_icon $helpicon
+     * @return self
+     */
+    public function set_help_icon(help_icon $helpicon): self {
+        $this->helpicon = $helpicon;
+        return $this;
+    }
+    /**
+     * Return column help icon
+     *
+     * @return help_icon|null
+     */
+    public function get_help_icon(): ?help_icon {
+        return $this->helpicon;
+    }
     /**
      * Return available state of the column for the current user. For instance the column may be added to a report with the
      * expectation that only some users are able to see it
+     *
      * @return bool

Proyectos de Subversion Moodle

(root)/reportbuilder/classes/local/report/column.php – Rev 1 → 1441