user cache

crazyserver · crazyserver · commit 310a35cbead4 · 2025-03-27T12:01:32.000+01:00
diff --git a/src/core/classes/stored-cache.ts b/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;
+};
diff --git a/src/core/features/user/services/database/user.ts b/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 @@ export const CORE_USER_CACHE_SITE_SCHEMA: CoreSiteSchema = {
                     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.
  */
diff --git a/src/core/features/user/services/user.ts b/src/core/features/user/services/user.ts
@@ -25,13 +25,14 @@ import { makeSingleton, Translate } from '@singletons';
 import { CoreEvents, CoreEventSiteData, CoreEventUserDeletedData, CoreEventUserSuspendedData } from '@singletons/events';
 import { CoreStatusWithWarningsWSResponse, CoreWSExternalWarning } from '@services/ws';
 import { CoreError } from '@classes/errors/error';
-import { USERS_TABLE_NAME, CoreUserDBRecord } from './database/user';
+import { USERS_CACHE_TABLE_NAME, CoreUserDBRecord } from './database/user';
 import { CoreUrl } from '@singletons/url';
 import { CoreSiteWSPreSets } from '@classes/sites/authenticated-site';
 import { CoreCacheUpdateFrequency, CoreConstants } from '@/core/constants';
 import { CorePromiseUtils } from '@singletons/promise-utils';
 import { CoreTextFormat } from '@singletons/text';
 import { CORE_USER_PROFILE_REFRESHED, CORE_USER_PROFILE_PICTURE_UPDATED, CORE_USER_PARTICIPANTS_LIST_LIMIT } from '../constants';
+import { CoreStoredCache } from '@classes/stored-cache';
 
 declare module '@singletons/events' {
 
@@ -61,6 +62,7 @@ export class CoreUserProvider {
     static readonly PARTICIPANTS_LIST_LIMIT = CORE_USER_PARTICIPANTS_LIST_LIMIT;
 
     protected logger: CoreLogger;
+    protected userCache = new CoreStoredCache(USERS_CACHE_TABLE_NAME);
 
     constructor() {
         this.logger = CoreLogger.getInstance('CoreUserProvider');
@@ -160,7 +162,7 @@ export class CoreUserProvider {
 
         await Promise.all([
             this.invalidateUserCache(userId, site.getId()),
-            site.getDb().deleteRecords(USERS_TABLE_NAME, { id: userId }),
+            this.userCache.deleteEntry(userId, site.getId()),
         ]);
     }
 
@@ -303,9 +305,7 @@ export class CoreUserProvider {
      * @returns Promise resolve when the user is retrieved.
      */
     protected async getUserFromLocalDb(userId: number, siteId?: string): Promise<CoreUserDBRecord> {
-        const site = await CoreSites.getSite(siteId);
-
-        return site.getDb().getRecord(USERS_TABLE_NAME, { id: userId });
+        return await this.userCache.getEntry(userId, siteId);
     }
 
     /**
@@ -382,7 +382,8 @@ export class CoreUserProvider {
         if ('country' in user && user.country) {
             user.country = CoreCountries.getCountryName(user.country);
         }
-        this.storeUser(user.id, user.fullname, user.profileimageurl);
+
+        this.storeUser(user);
 
         return user;
     }
@@ -706,25 +707,26 @@ export class CoreUserProvider {
     /**
      * Store user basic information in local DB to be retrieved if the WS call fails.
      *
-     * @param userId User ID.
-     * @param fullname User full name.
-     * @param avatar User avatar URL.
+     * @param user User to store.
      * @param siteId ID of the site. If not defined, use current site.
      */
-    protected async storeUser(userId: number, fullname: string, avatar?: string, siteId?: string): Promise<void> {
-        if (!userId) {
+    protected async storeUser(user: CoreUserBasicData, siteId?: string): Promise<void> {
+        if (!user.id) {
             return;
         }
 
-        const site = await CoreSites.getSite(siteId);
-
+        // Filter and map data to store.
         const userRecord: CoreUserDBRecord = {
-            id: userId,
-            fullname: fullname,
-            profileimageurl: avatar,
+            id: user.id,
+            fullname: user.fullname,
+            profileimageurl: user.profileimageurl,
+            firstname: user.firstname,
+            lastname: user.lastname,
+            initials: user.initials,
         };
 
-        await site.getDb().insertRecord(USERS_TABLE_NAME, userRecord);
+
+        await this.userCache.setEntry(user.id, userRecord, siteId);
     }
 
     /**
@@ -733,9 +735,8 @@ export class CoreUserProvider {
      * @param users Users to store.
      * @param siteId ID of the site. If not defined, use current site.
      */
-    async storeUsers(users: CoreUserBasicData[], siteId?: string): Promise<void> {
-        await Promise.all(users.map((user) =>
-            this.storeUser(Number(user.id), user.fullname, user.profileimageurl, siteId)));
+    async storeUsers(users: CoreUserDBRecord[], siteId?: string): Promise<void> {
+        await Promise.all(users.map((user) => this.storeUser(user, siteId)));
     }
 
     /**
@@ -853,7 +854,11 @@ export type CoreUserProfilePictureUpdatedData = {
 export type CoreUserBasicData = {
     id: number; // ID of the user.
     fullname: string; // The fullname of the user.
-    profileimageurl?: string; // User image profile URL - big version.
+    profileimageurl: string; // User image profile URL - big version.
+    firstname?: string; // The first name(s) of the user.
+    lastname?: string; // The family name of the user.
+    lastaccess?: number;
+    initials?: string; // Initials.
 };
 
 /**
