feat: update API controllers, validations, and Vue components

- Modified Api/Authors.Controller.ts to use only personal types and sort by dataset_count.
- Completely rewritten AvatarController.ts.
- Added new Api/CollectionsController.ts for querying collections and collection_roles.
- Modified Api/DatasetController.ts to preload titles, identifier and order by server_date_published.
- Modified FileController.ts to serve files from /storage/app/data/ instead of /storage/app/public.
- Added new Api/UserController for requesting submitters (getSubmitters).
- Improved OaiController.ts with performant DB queries for better ResumptionToken handling.
- Modified Submitter/DatasetController.ts by adding a categorize method for library classification.
- Rewritten ResumptionToken.ts.
- Improved TokenWorkerService.ts to utilize browser fingerprint.
- Edited dataset.ts by adding the doiIdentifier property.
- Enhanced person.ts to improve the fullName property.
- Completely rewritten AsideMenuItem.vue component.
- Updated CarBoxClient.vue to use TypeScript.
- Added new CardBoxDataset.vue for displaying recent datasets on the dashboard.
- Completely rewritten TableSampleClients.vue for the dashboard.
- Completely rewritten UserAvatar.vue.
- Made small layout changes in Dashboard.vue.
- Added new Category.vue for browsing scientific collections.
- Adapted the pinia store in main.ts.
- Added additional routes in start/routes.ts and start/api/routes.ts.
- Improved referenceValidation.ts for better ISBN existence checking.
- NPM dependency updates.

app/Controllers/Http/Api/AuthorsController.ts

@@ -9,12 +9,14 @@ export default class AuthorsController {
         // where exists (select * from gba.documents inner join gba.link_documents_persons on "documents"."id" = "link_documents_persons"."document_id"
         // 			  where ("link_documents_persons"."role" = 'author') and ("persons"."id" = "link_documents_persons"."person_id"));
         const authors = await Person.query()
+            .where('name_type', 'Personal')
             .whereHas('datasets', (dQuery) => {
                 dQuery.wherePivot('role', 'author');
             })
             .withCount('datasets', (query) => {
                 query.as('datasets_count');
-            });
+            })
+            .orderBy('datasets_count', 'desc');
 
         return authors;
     }

app/Controllers/Http/Api/AvatarController.ts

@@ -1,104 +1,135 @@
 import type { HttpContext } from '@adonisjs/core/http';
 import { StatusCodes } from 'http-status-codes';
+import redis from '@adonisjs/redis/services/main';
 
-const prefixes = ['von', 'van'];
+const PREFIXES = ['von', 'van'];
+const DEFAULT_SIZE = 50;
+const FONT_SIZE_RATIO = 0.4;
+const COLOR_LIGHTENING_PERCENT = 60;
+const COLOR_DARKENING_FACTOR = 0.6;
 
 export default class AvatarController {
     public async generateAvatar({ request, response }: HttpContext) {
         try {
-            const { name, size } = request.only(['name', 'size']);
+            const { name, size = DEFAULT_SIZE } = request.only(['name', 'size']);
+            if (!name) {
+                return response.status(StatusCodes.BAD_REQUEST).json({ error: 'Name is required' });
+            }
+
+            // Build a unique cache key for the given name and size
+            const cacheKey = `avatar:${name.trim().toLowerCase()}-${size}`;
+            const cachedSvg = await redis.get(cacheKey);
+            if (cachedSvg) {
+                this.setResponseHeaders(response);
+                return response.send(cachedSvg);
+            }
 
             const initials = this.getInitials(name);
+            const colors = this.generateColors(name);
+            const svgContent = this.createSvg(size, colors, initials);
 
-            const originalColor = this.getColorFromName(name);
-            const backgroundColor = this.lightenColor(originalColor, 60);
-            const textColor = this.darkenColor(originalColor);
-
-            const svgContent = `
-            <svg width="${size || 50}" height="${size || 50}" xmlns="http://www.w3.org/2000/svg">
-              <rect width="100%" height="100%" fill="#${backgroundColor}"/>
-              <text x="50%" y="50%" dominant-baseline="middle" text-anchor="middle" font-weight="bold" font-family="Arial, sans-serif" font-size="${
-                  (size / 100) * 40 || 25
-              }" fill="#${textColor}">${initials}</text>
-            </svg>
-          `;
-
-            response.header('Content-type', 'image/svg+xml');
-            response.header('Cache-Control', 'no-cache');
-            response.header('Pragma', 'no-cache');
-            response.header('Expires', '0');
+            // // Cache the generated avatar for future use, e.g. 1 hour expiry
+            await redis.setex(cacheKey, 3600, svgContent);
 
+            this.setResponseHeaders(response);
             return response.send(svgContent);
         } catch (error) {
-            return response.status(StatusCodes.OK).json({ error: error.message });
+            return response.status(StatusCodes.INTERNAL_SERVER_ERROR).json({ error: error.message });
         }
     }
 
-    private getInitials(name: string) {
-        const parts = name.split(' ');
-        let initials = '';
+    private getInitials(name: string): string {
+        const parts = name
+            .trim()
+            .split(' ')
+            .filter((part) => part.length > 0);
+
+        if (parts.length === 0) {
+            return 'NA';
+        }
 
         if (parts.length >= 2) {
-            const firstName = parts[0];
-            const lastName = parts[parts.length - 1];
-
-            const firstInitial = firstName.charAt(0).toUpperCase();
-            const lastInitial = lastName.charAt(0).toUpperCase();
-
-            if (prefixes.includes(lastName.toLowerCase()) && lastName === lastName.toUpperCase()) {
-                initials = firstInitial + lastName.charAt(1).toUpperCase();
-            } else {
-                initials = firstInitial + lastInitial;
-            }
-        } else if (parts.length === 1) {
-            initials = parts[0].substring(0, 2).toUpperCase();
+            return this.getMultiWordInitials(parts);
         }
-
-        return initials;
+        return parts[0].substring(0, 2).toUpperCase();
     }
 
-    private getColorFromName(name: string) {
+    private getMultiWordInitials(parts: string[]): string {
+        const firstName = parts[0];
+        const lastName = parts[parts.length - 1];
+        const firstInitial = firstName.charAt(0).toUpperCase();
+        const lastInitial = lastName.charAt(0).toUpperCase();
+
+        if (PREFIXES.includes(lastName.toLowerCase()) && lastName === lastName.toUpperCase()) {
+            return firstInitial + lastName.charAt(1).toUpperCase();
+        }
+        return firstInitial + lastInitial;
+    }
+
+    private generateColors(name: string): { background: string; text: string } {
+        const baseColor = this.getColorFromName(name);
+        return {
+            background: this.lightenColor(baseColor, COLOR_LIGHTENING_PERCENT),
+            text: this.darkenColor(baseColor),
+        };
+    }
+
+    private createSvg(size: number, colors: { background: string; text: string }, initials: string): string {
+        const fontSize = size * FONT_SIZE_RATIO;
+        return `
+            <svg width="${size}" height="${size}" xmlns="http://www.w3.org/2000/svg">
+              <rect width="100%" height="100%" fill="#${colors.background}"/>
+              <text x="50%" y="50%" dominant-baseline="middle" text-anchor="middle" font-weight="bold" font-family="Arial, sans-serif" font-size="${fontSize}" fill="#${colors.text}">${initials}</text>
+            </svg>
+          `;
+    }
+
+    private setResponseHeaders(response: HttpContext['response']): void {
+        response.header('Content-type', 'image/svg+xml');
+        response.header('Cache-Control', 'no-cache');
+        response.header('Pragma', 'no-cache');
+        response.header('Expires', '0');
+    }
+
+    private getColorFromName(name: string): string {
         let hash = 0;
         for (let i = 0; i < name.length; i++) {
             hash = name.charCodeAt(i) + ((hash << 5) - hash);
         }
-        let color = '#';
+
+        const colorParts = [];
         for (let i = 0; i < 3; i++) {
             const value = (hash >> (i * 8)) & 0xff;
-            color += ('00' + value.toString(16)).substr(-2);
+            colorParts.push(value.toString(16).padStart(2, '0'));
         }
-        return color.replace('#', '');
+        return colorParts.join('');
     }
 
-    private lightenColor(hexColor: string, percent: number) {
-        let r = parseInt(hexColor.substring(0, 2), 16);
-        let g = parseInt(hexColor.substring(2, 4), 16);
-        let b = parseInt(hexColor.substring(4, 6), 16);
+    private lightenColor(hexColor: string, percent: number): string {
+        const r = parseInt(hexColor.substring(0, 2), 16);
+        const g = parseInt(hexColor.substring(2, 4), 16);
+        const b = parseInt(hexColor.substring(4, 6), 16);
 
-        r = Math.floor((r * (100 + percent)) / 100);
-        g = Math.floor((g * (100 + percent)) / 100);
-        b = Math.floor((b * (100 + percent)) / 100);
+        const lightenValue = (value: number) => Math.min(255, Math.floor((value * (100 + percent)) / 100));
 
-        r = r < 255 ? r : 255;
-        g = g < 255 ? g : 255;
-        b = b < 255 ? b : 255;
+        const newR = lightenValue(r);
+        const newG = lightenValue(g);
+        const newB = lightenValue(b);
 
-        const lighterHex = ((r << 16) | (g << 8) | b).toString(16);
-
-        return lighterHex.padStart(6, '0');
+        return ((newR << 16) | (newG << 8) | newB).toString(16).padStart(6, '0');
     }
 
-    private darkenColor(hexColor: string) {
+    private darkenColor(hexColor: string): string {
         const r = parseInt(hexColor.slice(0, 2), 16);
         const g = parseInt(hexColor.slice(2, 4), 16);
         const b = parseInt(hexColor.slice(4, 6), 16);
 
-        const darkerR = Math.round(r * 0.6);
-        const darkerG = Math.round(g * 0.6);
-        const darkerB = Math.round(b * 0.6);
+        const darkenValue = (value: number) => Math.round(value * COLOR_DARKENING_FACTOR);
 
-        const darkerColor = ((darkerR << 16) + (darkerG << 8) + darkerB).toString(16);
+        const darkerR = darkenValue(r);
+        const darkerG = darkenValue(g);
+        const darkerB = darkenValue(b);
 
-        return darkerColor.padStart(6, '0');
+        return ((darkerR << 16) + (darkerG << 8) + darkerB).toString(16).padStart(6, '0');
     }
 }

app/Controllers/Http/Api/DatasetController.ts

@@ -6,10 +6,15 @@ import { StatusCodes } from 'http-status-codes';
 // node ace make:controller Author
 export default class DatasetController {
     public async index({}: HttpContext) {
-        // select * from gba.persons
-        // where exists (select * from gba.documents inner join gba.link_documents_persons on "documents"."id" = "link_documents_persons"."document_id"
-        // 			  where ("link_documents_persons"."role" = 'author') and ("persons"."id" = "link_documents_persons"."person_id"));
-        const datasets = await Dataset.query().where('server_state', 'published').orWhere('server_state', 'deleted');
+        // Select datasets with server_state 'published' or 'deleted' and sort by the last published date
+        const datasets = await Dataset.query()
+            .where(function (query) {
+                query.where('server_state', 'published')
+                     .orWhere('server_state', 'deleted');
+            })
+            .preload('titles')
+            .preload('identifier')
+            .orderBy('server_date_published', 'desc');
 
         return datasets;
     }

app/Controllers/Http/Api/FileController.ts

@@ -14,7 +14,7 @@ export default class FileController {
         //     where: { id: id },
         // });
         if (file) {
-            const filePath = '/storage/app/public/' + file.pathName;
+            const filePath = '/storage/app/data/' + file.pathName;
             const ext = path.extname(filePath);
             const fileName = file.label + ext;
             try {

app/Controllers/Http/Api/UserController.ts

@@ -9,6 +9,24 @@ import BackupCode from '#models/backup_code';
 
 // Here we are generating secret and recovery codes for the user that’s enabling 2FA and storing them to our database.
 export default class UserController {
+    public async getSubmitters({ response }: HttpContext) {
+        try {
+            const submitters = await User.query()
+                .preload('roles', (query) => {
+                    query.where('name', 'submitter')
+                })
+                .whereHas('roles', (query) => {
+                    query.where('name', 'submitter')
+                })
+                .exec();
+            return submitters;
+        } catch (error) {
+            return response.status(StatusCodes.INTERNAL_SERVER_ERROR).json({
+                message: 'Invalid TOTP state',
+            });
+        }
+    }
+
     public async enable({ auth, response, request }: HttpContext) {
         const user = (await User.find(auth.user?.id)) as User;
         // await user.load('totp_secret');

app/Controllers/Http/Api/collections_controller.ts

@@ -0,0 +1,36 @@
+import type { HttpContext } from '@adonisjs/core/http';
+import Collection from '#models/collection';
+
+export default class CollectionsController {
+    public async show({ params, response }: HttpContext) {
+        // Get the collection id from route parameters
+        const collectionId = params.id;
+
+        // Find the selected collection by id
+        const collection = await Collection.find(collectionId);
+        if (!collection) {
+            return response.status(404).json({ message: 'Collection not found' });
+        }
+
+        // Query for narrower concepts: collections whose parent_id equals the selected collection's id
+        const narrowerCollections = await Collection.query().where('parent_id', collection.id) || [];
+
+        // For broader concept, if the selected collection has a parent_id fetch that record (otherwise null)
+        const broaderCollection: Collection[] | never[] | null = await (async () => {
+            if (collection.parent_id) {
+              // Try to fetch the parent...
+              const parent = await Collection.find(collection.parent_id)
+              // If found, return it wrapped in an array; if not found, return null (or empty array if you prefer)
+              return parent ? [parent] : null
+            }
+            return []
+          })()
+
+        // Return the selected collection along with its narrower and broader concepts in JSON format
+        return response.json({
+            selectedCollection: collection,
+            narrowerCollections,
+            broaderCollection,
+        });
+    }
+}