9 files changed, 527 insertions, 0 deletions

diff --git a/app/Controllers/Http/Dashboard/AccountController.ts b/app/Controllers/Http/Dashboard/AccountController.ts
new file mode 100644
index 0000000..3c4e919
--- /dev/null
+++ b/app/Controllers/Http/Dashboard/AccountController.ts
@@ -0,0 +1,80 @@
+import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
+import { schema, rules, validator } from '@ioc:Adonis/Core/Validator';
+import crypto from 'node:crypto';
+
+export default class AccountController {
+  /**
+   * Shows the user account page
+   */
+  public async show({ auth, view }: HttpContextContract) {
+    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) {
+    try {
+      await validator.validate({
+        schema: schema.create({
+          username: schema.string([
+            rules.required(),
+            rules.unique({
+              table: 'users',
+              column: 'username',
+              caseInsensitive: true,
+              whereNot: { id: auth.user?.id },
+            }),
+          ]),
+          email: schema.string([
+            rules.required(),
+            rules.unique({
+              table: 'users',
+              column: 'email',
+              caseInsensitive: true,
+              whereNot: { id: auth.user?.id },
+            }),
+          ]),
+          lastname: schema.string([rules.required()]),
+        }),
+        data: request.only(['username', 'email', 'lastname']),
+      });
+    } catch (error) {
+      session.flash(error.messages);
+      return response.redirect('/user/account');
+    }
+
+    // Update user account
+    const { user } = auth;
+    if (user) {
+      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;
+      }
+      await user.save();
+    }
+
+    return view.render('dashboard/account', {
+      username: user?.username,
+      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
new file mode 100644
index 0000000..f77702f
--- /dev/null
+++ b/app/Controllers/Http/Dashboard/DataController.ts
@@ -0,0 +1,24 @@
+import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
+
+export default class DataController {
+  /**
+   * Display the data page
+   */
+  public async show({ view, auth }: HttpContextContract) {
+    const { user } = auth;
+
+    const services = await user?.related('services').query();
+    const workspaces = await user?.related('workspaces').query();
+
+    return view.render('dashboard/data', {
+      username: user?.username,
+      lastname: user?.lastname,
+      mail: user?.email,
+      created: user?.created_at.toFormat('yyyy-MM-dd HH:mm:ss'),
+      updated: user?.updated_at.toFormat('yyyy-MM-dd HH:mm:ss'),
+      stringify: JSON.stringify,
+      services,
+      workspaces,
+    });
+  }
+}
diff --git a/app/Controllers/Http/Dashboard/DeleteController.ts b/app/Controllers/Http/Dashboard/DeleteController.ts
new file mode 100644
index 0000000..ef8188c
--- /dev/null
+++ b/app/Controllers/Http/Dashboard/DeleteController.ts
@@ -0,0 +1,20 @@
+import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
+
+export default class DeleteController {
+  /**
+   * Display the delete page
+   */
+  public async show({ view }: HttpContextContract) {
+    return view.render('dashboard/delete');
+  }
+
+  /**
+   * Delete user and session
+   */
+  public async delete({ auth, response }: HttpContextContract) {
+    auth.user?.delete();
+    auth.use('web').logout();
+
+    return response.redirect('/user/login');
+  }
+}
diff --git a/app/Controllers/Http/Dashboard/ExportController.ts b/app/Controllers/Http/Dashboard/ExportController.ts
new file mode 100644
index 0000000..7155eab
--- /dev/null
+++ b/app/Controllers/Http/Dashboard/ExportController.ts
@@ -0,0 +1,56 @@
+import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
+
+// 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>;
+    } catch {
+      // If parsing fails, return the original value
+      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
+    >;
+  } else {
+    // If obj is an object, recursively parse its keys
+    const parsedObj: Record<string, unknown> = {};
+    for (const key in obj) {
+      if (obj.hasOwnProperty(key)) {
+        parsedObj[key] = deepParseToJSON(obj[key]);
+      }
+    }
+    return parsedObj;
+  }
+}
+
+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();
+
+    const exportData = {
+      username: user.username,
+      lastname: user.lastname,
+      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);
+  }
+}
diff --git a/app/Controllers/Http/Dashboard/ForgotPasswordController.ts b/app/Controllers/Http/Dashboard/ForgotPasswordController.ts
new file mode 100644
index 0000000..da05bbd
--- /dev/null
+++ b/app/Controllers/Http/Dashboard/ForgotPasswordController.ts
@@ -0,0 +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';
+
+export default class ForgotPasswordController {
+  /**
+   * Display the forgot password form
+   */
+  public async show({ view }: HttpContextContract) {
+    return view.render('dashboard/forgotPassword');
+  }
+
+  /**
+   * Send forget password email to user
+   */
+  public async forgotPassword({ view, request }: HttpContextContract) {
+    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();
+    } 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
new file mode 100644
index 0000000..41cbd31
--- /dev/null
+++ b/app/Controllers/Http/Dashboard/LogOutController.ts
@@ -0,0 +1,12 @@
+import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
+
+export default class LogOutController {
+  /**
+   * Login a user
+   */
+  public async logout({ auth, response }: HttpContextContract) {
+    auth.logout();
+
+    return response.redirect('/user/login');
+  }
+}
diff --git a/app/Controllers/Http/Dashboard/LoginController.ts b/app/Controllers/Http/Dashboard/LoginController.ts
new file mode 100644
index 0000000..ffb9eeb
--- /dev/null
+++ b/app/Controllers/Http/Dashboard/LoginController.ts
@@ -0,0 +1,81 @@
+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';
+
+export default class LoginController {
+  /**
+   * Display the login form
+   */
+  public async show({ view }: HttpContextContract) {
+    return view.render('dashboard/login');
+  }
+
+  /**
+   * Login a user
+   */
+  public async login({
+    request,
+    response,
+    auth,
+    session,
+  }: HttpContextContract) {
+    try {
+      await validator.validate({
+        schema: schema.create({
+          mail: schema.string([rules.email(), rules.required()]),
+          password: schema.string([rules.required()]),
+        }),
+        data: request.only(['mail', 'password']),
+      });
+    } catch {
+      session.flash({
+        type: 'danger',
+        message: 'Invalid mail or password',
+      });
+      session.flashExcept(['password']);
+
+      return response.redirect('/user/login');
+    }
+
+    try {
+      const { mail, password } = request.all();
+
+      // Check if user with email exists
+      const user = await User.query().where('email', mail).first();
+      if (!user?.email) {
+        throw new Error('User credentials not valid (Invalid email)');
+      }
+
+      const hashedPassword = crypto
+        .createHash('sha256')
+        .update(password)
+        .digest('base64');
+
+      // Verify password
+      let isMatchedPassword = false;
+      try {
+        isMatchedPassword = await handleVerifyAndReHash(user, hashedPassword);
+      } catch (error) {
+        return response.internalServerError({ message: error.message });
+      }
+
+      if (!isMatchedPassword) {
+        throw new Error('User credentials not valid (Invalid password)');
+      }
+
+      await auth.use('web').login(user);
+
+      return response.redirect('/user/account');
+    } catch {
+      session.flash({
+        type: 'danger',
+        message: 'Invalid mail or password',
+      });
+      session.flashExcept(['password']);
+
+      return response.redirect('/user/login');
+    }
+  }
+}
diff --git a/app/Controllers/Http/Dashboard/ResetPasswordController.ts b/app/Controllers/Http/Dashboard/ResetPasswordController.ts
new file mode 100644
index 0000000..0b9053f
--- /dev/null
+++ b/app/Controllers/Http/Dashboard/ResetPasswordController.ts
@@ -0,0 +1,85 @@
+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';
+
+export default class ResetPasswordController {
+  /**
+   * Display the reset password form
+   */
+  public async show({ view, request }: HttpContextContract) {
+    const { token } = request.qs();
+
+    if (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) {
+    try {
+      await validator.validate({
+        schema: schema.create({
+          password: schema.string([rules.required(), rules.confirmed()]),
+          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')}`);
+    }
+
+    const tokenRow = await Token.query()
+      .preload('user')
+      .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();
+
+    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();
+
+    // Delete token to prevent it from being used again
+    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
new file mode 100644
index 0000000..a005c1b
--- /dev/null
+++ b/app/Controllers/Http/Dashboard/TransferController.ts
@@ -0,0 +1,128 @@
+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';
+
+const importSchema = schema.create({
+  username: schema.string(),
+  lastname: schema.string(),
+  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 import({
+    auth,
+    request,
+    response,
+    session,
+    view,
+  }: HttpContextContract) {
+    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');
+    }
+
+    if (!file?.services || !file.workspaces) {
+      session.flash({
+        type: 'danger',
+        message: 'Invalid Ferdium account file (2)',
+      });
+      return response.redirect('/user/transfer');
+    }
+
+    const serviceIdTranslation = {};
+
+    // Import services
+    try {
+      for (const service of file.services) {
+        // Get new, unused uuid
+        let serviceId;
+        do {
+          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({
+          userId: auth.user?.id,
+          serviceId,
+          name: service.name,
+          recipeId: service.recipe_id,
+          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] = serviceId;
+      }
+    } catch (error) {
+      // eslint-disable-next-line no-console
+      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;
+
+        do {
+          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],
+        );
+
+        // eslint-disable-next-line no-await-in-loop
+        await Workspace.create({
+          userId: auth.user?.id,
+          workspaceId,
+          name: workspace.name,
+          order: workspace.order,
+          services: JSON.stringify(services),
+          data: JSON.stringify(workspace.data),
+        });
+      }
+    } catch (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!',
+    });
+  }
+}