MOBILE-4575 user: Sort user initials depending on translation

scripts/langindex.json

@@ -2666,6 +2666,7 @@
   "core.user.emailagain": "moodle",
   "core.user.errorloaduser": "local_moodlemobileapp",
   "core.user.firstname": "moodle",
+  "core.user.fullnamedisplay": "moodle",
   "core.user.idnumber": "moodle",
   "core.user.institution": "moodle",
   "core.user.interests": "moodle",

src/core/classes/stored-cache.ts

@@ -0,0 +1,171 @@
+// (C) Copyright 2015 Moodle Pty Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import { CoreSites, CoreSiteSchema } from '@services/sites';
+import { CoreText } from '@singletons/text';
+import { SQLiteDB } from './sqlitedb';
+import { CorePromiseUtils } from '@singletons/promise-utils';
+
+/**
+ * A cache to store values in database.
+ *
+ * The data is organized by "entries" that are identified by an ID. Each entry can have multiple values stored,
+ * and each value has its own timemodified.
+ *
+ * Values expire after a certain time.
+ */
+export class CoreStoredCache {
+
+    constructor(protected tableName: string) {
+
+    }
+
+    /**
+     * Clear the cache. Erasing all the entries.
+     *
+     * @param siteId ID of the site. If not defined, use current site.
+     */
+    async clear(siteId?: string): Promise<void> {
+        const db = await this.getDb(siteId);
+
+        await db.deleteRecords(this.tableName);
+    }
+
+    /**
+     * Get all the data stored in the cache for a certain id.
+     *
+     * @param id The ID to identify the entry.
+     * @param siteId ID of the site. If not defined, use current site.
+     * @returns The data from the cache. Undefined if not found.
+     */
+    async getEntry<T>(id: number, siteId?: string): Promise<T> {
+        const db = await this.getDb(siteId);
+
+        const record = await db.getRecord<CoreStoredCacheRecord>(this.tableName, { id });
+
+        return CoreText.parseJSON(record.data);
+    }
+
+    /**
+     * Invalidate all the cached data for a certain entry.
+     *
+     * @param id The ID to identify the entry.
+     * @param siteId ID of the site. If not defined, use current site.
+     */
+    async invalidate(id: number, siteId?: string): Promise<void> {
+        const db = await this.getDb(siteId);
+
+        await db.updateRecords(this.tableName, { timemodified: 0 }, { id });
+    }
+
+    /**
+     * Update the status of a module in the "cache".
+     *
+     * @param id The ID to identify the entry.
+     * @param value Value to set.
+     * @param siteId ID of the site. If not defined, use current site.
+     * @returns The set value.
+     */
+    async setEntry<T>(
+        id: number,
+        value: T,
+        siteId?: string,
+    ): Promise<void> {
+        const db = await this.getDb(siteId);
+
+        let entry = await CorePromiseUtils.ignoreErrors(this.getEntry<T>(id, siteId), { id });
+
+        entry = {
+            ...entry,
+            ...value,
+        };
+
+        const record: CoreStoredCacheRecord = {
+            id,
+            timemodified: Date.now(),
+            data: JSON.stringify(entry),
+        };
+
+        await db.insertRecord(this.tableName, record);
+    }
+
+    /**
+     * Delete an entry from the cache.
+     *
+     * @param id ID of the entry to delete.
+     * @param siteId ID of the site. If not defined, use current site.
+     */
+    async deleteEntry(id: number, siteId?: string): Promise<void> {
+        const db = await this.getDb(siteId);
+
+        await db.deleteRecords(this.tableName, { id });
+    }
+
+    /**
+     * Get the database to use.
+     *
+     * @param siteId ID of the site. If not defined, use current site.
+     * @returns Database.
+     */
+    protected async getDb(siteId?: string): Promise<SQLiteDB> {
+        const site = await CoreSites.getSite(siteId);
+
+        return site.getDb();
+    }
+
+}
+
+/**
+ * Helper function to get the schema to store cache in the database.
+ *
+ * @param schemaName Name of the schema.
+ * @param tableName Name of the table.
+ * @returns Schema.
+ */
+export function getStoredCacheDBSchema(schemaName: string, tableName: string): CoreSiteSchema {
+    return {
+        name: schemaName,
+        version: 1,
+        canBeCleared: [tableName],
+        tables: [
+            {
+                name: tableName,
+                columns: [
+                    {
+                        name: 'id',
+                        type: 'INTEGER',
+                        primaryKey: true,
+                    },
+                    {
+                        name: 'data',
+                        type: 'TEXT',
+                    },
+                    {
+                        name: 'timemodified',
+                        type: 'INTEGER',
+                    },
+                ],
+            },
+        ],
+    };
+}
+
+/**
+ * Stored cache entry.
+ */
+type CoreStoredCacheRecord = {
+    id: number;
+    data: string;
+    timemodified: number;
+};

src/core/features/user/lang.json

@@ -18,6 +18,7 @@
     "emailagain": "Email (again)",
     "errorloaduser": "Error loading user.",
     "firstname": "First name",
+    "fullnamedisplay": "{{$a.firstname}} {{$a.lastname}}",
     "idnumber": "ID number",
     "institution": "Institution",
     "interests": "Interests",

src/core/features/user/services/database/user.ts

@@ -14,6 +14,7 @@
 
 import { CoreSiteSchema } from '@services/sites';
 import { CoreUserBasicData } from '../user';
+import { getStoredCacheDBSchema } from '@classes/stored-cache';
 
 /**
  * Database variables for CoreUser service.
@@ -33,18 +34,21 @@
                     primaryKey: true,
                 },
                 {
-                    name: 'fullname',
+                    name: 'data',
                     type: 'TEXT',
                 },
                 {
-                    name: 'profileimageurl',
-                    type: 'TEXT',
+                    name: 'timemodified',
+                    type: 'INTEGER',
                 },
             ],
         },
     ],
 };
 
+export const USERS_CACHE_TABLE_NAME = 'users_cache';
+export const CORE_USER_CACHE_SITE_SCHEMA = getStoredCacheDBSchema('CoreUser', USERS_CACHE_TABLE_NAME);
+
 /**
  * Database variables for CoreUserOffline service.
  */

src/core/features/user/services/user-helper.ts

@@ -17,7 +17,7 @@
 import { CoreSites } from '@services/sites';
 
 import { makeSingleton, Translate } from '@singletons';
-import { CoreUser, CoreUserProfile, CoreUserRole } from './user';
+import { CoreUser, CoreUserBasicData, CoreUserProfile, CoreUserRole } from './user';
 import { CoreTime } from '@singletons/time';
 
 /**
@@ -90,15 +90,22 @@
      *
      * @param user User object.
      * @returns User initials.
-     * @deprecated since 4.4. Use getUserInitialsFromParts instead.
      */
     getUserInitials(user: Partial<CoreUserProfile>): string {
-        if (!user.firstname && !user.lastname) {
-            // @TODO: Use local info or check WS to get initials from.
-            return '';
-        }
-
-        return (user.firstname?.charAt(0) || '') + (user.lastname?.charAt(0) || '');
+        const nameFields = ['firstname', 'lastname'];
+        const dummyUser = {
+            firstname: 'firstname',
+            lastname: 'lastname',
+        };
+        const nameFormat = Translate.instant('core.user.fullnamedisplay', { $a:dummyUser });
+        const availableFieldsSorted = nameFields
+            .filter((field) => nameFormat.indexOf(field) >= 0)
+            .sort((a, b) => nameFormat.indexOf(a) - nameFormat.indexOf(b));
+
+        const initials = availableFieldsSorted.reduce((initials, fieldName) =>
+            initials + (user[fieldName]?.charAt(0) ?? ''), '');
+
+        return initials || 'UNK';
     }
 
     /**
@@ -108,27 +115,15 @@
      * @returns User initials.
      */
     async getUserInitialsFromParts(parts: CoreUserNameParts): Promise<string> {
-        if (!parts.firstname && !parts.lastname) {
-            if (!parts.fullname && parts.userId) {
-                const user = await CoreUser.getProfile(parts.userId, undefined, true);
-                parts.fullname = user.fullname || '';
-            }
-
-            if (parts.fullname) {
-                const split = parts.fullname.split(' ');
-
-                parts.firstname = split[0];
-                if (split.length > 1) {
-                    parts.lastname = split[split.length - 1];
-                }
-            }
+        const initials = this.getUserInitials(parts);
+        if (initials !== 'UNK' || !parts.userId) {
+            return initials;
         }
+        const user = await CoreUser.getProfile(parts.userId, undefined, false);
+        console.error(user, parts.userId);
 
-        if (!parts.firstname && !parts.lastname) {
-            return 'UNK';
-        }
+        return user.initials || 'UNK';
 
-        return (parts.firstname?.charAt(0) || '') + (parts.lastname?.charAt(0) || '');
     }
 
     /**
@@ -142,8 +137,52 @@
         return CoreTime.translateLegacyTimezone(tz);
     }
 
+    normalizeBasicFields<T extends CoreUserBasicData = CoreUserBasicData>(profile: CoreUserDenormalized): T {
+        let normalized = {
+            id: profile.id ?? profile.userid ?? 0,
+            fullname:  profile.fullname ?? profile.userfullname ?? '',
+            profileimageurl: profile.profileimageurl ?? profile.userprofileimageurl ??
+                profile.userpictureurl ?? profile.profileimageurlsmall ?? profile.urls?.profileimage ?? '',
+        } as T;
+
+        delete profile.userid;
+        delete profile.userfullname;
+        delete profile.userpictureurl;
+        delete profile.userprofileimageurl;
+        delete profile.profileimageurlsmall;
+        delete profile.urls;
+
+        normalized = { ...profile, ...normalized };
+
+        if (normalized.id === 0) {
+            throw new Error('Invalid user ID');
+        }
+
+        normalized.initials = CoreUserHelper.getUserInitials(profile);
+
+        return normalized;
+    }
+
 }
 
 export const CoreUserHelper = makeSingleton(CoreUserHelperProvider);
 
 type CoreUserNameParts = { firstname?: string; lastname?: string; fullname?: string; userId?: number };
+
+type CoreUserDenormalized = CoreUserBasicData & {
+    id?: number;
+    userid?: number;
+
+    initials?: string; // Initials.
+
+    fullname?: string;
+    userfullname?: string;
+
+    profileimageurl?: string;
+    userpictureurl?: string;
+    userprofileimageurl?: string;
+    profileimageurlsmall?: string;
+    urls?: {
+        profileimage?: string;
+    };
+};