feat: update to vite.js, Refactor configuration files, remove unused assets, and clean up commented code:

- ace.js: use ts-node-maintained
- adonisrc.ts: load vite_provider, sett assetBundler to false, addd hooks property
- Dockerfile: change to node version 22
- package.json: remove babel depencies; add @swc/wasm, add vitejs/plugin-vue, add hot-hook, add vite,  update eslint-config-prettier, tailwindcss, ts-node-maintained
- new vite.config.js and config/vite.ts
- inertia.js
- improved own vinejs_provider.ts
- adapted app.css needed for vitejs
- adapted app.ts: new resolve method neede for vitejs
relocated resources/js/logo.svg
- remove Buffer import into FileUpload.vue
- Create.vue: improved submit needed for @inertiajs/vue3 form helper
- Edit.vue: mproved submit needed for @inertiajs/vue3 form helper
- kernel.ts: load vite_middleware
- formated rotes.ts file
- rewritten allowed_extensions_mimetypes.ts file (removed typescript errors)

start/env.ts

@@ -11,39 +11,37 @@
 | and hence do not rename or move this file to a different location.
 |
 */
-import { Env } from "@adonisjs/core/env"
+import { Env } from '@adonisjs/core/env';
 
-export default await Env.create(new URL("../", import.meta.url), {
-  HOST: Env.schema.string({ format: 'host' }),
-  PORT: Env.schema.number(),
-  APP_KEY: Env.schema.string(),
-  APP_NAME: Env.schema.string(),
-  CACHE_VIEWS: Env.schema.boolean(),
-  SESSION_DRIVER: Env.schema.enum(["cookie", "memory"] as const),
+export default await Env.create(new URL('../', import.meta.url), {
+    HOST: Env.schema.string({ format: 'host' }),
+    PORT: Env.schema.number(),
+    APP_KEY: Env.schema.string(),
+    APP_NAME: Env.schema.string(),
+    CACHE_VIEWS: Env.schema.boolean(),
+    SESSION_DRIVER: Env.schema.enum(['cookie', 'memory'] as const),
 
-  DRIVE_DISK: Env.schema.enum(['local'] as const),
-  NODE_ENV: Env.schema.enum(['development', 'production', 'test'] as const),
-  DB_CONNECTION: Env.schema.string(),
-  PG_HOST: Env.schema.string({ format: 'host' }),
-  PG_PORT: Env.schema.number(),
-  PG_USER: Env.schema.string(),
-  PG_PASSWORD: Env.schema.string.optional(),
-  PG_DB_NAME: Env.schema.string(),
+    DRIVE_DISK: Env.schema.enum(['local'] as const),
+    NODE_ENV: Env.schema.enum(['development', 'production', 'test'] as const),
+    DB_CONNECTION: Env.schema.string(),
+    PG_HOST: Env.schema.string({ format: 'host' }),
+    PG_PORT: Env.schema.number(),
+    PG_USER: Env.schema.string(),
+    PG_PASSWORD: Env.schema.string.optional(),
+    PG_DB_NAME: Env.schema.string(),
 
-  REDIS_HOST: Env.schema.string({ format: 'host' }),
-  REDIS_PORT: Env.schema.number(),
+    REDIS_HOST: Env.schema.string({ format: 'host' }),
+    REDIS_PORT: Env.schema.number(),
 
-  HASH_DRIVER: Env.schema.enum(["scrypt", "argon", "bcrypt", "laravel", undefined] as const),
-  OAI_LIST_SIZE: Env.schema.number(),
+    HASH_DRIVER: Env.schema.enum(['scrypt', 'argon', 'bcrypt', 'laravel', undefined] as const),
+    OAI_LIST_SIZE: Env.schema.number(),
 
-  /*
+    /*
   |----------------------------------------------------------
   | Variables for configuring the mail package
   |----------------------------------------------------------
   */
-  SMTP_HOST: Env.schema.string.optional(),
-  SMTP_PORT: Env.schema.string.optional(),
-  RESEND_API_KEY: Env.schema.string.optional()
-
-})
-
+    SMTP_HOST: Env.schema.string.optional(),
+    SMTP_PORT: Env.schema.string.optional(),
+    RESEND_API_KEY: Env.schema.string.optional(),
+});

start/kernel.ts

@@ -24,8 +24,8 @@ server.use([
     () => import('@adonisjs/static/static_middleware'),
     // () => import('@adonisjs/cors/cors_middleware'),
     () => import('@adonisjs/inertia/inertia_middleware'),
+    () => import('@adonisjs/vite/vite_middleware'),
 ]);
-
 /**
  * The router middleware stack runs middleware on all the HTTP
  * requests with a registered route.

start/routes.ts

@@ -41,150 +41,361 @@ import db from '@adonisjs/lucid/services/db'; // Import the DB service
 router.get('/health', ({ response }: HttpContext) => response.noContent());
 
 // OAI routes
-router.group(() => {
-    router.get('/oai', [OaiController, 'index']).as('get');
-    router.post('/oai', [OaiController, 'index']).as('post');
-}).as('oai');
+router
+    .group(() => {
+        router.get('/oai', [OaiController, 'index']).as('get');
+        router.post('/oai', [OaiController, 'index']).as('post');
+    })
+    .as('oai');
 
 // Welcome route
-router.get('/welcome', async ({ view }: HttpContext) => {
-    return view.render('welcome');
-}).as('welcome');
+router
+    .get('/welcome', async ({ view }: HttpContext) => {
+        return view.render('welcome');
+    })
+    .as('welcome');
 
 // Dashboard route
-router.get('/', async ({ response }: HttpContext) => {
-    return response.redirect().toRoute('apps.dashboard');
-}).as('dashboard');
+router
+    .get('/', async ({ response }: HttpContext) => {
+        return response.redirect().toRoute('apps.dashboard');
+    })
+    .as('dashboard');
 
 // Apps group
-router.group(() => {
-    router.get('/dashboard', async ({ inertia }: HttpContext) => {
-        return inertia.render('Dashboard');
-    }).as('dashboard');
+router
+    .group(() => {
+        router
+            .get('/dashboard', async ({ inertia }: HttpContext) => {
+                return inertia.render('Dashboard');
+            })
+            .as('dashboard');
 
-    router.get('/map', async ({ inertia }: HttpContext) => {
-        return inertia.render('Map');
-    }).as('map');
+        router
+            .get('/map', async ({ inertia }: HttpContext) => {
+                return inertia.render('Map');
+            })
+            .as('map');
 
-    router.get('/', async ({ inertia }: HttpContext) => {
-        const users = await User.query().orderBy('login');
-        return inertia.render('App', {
-            testing: 'this is a test',
-            users: users,
-        });
-    }).as('index');
+        router
+            .get('/', async ({ inertia }: HttpContext) => {
+                const users = await User.query().orderBy('login');
+                return inertia.render('App', {
+                    testing: 'this is a test',
+                    users: users,
+                });
+            })
+            .as('index');
 
-    router.get('/register', async ({ inertia }: HttpContext) => {
-        return inertia.render('register-view/register-view-component');
-    }).as('register.show');
+        router
+            .get('/register', async ({ inertia }: HttpContext) => {
+                return inertia.render('register-view/register-view-component');
+            })
+            .as('register.show');
 
-    router.post('/register', async ({ request, response }: HttpContext) => {
-        await request.validateUsing(authValidator);
-        return response.redirect().toRoute('app.index');
-    }).as('register.store');
-}).prefix('apps').as('apps').use(middleware.auth());
+        router
+            .post('/register', async ({ request, response }: HttpContext) => {
+                await request.validateUsing(authValidator);
+                return response.redirect().toRoute('app.index');
+            })
+            .as('register.store');
+    })
+    .prefix('apps')
+    .as('apps')
+    .use(middleware.auth());
 
 // Auth routes
-router.get('/app/login', ({ inertia }: HttpContext) => {
-    return inertia.render('Auth/Login');
-}).as('app.login.show');
+router
+    .get('/app/login', ({ inertia }: HttpContext) => {
+        return inertia.render('Auth/Login');
+    })
+    .as('app.login.show');
 
 router.post('/app/login', [AuthController, 'login']).as('login.store');
 router.post('/app/twoFactorChallenge', [AuthController, 'twoFactorChallenge']).as('login.twoFactorChallenge');
 router.post('/signout', [AuthController, 'logout']).as('logout');
 
 // Administrator routes
-router.group(() => {
-    router.get('/settings', async ({ inertia }: HttpContext) => {
-        const updatedConfigValue = await db.from('appconfigs')
-            .select('configvalue')
-            .where('appid', 'backgroundjob')
-            .where('configkey', 'lastjob')
-            .first();
-        return inertia.render('Admin/Settings', {
-            lastCron: updatedConfigValue?.configvalue || '',
-        });
-    }).as('overview');
+router
+    .group(() => {
+        router
+            .get('/settings', async ({ inertia }: HttpContext) => {
+                const updatedConfigValue = await db
+                    .from('appconfigs')
+                    .select('configvalue')
+                    .where('appid', 'backgroundjob')
+                    .where('configkey', 'lastjob')
+                    .first();
+                return inertia.render('Admin/Settings', {
+                    lastCron: updatedConfigValue?.configvalue || '',
+                });
+            })
+            .as('overview');
 
-    router.post('/mail/store', [MailSettingsController, 'setMailSettings']).as('mail.store').use(middleware.can(['user-create']));
-    router.post('/mail/send', [MailSettingsController, 'sendTestMail']).as('mail.send').use(middleware.can(['user-create']));
+        router
+            .post('/mail/store', [MailSettingsController, 'setMailSettings'])
+            .as('mail.store')
+            .use(middleware.can(['user-create']));
+        router
+            .post('/mail/send', [MailSettingsController, 'sendTestMail'])
+            .as('mail.send')
+            .use(middleware.can(['user-create']));
 
-    // User routes
-    router.get('/user', [AdminuserController, 'index']).as('user.index').use(middleware.can(['user-list']));
-    router.get('/user/create', [AdminuserController, 'create']).as('user.create').use(middleware.can(['user-create']));
-    router.post('/user/store', [AdminuserController, 'store']).as('user.store').use(middleware.can(['user-create']));
-    router.get('/user/:id', [AdminuserController, 'show']).as('user.show').where('id', router.matchers.number());
-    router.get('/user/:id/edit', [AdminuserController, 'edit']).as('user.edit').where('id', router.matchers.number()).use(middleware.can(['user-edit']));
-    router.put('/user/:id/update', [AdminuserController, 'update']).as('user.update').where('id', router.matchers.number()).use(middleware.can(['user-edit']));
-    router.delete('/user/:id', [AdminuserController, 'destroy']).as('user.destroy').where('id', router.matchers.number()).use(middleware.can(['user-delete']));
+        // User routes
+        router
+            .get('/user', [AdminuserController, 'index'])
+            .as('user.index')
+            .use(middleware.can(['user-list']));
+        router
+            .get('/user/create', [AdminuserController, 'create'])
+            .as('user.create')
+            .use(middleware.can(['user-create']));
+        router
+            .post('/user/store', [AdminuserController, 'store'])
+            .as('user.store')
+            .use(middleware.can(['user-create']));
+        router.get('/user/:id', [AdminuserController, 'show']).as('user.show').where('id', router.matchers.number());
+        router
+            .get('/user/:id/edit', [AdminuserController, 'edit'])
+            .as('user.edit')
+            .where('id', router.matchers.number())
+            .use(middleware.can(['user-edit']));
+        router
+            .put('/user/:id/update', [AdminuserController, 'update'])
+            .as('user.update')
+            .where('id', router.matchers.number())
+            .use(middleware.can(['user-edit']));
+        router
+            .delete('/user/:id', [AdminuserController, 'destroy'])
+            .as('user.destroy')
+            .where('id', router.matchers.number())
+            .use(middleware.can(['user-delete']));
 
-    // Role routes
-    router.get('/role', [RoleController, 'index']).as('role.index').use(middleware.can(['user-list']));
-    router.get('/role/create', [RoleController, 'create']).as('role.create').use(middleware.can(['user-create']));
-    router.post('/role/store', [RoleController, 'store']).as('role.store').use(middleware.can(['user-create']));
-    router.get('/role/:id', [RoleController, 'show']).as('role.show').where('id', router.matchers.number());
-    router.get('/role/:id/edit', [RoleController, 'edit']).as('role.edit').where('id', router.matchers.number()).use(middleware.can(['user-edit']));
-    router.put('/role/:id/update', [RoleController, 'update']).as('role.update').where('id', router.matchers.number()).use(middleware.can(['user-edit']));
+        // Role routes
+        router
+            .get('/role', [RoleController, 'index'])
+            .as('role.index')
+            .use(middleware.can(['user-list']));
+        router
+            .get('/role/create', [RoleController, 'create'])
+            .as('role.create')
+            .use(middleware.can(['user-create']));
+        router
+            .post('/role/store', [RoleController, 'store'])
+            .as('role.store')
+            .use(middleware.can(['user-create']));
+        router.get('/role/:id', [RoleController, 'show']).as('role.show').where('id', router.matchers.number());
+        router
+            .get('/role/:id/edit', [RoleController, 'edit'])
+            .as('role.edit')
+            .where('id', router.matchers.number())
+            .use(middleware.can(['user-edit']));
+        router
+            .put('/role/:id/update', [RoleController, 'update'])
+            .as('role.update')
+            .where('id', router.matchers.number())
+            .use(middleware.can(['user-edit']));
 
-    // License routes
-    router.get('/license', [LicenseController, 'index']).as('license.index');
-    router.get('/license/:id/down', [LicenseController, 'down']).as('license.down').where('id', router.matchers.number()).use(middleware.can(['settings']));
-    router.get('/license/:id/up', [LicenseController, 'up']).as('license.up').where('id', router.matchers.number()).use(middleware.can(['settings']));
+        // License routes
+        router.get('/license', [LicenseController, 'index']).as('license.index');
+        router
+            .get('/license/:id/down', [LicenseController, 'down'])
+            .as('license.down')
+            .where('id', router.matchers.number())
+            .use(middleware.can(['settings']));
+        router
+            .get('/license/:id/up', [LicenseController, 'up'])
+            .as('license.up')
+            .where('id', router.matchers.number())
+            .use(middleware.can(['settings']));
 
-    // Mimetype routes
-    router.get('/mimetype', [MimetypeController, 'index']).as('mimetype.index');
-    router.get('/mimetype/create', [MimetypeController, 'create']).as('mimetype.create').use(middleware.can(['settings']));
-    router.post('/mimetype/store', [MimetypeController, 'store']).as('mimetype.store').use(middleware.can(['settings']));
-    router.get('/mimetype/:id/down', [MimetypeController, 'down']).as('mimetype.down').where('id', router.matchers.number()).use(middleware.can(['settings']));
-    router.get('/mimetype/:id/up', [MimetypeController, 'up']).as('mimetype.up').where('id', router.matchers.number()).use(middleware.can(['settings']));
-    router.get('/mimetype/:id/delete', [MimetypeController, 'delete']).as('mimetype.delete').use([middleware.auth(), middleware.can(['dataset-delete'])]);
-    router.delete('/mimetype/:id/deleteStore', [MimetypeController, 'deleteStore']).as('mimetype.deleteStore').use([middleware.auth(), middleware.can(['settings'])]);
-}).prefix('admin').as('settings').use([middleware.auth(), middleware.is(['administrator', 'moderator'])]);
+        // Mimetype routes
+        router.get('/mimetype', [MimetypeController, 'index']).as('mimetype.index');
+        router
+            .get('/mimetype/create', [MimetypeController, 'create'])
+            .as('mimetype.create')
+            .use(middleware.can(['settings']));
+        router
+            .post('/mimetype/store', [MimetypeController, 'store'])
+            .as('mimetype.store')
+            .use(middleware.can(['settings']));
+        router
+            .get('/mimetype/:id/down', [MimetypeController, 'down'])
+            .as('mimetype.down')
+            .where('id', router.matchers.number())
+            .use(middleware.can(['settings']));
+        router
+            .get('/mimetype/:id/up', [MimetypeController, 'up'])
+            .as('mimetype.up')
+            .where('id', router.matchers.number())
+            .use(middleware.can(['settings']));
+        router
+            .get('/mimetype/:id/delete', [MimetypeController, 'delete'])
+            .as('mimetype.delete')
+            .use([middleware.auth(), middleware.can(['dataset-delete'])]);
+        router
+            .delete('/mimetype/:id/deleteStore', [MimetypeController, 'deleteStore'])
+            .as('mimetype.deleteStore')
+            .use([middleware.auth(), middleware.can(['settings'])]);
+    })
+    .prefix('admin')
+    .as('settings')
+    .use([middleware.auth(), middleware.is(['administrator', 'moderator'])]);
 
 router.get('/settings/user/security', [UserController, 'accountInfo']).as('settings.user').use(middleware.auth());
 router.post('/settings/user/store', [UserController, 'accountInfoStore']).as('account.password.store').use(middleware.auth());
 
 // Submitter routes
-router.group(() => {
-    router.get('/dataset', [DatasetController, 'index']).as('dataset.list').use([middleware.auth(), middleware.can(['dataset-list'])]);
-    router.get('/dataset/create', [DatasetController, 'create']).as('dataset.create').use([middleware.auth(), middleware.can(['dataset-submit'])]);
-    router.post('/dataset/first/first-step', [DatasetController, 'firstStep']).as('dataset.first.step').use([middleware.auth(), middleware.can(['dataset-submit'])]);
-    router.post('/dataset/second/second-step', [DatasetController, 'secondStep']).as('dataset.second.step').use([middleware.auth(), middleware.can(['dataset-submit'])]);
-    router.post('/dataset/second/third-step', [DatasetController, 'thirdStep']).as('dataset.third.step').use([middleware.auth(), middleware.can(['dataset-submit'])]);
-    router.post('/dataset/submit', [DatasetController, 'store']).as('dataset.submit').use([middleware.auth(), middleware.can(['dataset-submit'])]);
-    router.get('/dataset/:id/release', [DatasetController, 'release']).as('dataset.release').where('id', router.matchers.number()).use([middleware.auth(), middleware.can(['dataset-edit'])]);
-    router.put('/dataset/:id/releaseupdate', [DatasetController, 'releaseUpdate']).as('dataset.releaseUpdate').use([middleware.auth(), middleware.can(['dataset-edit'])]);
-    router.get('/dataset/:id/edit', [DatasetController, 'edit']).as('dataset.edit').where('id', router.matchers.number()).use([middleware.auth(), middleware.can(['dataset-edit'])]);
-    router.put('/dataset/:id/update', [DatasetController, 'update']).as('dataset.update').where('id', router.matchers.number()).use([middleware.auth(), middleware.can(['dataset-edit'])]);
-    router.get('/dataset/:id/delete', [DatasetController, 'delete']).as('dataset.delete').use([middleware.auth(), middleware.can(['dataset-delete'])]);
-    router.put('/dataset/:id/deleteupdate', [DatasetController, 'deleteUpdate']).as('dataset.deleteUpdate').use([middleware.auth(), middleware.can(['dataset-delete'])]);
-    router.get('/person', [PersonController, 'index']).as('person.index').use([middleware.auth()]);
-    router.get('/dataset/categorize', ({ inertia }: HttpContext) => {
-        return inertia.render('Submitter/Dataset/Category');
-    });
-}).prefix('submitter');
+router
+    .group(() => {
+        router
+            .get('/dataset', [DatasetController, 'index'])
+            .as('dataset.list')
+            .use([middleware.auth(), middleware.can(['dataset-list'])]);
+        router
+            .get('/dataset/create', [DatasetController, 'create'])
+            .as('dataset.create')
+            .use([middleware.auth(), middleware.can(['dataset-submit'])]);
+        router
+            .post('/dataset/first/first-step', [DatasetController, 'firstStep'])
+            .as('dataset.first.step')
+            .use([middleware.auth(), middleware.can(['dataset-submit'])]);
+        router
+            .post('/dataset/second/second-step', [DatasetController, 'secondStep'])
+            .as('dataset.second.step')
+            .use([middleware.auth(), middleware.can(['dataset-submit'])]);
+        router
+            .post('/dataset/second/third-step', [DatasetController, 'thirdStep'])
+            .as('dataset.third.step')
+            .use([middleware.auth(), middleware.can(['dataset-submit'])]);
+        router
+            .post('/dataset/submit', [DatasetController, 'store'])
+            .as('dataset.submit')
+            .use([middleware.auth(), middleware.can(['dataset-submit'])]);
+        router
+            .get('/dataset/:id/release', [DatasetController, 'release'])
+            .as('dataset.release')
+            .where('id', router.matchers.number())
+            .use([middleware.auth(), middleware.can(['dataset-edit'])]);
+        router
+            .put('/dataset/:id/releaseupdate', [DatasetController, 'releaseUpdate'])
+            .as('dataset.releaseUpdate')
+            .use([middleware.auth(), middleware.can(['dataset-edit'])]);
+        router
+            .get('/dataset/:id/edit', [DatasetController, 'edit'])
+            .as('dataset.edit')
+            .where('id', router.matchers.number())
+            .use([middleware.auth(), middleware.can(['dataset-edit'])]);
+        router
+            .put('/dataset/:id/update', [DatasetController, 'update'])
+            .as('dataset.update')
+            .where('id', router.matchers.number())
+            .use([middleware.auth(), middleware.can(['dataset-edit'])]);
+        router
+            .get('/dataset/:id/delete', [DatasetController, 'delete'])
+            .as('dataset.delete')
+            .use([middleware.auth(), middleware.can(['dataset-delete'])]);
+        router
+            .put('/dataset/:id/deleteupdate', [DatasetController, 'deleteUpdate'])
+            .as('dataset.deleteUpdate')
+            .use([middleware.auth(), middleware.can(['dataset-delete'])]);
+        router.get('/person', [PersonController, 'index']).as('person.index').use([middleware.auth()]);
+        router.get('/dataset/categorize', ({ inertia }: HttpContext) => {
+            return inertia.render('Submitter/Dataset/Category');
+        });
+    })
+    .prefix('submitter');
 
 // Editor routes
-router.group(() => {
-    router.get('/dataset', [EditorDatasetController, 'index']).as('editor.dataset.list').use([middleware.auth(), middleware.can(['dataset-editor-list'])]);
-    router.get('dataset/:id/receive', [EditorDatasetController, 'receive']).as('editor.dataset.receive').where('id', router.matchers.number()).use([middleware.auth(), middleware.can(['dataset-receive'])]);
-    router.put('dataset/:id/receive', [EditorDatasetController, 'receiveUpdate']).as('editor.dataset.receiveUpdate').where('id', router.matchers.number()).use([middleware.auth(), middleware.can(['dataset-receive'])]);
-    router.get('dataset/:id/approve', [EditorDatasetController, 'approve']).as('editor.dataset.approve').where('id', router.matchers.number()).use([middleware.auth(), middleware.can(['dataset-approve'])]);
-    router.put('dataset/:id/approve', [EditorDatasetController, 'approveUpdate']).as('editor.dataset.approveUpdate').where('id', router.matchers.number()).use([middleware.auth(), middleware.can(['dataset-approve'])]);
-    router.get('dataset/:id/reject', [EditorDatasetController, 'reject']).as('editor.dataset.reject').where('id', router.matchers.number()).use([middleware.auth(), middleware.can(['dataset-editor-reject'])]);
-    router.put('dataset/:id/reject', [EditorDatasetController, 'rejectUpdate']).as('editor.dataset.rejectUpdate').where('id', router.matchers.number()).use([middleware.auth(), middleware.can(['dataset-editor-reject'])]);
-    router.get('dataset/:id/publish', [EditorDatasetController, 'publish']).as('editor.dataset.publish').where('id', router.matchers.number()).use([middleware.auth(), middleware.can(['dataset-publish'])]);
-    router.put('dataset/:id/publish', [EditorDatasetController, 'publishUpdate']).as('editor.dataset.publishUpdate').where('id', router.matchers.number()).use([middleware.auth(), middleware.can(['dataset-publish'])]);
-    router.get('dataset/:id/doi', [EditorDatasetController, 'doiCreate']).as('editor.dataset.doi').where('id', router.matchers.number()).use([middleware.auth(), middleware.can(['dataset-publish'])]);
-    router.put('dataset/:publish_id/doi', [EditorDatasetController, 'doiStore']).as('editor.dataset.doiStore').where('id', router.matchers.number()).use([middleware.auth(), middleware.can(['dataset-publish'])]);
-    router.put('/dataset/:id/update', [EditorDatasetController, 'update']).as('editor.dataset.update').use([middleware.auth(), middleware.can(['dataset-editor-edit'])]);
-}).prefix('editor');
+router
+    .group(() => {
+        router
+            .get('/dataset', [EditorDatasetController, 'index'])
+            .as('editor.dataset.list')
+            .use([middleware.auth(), middleware.can(['dataset-editor-list'])]);
+        router
+            .get('dataset/:id/receive', [EditorDatasetController, 'receive'])
+            .as('editor.dataset.receive')
+            .where('id', router.matchers.number())
+            .use([middleware.auth(), middleware.can(['dataset-receive'])]);
+        router
+            .put('dataset/:id/receive', [EditorDatasetController, 'receiveUpdate'])
+            .as('editor.dataset.receiveUpdate')
+            .where('id', router.matchers.number())
+            .use([middleware.auth(), middleware.can(['dataset-receive'])]);
+        router
+            .get('dataset/:id/approve', [EditorDatasetController, 'approve'])
+            .as('editor.dataset.approve')
+            .where('id', router.matchers.number())
+            .use([middleware.auth(), middleware.can(['dataset-approve'])]);
+        router
+            .put('dataset/:id/approve', [EditorDatasetController, 'approveUpdate'])
+            .as('editor.dataset.approveUpdate')
+            .where('id', router.matchers.number())
+            .use([middleware.auth(), middleware.can(['dataset-approve'])]);
+        router
+            .get('dataset/:id/reject', [EditorDatasetController, 'reject'])
+            .as('editor.dataset.reject')
+            .where('id', router.matchers.number())
+            .use([middleware.auth(), middleware.can(['dataset-editor-reject'])]);
+        router
+            .put('dataset/:id/reject', [EditorDatasetController, 'rejectUpdate'])
+            .as('editor.dataset.rejectUpdate')
+            .where('id', router.matchers.number())
+            .use([middleware.auth(), middleware.can(['dataset-editor-reject'])]);
+        router
+            .get('dataset/:id/publish', [EditorDatasetController, 'publish'])
+            .as('editor.dataset.publish')
+            .where('id', router.matchers.number())
+            .use([middleware.auth(), middleware.can(['dataset-publish'])]);
+        router
+            .put('dataset/:id/publish', [EditorDatasetController, 'publishUpdate'])
+            .as('editor.dataset.publishUpdate')
+            .where('id', router.matchers.number())
+            .use([middleware.auth(), middleware.can(['dataset-publish'])]);
+        router
+            .get('dataset/:id/doi', [EditorDatasetController, 'doiCreate'])
+            .as('editor.dataset.doi')
+            .where('id', router.matchers.number())
+            .use([middleware.auth(), middleware.can(['dataset-publish'])]);
+        router
+            .put('dataset/:publish_id/doi', [EditorDatasetController, 'doiStore'])
+            .as('editor.dataset.doiStore')
+            .where('id', router.matchers.number())
+            .use([middleware.auth(), middleware.can(['dataset-publish'])]);
+        router
+            .put('/dataset/:id/update', [EditorDatasetController, 'update'])
+            .as('editor.dataset.update')
+            .use([middleware.auth(), middleware.can(['dataset-editor-edit'])]);
+    })
+    .prefix('editor');
 
 // Reviewer routes
-router.group(() => {
-    router.get('/dataset', [ReviewerDatasetController, 'index']).as('reviewer.dataset.list').use([middleware.auth(), middleware.can(['dataset-review-list'])]);
-    router.get('dataset/:id/review', [ReviewerDatasetController, 'review']).as('reviewer.dataset.review').where('id', router.matchers.number()).use([middleware.auth(), middleware.can(['dataset-review'])]);
-    router.put('dataset/:id/review', [ReviewerDatasetController, 'reviewUpdate']).as('reviewer.dataset.reviewUpdate').where('id', router.matchers.number()).use([middleware.auth(), middleware.can(['dataset-review'])]);
-    router.get('dataset/:id/reject', [ReviewerDatasetController, 'reject']).as('reviewer.dataset.reject').where('id', router.matchers.number()).use([middleware.auth(), middleware.can(['dataset-review-reject'])]);
-    router.put('dataset/:id/reject', [ReviewerDatasetController, 'rejectUpdate']).as('reviewer.dataset.rejectUpdate').where('id', router.matchers.number()).use([middleware.auth(), middleware.can(['dataset-review-reject'])]);
-}).prefix('reviewer');
+router
+    .group(() => {
+        router
+            .get('/dataset', [ReviewerDatasetController, 'index'])
+            .as('reviewer.dataset.list')
+            .use([middleware.auth(), middleware.can(['dataset-review-list'])]);
+        router
+            .get('dataset/:id/review', [ReviewerDatasetController, 'review'])
+            .as('reviewer.dataset.review')
+            .where('id', router.matchers.number())
+            .use([middleware.auth(), middleware.can(['dataset-review'])]);
+        router
+            .put('dataset/:id/review', [ReviewerDatasetController, 'reviewUpdate'])
+            .as('reviewer.dataset.reviewUpdate')
+            .where('id', router.matchers.number())
+            .use([middleware.auth(), middleware.can(['dataset-review'])]);
+        router
+            .get('dataset/:id/reject', [ReviewerDatasetController, 'reject'])
+            .as('reviewer.dataset.reject')
+            .where('id', router.matchers.number())
+            .use([middleware.auth(), middleware.can(['dataset-review-reject'])]);
+        router
+            .put('dataset/:id/reject', [ReviewerDatasetController, 'rejectUpdate'])
+            .as('reviewer.dataset.rejectUpdate')
+            .where('id', router.matchers.number())
+            .use([middleware.auth(), middleware.can(['dataset-review-reject'])]);
+    })
+    .prefix('reviewer');

start/routes/api.ts

@@ -6,30 +6,32 @@ import HomeController from '#controllers/Http/Api/HomeController';
 import FileController from '#controllers/Http/Api/FileController';
 import AvatarController from '#controllers/Http/Api/AvatarController';
 import UserController from '#controllers/Http/Api/UserController';
-import { middleware } from '../kernel.js'
+import { middleware } from '../kernel.js';
 // API
-router.group(() => {
-  
+router
+    .group(() => {
+        router.get('authors', [AuthorsController, 'index']).as('author.index');
+        router.get('datasets', [DatasetController, 'index']).as('dataset.index');
+        router.get('persons', [AuthorsController, 'persons']).as('author.persons');
 
-   
-        router.get('authors', [AuthorsController, "index"]).as('author.index');
-        router.get('datasets', [DatasetController, "index"]).as('dataset.index');
-        router.get('persons', [AuthorsController, "persons"]).as('author.persons');
-     
-        router.get('/dataset',  [DatasetController, "findAll"]).as('dataset.findAll');
-        router.get('/dataset/:publish_id', [DatasetController, "findOne"]).as('dataset.findOne');
-        router.get('/sitelinks/:year', [HomeController, "findDocumentsPerYear"]);
-        router.get('/years',  [HomeController, "findYears"]);
-        router.get('/statistic/:year',  [HomeController, "findPublicationsPerMonth"]);
+        router.get('/dataset', [DatasetController, 'findAll']).as('dataset.findAll');
+        router.get('/dataset/:publish_id', [DatasetController, 'findOne']).as('dataset.findOne');
+        router.get('/sitelinks/:year', [HomeController, 'findDocumentsPerYear']);
+        router.get('/years', [HomeController, 'findYears']);
+        router.get('/statistic/:year', [HomeController, 'findPublicationsPerMonth']);
 
-        router.get('/download/:id', [FileController, "findOne"]).as('file.findOne');
+        router.get('/download/:id', [FileController, 'findOne']).as('file.findOne');
 
         router.get('/avatar/:name/:background?/:textColor?/:size?', [AvatarController, 'generateAvatar']);
 
-    
-        router.post('/twofactor_totp/settings/enable/:state/:code?', [UserController, 'enable']).as('apps.twofactor_totp.enable') .use(middleware.auth());
-        router.post('/twofactor_backupcodes/settings/create', [UserController, 'createCodes']).as('apps.twofactor_backupcodes.create') .use(middleware.auth());
-    
-})
+        router
+            .post('/twofactor_totp/settings/enable/:state/:code?', [UserController, 'enable'])
+            .as('apps.twofactor_totp.enable')
+            .use(middleware.auth());
+        router
+            .post('/twofactor_backupcodes/settings/create', [UserController, 'createCodes'])
+            .as('apps.twofactor_backupcodes.create')
+            .use(middleware.auth());
+    })
     // .namespace('App/Controllers/Http/Api')
     .prefix('api');

start/rules/allowed_extensions_mimetypes.ts

@@ -9,7 +9,6 @@ import vine from '@vinejs/vine';
 // import { VineString } from '@vinejs/vine';
 import { VineMultipartFile, isBodyParserFile } from '#providers/vinejs_provider';
 import type { MultipartFile } from '@adonisjs/core/bodyparser';
-// import db from '@adonisjs/lucid/services/db';
 import MimeType from '#models/mime_type';
 
 /**
@@ -22,11 +21,14 @@ import MimeType from '#models/mime_type';
 type Options = {
     // size: string | number;
     // extnames: string[];
-    clientNameSizeLimit: number;
+    // clientNameSizeLimit?: number;
+    allowedExtensions: string[];
+    allowedMimeTypes: string[];
 };
 
+
 // async function allowedMimetypeExtensions(file: VineMultipartFile | unknown, options: Options | unknown, field: FieldContext) {
-async function allowedMimetypeExtensions(file: VineMultipartFile | unknown, options: Options | unknown, field: FieldContext) {
+async function allowedMimetypeExtensions(file: VineMultipartFile | unknown, options: Options, field: FieldContext) {
     // if (typeof value !== 'string' && typeof value != 'number') {
     //     return;
     // }
@@ -42,7 +44,7 @@ async function allowedMimetypeExtensions(file: VineMultipartFile | unknown, opti
     const mimeRecord = await MimeType.query().select('file_extension').where('name', mimeType).andWhere('enabled', true).first();
 
     if (!mimeRecord) {
-        const allowedMimetypes = await MimeType.query().select('name').where('enabled', true);
+        const allowedMimetypes = await MimeType.query().select('name').where('enabled', true)
         // Transform allowed MIME types to a concatenated string
         const allowedMimetypesString = allowedMimetypes.map((mime) => mime.name).join(', ');
         // throw new Error('Invalid MIME type');
@@ -53,14 +55,19 @@ async function allowedMimetypeExtensions(file: VineMultipartFile | unknown, opti
             field,
         );
     } else {
-        const allowedExtensions = mimeRecord.file_extension.split('|');
+        let allowedExtensions: string[] = [];
+        if (options && options.allowedExtensions) {
+            allowedExtensions = options.allowedExtensions;
+        } else {
+            allowedExtensions = mimeRecord.file_extension.split('|');
+        }
         // Validate if the file's extension is in the allowed extensions
         if (!allowedExtensions.includes(fileExtension)) {
             //throw new Error(`File extension ${fileExtension} is not allowed for MIME type ${mimeType}`);
             field.report(
                 `File extension ${fileExtension} is not allowed for MIME type ${mimeType}. Allowed extensions are: ${mimeRecord.file_extension}`,
-                'allowedMimetypeExtensions', 
-                field
+                'allowedMimetypeExtensions',
+                field,
             );
         }
         // if (validatedFile.clientName.length > options.clientNameSizeLimit) {
@@ -74,10 +81,10 @@ export const allowedMimetypeExtensionsRule = vine.createRule(allowedMimetypeExte
 
 declare module '#providers/vinejs_provider' {
     interface VineMultipartFile {
-        allowedMimetypeExtensions(options?: Options): this;        
+        allowedMimetypeExtensions(options?: Options): this;
     }
 }
 
 VineMultipartFile.macro('allowedMimetypeExtensions', function (this: VineMultipartFile, options: Options) {
-    return this.use(allowedMimetypeExtensionsRule(options));    
+    return this.use(allowedMimetypeExtensionsRule(options));
 });

start/rules/referenceValidation.ts

@@ -1,7 +1,7 @@
 import { FieldContext } from '@vinejs/vine/types';
 import vine from '@vinejs/vine';
 import { VineString } from '@vinejs/vine';
-import axios from 'axios';
+import { default as axios } from 'axios';
 import { ReferenceIdentifierTypes } from '#contracts/enums';
 
 type Options = {
@@ -11,7 +11,7 @@ type Options = {
 // Function to check if DOI exists using the DOI API
 async function checkDoiExists(doi: string): Promise<boolean> {
     try {
-        const response = await axios.default.get(`${doi}`);
+        const response = await axios.get(`${doi}`);
         return response.status === 200; // If status is 200, DOI is valid
     } catch (error) {
         return false; // If request fails, DOI does not exist
@@ -21,7 +21,7 @@ async function checkDoiExists(doi: string): Promise<boolean> {
 // Function to check if ISBN exists using the Open Library API
 async function checkIsbnExists(isbn: string): Promise<boolean> {
     try {
-        const response = await axios.default.get(`https://isbnsearch.org/isbn/${isbn}`);
+        const response = await axios.get(`https://isbnsearch.org/isbn/${isbn}`);
         return response.data && response.status == 200; // If title is returned, ISBN is valid
     } catch (error) {
         return false; // If request fails, ISBN does not exist

start/rules/translated_language.ts

@@ -17,7 +17,7 @@ type Options = {
 };
 
 async function translatedLanguage(value: unknown, options: Options, field: FieldContext) {
-    if (typeof value !== 'string' && typeof value != 'number') {
+    if (typeof value !== 'string' && typeof value !== 'number') {
         return;
     }
 

start/rules/unique.ts

@@ -15,11 +15,11 @@ import { VineString, VineNumber } from '@vinejs/vine';
 type Options = {
     table: string;
     column: string;
-    whereNot?:  ((field: FieldContext) => string);
+    whereNot?: (field: FieldContext) => string;
 };
 
 async function isUnique(value: unknown, options: Options, field: FieldContext) {
-    if (typeof value !== 'string' && typeof value != 'number') {
+    if (typeof value !== 'string' && typeof value !== 'number') {
         return;
     }
 
@@ -37,13 +37,11 @@ async function isUnique(value: unknown, options: Options, field: FieldContext) {
         // report that value is NOT unique
         field.report('The {{ field }} field is not unique', 'isUnique', field);
         // field.report(messages.unique, "isUnique", field);
-    
-    }   
+    }
 }
 
 export const isUniqueRule = vine.createRule(isUnique);
 
-
 declare module '@vinejs/vine' {
     interface VineString {
         isUnique(options: Options): this;
@@ -58,4 +56,4 @@ VineString.macro('isUnique', function (this: VineString, options: Options) {
 });
 VineNumber.macro('isUnique', function (this: VineNumber, options: Options) {
     return this.use(isUniqueRule(options));
-});
+});

start/rules/unique_person.ts

@@ -19,9 +19,8 @@ type Options = {
     idField: string;
 };
 
-
 async function isUniquePerson(value: unknown, options: Options, field: FieldContext) {
-    if (typeof value !== 'string' && typeof value != 'number') {
+    if (typeof value !== 'string' && typeof value !== 'number') {
         return;
     }
 
@@ -40,13 +39,11 @@ async function isUniquePerson(value: unknown, options: Options, field: FieldCont
     if (result) {
         // report that value is NOT unique
         field.report('The {{ field }} field is not unique', 'isUnique', field);
-    
-    }   
+    }
 }
 
 export const isUniquePersonRule = vine.createRule(isUniquePerson);
 
-
 declare module '@vinejs/vine' {
     interface VineString {
         isUniquePerson(options: Options): this;
@@ -61,4 +58,4 @@ VineString.macro('isUniquePerson', function (this: VineString, options: Options)
 });
 VineNumber.macro('isUniquePerson', function (this: VineNumber, options: Options) {
     return this.use(isUniquePersonRule(options));
-});
+});

start/validator.ts

@@ -13,20 +13,18 @@ import vine from '@vinejs/vine';
 // import db from '@adonisjs/lucid/services/db';
 import { VanillaErrorReporter } from '#validators/vanilla_error_reporter';
 
-
 // vine.messagesProvider = new SimpleMessagesProvider({
 //      // Applicable for all fields
 //      'required': 'The {{ field }} field is required',
 //      'string': 'The value of {{ field }} field must be a string',
 //      'email': 'The value is not a valid email address',
-   
+
 //      // 'contacts.0.email.required': 'The primary email of the contact is required',
 //      // 'contacts.*.email.required': 'Contact email is required',
 //      'permissions.minLength': 'at least {{ options.minLength }} permission must be defined',
 //      'permissions.*.number': 'Define permissions as valid numbers',
 //   })
 vine.errorReporter = () => new VanillaErrorReporter();
-  
 
 // /**
 //  * Options accepted by the unique rule