WebSVN – Moodle – Diff – /reportbuilder/classes/local/entities/user.php

 use context_helper;
 use context_system;
 use context_user;
 use core\context;
 use core_component;
+use core_date;
+use core_user;
 use html_writer;
 use lang_string;
 use moodle_url;
 use stdClass;
 use theme_config;
     protected function get_default_entity_title(): lang_string {
         return new lang_string('entityuser', 'core_reportbuilder');
+    }
     /**
-     * Initialise the entity, add all user fields and all 'visible' user profile fields
+     * Initialise the entity
+     *
      * @return base
      */
+    public function initialise(): base {
+        $tablealias = $this->get_table_alias('user');
-    public function initialise(): base {
+        $userprofilefields = (new user_profile_fields(
+            "{$tablealias}.id",
+            $this->get_entity_name(),
+        ))
-        $userprofilefields = $this->get_user_profile_fields();
+            ->add_joins($this->get_joins());
         $columns = array_merge($this->get_all_columns(), $userprofilefields->get_columns());
         foreach ($columns as $column) {
+            $this->add_column($column);
             $this->add_column($column);
-        $filters = array_merge($this->get_all_filters(), $userprofilefields->get_filters());
+        // All the filters defined by the entity can also be used as conditions.
-        foreach ($filters as $filter) {
-            $this->add_filter($filter);
-        }
+        $filters = array_merge($this->get_all_filters(), $userprofilefields->get_filters());
+        foreach ($filters as $filter) {
-        $conditions = array_merge($this->get_all_filters(), $userprofilefields->get_filters());
+            $this
-        foreach ($conditions as $condition) {
+                ->add_condition($filter)
-            $this->add_condition($condition);
+                ->add_filter($filter);
+        }
-        return $this;
-    }
-    /**
-     * Get user profile fields helper instance
-     *
-     * @return user_profile_fields
-     */
-    protected function get_user_profile_fields(): user_profile_fields {
-        $userprofilefields = new user_profile_fields($this->get_table_alias('user') . '.id', $this->get_entity_name());
         $userprofilefields->add_joins($this->get_joins());
-        return $userprofilefields;
+        return $this;
+    }
     /**
             new lang_string('fullname'),
             $this->get_entity_name()
         ))
             ->add_joins($this->get_joins())
             ->add_fields($fullnameselect)
-            ->set_type(column::TYPE_TEXT)
-            ->set_is_sortable($this->is_sortable('fullname'), $fullnamesort)
+            ->set_is_sortable(true, $fullnamesort)
-            ->add_callback(static function(?string $value, stdClass $row) use ($viewfullnames): string {
+            ->add_callback(static function($value, stdClass $row) use ($viewfullnames): string {
-                if ($value === null) {
+                // Ensure we have at least one field present.
+                if (count(array_filter((array) $row, fn($field) => $field !== null)) === 0) {
                     return '';
+                }
                 // Ensure we populate all required name properties.
                 $this->get_entity_name()
             ))
                 ->add_joins($this->get_joins())
                 ->add_fields($fullnameselect)
                 ->add_field("{$usertablealias}.id")
-                ->set_type(column::TYPE_TEXT)
-                ->set_is_sortable($this->is_sortable($fullnamefield), $fullnamesort)
+                ->set_is_sortable(true, $fullnamesort)
-                ->add_callback(static function(?string $value, stdClass $row) use ($fullnamefield, $viewfullnames): string {
+                ->add_callback(static function($value, stdClass $row) use ($fullnamefield, $viewfullnames): string {
                     global $OUTPUT;
+                    // Ensure we have at least one field present.
-                    if ($value === null) {
+                    if (count(array_filter((array) $row, fn($field) => $field !== null)) === 0) {
                         return '';
+                    }
                         return html_writer::link(new moodle_url('/user/profile.php', ['id' => $row->id]),
                             $OUTPUT->user_picture($row, ['link' => false, 'alttext' => false]) .
                             fullname($row, $viewfullnames));
+                    }
-                    return $value;
+                    return (string) $value;
                 });
             // Picture fields need some more data.
+        }
         // Picture column.
         $columns[] = (new column(
             'picture',
-            new lang_string('userpicture', 'core_reportbuilder'),
+            new lang_string('picture'),
             $this->get_entity_name()
         ))
             ->add_joins($this->get_joins())
-            ->add_fields($userpictureselect)
-            ->set_type(column::TYPE_INTEGER)
-            ->set_is_sortable($this->is_sortable('picture'))
-            // It doesn't make sense to offer integer aggregation methods for this column.
-            ->set_disabled_aggregation(['avg', 'max', 'min', 'sum'])
+            ->add_fields($userpictureselect)
-            ->add_callback(static function ($value, stdClass $row): string {
+            ->add_callback(static function($value, stdClass $row): string {
                 global $OUTPUT;
                 return !empty($row->id) ? $OUTPUT->user_picture($row, ['link' => false, 'alttext' => false]) : '';
             });
         // Add all other user fields.
-        $userfields = $this->get_user_fields();
-        foreach ($userfields as $userfield => $userfieldlang) {
-            $columntype = $this->get_user_field_type($userfield);
-            $columnfieldsql = "{$usertablealias}.{$userfield}";
-            if ($columntype === column::TYPE_LONGTEXT && $DB->get_dbfamily() === 'oracle') {
+        $userfields = $this->get_user_fields();
-                $columnfieldsql = $DB->sql_order_by_text($columnfieldsql, 1024);
+        foreach ($userfields as $userfield => $userfieldlang) {
             $columntype = $this->get_user_field_type($userfield);
             $column = (new column(
                 $userfield,
                 $userfieldlang,
                 $this->get_entity_name()
             ))
                 ->add_joins($this->get_joins())
                 ->set_type($columntype)
-                ->add_field($columnfieldsql, $userfield)
+                ->add_field("{$usertablealias}.{$userfield}")
-                ->set_is_sortable($this->is_sortable($userfield))
+                ->set_is_sortable(true)
         return $columns;
+    }
-    /**
-     * Check if this field is sortable
-     *
-     * @param string $fieldname
-     * @return bool
-     */
-    protected function is_sortable(string $fieldname): bool {
-        // Some columns can't be sorted, like longtext or images.
-        $nonsortable = [
-            'description',
-            'picture',
-        ];
-        return !in_array($fieldname, $nonsortable);
-    }
     /**
      * Formats the user field for display.
+     *
      * @param mixed $value Current field value.
             return format::userdate($value, $row);
+        }
         // If the column has corresponding filter, determine the value from its options.
         $options = $this->get_options_for($fieldname);
-        if ($options !== null && array_key_exists($value, $options)) {
+        if ($options !== null && $value !== null && array_key_exists($value, $options)) {
             return $options[$value];
+        }
      */
     public static function get_name_fields_select(string $usertablealias = 'u'): string {
-        $namefields = fields::get_name_fields(true);
-        // Create a dummy user object containing all name fields.
+        $namefields = fields::get_name_fields(true);
-        $dummyuser = (object) array_combine($namefields, $namefields);
         $viewfullnames = has_capability('moodle/site:viewfullnames', context_system::instance());
-        $dummyfullname = fullname($dummyuser, $viewfullnames);
+        $dummyfullname = core_user::get_dummy_fullname(null, ['override' => $viewfullnames]);
             'firstname' => new lang_string('firstname'),
             'lastname' => new lang_string('lastname'),
             'email' => new lang_string('email'),
             'city' => new lang_string('city'),
             'country' => new lang_string('country'),
+            'lang' => new lang_string('language'),
+            'timezone' => new lang_string('timezone'),
             'theme' => new lang_string('theme'),
             'description' => new lang_string('description'),
             'firstnamephonetic' => new lang_string('firstnamephonetic'),
             'lastnamephonetic' => new lang_string('lastnamephonetic'),
             'middlename' => new lang_string('middlename'),
      * Return list of all available filters
+     *
      * @return filter[]
      */
     protected function get_all_filters(): array {
-        global $DB;
-        $filters = [];
         $tablealias = $this->get_table_alias('user');
         // Fullname filter.
         $canviewfullnames = has_capability('moodle/site:viewfullnames', context_system::instance());
             $fullnamesql,
             $fullnameparams
         ))
             ->add_joins($this->get_joins());
+        // Picture filter.
+        $filters[] = (new filter(
+            boolean_select::class,
+            'picture',
+            new lang_string('picture'),
+            $this->get_entity_name(),
+            "CASE WHEN {$tablealias}.picture > 0 THEN 1 ELSE 0 END",
+        ))
+            ->add_joins($this->get_joins());
         // User fields filters.
         $fields = $this->get_user_fields();
-        foreach ($fields as $field => $name) {
-            $filterfieldsql = "{$tablealias}.{$field}";
-            if ($this->get_user_field_type($field) === column::TYPE_LONGTEXT) {
-                $filterfieldsql = $DB->sql_cast_to_char($filterfieldsql);
-            }
         foreach ($fields as $field => $name) {
             $optionscallback = [static::class, 'get_options_for_' . $field];
             if (is_callable($optionscallback)) {
                 $classname = select::class;
             } else if ($this->get_user_field_type($field) === column::TYPE_BOOLEAN) {
             $filter = (new filter(
                 $classname,
                 $field,
                 $name,
                 $this->get_entity_name(),
-                $filterfieldsql
+                "{$tablealias}.{$field}"
             ))
                 ->add_joins($this->get_joins());
             // Populate filter options by callback, if available.
     public static function get_options_for_country(): array {
         return get_string_manager()->get_list_of_countries();
+    }
+    /**
+     * List of options for the field lang.
+     *
+     * @return string[]
+     */
+    public static function get_options_for_lang(): array {
+        return get_string_manager()->get_list_of_translations();
+    }
+    /**
+     * List of options for the field timezone.
+     *
+     * @return string[]
+     */
+    public static function get_options_for_timezone(): array {
+        return core_date::get_list_of_timezones(null, true);
+    }
     /**
      * List of options for the field theme.
+     *
      * @return string[]
      */

Proyectos de Subversion Moodle

(root)/reportbuilder/classes/local/entities/user.php – Rev 1 → 1441