Implemented personal settings

backend/controllers/authController.js

@@ -21,6 +21,7 @@ export const login = async (req, res) => {
         if (error.message === 'credentialsinvalid') {
             res.status(404).json({ error: error.message })
         } else {
+            console.log(error);
             res.status(500).json({ error: error.message });
         }
     }

backend/controllers/settingsController.js

@@ -0,0 +1,113 @@
+import UserParamType from '../models/type/user_param.js';
+import SettingsType from '../models/type/settings.js';
+import UserParam from '../models/community/user_param.js';
+import User from '../models/community/user.js';
+import UserParamValue from '../models/type/user_param_value.js';
+
+export const filterSettings = async (req, res) => {
+    const { userid, type } = req.body;
+    console.log(userid, type);
+    try {
+        const fields = await UserParamType.findAll({
+            include: [
+                {
+                    model: SettingsType,
+                    as: 'settings_type',
+                    where: { name: type }
+                },
+                {
+                    model: UserParam,
+                    as: 'user_params',
+                    required: false,
+                    include: [
+                        {
+                            model: User,
+                            as: 'user',
+                            where: { hashedId: userid }
+                        }
+                    ]
+                }
+            ]
+        });
+
+        const responseFields = await Promise.all(fields.map(async (field) => {
+            const options = ['singleselect', 'multiselect'].includes(field.datatype) ? await UserParamValue.findAll({
+                where: { userParamTypeId: field.id }
+            }) : [];
+
+            return {
+                id: field.id,
+                name: field.description,
+                minAge: field.minAge,
+                gender: field.gender,
+                datatype: field.datatype,
+                value: field.user_params.length > 0 ? field.user_params[0].value : null,
+                options: options.map(opt => ({ id: opt.id, value: opt.value }))
+            };
+        }));
+
+        res.status(200).json(responseFields);
+    } catch (error) {
+        console.error('Error fetching settings:', error);
+        res.status(500).json({ error: 'Internal server error' });
+    }
+};
+
+export const updateSetting = async (req, res) => {
+    const { userid, settingId, value } = req.body;
+    try {
+        const user = await User.findOne({ where: { hashedId: userid } });
+        if (!user) {
+            return res.status(404).json({ error: 'User not found' });
+        }
+
+        const paramType = await UserParamType.findOne({ where: { id: settingId } });
+        if (!paramType) {
+            return res.status(404).json({ error: 'Parameter type not found' });
+        }
+        console.log(value);
+        await UserParam.upsertParam(user.id, paramType.id, value);
+        res.status(200).json({ message: 'Setting updated successfully' });
+    } catch (error) {
+        console.error('Error updating user setting:', error);
+        res.status(500).json({ error: 'Internal server error' });
+    }
+};
+
+export const getTypeParamValueId = async(req, res) => {
+    const { paramValue } = req.body;
+    const userParamValueObject = await UserParamValue.findOne({
+        where: { value: paramValue }
+    });
+    if (!userParamValueObject) {
+        res.status(404).json({ error: "notfound" });
+        return;
+    }
+    res.status(200).json({ paramValueId: userParamValueObject.id });
+};
+
+export const getTypeParamValues = async(req, res) => {
+    const { type } = req.body;
+    const userParamValues = await UserParamValue.findAll({
+        include: [
+            {
+                model: UserParamType,
+                as: 'user_param_type',
+                where: { description: type }
+            }
+        ]
+    });
+    res.status(200).json(userParamValues.map(type => { return { id: type.dataValues.id, name: type.dataValues.value}}));
+}
+
+export const getTypeParamValue = async(req, res) => {
+    const { id } = req.param;
+    const userParamValueObject = await UserParamValue.findOne({
+        where: { id: id }
+    });
+    if (!userParamValueObject) {
+        res.status(404).json({ error: "notfound" });
+        return;
+    }
+    res.status(200).json({ paramValueId: userParamValueObject.value });
+};