9 files changed, 138 insertions, 173 deletions

diff --git a/app/Controllers/Http/Dashboard/AccountController.ts b/app/Controllers/Http/Dashboard/AccountController.ts
index 3c4e919..5870f19 100644
--- a/app/Controllers/Http/Dashboard/AccountController.ts
+++ b/app/Controllers/Http/Dashboard/AccountController.ts
@@ -1,29 +1,23 @@
-import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
-import { schema, rules, validator } from '@ioc:Adonis/Core/Validator';
-import crypto from 'node:crypto';
+import type { HttpContext } from '@adonisjs/core/http'
+import { schema, rules, validator } from '@adonisjs/validator'
+import crypto from 'node:crypto'
 
 export default class AccountController {
   /**
    * Shows the user account page
    */
-  public async show({ auth, view }: HttpContextContract) {
+  public async show({ auth, view }: HttpContext) {
     return view.render('dashboard/account', {
       username: auth.user?.username,
       email: auth.user?.email,
       lastname: auth.user?.lastname,
-    });
+    })
   }
 
   /**
    * Stores user account data
    */
-  public async store({
-    auth,
-    request,
-    response,
-    session,
-    view,
-  }: HttpContextContract) {
+  public async store({ auth, request, response, session, view }: HttpContext) {
     try {
       await validator.validate({
         schema: schema.create({
@@ -48,26 +42,26 @@ export default class AccountController {
           lastname: schema.string([rules.required()]),
         }),
         data: request.only(['username', 'email', 'lastname']),
-      });
+      })
     } catch (error) {
-      session.flash(error.messages);
-      return response.redirect('/user/account');
+      session.flash(error.messages)
+      return response.redirect('/user/account')
     }
 
     // Update user account
-    const { user } = auth;
+    const { user } = auth
     if (user) {
-      user.username = request.input('username');
-      user.lastname = request.input('lastname');
-      user.email = request.input('email');
+      user.username = request.input('username')
+      user.lastname = request.input('lastname')
+      user.email = request.input('email')
       if (request.input('password')) {
         const hashedPassword = crypto
           .createHash('sha256')
           .update(request.input('password'))
-          .digest('base64');
-        user.password = hashedPassword;
+          .digest('base64')
+        user.password = hashedPassword
       }
-      await user.save();
+      await user.save()
     }
 
     return view.render('dashboard/account', {
@@ -75,6 +69,6 @@ export default class AccountController {
       lastname: user?.lastname,
       email: user?.email,
       success: user !== undefined,
-    });
+    })
   }
 }
diff --git a/app/Controllers/Http/Dashboard/DataController.ts b/app/Controllers/Http/Dashboard/DataController.ts
index f77702f..8a77329 100644
--- a/app/Controllers/Http/Dashboard/DataController.ts
+++ b/app/Controllers/Http/Dashboard/DataController.ts
@@ -1,14 +1,14 @@
-import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
+import type { HttpContext } from '@adonisjs/core/http'
 
 export default class DataController {
   /**
    * Display the data page
    */
-  public async show({ view, auth }: HttpContextContract) {
-    const { user } = auth;
+  public async show({ view, auth }: HttpContext) {
+    const { user } = auth
 
-    const services = await user?.related('services').query();
-    const workspaces = await user?.related('workspaces').query();
+    const services = await user?.related('services').query()
+    const workspaces = await user?.related('workspaces').query()
 
     return view.render('dashboard/data', {
       username: user?.username,
@@ -19,6 +19,6 @@ export default class DataController {
       stringify: JSON.stringify,
       services,
       workspaces,
-    });
+    })
   }
 }
diff --git a/app/Controllers/Http/Dashboard/DeleteController.ts b/app/Controllers/Http/Dashboard/DeleteController.ts
index ef8188c..bd824b0 100644
--- a/app/Controllers/Http/Dashboard/DeleteController.ts
+++ b/app/Controllers/Http/Dashboard/DeleteController.ts
@@ -1,20 +1,20 @@
-import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
+import type { HttpContext } from '@adonisjs/core/http'
 
 export default class DeleteController {
   /**
    * Display the delete page
    */
-  public async show({ view }: HttpContextContract) {
-    return view.render('dashboard/delete');
+  public async show({ view }: HttpContext) {
+    return view.render('dashboard/delete')
   }
 
   /**
    * Delete user and session
    */
-  public async delete({ auth, response }: HttpContextContract) {
-    auth.user?.delete();
-    auth.use('web').logout();
+  public async delete({ auth, response }: HttpContext) {
+    auth.user?.delete()
+    auth.use('web').logout()
 
-    return response.redirect('/user/login');
+    return response.redirect('/user/login')
   }
 }
diff --git a/app/Controllers/Http/Dashboard/ExportController.ts b/app/Controllers/Http/Dashboard/ExportController.ts
index 7155eab..5b6df70 100644
--- a/app/Controllers/Http/Dashboard/ExportController.ts
+++ b/app/Controllers/Http/Dashboard/ExportController.ts
@@ -1,33 +1,30 @@
-import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
+import type { HttpContext } from '@adonisjs/core/http'
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function deepParseToJSON(obj: any): Record<string, unknown> {
   if (typeof obj !== 'object' || obj === null) {
     try {
       // Try to parse the object as JSON
-      return JSON.parse(obj) as Record<string, unknown>;
+      return JSON.parse(obj) as Record<string, unknown>
     } catch {
       // If parsing fails, return the original value
-      return obj;
+      return obj
     }
   }
 
   // If obj is an object, recursively parse its keys
   if (Array.isArray(obj)) {
     // If obj is an array, recursively parse each element
-    return obj.map(item => deepParseToJSON(item)) as unknown as Record<
-      string,
-      unknown
-    >;
+    return obj.map((item) => deepParseToJSON(item)) as unknown as Record<string, unknown>
   } else {
     // If obj is an object, recursively parse its keys
-    const parsedObj: Record<string, unknown> = {};
+    const parsedObj: Record<string, unknown> = {}
     for (const key in obj) {
       if (obj.hasOwnProperty(key)) {
-        parsedObj[key] = deepParseToJSON(obj[key]);
+        parsedObj[key] = deepParseToJSON(obj[key])
       }
     }
-    return parsedObj;
+    return parsedObj
   }
 }
 
@@ -35,10 +32,10 @@ export default class ExportController {
   /**
    * Display the export page
    */
-  public async show({ auth, response }: HttpContextContract) {
-    const user = auth.user!;
-    const services = await user.related('services').query();
-    const workspaces = await user.related('workspaces').query();
+  public async show({ auth, response }: HttpContext) {
+    const user = auth.user!
+    const services = await user.related('services').query()
+    const workspaces = await user.related('workspaces').query()
 
     const exportData = {
       username: user.username,
@@ -46,11 +43,11 @@ export default class ExportController {
       mail: user.email,
       services: deepParseToJSON(JSON.parse(JSON.stringify(services))),
       workspaces: deepParseToJSON(JSON.parse(JSON.stringify(workspaces))),
-    };
+    }
 
     return response
       .header('Content-Type', 'application/force-download')
       .header('Content-disposition', 'attachment; filename=export.ferdium-data')
-      .send(exportData);
+      .send(exportData)
   }
 }
diff --git a/app/Controllers/Http/Dashboard/ForgotPasswordController.ts b/app/Controllers/Http/Dashboard/ForgotPasswordController.ts
index da05bbd..f7b1d0e 100644
--- a/app/Controllers/Http/Dashboard/ForgotPasswordController.ts
+++ b/app/Controllers/Http/Dashboard/ForgotPasswordController.ts
@@ -1,41 +1,41 @@
-import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
-import { schema, rules, validator } from '@ioc:Adonis/Core/Validator';
-import User from 'App/Models/User';
+import type { HttpContext } from '@adonisjs/core/http'
+import { schema, rules, validator } from '@adonisjs/validator'
+import User from '#app/Models/User'
 
 export default class ForgotPasswordController {
   /**
    * Display the forgot password form
    */
-  public async show({ view }: HttpContextContract) {
-    return view.render('dashboard/forgotPassword');
+  public async show({ view }: HttpContext) {
+    return view.render('dashboard/forgotPassword')
   }
 
   /**
    * Send forget password email to user
    */
-  public async forgotPassword({ view, request }: HttpContextContract) {
+  public async forgotPassword({ view, request }: HttpContext) {
     try {
       await validator.validate({
         schema: schema.create({
           mail: schema.string([rules.email(), rules.required()]),
         }),
         data: request.only(['mail']),
-      });
+      })
     } catch {
       return view.render('others/message', {
         heading: 'Cannot reset your password',
         text: 'Please enter a valid email address',
-      });
+      })
     }
 
     try {
-      const user = await User.findByOrFail('email', request.input('mail'));
-      await user.forgotPassword();
+      const user = await User.findByOrFail('email', request.input('mail'))
+      await user.forgotPassword()
     } catch {}
 
     return view.render('others/message', {
       heading: 'Reset password',
       text: 'If your provided E-Mail address is linked to an account, we have just sent an E-Mail to that address.',
-    });
+    })
   }
 }
diff --git a/app/Controllers/Http/Dashboard/LogOutController.ts b/app/Controllers/Http/Dashboard/LogOutController.ts
index 41cbd31..5d250c4 100644
--- a/app/Controllers/Http/Dashboard/LogOutController.ts
+++ b/app/Controllers/Http/Dashboard/LogOutController.ts
@@ -1,12 +1,12 @@
-import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
+import type { HttpContext } from '@adonisjs/core/http'
 
 export default class LogOutController {
   /**
    * Login a user
    */
-  public async logout({ auth, response }: HttpContextContract) {
-    auth.logout();
+  public async logout({ auth, response }: HttpContext) {
+    auth.logout()
 
-    return response.redirect('/user/login');
+    return response.redirect('/user/login')
   }
 }
diff --git a/app/Controllers/Http/Dashboard/LoginController.ts b/app/Controllers/Http/Dashboard/LoginController.ts
index ffb9eeb..5a54448 100644
--- a/app/Controllers/Http/Dashboard/LoginController.ts
+++ b/app/Controllers/Http/Dashboard/LoginController.ts
@@ -1,26 +1,21 @@
-import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
-import { schema, rules, validator } from '@ioc:Adonis/Core/Validator';
-import User from 'App/Models/User';
-import crypto from 'node:crypto';
-import { handleVerifyAndReHash } from '../../../../helpers/PasswordHash';
+import type { HttpContext } from '@adonisjs/core/http'
+import { schema, rules, validator } from '@adonisjs/validator'
+import User from '#app/Models/User'
+import crypto from 'node:crypto'
+import { handleVerifyAndReHash } from '../../../../helpers/PasswordHash.js'
 
 export default class LoginController {
   /**
    * Display the login form
    */
-  public async show({ view }: HttpContextContract) {
-    return view.render('dashboard/login');
+  public async show({ view }: HttpContext) {
+    return view.render('dashboard/login')
   }
 
   /**
    * Login a user
    */
-  public async login({
-    request,
-    response,
-    auth,
-    session,
-  }: HttpContextContract) {
+  public async login({ request, response, auth, session }: HttpContext) {
     try {
       await validator.validate({
         schema: schema.create({
@@ -28,54 +23,51 @@ export default class LoginController {
           password: schema.string([rules.required()]),
         }),
         data: request.only(['mail', 'password']),
-      });
+      })
     } catch {
       session.flash({
         type: 'danger',
         message: 'Invalid mail or password',
-      });
-      session.flashExcept(['password']);
+      })
+      session.flashExcept(['password'])
 
-      return response.redirect('/user/login');
+      return response.redirect('/user/login')
     }
 
     try {
-      const { mail, password } = request.all();
+      const { mail, password } = request.all()
 
       // Check if user with email exists
-      const user = await User.query().where('email', mail).first();
+      const user = await User.query().where('email', mail).first()
       if (!user?.email) {
-        throw new Error('User credentials not valid (Invalid email)');
+        throw new Error('User credentials not valid (Invalid email)')
       }
 
-      const hashedPassword = crypto
-        .createHash('sha256')
-        .update(password)
-        .digest('base64');
+      const hashedPassword = crypto.createHash('sha256').update(password).digest('base64')
 
       // Verify password
-      let isMatchedPassword = false;
+      let isMatchedPassword = false
       try {
-        isMatchedPassword = await handleVerifyAndReHash(user, hashedPassword);
+        isMatchedPassword = await handleVerifyAndReHash(user, hashedPassword)
       } catch (error) {
-        return response.internalServerError({ message: error.message });
+        return response.internalServerError({ message: error.message })
       }
 
       if (!isMatchedPassword) {
-        throw new Error('User credentials not valid (Invalid password)');
+        throw new Error('User credentials not valid (Invalid password)')
       }
 
-      await auth.use('web').login(user);
+      await auth.use('web').login(user)
 
-      return response.redirect('/user/account');
+      return response.redirect('/user/account')
     } catch {
       session.flash({
         type: 'danger',
         message: 'Invalid mail or password',
-      });
-      session.flashExcept(['password']);
+      })
+      session.flashExcept(['password'])
 
-      return response.redirect('/user/login');
+      return response.redirect('/user/login')
     }
   }
 }
diff --git a/app/Controllers/Http/Dashboard/ResetPasswordController.ts b/app/Controllers/Http/Dashboard/ResetPasswordController.ts
index 0b9053f..b62b5d2 100644
--- a/app/Controllers/Http/Dashboard/ResetPasswordController.ts
+++ b/app/Controllers/Http/Dashboard/ResetPasswordController.ts
@@ -1,35 +1,30 @@
-import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
-import { schema, rules, validator } from '@ioc:Adonis/Core/Validator';
-import Token from 'App/Models/Token';
-import moment from 'moment';
-import crypto from 'node:crypto';
+import type { HttpContext } from '@adonisjs/core/http'
+import { schema, rules, validator } from '@adonisjs/validator'
+import Token from '#app/Models/Token'
+import moment from 'moment'
+import crypto from 'node:crypto'
 
 export default class ResetPasswordController {
   /**
    * Display the reset password form
    */
-  public async show({ view, request }: HttpContextContract) {
-    const { token } = request.qs();
+  public async show({ view, request }: HttpContext) {
+    const { token } = request.qs()
 
     if (token) {
-      return view.render('dashboard/resetPassword', { token });
+      return view.render('dashboard/resetPassword', { token })
     }
 
     return view.render('others/message', {
       heading: 'Invalid token',
       text: 'Please make sure you are using a valid and recent link to reset your password.',
-    });
+    })
   }
 
   /**
    * Resets user password
    */
-  public async resetPassword({
-    response,
-    request,
-    session,
-    view,
-  }: HttpContextContract) {
+  public async resetPassword({ response, request, session, view }: HttpContext) {
     try {
       await validator.validate({
         schema: schema.create({
@@ -37,14 +32,14 @@ export default class ResetPasswordController {
           token: schema.string([rules.required()]),
         }),
         data: request.only(['password', 'password_confirmation', 'token']),
-      });
+      })
     } catch {
       session.flash({
         type: 'danger',
         message: 'Passwords do not match',
-      });
+      })
 
-      return response.redirect(`/user/reset?token=${request.input('token')}`);
+      return response.redirect(`/user/reset?token=${request.input('token')}`)
     }
 
     const tokenRow = await Token.query()
@@ -52,34 +47,30 @@ export default class ResetPasswordController {
       .where('token', request.input('token'))
       .where('type', 'forgot_password')
       .where('is_revoked', false)
-      .where(
-        'updated_at',
-        '>=',
-        moment().subtract(24, 'hours').format('YYYY-MM-DD HH:mm:ss'),
-      )
-      .first();
+      .where('updated_at', '>=', moment().subtract(24, 'hours').format('YYYY-MM-DD HH:mm:ss'))
+      .first()
 
     if (!tokenRow) {
       return view.render('others/message', {
         heading: 'Cannot reset your password',
         text: 'Please make sure you are using a valid and recent link to reset your password and that your passwords entered match.',
-      });
+      })
     }
 
     // Update user password
     const hashedPassword = crypto
       .createHash('sha256')
       .update(request.input('password'))
-      .digest('base64');
-    tokenRow.user.password = hashedPassword;
-    await tokenRow.user.save();
+      .digest('base64')
+    tokenRow.user.password = hashedPassword
+    await tokenRow.user.save()
 
     // Delete token to prevent it from being used again
-    await tokenRow.delete();
+    await tokenRow.delete()
 
     return view.render('others/message', {
       heading: 'Reset password',
       text: 'Successfully reset your password. You can now login to your account using your new password.',
-    });
+    })
   }
 }
diff --git a/app/Controllers/Http/Dashboard/TransferController.ts b/app/Controllers/Http/Dashboard/TransferController.ts
index b113e50..0296973 100644
--- a/app/Controllers/Http/Dashboard/TransferController.ts
+++ b/app/Controllers/Http/Dashboard/TransferController.ts
@@ -1,8 +1,8 @@
-import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
-import { schema, validator } from '@ioc:Adonis/Core/Validator';
-import Service from 'App/Models/Service';
-import Workspace from 'App/Models/Workspace';
-import { v4 as uuidv4 } from 'uuid';
+import type { HttpContext } from '@adonisjs/core/http'
+import { schema, validator } from '@adonisjs/validator'
+import Service from '#app/Models/Service'
+import Workspace from '#app/Models/Workspace'
+import { v4 as uuidv4 } from 'uuid'
 
 const importSchema = schema.create({
   username: schema.string(),
@@ -10,58 +10,52 @@ const importSchema = schema.create({
   mail: schema.string(),
   services: schema.array().anyMembers(),
   workspaces: schema.array().anyMembers(),
-});
+})
 
 export default class TransferController {
   /**
    * Display the transfer page
    */
-  public async show({ view }: HttpContextContract) {
-    return view.render('dashboard/transfer');
+  public async show({ view }: HttpContext) {
+    return view.render('dashboard/transfer')
   }
 
-  public async import({
-    auth,
-    request,
-    response,
-    session,
-    view,
-  }: HttpContextContract) {
-    let file;
+  public async import({ auth, request, response, session, view }: HttpContext) {
+    let file
     try {
       file = await validator.validate({
         schema: importSchema,
         data: JSON.parse(request.body().file),
-      });
+      })
     } catch {
       session.flash({
         message: 'Invalid Ferdium account file',
-      });
+      })
 
-      return response.redirect('/user/transfer');
+      return response.redirect('/user/transfer')
     }
 
     if (!file?.services || !file.workspaces) {
       session.flash({
         type: 'danger',
         message: 'Invalid Ferdium account file (2)',
-      });
-      return response.redirect('/user/transfer');
+      })
+      return response.redirect('/user/transfer')
     }
 
-    const serviceIdTranslation = {};
+    const serviceIdTranslation = {}
 
     // Import services
     try {
       for (const service of file.services) {
         // Get new, unused uuid
-        let serviceId;
+        let serviceId
         do {
-          serviceId = uuidv4();
+          serviceId = uuidv4()
         } while (
           // eslint-disable-next-line no-await-in-loop, unicorn/no-await-expression-member
           (await Service.query().where('serviceId', serviceId)).length > 0
-        );
+        )
 
         // eslint-disable-next-line no-await-in-loop
         await Service.create({
@@ -73,38 +67,37 @@ export default class TransferController {
             typeof service.settings === 'string'
               ? service.settings
               : JSON.stringify(service.settings),
-        });
+        })
 
         // @ts-expect-error Element implicitly has an 'any' type because expression of type 'any' can't be used to index type '{}'
-        serviceIdTranslation[service.service_id || service.serviceId] =
-          serviceId;
+        serviceIdTranslation[service.service_id || service.serviceId] = serviceId
       }
     } catch (error) {
       // eslint-disable-next-line no-console
-      console.log(error);
-      const errorMessage = `Could not import your services into our system.\nError: ${error}`;
+      console.log(error)
+      const errorMessage = `Could not import your services into our system.\nError: ${error}`
       return view.render('others/message', {
         heading: 'Error while importing',
         text: errorMessage,
-      });
+      })
     }
 
     // Import workspaces
     try {
       for (const workspace of file.workspaces) {
-        let workspaceId;
+        let workspaceId
 
         do {
-          workspaceId = uuidv4();
+          workspaceId = uuidv4()
         } while (
           // eslint-disable-next-line no-await-in-loop, unicorn/no-await-expression-member
           (await Workspace.query().where('workspaceId', workspaceId)).length > 0
-        );
+        )
 
         const services = workspace.services.map(
           // @ts-expect-error Parameter 'service' implicitly has an 'any' type.
-          service => serviceIdTranslation[service],
-        );
+          (service) => serviceIdTranslation[service]
+        )
 
         // eslint-disable-next-line no-await-in-loop
         await Workspace.create({
@@ -114,22 +107,20 @@ export default class TransferController {
           order: workspace.order,
           services: JSON.stringify(services),
           data:
-            typeof workspace.data === 'string'
-              ? workspace.data
-              : JSON.stringify(workspace.data),
-        });
+            typeof workspace.data === 'string' ? workspace.data : JSON.stringify(workspace.data),
+        })
       }
     } catch (error) {
-      const errorMessage = `Could not import your workspaces into our system.\nError: ${error}`;
+      const errorMessage = `Could not import your workspaces into our system.\nError: ${error}`
       return view.render('others/message', {
         heading: 'Error while importing',
         text: errorMessage,
-      });
+      })
     }
 
     return view.render('others/message', {
       heading: 'Successfully imported',
       text: 'Your account has been imported, you can now login as usual!',
-    });
+    })
   }
 }