Merge branch 'cleanup' of ai-anchor/video-maker into master

frontend/src/App.vue

@@ -10,7 +10,7 @@
 import { RouterView } from "vue-router";
 import { useMainStore } from "@/stores/main";
 import { onMounted } from "vue";
-import LoadingView from "./views/LoadingView.vue";
+import LoadingView from "@/components/Loading.vue";
 import { storeToRefs } from "pinia";
 import NotificationsManager from "@/components/NotificationsManager.vue";
 //store

frontend/src/api.ts

@@ -1,6 +1,6 @@
 import axios from "axios";
 import { apiUrl } from "@/env";
-import type { IUserProfile, IUserProfileUpdate, IUserProfileCreate, IUserProfileRegister } from "@/interfaces";
+import type { IUserProfile, IUserProfileUpdate, IUserProfileCreate} from "@/interfaces";
 
 function authHeaders(token: string) {
   return {
@@ -40,13 +40,13 @@ export const api = {
   async passwordRecovery(email: string) {
     return axios.post(`${apiUrl}/api/v1/password-recovery/${email}`);
   },
-  async resetPassword(password: string, token: string) {
+  async resetPassword(token: string, password: string) {
     return axios.post(`${apiUrl}/api/v1/reset-password/`, {
+      token: token,
       new_password: password,
-      token,
     });
   },
-  async registerUser(data: IUserProfileRegister) {
+  async registerUser(data: IUserProfileCreate) {
     return axios.post(`${apiUrl}/api/v1/users/register`, data);
   },
   async testCeleryMsg(token: string, data:{msg: string}){

frontend/src/components/NotificationsManager.vue

@@ -12,7 +12,7 @@
 
 <script setup lang="ts">
   import { ref, computed, watch } from 'vue';
-  import type { AppNotification } from '@/stores/main';
+  import type { AppNotification } from '@/interfaces';
   import { useMainStore } from '@/stores/main';
   import { storeToRefs } from 'pinia';
 

frontend/src/interfaces/index.ts

@@ -22,7 +22,18 @@ export interface IUserProfileCreate {
     is_superuser?: boolean;
 }
 
-export interface IUserProfileRegister {
-    email: string;
-    password: string;
-}
+export interface AppNotification {
+  content: string;
+  color?: string;
+  showProgress?: boolean;
+};
+
+export interface MainState {
+  token: string;
+  isLoggedIn: boolean | null;
+  logInError: boolean;
+  userProfile: IUserProfile | null;
+  dashboardMiniDrawer: boolean;
+  dashboardShowDrawer: boolean;
+  notifications: AppNotification[];
+};

frontend/src/stores/admin.ts

@@ -9,121 +9,121 @@ interface AdminState {
 }
 
 const defaultState: AdminState = {
-    users: [],
+  users: [],
 };
   
 export const useAdminStore = defineStore("AdminStoreId", {
-    state: () => defaultState,
-    getters: {
-        readAdminUsers: (state) => state.users,
-        readAdminOneUser: (state) => {
-          return (userId:number) => state.users.filter((user) => user.id === userId)[0] || undefined;
-        },
-    },
-    actions: {
-        // setters
-        setUsers(payload: IUserProfile[]) {
-          this.users = payload;
-        },
-        setUser(payload: IUserProfile) {
-          const users = this.users.filter((user: IUserProfile) => user.id !== payload.id);
-          users.push(payload);
-          this.users = users;
-        },
-        
-        // actions
-        async actionGetUsers(){
-          const mainStore = useMainStore();
-          try {
-              const response = await api.getUsers(mainStore.token)
-              if (response) {
-                this.setUsers(response.data);
-              }
-          } catch (error) {
-              await mainStore.checkApiError(error);
-          }
-        },
-        async actionUpdateUser(payload: { id: number; user: IUserProfileUpdate }) {
-            const mainStore = useMainStore();
-            try {
-                const loadingNotification = { content: "saving", showProgress: true };
-                mainStore.addNotification(loadingNotification);
-                const response = (
-                  await Promise.all([
-                    api.updateUser(mainStore.token, payload.id, payload.user),
-                    await new Promise<void>((resolve, _) => setTimeout(() => resolve(), 500)),
-                  ])
-                )[0];
-                this.setUser(response.data);
-                mainStore.removeNotification(loadingNotification);
-                mainStore.addNotification({
-                  content: "User successfully updated",
-                  color: "success",
-                });
-            } catch (error) {
-                await mainStore.checkApiError(error);
-            }
-        },
-        async actionCreateUser(payload: IUserProfileCreate) {
-            const mainStore = useMainStore();
-            try {
-              const loadingNotification = { content: "saving", showProgress: true };
-              mainStore.addNotification(loadingNotification);
-              const response = (
-                await Promise.all([
-                  api.createUser(mainStore.token, payload),
-                  await new Promise<void>((resolve, _) => setTimeout(() => resolve(), 500)),
-                ])
-              )[0];
-              this.setUser(response.data);
-              mainStore.removeNotification(loadingNotification);
-              mainStore.addNotification({
-                content: "User successfully created",
-                color: "success",
-              });
-            } catch (error) {
-              await mainStore.checkApiError(error);
-            }
-        },
-        async actionTestCeleryMsg(payload: {msg:string}) {
-          const mainStore = useMainStore();
-          try {
-            const loadingNotification = { content: "sending", showProgress: true };
-            mainStore.addNotification(loadingNotification);
-            const response = (
-              await Promise.all([
-                api.testCeleryMsg(mainStore.token, payload),
-                await new Promise<void>((resolve, _) => setTimeout(() => resolve(), 500)),
-              ])
-            );
-            mainStore.removeNotification(loadingNotification);
-            mainStore.addNotification({
-              content: "Word received",
-                color: "success",
-            })
-          } catch (error) {
-            await mainStore.checkApiError(error);
-          }
-        },
-        async actionTestCeleryFile(payload: File) {
-          const mainStore = useMainStore();
-          try {
-            const loadingNotification = { content: "sending", showProgress: true };
-            mainStore.addNotification(loadingNotification);
-            const response = (
-              await Promise.all([
-                api.testCeleryFile(mainStore.token, payload),
-                await new Promise<void>((resolve, _) => setTimeout(() => resolve(), 500)),
-              ])
-            );
-            mainStore.removeNotification(loadingNotification);
-            mainStore.addNotification({
-              content: "File received",
-                color: "success",
-            })
-          } catch (error) {
-            await mainStore.checkApiError(error);
+  state: () => defaultState,
+  getters: {
+      readAdminUsers: (state) => state.users,
+      readAdminOneUser: (state) => {
+        return (userId:number) => state.users.filter((user) => user.id === userId)[0] || undefined;
+      },
+  },
+  actions: {
+      // setters
+      setUsers(payload: IUserProfile[]) {
+        this.users = payload;
+      },
+      setUser(payload: IUserProfile) {
+        const users = this.users.filter((user: IUserProfile) => user.id !== payload.id);
+        users.push(payload);
+        this.users = users;
+      },
+      
+      // actions
+      async actionGetUsers(){
+        const mainStore = useMainStore();
+        try {
+          const response = await api.getUsers(mainStore.token)
+          if (response) {
+            this.setUsers(response.data);
           }
+        } catch (error) {
+          await mainStore.checkApiError(error);
+        }
+      },
+      async actionUpdateUser(payload: { id: number; user: IUserProfileUpdate }) {
+        const mainStore = useMainStore();
+        try {
+          const loadingNotification = { content: "saving", showProgress: true };
+          mainStore.addNotification(loadingNotification);
+          const response = (
+            await Promise.all([
+              api.updateUser(mainStore.token, payload.id, payload.user),
+              await new Promise<void>((resolve, _) => setTimeout(() => resolve(), 500)),
+            ])
+          )[0];
+          this.setUser(response.data);
+          mainStore.removeNotification(loadingNotification);
+          mainStore.addNotification({
+            content: "User successfully updated",
+            color: "success",
+          });
+        } catch (error) {
+          await mainStore.checkApiError(error);
+        }
+      },
+      async actionCreateUser(payload: IUserProfileCreate) {
+        const mainStore = useMainStore();
+        try {
+          const loadingNotification = { content: "saving", showProgress: true };
+          mainStore.addNotification(loadingNotification);
+          const response = (
+            await Promise.all([
+              api.createUser(mainStore.token, payload),
+              await new Promise<void>((resolve, _) => setTimeout(() => resolve(), 500)),
+            ])
+          )[0];
+          this.setUser(response.data);
+          mainStore.removeNotification(loadingNotification);
+          mainStore.addNotification({
+            content: "User successfully created",
+            color: "success",
+          });
+        } catch (error) {
+          await mainStore.checkApiError(error);
+        }
+      },
+      async actionTestCeleryMsg(payload: {msg:string}) {
+        const mainStore = useMainStore();
+        try {
+          const loadingNotification = { content: "sending", showProgress: true };
+          mainStore.addNotification(loadingNotification);
+          const response = (
+            await Promise.all([
+              api.testCeleryMsg(mainStore.token, payload),
+              await new Promise<void>((resolve, _) => setTimeout(() => resolve(), 500)),
+            ])
+          );
+          mainStore.removeNotification(loadingNotification);
+          mainStore.addNotification({
+            content: "Word received",
+              color: "success",
+          })
+        } catch (error) {
+          await mainStore.checkApiError(error);
+        }
+      },
+      async actionTestCeleryFile(payload: File) {
+        const mainStore = useMainStore();
+        try {
+          const loadingNotification = { content: "sending", showProgress: true };
+          mainStore.addNotification(loadingNotification);
+          const response = (
+            await Promise.all([
+              api.testCeleryFile(mainStore.token, payload),
+              await new Promise<void>((resolve, _) => setTimeout(() => resolve(), 500)),
+            ])
+          );
+          mainStore.removeNotification(loadingNotification);
+          mainStore.addNotification({
+            content: "File received",
+              color: "success",
+          })
+        } catch (error) {
+          await mainStore.checkApiError(error);
         }
-    },
+      }
+  },
 });

frontend/src/stores/main.ts

@@ -3,244 +3,229 @@ import { defineStore } from "pinia";
 import { api } from "@/api"
 import router from "@/router"
 import { getLocalToken, removeLocalToken, saveLocalToken } from "@/utils";
-import type { IUserProfile, IUserProfileRegister, IUserProfileUpdate } from '@/interfaces';
-
-export interface AppNotification {
-  content: string;
-  color?: string;
-  showProgress?: boolean;
-};
-
-interface MainState {
-  token: string;
-  isLoggedIn: boolean | null;
-  logInError: boolean;
-  userProfile: IUserProfile | null;
-  dashboardMiniDrawer: boolean;
-  dashboardShowDrawer: boolean;
-  notifications: AppNotification[];
-};
+import type { AppNotification } from '@/interfaces';
+import type { IUserProfile, IUserProfileCreate, IUserProfileUpdate, MainState } from '@/interfaces';
 
 const defaultState: MainState = {
-    isLoggedIn: null,
-    token: '',
-    logInError: false,
-    userProfile: null,
-    dashboardMiniDrawer: false,
-    dashboardShowDrawer: true,
-    notifications: [],
+  isLoggedIn: null,
+  token: '',
+  logInError: false,
+  userProfile: null,
+  dashboardMiniDrawer: false,
+  dashboardShowDrawer: true,
+  notifications: [],
 };
 
 export const useMainStore = defineStore("MainStoreId", {
-    state: () => defaultState,
-    
-    getters: {
-        readhasAdminAccess: (state) => 
-            state.userProfile && state.userProfile.is_superuser && state.userProfile.is_active,
-        readLoginError: (state) => state.logInError,
-        readDashboardShowDrawer: (state) => state.dashboardShowDrawer,
-        readDashboardMiniDrawer: (state) => state.dashboardMiniDrawer,
-        readUserProfile: (state) => state.userProfile,
-        readToken: (state) => state.token,
-        readIsLoggedIn: (state) => state.isLoggedIn,
-        readFirstNotification: (state) => state.notifications.length > 0 && state.notifications[0], 
+  state: () => defaultState,
+  
+  getters: {
+    readhasAdminAccess: (state) => 
+        state.userProfile && state.userProfile.is_superuser && state.userProfile.is_active,
+    readLoginError: (state) => state.logInError,
+    readDashboardShowDrawer: (state) => state.dashboardShowDrawer,
+    readDashboardMiniDrawer: (state) => state.dashboardMiniDrawer,
+    readUserProfile: (state) => state.userProfile,
+    readToken: (state) => state.token,
+    readIsLoggedIn: (state) => state.isLoggedIn,
+    readFirstNotification: (state) => state.notifications.length > 0 && state.notifications[0], 
+  },
+  
+  actions:{
+    // setters
+    setToken(payload: string) { this.token = payload; },
+    setLoggedIn(payload: boolean) { this.isLoggedIn = payload; },
+    setLogInError(payload: boolean) { this.logInError = payload; },
+    setUserProfile(payload: IUserProfile) { this.userProfile = payload },
+    setDashboardMiniDrawer(payload: boolean) { this.dashboardMiniDrawer = payload; },
+    setDashboardShowDrawer(payload: boolean) { this.dashboardShowDrawer = payload; },
+    addNotification(payload: AppNotification) { this.notifications.push(payload); },
+    removeNotification(payload: AppNotification) {
+      if (payload) { 
+        this.notifications = this.notifications.filter(
+          (notification) => notification !== payload,
+        );
+      }
+    },
+    // actions
+    async logIn(username:string, password:string) {
+      try {
+        const response = await api.logInGetToken(username, password);
+        const token: string = response.data.access_token;
+        if (token) {
+          saveLocalToken(token);
+          this.setToken(token);
+          this.setLoggedIn(true);
+          this.setLogInError(false);
+          await this.getUserProfile();
+          await this.routeLoggedIn();
+          this.addNotification({content: "Logged in", color: "success" });
+        } else {
+          await this.logOut();
+        }
+      } catch (err) {
+        this.setLogInError(true);
+        await this.logOut();
+      }
     },
-    
-    actions:{
-        // setters
-        setToken(payload: string) { this.token = payload; },
-        setLoggedIn(payload: boolean) { this.isLoggedIn = payload; },
-        setLogInError(payload: boolean) { this.logInError = payload; },
-        setUserProfile(payload: IUserProfile) { this.userProfile = payload },
-        setDashboardMiniDrawer(payload: boolean) { this.dashboardMiniDrawer = payload; },
-        setDashboardShowDrawer(payload: boolean) { this.dashboardShowDrawer = payload; },
-        addNotification(payload: AppNotification) { this.notifications.push(payload); },
-        removeNotification(payload: AppNotification) {
-            if (payload) { 
-                this.notifications = this.notifications.filter(
-                    (notification) => notification !== payload,
-                );
-            }
-        },
-        // actions
-        async logIn(username:string, password:string) {
-            try {
-                const response = await api.logInGetToken(username, password);
-                const token: string = response.data.access_token;
-                if (token) {
-                    saveLocalToken(token);
-                    this.setToken(token);
-                    this.setLoggedIn(true);
-                    this.setLogInError(false);
-                    await this.getUserProfile();
-                    await this.routeLoggedIn();
-                    this.addNotification({content: "Logged in", color: "success" });
-                } else {
-                    await this.logOut();
-                }
-            } catch (err) {
-                this.setLogInError(true);
-                await this.logOut();
-            }
-        },
-        async getUserProfile() {
-            try {
-                const response = await api.getMe(this.token);
-                if (response.data) {
-                    this.setUserProfile(response.data)
-                }
-            } catch (error) {
-                await this.checkApiError(error);
-            }
-        },  
-        async updateUserProfile(payload: IUserProfileUpdate) {
-            try {
-                const loadingNotification = { content: "saving", showProgress: true };
-                await this.addNotification(loadingNotification);
-                const response = (
-                  await Promise.all([
-                    api.updateMe(this.token, payload),
-                    await new Promise<void>((resolve, _) => setTimeout(() => resolve(), 500)),
-                  ])
-                )[0];
-                this.setUserProfile(response.data);
-                this.removeNotification(loadingNotification);
-                this.addNotification({
-                  content: "Profile successfully updated",
-                  color: "success",
-                });
-            } catch (error) {
-                await this.checkApiError(error);
-            }
-        },
-        async checkLoggedIn() {
-            if (!this.isLoggedIn) {
-                let token = this.token;
-                if (!token) {
-                  const localToken = getLocalToken();
-                  if (localToken) {
-                    this.setToken(localToken);
-                    token = localToken;
-                  }
-                }
-                if (token) {
-                  try {
-                    const response = await api.getMe(token);
-                    this.setLoggedIn(true);
-                    this.setUserProfile(response.data);
-                  } catch (error) {
-                    await this.removeLogIn();
-                  }
-                } else {
-                  await this.removeLogIn();
-                }
-            }
-        },
-        async removeLogIn() {
-            removeLocalToken();
-            this.setToken("");
-            this.setLoggedIn(false);
-        },
-        async logOut() {
+    async getUserProfile() {
+      try {
+        const response = await api.getMe(this.token);
+        if (response.data) {
+          this.setUserProfile(response.data)
+        }
+      } catch (error) {
+        await this.checkApiError(error);
+      }
+    },  
+    async updateUserProfile(user: IUserProfileUpdate) {
+      try {
+        const loadingNotification = { content: "saving", showProgress: true };
+        await this.addNotification(loadingNotification);
+        const response = (
+          await Promise.all([
+            api.updateMe(this.token, user),
+            await new Promise<void>((resolve, _) => setTimeout(() => resolve(), 500)),
+          ])
+        )[0];
+        this.setUserProfile(response.data);
+        this.removeNotification(loadingNotification);
+        this.addNotification({
+          content: "Profile successfully updated",
+          color: "success",
+        });
+      } catch (error) {
+        await this.checkApiError(error);
+      }
+    },
+    async checkLoggedIn() {
+      if (!this.isLoggedIn) {
+        let token = this.token;
+        if (!token) {
+          const localToken = getLocalToken();
+          if (localToken) {
+            this.setToken(localToken);
+            token = localToken;
+          }
+        }
+        if (token) {
+          try {
+            const response = await api.getMe(token);
+            this.setLoggedIn(true);
+            this.setUserProfile(response.data);
+          } catch (error) {
             await this.removeLogIn();
-            this.routeLogOut();
-        },
-        async userLogOut() {
-            await this.logOut();
-            this.addNotification({ content: "Logged out", color: "success" });
-        },
-        routeLogOut() {
-            if (router.currentRoute.value.path !== "/login") {
-                router.push("/login");
-            }
-        },
-        async checkApiError(payload: unknown) {
-            if (axios.isAxiosError(payload)) {
-                if (payload.response?.status === 401) {
-                  await this.logOut();
-                }
-            }
-        },
-        routeLoggedIn() {
-            if (router.currentRoute.value.path === "/login" || router.currentRoute.value.path === "/") {
-                router.push("/main/dashboard");
-            }
-        },
-        async dispatchRemoveNotification(payload: {notification: AppNotification; timeout: number },) {
-            return new Promise((resolve, _) => {
-                setTimeout(() => {
-                  this.removeNotification(payload.notification);
-                  resolve(true);
-                }, payload.timeout);
-            });
-        },
-        async register(payload: IUserProfileRegister) {
-            const loadingNotification = {
-                content: "Sgining up...",
-                showProgress: true,
-            };
-            try {
-                this.addNotification(loadingNotification);
-                const response = (
-                  await Promise.all([
-                    api.registerUser(payload),
-                    await new Promise<void>((resolve, _) => setTimeout(() => resolve(), 500)),
-                  ])
-                )[0];
-                this.removeNotification(loadingNotification);
-                this.addNotification({
-                  content: "successfully registered",
-                  color: "success",
-                });
-            } catch (error) {
-              await this.checkApiError(error);
           }
-        },
-        async passwordRecovery(payload: {username: string }) {
-            const loadingNotification = {
-                content: "Sending password recovery email",
-                showProgress: true,
-            };
-            try {
-                this.addNotification(loadingNotification);
-                await Promise.all([
-                  api.passwordRecovery(payload.username),
-                  await new Promise<void>((resolve, _) => setTimeout(() => resolve(), 500)),
-                ]);
-                this.removeNotification(loadingNotification);
-                this.addNotification({
-                  content: "Password recovery email sent",
-                  color: "success",
-                });
-                await this.logOut();
-            } catch (error) {
-                this.removeNotification(loadingNotification);
-                this.addNotification({ color: "error", content: "Incorrect username" });
-            }
-        },
-        async resetPassword(payload: {password: string; token: string }) {
-            const loadingNotification = { content: "Resetting password", showProgress: true };
-            try {
-                this.addNotification(loadingNotification);
-                await Promise.all([
-                    api.resetPassword(payload.password, payload.token),
-                    await new Promise<void>((resolve, _) => setTimeout(() => resolve(), 500)),
-                ]);
-                this.removeNotification(loadingNotification);
-                this.addNotification( {
-                    content: "Password successfully reset",
-                    color: "success",
-                });
-                await this.logOut();
-            } catch (error) {
-                this.removeNotification(loadingNotification);
-                this.addNotification({
-                    color: "error",
-                    content: "Error resetting password",
-                });
-            }
-        },
-    }
-  });
+        } else {
+          await this.removeLogIn();
+        }
+      }
+    },
+    async removeLogIn() {
+      removeLocalToken();
+      this.setToken("");
+      this.setLoggedIn(false);
+    },
+    async logOut() {
+      await this.removeLogIn();
+      this.routeLogOut();
+  },
+    async userLogOut() {
+      await this.logOut();
+      this.addNotification({ content: "Logged out", color: "success" });
+    },
+    routeLogOut() {
+      if (router.currentRoute.value.path !== "/login") {
+          router.push("/login");
+      }
+    },
+    async checkApiError(payload: unknown) {
+      if (axios.isAxiosError(payload)) {
+        if (payload.response?.status === 401) {
+          await this.logOut();
+        }
+      }
+    },
+    routeLoggedIn() {
+      if (router.currentRoute.value.path === "/login" || router.currentRoute.value.path === "/") {
+        router.push("/main/dashboard");
+      }
+    },
+    async dispatchRemoveNotification(payload: {notification: AppNotification; timeout: number },) {
+      return new Promise((resolve, _) => {
+        setTimeout(() => {
+          this.removeNotification(payload.notification);
+          resolve(true);
+        }, payload.timeout);
+      });
+    },
+    async register(user: IUserProfileCreate) {
+      const loadingNotification = {
+        content: "Sgining up...",
+        showProgress: true,
+      };
+      try {
+        this.addNotification(loadingNotification);
+        const response = (
+          await Promise.all([
+            api.registerUser(user),
+            await new Promise<void>((resolve, _) => setTimeout(() => resolve(), 500)),
+          ])
+        )[0];
+        this.removeNotification(loadingNotification);
+        this.addNotification({
+          content: "successfully registered",
+          color: "success",
+        });
+      } catch (error) {
+        await this.checkApiError(error);
+      }
+    },
+    async passwordRecovery(email: string) {
+      const loadingNotification = {
+        content: "Sending password recovery email",
+        showProgress: true,
+      };
+      try {
+        this.addNotification(loadingNotification);
+        await Promise.all([
+          api.passwordRecovery(email),
+          await new Promise<void>((resolve, _) => setTimeout(() => resolve(), 500)),
+        ]);
+        this.removeNotification(loadingNotification);
+        this.addNotification({
+          content: "Password recovery email sent",
+          color: "success",
+        });
+        await this.logOut();
+      } catch (error) {
+        this.removeNotification(loadingNotification);
+        this.addNotification({ color: "error", content: "Incorrect username" });
+      }
+    },
+    async resetPassword(token: string, password: string ) {
+      const loadingNotification = { content: "Resetting password", showProgress: true };
+      try {
+        this.addNotification(loadingNotification);
+        await Promise.all([
+          api.resetPassword(token, password),
+          await new Promise<void>((resolve, _) => setTimeout(() => resolve(), 500)),
+        ]);
+        this.removeNotification(loadingNotification);
+        this.addNotification( {
+          content: "Password successfully reset",
+          color: "success",
+        });
+        await this.logOut();
+      } catch (error) {
+        this.removeNotification(loadingNotification);
+        this.addNotification({
+          color: "error",
+          content: "Error resetting password",
+        });
+      }
+    },
+  }
+});
 
 

frontend/src/views/Login.vue

@@ -103,57 +103,4 @@ onMounted(() => {});
       </v-col>
     </v-row>
   </v-container>
-
-  <!-- <v-container fluid class="d-flex fill-height">
-    <v-row align="center" justify="center">
-      <v-col :cols="width">
-        <v-card class="elevation-12">
-          <v-toolbar dark color="primary">
-            <v-toolbar-title>{{ appName }}</v-toolbar-title>
-            <v-spacer></v-spacer>
-            <v-btn to="/signup">SignUp</v-btn>
-          </v-toolbar>
-          <v-card-text>
-            <v-form @keyup.enter="submit">
-              <v-text-field
-                @keyup.enter="submit"
-                v-model="email"
-                prepend-icon="person"
-                name="email"
-                label="Email"
-                type="text"
-              ></v-text-field>
-              <v-text-field
-                @keyup.enter="submit"
-                v-model="password"
-                prepend-icon="key"
-                name="password"
-                label="Password"
-                id="password"
-                type="password"
-              ></v-text-field>
-            </v-form>
-            <div v-if="loginError">
-              <v-alert
-                :value="loginError"
-                transition="fade-transition"
-                type="error"
-              >
-                Incorrect email or password
-              </v-alert>
-            </div>
-            <div class="d-flex align-end flex-column">
-              <router-link to="/recover-password"
-                >Forgot your password?</router-link
-              >
-            </div>
-          </v-card-text>
-          <v-card-actions>
-            <v-spacer></v-spacer>
-            <v-btn @click.prevent="submit">Login</v-btn>
-          </v-card-actions>
-        </v-card>
-      </v-col>
-    </v-row>
-  </v-container> -->
 </template>

frontend/src/views/ResetPassword.vue

@@ -86,7 +86,7 @@ async function submit(){
   if (valid.value) {
     const token = checkToken();
     if (token) {
-      await mainStore.resetPassword({token, password: password1.value});
+      await mainStore.resetPassword(token, password1.value);
       router.push('/');
     }
   }

frontend/src/views/Signup.vue

@@ -40,7 +40,6 @@ const width = computed(() => {
 // action
 async function submit() {
   if (confirmPassword.value === data.password) {
-    console.log("data", data.password);
     mainStore.register(data);
   } else {
     confirmState.value = true;
@@ -186,41 +185,6 @@ async function submit() {
       </v-col>
     </v-row>
   </v-container>
-
-  <!-- <v-container fluid class="d-flex fill-height">
-    <v-row align="center" justify="center">
-      <v-col :cols="width">
-        <v-card class="elevation-12">
-          <v-toolbar dark color="primary">
-            <v-toolbar-title>{{ appName }}</v-toolbar-title>
-            <v-spacer></v-spacer>
-            <v-btn to="/login">LogIn</v-btn>
-          </v-toolbar>
-          <v-card-text>
-            <v-form @keyup.enter="submit">
-              <v-text-field
-                @keyup.enter="submit"
-                v-model="email"
-                prepend-icon="person"
-                name="email"
-                label="Email"
-                type="text"
-              ></v-text-field>
-              <v-text-field
-                @keyup.enter="submit"
-                v-model="password"
-                prepend-icon="key"
-                name="password"
-                label="Password"
-                id="password"
-                type="password"
-              ></v-text-field>
-            </v-form>
-          </v-card-text>
-        </v-card>
-      </v-col>
-    </v-row>
-  </v-container> -->
 </template>
 
 <style lang="scss">