- npm updates

- renamed 'models' and 'validators' folders
- removed unneccessary files in contracts folder

app/models/file.ts

@@ -0,0 +1,184 @@
+import { DateTime } from 'luxon';
+import { column, hasMany, belongsTo, SnakeCaseNamingStrategy, computed } from '@adonisjs/lucid/orm';
+import HashValue from './hash_value.js';
+import Dataset from './dataset.js';
+import BaseModel from './base_model.js';
+// import { Buffer } from 'buffer';
+import * as fs from 'fs';
+import crypto from 'crypto';
+// import Drive from '@ioc:Adonis/Core/Drive';
+// import Drive from '@adonisjs/drive';
+import drive from '#services/drive';
+
+import type { HasMany } from "@adonisjs/lucid/types/relations";
+import type { BelongsTo } from "@adonisjs/lucid/types/relations";
+// import { TransactionClientContract } from "@adonisjs/lucid/database";
+import { TransactionClientContract } from '@adonisjs/lucid/types/database';
+
+
+
+
+
+export default class File extends BaseModel {
+    // private readonly _data: Uint8Array;
+    // private readonly _type: string;
+    // private readonly _size: number;
+
+    public static namingStrategy = new SnakeCaseNamingStrategy();
+    public static primaryKey = 'id';
+    public static table = 'document_files';
+    public static selfAssignPrimaryKey = false;
+
+    @column({
+        isPrimary: true,
+    })
+    public id: number;
+
+    @column({})
+    public document_id: number;
+
+    @column({})
+    public pathName: string;
+
+    @column()
+    public label: string;
+
+    @column()
+    public comment: string;
+
+    @column()
+    public mimeType: string;
+
+    @column()
+    public language: string;
+
+    @column()
+    public fileSize: number;
+
+    @column()
+    public visibleInOai: boolean;
+
+    @column()
+    public visibleInFrontdoor: boolean;
+
+    @column()
+    public sortOrder: number;
+
+    @column.dateTime({ autoCreate: true })
+    public createdAt: DateTime;
+
+    @column.dateTime({ autoCreate: true, autoUpdate: true })
+    public updatedAt: DateTime;
+
+    // public function dataset()
+    // {
+    //     return $this->belongsTo(Dataset::class, 'document_id', 'id');
+    // }
+    @belongsTo(() => Dataset, {
+        foreignKey: 'document_id',
+    })
+    public dataset: BelongsTo<typeof Dataset>;
+
+    @hasMany(() => HashValue, {
+        foreignKey: 'file_id',
+    })
+    public hashvalues: HasMany<typeof HashValue>;
+
+    @computed({
+        serializeAs: 'filePath',
+    })
+    public get filePath() {
+        return `/storage/app/public/${this.pathName}`;
+        // const mainTitle = this.titles?.find((title) => title.type === 'Main');
+        // return mainTitle ? mainTitle.value : null;
+    }
+
+    @computed({
+        serializeAs: 'size',
+    })
+    public get size() {
+        return this.fileSize;
+    }
+
+    @computed({
+        serializeAs: 'type',
+    })
+    public get type() {
+        return this.mimeType;
+    }
+
+    @computed({
+        serializeAs: 'name',
+    })
+    get name(): string {
+        return this.label;
+    }
+
+    @computed({
+        serializeAs: 'lastModified',
+    })
+    get lastModified(): number {
+        return this.updatedAt.toUnixInteger(); //.toFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
+    }
+
+    readonly webkitRelativePath: string = '';
+
+    @computed({
+        serializeAs: 'fileData',
+    })
+    public get fileData(): string {
+        try {
+            const fileContent: Buffer = fs.readFileSync(this.filePath);
+            // Create a Blob from the file content
+            // const blob = new Blob([fileContent], { type: this.type }); // Adjust
+            // let fileSrc = URL.createObjectURL(blob);
+            // return fileSrc;
+
+            // create a JSON string that contains the data in the property "blob"
+            const json = JSON.stringify({ blob: fileContent.toString('base64') });
+            return json;
+        } catch (err) {
+            // console.error(`Error reading file: ${err}`);
+            return '';
+        }
+    }
+
+    public async createHashValues(trx?: TransactionClientContract) {
+        const hashtypes: string[] = ['md5', 'sha512'];
+
+        for (const type of hashtypes) {
+            const hash = new HashValue();
+            hash.type = type;
+            const hashString = await this._checksumFile(this.filePath, type); // Assuming getRealHash is a method in the same model
+            hash.value = hashString;
+
+            // https://github.com/adonisjs/core/discussions/1872#discussioncomment-132289
+            const file: File = this;
+            if (trx) {
+                await file.useTransaction(trx).related('hashvalues').save(hash); // Save the hash value to the database
+            } else {
+                await file.related('hashvalues').save(hash); // Save the hash value to the database
+            }
+        }
+    }
+
+    public async delete() {
+        if (this.pathName) {
+            // Delete file from additional storage
+            await drive.delete(this.pathName);
+        }
+
+        // Call the original delete method of the BaseModel to remove the record from the database
+        await super.delete();
+    }
+
+    private async _checksumFile(path: string, hashName = 'md5'): Promise<string> {
+        return new Promise((resolve, reject) => {
+            const hash = crypto.createHash(hashName);
+            const stream = fs.createReadStream(path);
+            stream.on('error', (err) => reject(err));
+            stream.on('data', (chunk) => hash.update(chunk));
+            stream.on('end', () => resolve(hash.digest('hex')));
+        });
+    }
+}