✨ Added search view

Signed-off-by: Pau Costa <mico@micodev.es>

DevSpaceOApi.json

@@ -100,18 +100,26 @@
             "User": {
                 "type": "object",
                 "properties": {
-                    "id": {
+                  "id": {
-                        "type": "integer",
+                    "type": "integer",
-                        "description": "User ID"
+                    "description": "User ID"
-                    },
+                  },
-                    "firstName": {
+                  "firstName": {
-                        "type": "string",
+                    "type": "string",
-                        "description": "User first name"
+                    "description": "User first name"
-                    },
+                  },
-                    "lastName": {
+                  "isPrivate": {
-                        "type": "string",
+                    "type": "boolean",
-                        "description": "User last name"
+                    "description": "User private status"
-                    }
+                  },
+                  "profilePictureId": {
+                    "type": "string",
+                    "description": "User profile picture ID"
+                  },
+                  "lastName": {
+                    "type": "string",
+                    "description": "User last name"
+                  }
                 }
             },
             "UserWithRelations": {
@@ -768,29 +776,71 @@
             }
         },
         "/users/me": {
-            "get": {
+          "get": {
-                "tags": [
+            "tags": ["Users"],
-                    "Users"
+            "summary": "Get the currently logged in user",
-                ],
+            "security": [
-                "summary": "Get the currently logged in user",
+              {
-                "security": [
+                "bearerAuth": []
-                    {
+              }
-                        "bearerAuth": []
+            ],
-                    }
+            "responses": {
-                ],
+              "200": {
-                "responses": {
+                "description": "The currently logged in user",
-                    "200": {
+                "content": {
-                        "description": "The currently logged in user",
+                  "application/json": {
-                        "content": {
+                    "schema": {
-                            "application/json": {
+                      "$ref": "#/components/schemas/UserWithRelationsAndNotifications"
-                                "schema": {
-                                    "$ref": "#/components/schemas/UserWithRelationsAndNotifications"
-                                }
-                            }
-                        }
                     }
+                  }
                 }
+              }
             }
+          },
+          "patch": {
+            "security": [
+              {
+                "bearerAuth": []
+              }
+            ],
+            "tags": ["Users"],
+            "summary": "Update the currently logged in user",
+            "requestBody": {
+              "required": true,
+              "content": {
+                "application/json": {
+                  "schema": {
+                    "type": "object",
+                    "properties": {
+                      "isPrivate": {
+                        "type": "boolean",
+                        "description": "Whether the user's account is private"
+                      },
+                      "profilePictureId": {
+                        "type": "string",
+                        "description": "The ID of the user's profile picture"
+                      }
+                    }
+                  }
+                }
+              }
+            },
+            "responses": {
+              "200": {
+                "description": "Successfully updated the user",
+                "content": {
+                  "application/json": {
+                    "schema": {
+                      "$ref": "#/components/schemas/UserWithRelationsAndNotifications"
+                    }
+                  }
+                }
+              },
+              "400": {
+                "description": "Invalid request body"
+              }
+            }
+          }
         },
         "/users/{id}/follow": {
             "post": {

client/src/api/.openapi-generator/FILES

@@ -1,6 +1,5 @@
 .gitignore
 .npmignore
-.openapi-generator-ignore
 api.ts
 base.ts
 common.ts

client/src/api/api.ts

@@ -284,6 +284,18 @@ export interface User {
      * @memberof User
      */
     'firstName'?: string;
+    /**
+     * User private status
+     * @type {boolean}
+     * @memberof User
+     */
+    'isPrivate'?: boolean;
+    /**
+     * User profile picture ID
+     * @type {string}
+     * @memberof User
+     */
+    'profilePictureId'?: string;
     /**
      * User last name
      * @type {string}
@@ -309,6 +321,18 @@ export interface UserWithRelations {
      * @memberof UserWithRelations
      */
     'firstName'?: string;
+    /**
+     * User private status
+     * @type {boolean}
+     * @memberof UserWithRelations
+     */
+    'isPrivate'?: boolean;
+    /**
+     * User profile picture ID
+     * @type {string}
+     * @memberof UserWithRelations
+     */
+    'profilePictureId'?: string;
     /**
      * User last name
      * @type {string}
@@ -358,6 +382,18 @@ export interface UserWithRelationsAndNotifications {
      * @memberof UserWithRelationsAndNotifications
      */
     'firstName'?: string;
+    /**
+     * User private status
+     * @type {boolean}
+     * @memberof UserWithRelationsAndNotifications
+     */
+    'isPrivate'?: boolean;
+    /**
+     * User profile picture ID
+     * @type {string}
+     * @memberof UserWithRelationsAndNotifications
+     */
+    'profilePictureId'?: string;
     /**
      * User last name
      * @type {string}
@@ -395,6 +431,25 @@ export interface UserWithRelationsAndNotifications {
      */
     'notifications'?: Array<Notification>;
 }
+/**
+ * 
+ * @export
+ * @interface UsersMePatchRequest
+ */
+export interface UsersMePatchRequest {
+    /**
+     * Whether the user\'s account is private
+     * @type {boolean}
+     * @memberof UsersMePatchRequest
+     */
+    'isPrivate'?: boolean;
+    /**
+     * The ID of the user\'s profile picture
+     * @type {string}
+     * @memberof UsersMePatchRequest
+     */
+    'profilePictureId'?: string;
+}
 
 /**
  * AuthenticationApi - axios parameter creator
@@ -1528,6 +1583,46 @@ export const UsersApiAxiosParamCreator = function (configuration?: Configuration
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
 
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * 
+         * @summary Update the currently logged in user
+         * @param {UsersMePatchRequest} usersMePatchRequest 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        usersMePatch: async (usersMePatchRequest: UsersMePatchRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'usersMePatchRequest' is not null or undefined
+            assertParamExists('usersMePatch', 'usersMePatchRequest', usersMePatchRequest)
+            const localVarPath = `/users/me`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'PATCH', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // authentication bearerAuth required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration)
+
+
+    
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+            localVarRequestOptions.data = serializeDataIfNeeded(usersMePatchRequest, localVarRequestOptions, configuration)
+
             return {
                 url: toPathString(localVarUrlObj),
                 options: localVarRequestOptions,
@@ -1606,6 +1701,19 @@ export const UsersApiFp = function(configuration?: Configuration) {
             const localVarOperationServerBasePath = operationServerMap['UsersApi.usersMeGet']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
+        /**
+         * 
+         * @summary Update the currently logged in user
+         * @param {UsersMePatchRequest} usersMePatchRequest 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async usersMePatch(usersMePatchRequest: UsersMePatchRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<UserWithRelationsAndNotifications>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.usersMePatch(usersMePatchRequest, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['UsersApi.usersMePatch']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
     }
 };
 
@@ -1664,6 +1772,16 @@ export const UsersApiFactory = function (configuration?: Configuration, basePath
         usersMeGet(options?: any): AxiosPromise<UserWithRelationsAndNotifications> {
             return localVarFp.usersMeGet(options).then((request) => request(axios, basePath));
         },
+        /**
+         * 
+         * @summary Update the currently logged in user
+         * @param {UsersMePatchRequest} usersMePatchRequest 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        usersMePatch(usersMePatchRequest: UsersMePatchRequest, options?: any): AxiosPromise<UserWithRelationsAndNotifications> {
+            return localVarFp.usersMePatch(usersMePatchRequest, options).then((request) => request(axios, basePath));
+        },
     };
 };
 
@@ -1731,6 +1849,18 @@ export class UsersApi extends BaseAPI {
     public usersMeGet(options?: RawAxiosRequestConfig) {
         return UsersApiFp(this.configuration).usersMeGet(options).then((request) => request(this.axios, this.basePath));
     }
+
+    /**
+     * 
+     * @summary Update the currently logged in user
+     * @param {UsersMePatchRequest} usersMePatchRequest 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof UsersApi
+     */
+    public usersMePatch(usersMePatchRequest: UsersMePatchRequest, options?: RawAxiosRequestConfig) {
+        return UsersApiFp(this.configuration).usersMePatch(usersMePatchRequest, options).then((request) => request(this.axios, this.basePath));
+    }
 }
 
 

client/src/app/store.ts

@@ -2,11 +2,13 @@ import { Action, ThunkAction, configureStore } from "@reduxjs/toolkit";
 import { useDispatch } from "react-redux";
 import loginReducer from "./loginSlice";
 import postReducer from "./postSlice";
+import usersReducer from "./usersSlice";
 
 export const store = configureStore({
   reducer: {
     login: loginReducer,
     post: postReducer,
+    users: usersReducer,
   },
 });
 

client/src/app/usersSlice.ts

@@ -0,0 +1,116 @@
+import { Store, createSlice } from "@reduxjs/toolkit";
+import { Configuration, User, UserWithRelations, UsersApi } from "../api";
+import { Status } from "../util/types";
+import { AppThunk, store } from "./store";
+
+interface userState {
+  status: Status;
+  error: string | null;
+  users: User[];
+  userWithRelations: UserWithRelations | null;
+}
+
+const initialState: userState = {
+  status: Status.idle,
+  error: null,
+  users: [],
+  userWithRelations: null,
+};
+
+export const usersSlice = createSlice({
+  name: "users",
+  initialState,
+  reducers: {
+    setUsers: (state, action) => {
+      state.users = action.payload;
+    },
+    setStatus: (state, action) => {
+      state.status = action.payload;
+    },
+    setError: (state, action) => {
+      state.error = action.payload;
+    },
+    setUserWithRelations: (state, action) => {
+      state.userWithRelations = action.payload;
+    },
+  },
+});
+
+export const getUsers = (): AppThunk => async (dispatch) => {
+  const api = createApi(store);
+
+  dispatch(setStatus(Status.loading));
+  try {
+    const response = await api.usersGet();
+    dispatch(setUsers(response.data));
+    dispatch(setStatus(Status.idle));
+  } catch (error) {
+    dispatch(setError((error as Error).message));
+    dispatch(setStatus(Status.idle));
+  }
+};
+
+export const getUserWithRelations =
+  (userId: number): AppThunk =>
+  async (dispatch) => {
+    const api = createApi(store);
+
+    dispatch(setStatus(Status.loading));
+    try {
+      const response = await api.usersIdGet(userId);
+      dispatch(setUserWithRelations(response));
+      dispatch(setStatus(Status.idle));
+    } catch (error) {
+      dispatch(setError((error as Error).message));
+      dispatch(setStatus(Status.idle));
+    }
+  };
+
+export const followUser =
+  (userId: number): AppThunk =>
+  async (dispatch) => {
+    const api = createApi(store);
+
+    dispatch(setStatus(Status.loading));
+    try {
+      await api.usersIdFollowPost(userId);
+      dispatch(getUsers());
+    } catch (error) {
+      dispatch(setError((error as Error).message));
+      dispatch(setStatus(Status.idle));
+    }
+  };
+
+export const unFollowUser =
+  (userId: number): AppThunk =>
+  async (dispatch) => {
+    const api = createApi(store);
+
+    dispatch(setStatus(Status.loading));
+    try {
+      await api.usersIdFollowDelete(userId);
+      dispatch(getUsers());
+    } catch (error) {
+      dispatch(setError((error as Error).message));
+      dispatch(setStatus(Status.idle));
+    }
+  };
+
+export const { setUsers, setStatus, setError, setUserWithRelations } =
+  usersSlice.actions;
+
+export default usersSlice.reducer;
+
+export const selectUsers = (state: { users: userState }) => state.users.users;
+export const selectAUser = (state: { users: userState }) =>
+  state.users.userWithRelations;
+export const selectStatus = (state: { users: userState }) => state.users.status;
+export const selectError = (state: { users: userState }) => state.users.error;
+
+function createApi(store: Store) {
+  const configuration = new Configuration({
+    basePath: process.env.REACT_APP_BACKEND_URL,
+    accessToken: store.getState().login.userInfo.jwt,
+  });
+  return new UsersApi(configuration);
+}

client/src/components/appAvatar.tsx

@@ -0,0 +1,15 @@
+import { Avatar } from "@mui/material";
+import { User, UserWithRelations } from "../api";
+
+interface AppAvatarProps {
+  user: User | UserWithRelations;
+}
+
+export function AppAvatar(props: AppAvatarProps) {
+  return (
+    <Avatar
+      alt={`${props.user.firstName} ${props.user.lastName}`}
+      src={`/images/${props.user.profilePictureId}`}
+    />
+  );
+}

client/src/components/topAppBar.tsx

@@ -5,13 +5,13 @@ import Toolbar from "@mui/material/Toolbar";
 import IconButton from "@mui/material/IconButton";
 import Typography from "@mui/material/Typography";
 import Menu from "@mui/material/Menu";
-import Avatar from "@mui/material/Avatar";
 import Tooltip from "@mui/material/Tooltip";
 import MenuItem from "@mui/material/MenuItem";
 import NotificationBell from "./notificationBell";
 import {useSelector} from "react-redux";
 import { postLogout, selectUserInfo } from "../app/loginSlice";
 import { useAppDispatch } from "../app/store";
+import { AppAvatar } from "./appAvatar";
 
 interface TopAppBarProps {
   height: number;
@@ -39,73 +39,73 @@ function TopAppBar(props: TopAppBarProps) {
   };
 
   return (
-    <AppBar position="absolute" sx={{zIndex:1600, height: `${props.height}px` }}>
+    <AppBar
-        <Toolbar disableGutters>
+      position="absolute"
-          <Typography
+      sx={{ zIndex: 1600, height: `${props.height}px` }}
-            variant="h6"
+    >
-            noWrap
+      <Toolbar disableGutters>
-            component="a"
+        <Typography
-            sx={{
+          variant="h6"
-              marginLeft: "1rem",
+          noWrap
-              mr: 2,
+          component="a"
-              display: "flex",
+          sx={{
-              fontFamily: "monospace",
+            marginLeft: "1rem",
-              fontWeight: 700,
+            mr: 2,
-              letterSpacing: ".3rem",
+            display: "flex",
-              color: "inherit",
+            fontFamily: "monospace",
-              textDecoration: "none",
+            fontWeight: 700,
-            }}
+            letterSpacing: ".3rem",
-          >
+            color: "inherit",
-            DevSpace
+            textDecoration: "none",
-          </Typography>
+          }}
-          <Box
+        >
-            sx={{
+          DevSpace
-              flexGrow: 1,
+        </Typography>
-              display: "flex",
+        <Box
-              justifyContent: "right",
+          sx={{
-              padding: "1rem",
+            flexGrow: 1,
-            }}
+            display: "flex",
-          >
+            justifyContent: "right",
-            <NotificationBell />
+            padding: "1rem",
-          </Box>
+          }}
+        >
+          <NotificationBell />
+        </Box>
 
-          <Box sx={{ flexGrow: 0, mr:"2rem" }}>
+        <Box sx={{ flexGrow: 0, mr: "2rem" }}>
-            <Tooltip title="Open settings" >
+          <Tooltip title="Open settings">
-              <IconButton onClick={handleOpenUserMenu} sx={{ p: 0 }}>
+            <IconButton onClick={handleOpenUserMenu} sx={{ p: 0 }}>
-                <Avatar
+              <AppAvatar user={userInfo} />
-                  alt={`${userInfo.firstName} ${userInfo.lastName}`}
+            </IconButton>
-                  src="/static/images/avatar/2.jpg"
+          </Tooltip>
-                />
+          <Menu
-              </IconButton>
+            sx={{ mt: "45px" }}
-            </Tooltip>
+            id="menu-appbar"
-            <Menu
+            anchorEl={anchorElUser}
-              sx={{ mt: "45px" }}
+            anchorOrigin={{
-              id="menu-appbar"
+              vertical: "top",
-              anchorEl={anchorElUser}
+              horizontal: "right",
-              anchorOrigin={{
+            }}
-                vertical: "top",
+            keepMounted
-                horizontal: "right",
+            transformOrigin={{
-              }}
+              vertical: "top",
-              keepMounted
+              horizontal: "right",
-              transformOrigin={{
+            }}
-                vertical: "top",
+            open={Boolean(anchorElUser)}
-                horizontal: "right",
+            onClose={handleCloseUserMenu}
-              }}
+          >
-              open={Boolean(anchorElUser)}
+            <MenuItem key={"profile"} onClick={handleCloseUserMenu}>
-              onClose={handleCloseUserMenu}
+              <Typography textAlign="center">{"Profile"}</Typography>
-            >
+            </MenuItem>
-              <MenuItem key={"profile"} onClick={handleCloseUserMenu}>
+            <MenuItem key={"settings"} onClick={handleCloseUserMenu}>
-                <Typography textAlign="center">{"Profile"}</Typography>
+              <Typography textAlign="center">{"Settings"}</Typography>
-              </MenuItem>
+            </MenuItem>
-              <MenuItem key={"settings"} onClick={handleCloseUserMenu}>
+            <MenuItem key={"logout"} onClick={handleLogout}>
-                <Typography textAlign="center">{"Settings"}</Typography>
+              <Typography textAlign="center">{"Logout"}</Typography>
-              </MenuItem>
+            </MenuItem>
-              <MenuItem key={"logout"} onClick={handleLogout}>
+          </Menu>
-                <Typography textAlign="center">{"Logout"}</Typography>
+        </Box>
-              </MenuItem>
+      </Toolbar>
-            </Menu>
-          </Box>
-        </Toolbar>
     </AppBar>
   );
 }

client/src/routes/search.tsx

@@ -1,3 +1,79 @@
+import { useSelector } from "react-redux";
+import { getUsers, selectUsers } from "../app/usersSlice";
+import React, { MouseEventHandler, useEffect } from "react";
+import { useAppDispatch } from "../app/store";
+import {
+  Box,
+  Button,
+  Divider,
+  List,
+  ListItem,
+  ListItemText,
+  Paper,
+  TextField,
+} from "@mui/material";
+import { AppAvatar } from "../components/appAvatar";
+import { useNavigate } from "react-router-dom";
+import { matchSorter } from "match-sorter";
+
 export default function Search() {
-  return <>Search</>;
+  const userList = useSelector(selectUsers);
+  const [displayUserList, setDisplayUserList] = React.useState(userList);
+  const dispatch = useAppDispatch();
+  const navigate = useNavigate();
+
+  useEffect(() => {
+    dispatch(getUsers());
+  }, []);
+
+  const handleSearchChange = (event: React.ChangeEvent<HTMLInputElement>) => {
+    const searchValue = event.currentTarget.value;
+    if (searchValue === "") {
+      setDisplayUserList(userList);
+      return;
+    }
+    setDisplayUserList(
+      matchSorter(userList, searchValue, { keys: ["firstName", "lastName"] })
+    );
+  };
+
+  const handleClick: MouseEventHandler = (event) => {
+    const userId = event.currentTarget.id;
+    navigate(`/user/${userId}`);
+  };
+
+  return (
+    <Box sx={{ display: "flex", flexDirection: "column" }}>
+      <Paper sx={{ mb: "2rem" }}>
+        <TextField
+          sx={{ width: "100%" }}
+          label="Search for a user..."
+          onChange={handleSearchChange}
+        />
+      </Paper>
+      <Paper>
+        <List>
+          {displayUserList.map((user) => (
+            <>
+              <ListItem key={user.id}>
+                <Button
+                  fullWidth
+                  sx={{ textAlign: "start" }}
+                  id={user.id?.toString()}
+                  onClick={handleClick}
+                >
+                  <AppAvatar user={user} />
+                  <ListItemText
+                    sx={{ ml: "2rem" }}
+                    primary={`${user.firstName} ${user.lastName}`}
+                  />
+                </Button>
+              </ListItem>
+              <Divider sx={{ mb: "0.3rem" }} />
+            </>
+          ))}
+        </List>
+      </Paper>
+    </Box>
+  );
 }

server/src/controller/UserController.ts

@@ -38,7 +38,10 @@ export class UserController {
         user.deleteSensitiveFields();
       });
 
-      res.status(200).send(users);
+      // remove the users set to private
+      const publicUsers = users.filter((user) => user.isPrivate === false);
+
+      res.status(200).send(publicUsers);
     }
   );
 
@@ -67,7 +70,7 @@ export class UserController {
    *              $ref: '#/components/schemas/UserWithRelations'
    */
   public getUser = catchAsync(
-    async (req: Request, res: Response, next: NextFunction) => {
+    async (req: AppRequest, res: Response, next: NextFunction) => {
       const id = req.params.id;
       const parsedId = parseInt(id);
       // Check if ID is a number
@@ -92,6 +95,18 @@ export class UserController {
       );
       user.followers.forEach((follower) => follower.deleteSensitiveFields());
 
+      // If the user is private, only return the user
+      // if the requesting user is following
+      const followStatus = user.followers.some(
+        (follower) => follower.id === req.user.id
+      );
+      if (user.isPrivate && !followStatus) {
+        user.followed = [];
+        user.followers = [];
+        user.posts = [];
+        user.comments = [];
+      }
+
       return res.send(user);
     }
   );
@@ -135,6 +150,60 @@ export class UserController {
     }
   );
 
+  /**
+   * @swagger
+   * /users/me:
+   *  patch:
+   *    security:
+   *      - bearerAuth: []
+   *    tags:
+   *      - Users
+   *    summary: Update the currently logged in user
+   *    requestBody:
+   *      required: true
+   *      content:
+   *        application/json:
+   *          schema:
+   *            type: object
+   *            properties:
+   *              isPrivate:
+   *                type: boolean
+   *                description: Whether the user's account is private
+   *              profilePictureId:
+   *                type: string
+   *                description: The ID of the user's profile picture
+   *    responses:
+   *      200:
+   *        description: Successfully updated the user
+   *        content:
+   *          application/json:
+   *            schema:
+   *              $ref: '#/components/schemas/UserWithRelationsAndNotifications'
+   *      400:
+   *        description: Invalid request body
+   */
+  public updateMe = catchAsync(
+    async (req: AppRequest, res: Response, next: NextFunction) => {
+      const user = await this.userRepository.findOne({
+        where: { id: req.user.id },
+        relations: {
+          followed: true,
+          followers: true,
+          posts: true,
+          comments: true,
+          notifications: true,
+        },
+      });
+
+      user.isPrivate = req.body.isPrivate || user.isPrivate;
+      user.profilePictureId =
+        req.body.profilePictureId || user.profilePictureId;
+      await this.userRepository.save(user);
+
+      return res.status(200).send(user);
+    }
+  );
+
   /**
    * @swagger
    * /users/{id}/follow:

server/src/entity/User.ts

@@ -6,53 +6,57 @@ import {Notification} from "./Notification";
 
 @Entity()
 export class User {
+  @PrimaryGeneratedColumn()
+  id: number;
 
-    @PrimaryGeneratedColumn()
+  @Column()
-    id: number
+  firstName: string;
 
-    @Column()
+  @Column()
-    firstName: string
+  lastName: string;
 
-    @Column()
+  @Column()
-    lastName: string
+  email: string;
 
-    @Column()
+  @Column()
-    email: string
+  password: string;
 
-    @Column()
+  @Column({ default: false })
-    password: string
+  isPrivate: boolean;
 
-    @ManyToMany(type => User)
+  @Column({ default: null })
-    @JoinTable()
+  profilePictureId: string;
-    followed: User[]
 
-    @ManyToMany(type => User)
+  @ManyToMany((type) => User)
-    @JoinTable()
+  @JoinTable()
-    followers: User[]
+  followed: User[];
 
-    @OneToMany(type => Post, post=> post.createdBy)
+  @ManyToMany((type) => User)
-    posts: Post[]
+  @JoinTable()
+  followers: User[];
 
-    @OneToMany(type => Comment, comment=> comment.createdBy)
+  @OneToMany((type) => Post, (post) => post.createdBy)
-    comments: Comment[]
+  posts: Post[];
 
-    @OneToMany(type => Notification, notification => notification.belongsTo)
+  @OneToMany((type) => Comment, (comment) => comment.createdBy)
-    notifications: Notification[]
+  comments: Comment[];
 
+  @OneToMany((type) => Notification, (notification) => notification.belongsTo)
+  notifications: Notification[];
 
-    static async hashPassword(password: string){
+  static async hashPassword(password: string) {
-        return await bcrypt.hash(password, parseInt(process.env.SALT_ROUNDS))
+    return await bcrypt.hash(password, parseInt(process.env.SALT_ROUNDS));
-    }
+  }
 
-    async comparePassword(password: string){
+  async comparePassword(password: string) {
-        return await bcrypt.compare(password, this.password)
+    return await bcrypt.compare(password, this.password);
-    }
+  }
 
-    public deleteSensitiveFields(){
+  public deleteSensitiveFields() {
-        delete this.password
+    delete this.password;
-        delete this.email
+    delete this.email;
-        delete this.notifications
+    delete this.notifications;
-        delete this.followed
+    delete this.followed;
-        delete this.followers
+    delete this.followers;
-    }
+  }
 }

server/src/routes/swaggerRoutes.ts

@@ -115,6 +115,14 @@ const swaggerOptions = {
               type: "string",
               description: "User first name",
             },
+            isPrivate: {
+              type: "boolean",
+              description: "User private status",
+            },
+            profilePictureId: {
+              type: "string",
+              description: "User profile picture ID",
+            },
             lastName: {
               type: "string",
               description: "User last name",

server/src/routes/userRoutes.ts

@@ -6,7 +6,9 @@ export const UserRoutes = Router();
 const userController = new UserController()
 
 UserRoutes.route("/").get(userController.getAllUsers)
-UserRoutes.route("/me").get(userController.getMe)
+UserRoutes.route("/me")
+  .get(userController.getMe)
+  .patch(userController.updateMe);
 UserRoutes.route("/:id").get(userController.getUser)
 UserRoutes.route("/follow/:id")
     .post(userController.followUser)