-
+
+
+
);
}
\ No newline at end of file
diff --git a/clients/plan-it-web/src/components/Task/TaskCard.tsx b/clients/plan-it-web/src/components/Task/TaskCard.tsx
index 23fdd86..eb2e865 100644
--- a/clients/plan-it-web/src/components/Task/TaskCard.tsx
+++ b/clients/plan-it-web/src/components/Task/TaskCard.tsx
@@ -1,23 +1,79 @@
-import { Card, Avatar, Text, Progress, Badge, Group, ActionIcon, useMantineTheme, Stack } from '@mantine/core';
-import { IconUpload } from '@tabler/icons-react';
+import { Card, Avatar, Text, Progress, Badge, Group, ActionIcon, useMantineTheme, Stack, Title, Modal, Flex } from '@mantine/core';
import classes from './TaskCard.module.css';
+import { IconSettings, IconX } from '@tabler/icons-react';
+import { useDeleteProjectTaskMutation } from '../../services/planit-api';
+import { notifications } from '@mantine/notifications';
+import { useDisclosure } from '@mantine/hooks';
+import { ExtendedModal } from '../Common/ExtendedModal';
+import { TaskSettings } from './TaskSettings';
interface TaskCardProps
{
- id: number;
+ projectId: string;
+ taskId: string;
name: string;
description: string;
+ onDelete: () => void;
};
-export function TaskCard( {id, name, description} : TaskCardProps) {
+export function TaskCard( {
+ projectId,
+ taskId,
+ name,
+ description,
+ onUpdate,
+ onDelete
+} : TaskCardProps) {
+ const [deleteProjectTask] = useDeleteProjectTaskMutation();
+ const [modalOpened, { open, close }] = useDisclosure(false);
+
const theme = useMantineTheme();
+ const handleDelete = async () => {
+ console.log('Deleting project task:', taskId);
+ const result = await deleteProjectTask({projectId, taskId});
+
+ if (result.error)
+ {
+ console.error('Error deleting project task:', result.error);
+ notifications.show({
+ title: 'Error deleting project task',
+ message: 'Could not delete project task, please try again!',
+ color: 'red'
+ });
+ return;
+ }
+
+ // Callback from top component
+ onDelete();
+ notifications.show({
+ title: 'Project task deleted',
+ message: 'Project task was successfully deleted',
+ color: 'green'
+ });
+
+ }
+
return (
+ <>
+
+
+
-
-
- {name}
-
+
+
+
+ {name}
+
+
+
+
+
+
+
+
+
+
{description}
@@ -29,5 +85,6 @@ export function TaskCard( {id, name, description} : TaskCardProps) {
+
);
}
\ No newline at end of file
diff --git a/clients/plan-it-web/src/components/Task/TaskSettings.module.css b/clients/plan-it-web/src/components/Task/TaskSettings.module.css
new file mode 100644
index 0000000..cc1237d
--- /dev/null
+++ b/clients/plan-it-web/src/components/Task/TaskSettings.module.css
@@ -0,0 +1,3 @@
+.container {
+
+}
\ No newline at end of file
diff --git a/clients/plan-it-web/src/components/Task/TaskSettings.tsx b/clients/plan-it-web/src/components/Task/TaskSettings.tsx
new file mode 100644
index 0000000..f76f3aa
--- /dev/null
+++ b/clients/plan-it-web/src/components/Task/TaskSettings.tsx
@@ -0,0 +1,81 @@
+import { Button, Flex, Group, Loader, Stack, TextInput, Title } from "@mantine/core";
+import classes from "./TaskSettings.module.css"
+import { useEffect, useState } from "react";
+import { notifications } from '@mantine/notifications';
+import { useGetProjectQuery, useGetProjectTasksQuery, useUpdateProjectTaskMutation, } from "../../services/planit-api";
+import { Task } from "../../types/Task";
+
+interface TaskSettingsProps {
+ onUpdate: (projectId: string, taskId: string, updatedTask: Task) => void;
+ projectId: string;
+ taskId: string;
+}
+
+export function TaskSettings({
+ onUpdate,
+ projectId,
+ taskId} : TaskSettingsProps)
+{
+ // Get details about the Task and Task Tasks
+ const { data: project, error : taskError , isLoading : projectLoading } = useGetProjectQuery(projectId);
+
+ // Local state for the Task settings
+ const [ taskName, setTaskName ] = useState("");
+ const [ taskDescription, setTaskDescription ] =useState("");
+ const [ updateProjectTask, { isLoading : TaskUpdating } ] = useUpdateProjectTaskMutation();
+
+ let task;
+
+ if (!projectLoading)
+ {
+ if (project)
+ {
+ task = project.projectTasks.find(t => t.id === taskId);
+ }
+ }
+
+
+ const handleSaveTask = async () => {
+ // Save the Task settings
+ const updatedTask = {
+ name: taskName,
+ description: taskDescription
+ };
+
+ const result = await updateProjectTask({projectId, taskId, updatedTask});
+
+ if (result.error)
+ {
+ console.error('Error updating Task:', result.error);
+ notifications.show({
+ title: 'Erorr updating Task',
+ message: `${result.error.data.title}`,
+ color: 'red'
+ })
+ return;
+ }
+
+ onUpdate(projectId, taskId, result.data);
+
+ notifications.show({
+ title: 'Success',
+ message: 'Task settings saved successfuly',
+ color: 'green'
+ });
+ }
+
+ return (
+
+ { projectLoading && }
+
+
+ setTaskName(e.currentTarget.value) } />
+ setTaskDescription(e.currentTarget.value) }/>
+
+
+
+
+
+
+ )
+}
\ No newline at end of file
diff --git a/clients/plan-it-web/src/components/UserButton/UserButton.tsx b/clients/plan-it-web/src/components/UserButton/UserButton.tsx
index f3f89e0..bd31885 100644
--- a/clients/plan-it-web/src/components/UserButton/UserButton.tsx
+++ b/clients/plan-it-web/src/components/UserButton/UserButton.tsx
@@ -2,9 +2,13 @@ import { UnstyledButton, Group, Avatar, Text } from '@mantine/core';
import { IconChevronRight } from '@tabler/icons-react';
import classes from './UserButton.module.css';
-export function UserButton() {
+interface UserButton {
+ onClick: () => void;
+}
+
+export function UserButton({onClick} : UserButton) {
return (
-
+
{
+
+ return (
+
+
+
+ {row.name}
+
+
+ {row.description}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ );
+ });
+
+ return (
+
+
+
+
+ Title
+ Description
+ Assigned users
+ Reviews distribution
+ Delete
+
+
+ {rows}
+
+
+ );
+}
\ No newline at end of file
diff --git a/clients/plan-it-web/src/components/WorkspaceSettings/WorkspaceSettings.module.css b/clients/plan-it-web/src/components/WorkspaceSettings/WorkspaceSettings.module.css
new file mode 100644
index 0000000..ee7d415
--- /dev/null
+++ b/clients/plan-it-web/src/components/WorkspaceSettings/WorkspaceSettings.module.css
@@ -0,0 +1,7 @@
+.container {
+ width: 100%;
+ flex-direction: row;
+ flex-wrap: wrap;
+ margin-left: 15px;
+ margin-top: 15px;
+}
\ No newline at end of file
diff --git a/clients/plan-it-web/src/components/WorkspaceSettings/WorkspaceSettings.tsx b/clients/plan-it-web/src/components/WorkspaceSettings/WorkspaceSettings.tsx
new file mode 100644
index 0000000..00f927d
--- /dev/null
+++ b/clients/plan-it-web/src/components/WorkspaceSettings/WorkspaceSettings.tsx
@@ -0,0 +1,84 @@
+import { Button, Flex, Paper, Stack, Text, TextInput, Title } from "@mantine/core";
+import classes from "./WorkspaceSettings.module.css"
+import { useNavigate, useParams } from "react-router-dom";
+import { useGetProjectsForWorkspaceQuery, useGetWorkspaceQuery, useUpdateWorkspaceMutation } from "../../services/planit-api";
+import { WorkspaceProjectsTable } from "./WorkspaceProjectsTable";
+import { useState } from "react";
+import { updateWorkspaceLocal } from "../../redux/workspacesSlice";
+import { useAppDispatch } from "../../hooks/reduxHooks";
+import { notifications } from '@mantine/notifications';
+
+export function WorkspaceSettings()
+{
+ const dispatch = useAppDispatch();
+ const navigate = useNavigate();
+ // Get the workspace ID from the URL
+ const { workspaceId } = useParams<{ workspaceId: string }>();
+
+ if (!workspaceId)
+ {
+ console.error('No workspace ID found');
+
+ notifications.show({
+ title: 'Erorr accessing workspace',
+ message: 'Workspace was not found, please try again!',
+ color: 'red'
+ })
+
+ navigate('/');
+
+ return;
+ }
+
+ // Get details about the workspace and workspace projects
+ const { data: workspace, error : workspaceError , isLoading : workspaceLoading } = useGetWorkspaceQuery(workspaceId);
+ const { data : projects, error : projectsError , isLoading : projectsLoading, refetch } = useGetProjectsForWorkspaceQuery(workspaceId);
+
+ // Local state for the workspace settings
+ const [ workspaceName, setWorkspaceName ] = useState(workspace?.name);
+ const [ workspaceDescription, setWorkspaceDescription ] =useState(workspace?.description);
+
+ const [ updateWorkspace, { isLoading : workspaceUpdating } ] = useUpdateWorkspaceMutation();
+
+
+ const handleSaveWorkspace = async () => {
+ // Save the workspace settings
+ const updatedWorkspace = {
+ name: workspaceName,
+ description: workspaceDescription
+ };
+
+ const result = await updateWorkspace({updatedWorkspace, workspaceId: workspaceId});
+
+ if (result.error)
+ {
+ console.error('Error updating workspace:', result.error);
+ notifications.show({
+ title: 'Erorr updating workspace',
+ message: 'Could not update workspace, please try again!',
+ color: 'red'
+ })
+ return;
+ }
+
+ dispatch(updateWorkspaceLocal(result.data));
+ }
+
+ return (
+
+ {(workspaceLoading || projectsLoading) && Loading...}
+
+
+
+ Workspace Settings
+ setWorkspaceName(e.currentTarget.value) } />
+ setWorkspaceDescription(e.currentTarget.value) }/>
+
+ Projects
+
+
+
+
+
+ )
+}
\ No newline at end of file
diff --git a/clients/plan-it-web/src/hooks/reduxHooks.ts b/clients/plan-it-web/src/hooks/reduxHooks.ts
new file mode 100644
index 0000000..3d2b22f
--- /dev/null
+++ b/clients/plan-it-web/src/hooks/reduxHooks.ts
@@ -0,0 +1,6 @@
+import { useDispatch, useSelector } from 'react-redux'
+import type { RootState, AppDispatch } from '../redux/store'
+
+// Use throughout your app instead of plain `useDispatch` and `useSelector`
+export const useAppDispatch = useDispatch.withTypes()
+export const useAppSelector = useSelector.withTypes()
\ No newline at end of file
diff --git a/clients/plan-it-web/src/hooks/useJwtAuth.ts b/clients/plan-it-web/src/hooks/useJwtAuth.ts
new file mode 100644
index 0000000..15520dc
--- /dev/null
+++ b/clients/plan-it-web/src/hooks/useJwtAuth.ts
@@ -0,0 +1,40 @@
+import { useEffect } from 'react';
+import { useAppDispatch, useAppSelector } from '../hooks/reduxHooks';
+import { setCredentials, logOut } from '../redux/authSlice';
+import { JwtInformation } from '../types/Auth';
+import { jwtDecode } from 'jwt-decode';
+
+// Hook that checks if the user is authenticated based on JWT token received from the server
+export const useJwtAuth = () => {
+ const dispatch = useAppDispatch();
+ const isAuthenticated = useAppSelector(state => state.auth.isAuthenticated);
+
+ useEffect(() => {
+ const token = localStorage.getItem('token');
+
+ if (token) {
+ try {
+ const decodedToken: JwtInformation = jwtDecode(token);
+
+ const userFromToken = {
+ id: decodedToken.jti,
+ firstName: decodedToken.given_name,
+ lastName: decodedToken.family_name,
+ };
+
+ // Sprawdzenie, czy token jest nadal waΕΌny
+ if (decodedToken.exp && decodedToken.exp * 1000 > Date.now()) {
+ dispatch(setCredentials({ token, user: userFromToken }));
+ } else {
+ // Token wygasΕ
+ dispatch(logOut());
+ }
+ } catch (err) {
+ console.error('Invalid token:', err);
+ dispatch(logOut());
+ }
+ }
+ }, [dispatch]);
+
+ return isAuthenticated;
+};
diff --git a/clients/plan-it-web/src/hooks/useMultipleProjectsHook.tsx b/clients/plan-it-web/src/hooks/useMultipleProjectsHook.tsx
index 32958ac..2017474 100644
--- a/clients/plan-it-web/src/hooks/useMultipleProjectsHook.tsx
+++ b/clients/plan-it-web/src/hooks/useMultipleProjectsHook.tsx
@@ -12,12 +12,10 @@ const PLACEHOLDER_ID = 'placeholder';
export type Items = Record;
export const useMultipleContainers = (items: Items, setItems: React.Dispatch>) => {
- const [containers, setContainers] = useState(Object.keys(items));
const [activeId, setActiveId] = useState(null);
const [clonedItems, setClonedItems] = useState(null);
const lastOverId = useRef(null);
const recentlyMovedToNewContainer = useRef(false);
-
const sensors = useSensors(useSensor(MouseSensor), useSensor(TouchSensor));
const findContainer = useCallback((id: string) => {
@@ -33,7 +31,7 @@ export const useMultipleContainers = (items: Items, setItems: React.Dispatch task.id === id);
- }, [findContainer, items]);
+ }, [items, findContainer]);
const onDragStart = useCallback(({ active }) => {
setActiveId(active.id);
@@ -50,15 +48,15 @@ export const useMultipleContainers = (items: Items, setItems: React.Dispatch {
- const activeItems = items[activeContainer].projectTasks;
- const overItems = items[overContainer].projectTasks;
- const overIndex = overId in items ? overItems.length + 1 : overItems.findIndex((task) => task.id === overId);
+ setItems((prevItems) => {
+ const activeItems = prevItems[activeContainer].projectTasks;
+ const overItems = prevItems[overContainer].projectTasks;
+ const overIndex = overId in prevItems ? overItems.length + 1 : overItems.findIndex((task) => task.id === overId);
const activeIndex = activeItems.findIndex((task) => task.id === active.id);
let newIndex: number;
- if (overId in items) {
+ if (overId in prevItems) {
newIndex = overItems.length + 1;
} else {
const isBelowOverItem = over && active.rect.current.translated &&
@@ -70,30 +68,32 @@ export const useMultipleContainers = (items: Items, setItems: React.Dispatch item.id !== active.id)
+ ...prevItems[activeContainer],
+ projectTasks: prevItems[activeContainer].projectTasks.filter((item) => item.id !== active.id)
},
[overContainer]: {
- ...items[overContainer],
+ ...prevItems[overContainer],
projectTasks: [
- ...items[overContainer].projectTasks.slice(0, newIndex),
- items[activeContainer].projectTasks.find((item) => item.id === active.id)!,
- ...items[overContainer].projectTasks.slice(newIndex)
+ ...prevItems[overContainer].projectTasks.slice(0, newIndex),
+ prevItems[activeContainer].projectTasks.find((item) => item.id === active.id)!,
+ ...prevItems[overContainer].projectTasks.slice(newIndex)
],
}
};
});
}
- }, [findContainer, items]);
+ }, [items, findContainer, setItems]);
const onDragEnd = useCallback(({ active, over }) => {
if (active.id in items && over?.id) {
- setContainers((containers) => {
- const activeIndex = containers.indexOf(active.id);
- const overIndex = containers.indexOf(over.id);
- return arrayMove(containers, activeIndex, overIndex);
+ setItems((prevItems) => {
+ const activeIndex = Object.keys(prevItems).indexOf(active.id);
+ const overIndex = Object.keys(prevItems).indexOf(over.id);
+ return Object.fromEntries(
+ arrayMove(Object.entries(prevItems), activeIndex, overIndex)
+ );
});
}
@@ -113,17 +113,16 @@ export const useMultipleContainers = (items: Items, setItems: React.Dispatch [...containers, newContainerId]);
- setItems((items) => ({
- ...items,
+ setItems((prevItems) => ({
+ ...prevItems,
[activeContainer]: {
- ...items[activeContainer],
- projectTasks: items[activeContainer].projectTasks.filter((task) => task.id !== active.id)
+ ...prevItems[activeContainer],
+ projectTasks: prevItems[activeContainer].projectTasks.filter((task) => task.id !== active.id)
},
[newContainerId]: {
name: "New project",
description: "",
- projectTasks: [items[activeContainer].projectTasks.find((task) => task.id === active.id)!]
+ projectTasks: [prevItems[activeContainer].projectTasks.find((task) => task.id === active.id)!]
},
}));
setActiveId(null);
@@ -137,18 +136,18 @@ export const useMultipleContainers = (items: Items, setItems: React.Dispatch ({
- ...items,
+ setItems((prevItems) => ({
+ ...prevItems,
[overContainer]: {
- ...items[overContainer],
- projectTasks: arrayMove(items[overContainer].projectTasks, activeIndex, overIndex)
+ ...prevItems[overContainer],
+ projectTasks: arrayMove(prevItems[overContainer].projectTasks, activeIndex, overIndex)
},
}));
}
}
setActiveId(null);
- }, [findContainer, getIndex, items]);
+ }, [items, findContainer, getIndex, setItems]);
const onDragCancel = useCallback(() => {
if (clonedItems) {
@@ -156,11 +155,11 @@ export const useMultipleContainers = (items: Items, setItems: React.Dispatch {
const containerId = findContainer(id) as UniqueIdentifier;
- const projectTask = items[containerId].projectTasks.find( (task) => task.id === id);
+ const projectTask = items[containerId].projectTasks.find((task) => task.id === id);
return (
-
);
- }
+ }, [items]);
return {
sensors,
activeId,
- containers,
- setContainers,
onDragStart,
onDragOver,
onDragEnd,
@@ -211,5 +208,4 @@ export const useMultipleContainers = (items: Items, setItems: React.Dispatch
-
+
+
+
+
+
+
,
)
diff --git a/clients/plan-it-web/src/redux/authSlice.ts b/clients/plan-it-web/src/redux/authSlice.ts
new file mode 100644
index 0000000..94f0fd0
--- /dev/null
+++ b/clients/plan-it-web/src/redux/authSlice.ts
@@ -0,0 +1,38 @@
+import { createSlice, PayloadAction } from '@reduxjs/toolkit';
+import { User } from '../types/User';
+
+interface AuthState {
+ user: User | null;
+ token: string | null;
+ isAuthenticated: boolean;
+}
+
+const initialState: AuthState = {
+ user: null,
+ token: localStorage.getItem('token'),
+ isAuthenticated: false,
+};
+
+const authSlice = createSlice({
+ name: 'auth',
+ initialState,
+ reducers: {
+ setCredentials: (state, action: PayloadAction<{ user: User; token: string }>) => {
+ const { user, token } = action.payload;
+ state.user = user;
+ state.token = token;
+ state.isAuthenticated = true;
+ localStorage.setItem('token', token);
+ },
+ logOut: (state) => {
+ state.user = null;
+ state.token = null;
+ state.isAuthenticated = false;
+ localStorage.removeItem('token');
+ }
+ }
+});
+
+export const { setCredentials, logOut } = authSlice.actions;
+
+export default authSlice.reducer;
diff --git a/clients/plan-it-web/src/redux/store.ts b/clients/plan-it-web/src/redux/store.ts
index f71caf0..617075f 100644
--- a/clients/plan-it-web/src/redux/store.ts
+++ b/clients/plan-it-web/src/redux/store.ts
@@ -2,18 +2,30 @@ import { configureStore } from '@reduxjs/toolkit'
// Or from '@reduxjs/toolkit/query/react'
import { setupListeners } from '@reduxjs/toolkit/query'
import { projectApi } from '../services/planit-api'
+import authReducer from './authSlice';
+
+import workspacesReducer from './workspacesSlice'
+import { authApi } from '../services/auth-api'
export const store = configureStore({
reducer: {
// Add the generated reducer as a specific top-level slice
+ auth: authReducer,
+ [authApi.reducerPath]: authApi.reducer,
[projectApi.reducerPath]: projectApi.reducer,
+ workspaces: workspacesReducer,
},
// Adding the api middleware enables caching, invalidation, polling,
// and other useful features of `rtk-query`.
middleware: (getDefaultMiddleware) =>
- getDefaultMiddleware().concat(projectApi.middleware),
+ getDefaultMiddleware().concat(projectApi.middleware, authApi.middleware),
})
// optional, but required for refetchOnFocus/refetchOnReconnect behaviors
// see `setupListeners` docs - takes an optional callback as the 2nd arg for customization
-setupListeners(store.dispatch)
\ No newline at end of file
+setupListeners(store.dispatch)
+
+// Infer the `RootState` and `AppDispatch` types from the store itself
+export type RootState = ReturnType
+// Inferred type: {posts: PostsState, comments: CommentsState, users: UsersState}
+export type AppDispatch = typeof store.dispatch
\ No newline at end of file
diff --git a/clients/plan-it-web/src/redux/workspacesSlice.ts b/clients/plan-it-web/src/redux/workspacesSlice.ts
new file mode 100644
index 0000000..564e479
--- /dev/null
+++ b/clients/plan-it-web/src/redux/workspacesSlice.ts
@@ -0,0 +1,40 @@
+import { createSlice, PayloadAction } from '@reduxjs/toolkit'
+import { Workspace } from '../types/Project'
+
+interface WorkspacesState {
+ workspaces: Workspace[]
+}
+
+const initialState: WorkspacesState = {
+ workspaces: []
+}
+
+const workspacesSlice = createSlice({
+ name: 'workspaces',
+ initialState,
+ reducers: {
+ addWorkspace: (state, action: PayloadAction) => {
+ state.workspaces.push(action.payload)
+ },
+ updateWorkspaceLocal: (state, action: PayloadAction) => {
+ const index = state.workspaces.findIndex(workspace => workspace.id === action.payload.id)
+ if (index !== -1) {
+ state.workspaces[index] = action.payload
+ }
+ },
+ deleteWorkspaceLocal: (state, action: PayloadAction) => {
+ state.workspaces = state.workspaces.filter(workspace => workspace.id !== action.payload)
+ },
+ setWorkspaces: (state, action: PayloadAction) => {
+ state.workspaces = action.payload
+ }
+ }
+})
+
+export const {
+ addWorkspace,
+ updateWorkspaceLocal,
+ deleteWorkspaceLocal,
+ setWorkspaces
+ } = workspacesSlice.actions
+export default workspacesSlice.reducer
diff --git a/clients/plan-it-web/src/router/ProtectedRoute.tsx b/clients/plan-it-web/src/router/ProtectedRoute.tsx
new file mode 100644
index 0000000..69eec19
--- /dev/null
+++ b/clients/plan-it-web/src/router/ProtectedRoute.tsx
@@ -0,0 +1,33 @@
+import React from 'react';
+import { Navigate, useLocation } from 'react-router-dom';
+import { useAppSelector } from '../hooks/reduxHooks';
+import { showNotification } from '@mantine/notifications';
+
+interface ProtectedRouteProps {
+ children: React.ReactNode;
+}
+
+export const ProtectedRoute: React.FC = ({ children }) => {
+ const isAuthenticated = useAppSelector(state => state.auth.isAuthenticated);
+ const location = useLocation();
+
+ React.useEffect(() => {
+ if (!isAuthenticated) {
+ showNotification({
+ title: 'Error',
+ message: 'You must be logged in to view this page',
+ color: 'red',
+ });
+ }
+ }, [isAuthenticated]);
+
+ if (!isAuthenticated) {
+ // Redirect them to the /login page, but save the current location they were
+ // trying to go to when they were redirected. This allows us to send them
+ // along to that page after they login, which is a nicer user experience
+ // than dropping them off on the home page.
+ return ;
+ }
+
+ return <>{children};
+};
diff --git a/clients/plan-it-web/src/services/auth-api.ts b/clients/plan-it-web/src/services/auth-api.ts
new file mode 100644
index 0000000..3545e86
--- /dev/null
+++ b/clients/plan-it-web/src/services/auth-api.ts
@@ -0,0 +1,37 @@
+import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query/react';
+import { RootState } from '../redux/store';
+import { LoginCredentials, RegisterData, AuthResponse } from '../types/Auth';
+
+const HOST = "https://localhost:5234";
+
+export const authApi = createApi({
+ reducerPath: 'authApi',
+ baseQuery: fetchBaseQuery({
+ baseUrl: HOST,
+ prepareHeaders: (headers, { getState }) => {
+ const token = (getState() as RootState).auth.token;
+ if (token) {
+ headers.set('Authorization', `Bearer ${token}`);
+ }
+ return headers;
+ },
+ }),
+ endpoints: (builder) => ({
+ login: builder.mutation({
+ query: (credentials) => ({
+ url: '/auth/login',
+ method: 'POST',
+ body: credentials,
+ }),
+ }),
+ register: builder.mutation({
+ query: (userData) => ({
+ url: '/auth/register',
+ method: 'POST',
+ body: userData,
+ }),
+ }),
+ }),
+});
+
+export const { useLoginMutation, useRegisterMutation } = authApi;
diff --git a/clients/plan-it-web/src/services/planit-api.ts b/clients/plan-it-web/src/services/planit-api.ts
index c1d3452..7687ce2 100644
--- a/clients/plan-it-web/src/services/planit-api.ts
+++ b/clients/plan-it-web/src/services/planit-api.ts
@@ -1,6 +1,6 @@
import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query/react'
-
-import type { Project } from '../types/Project'
+import type { Project, ProjectTask, Workspace, WorkspaceProjects } from '../types/Project'
+import { User } from '../types/User';
const HOST = "https://localhost:5234";
@@ -10,14 +10,126 @@ export const projectApi = createApi({
baseQuery: fetchBaseQuery({
baseUrl: `${HOST}/api`,
mode: 'cors',
+ prepareHeaders: (headers, { getState }) => {
+ const token = (getState() as RootState).auth.token;
+ if (token) {
+ headers.set('Authorization', `Bearer ${token}`);
+ }
+ return headers;
+ },
}),
endpoints: (builder) => ({
- getProjectById: builder.query({
+ getProject: builder.query({
query: (id) => `projects/${id}`,
}),
+ getUserWorkspaces: builder.query({
+ query: (userId) => `users/${userId}/workspaces/`,
+ }),
+ getProjectsForWorkspace: builder.query({
+ query: (workspaceId) => `workspaces/${workspaceId}/projects`,
+ }),
+ createProject: builder.mutation>({
+ query: (newProject) => ({
+ url: `projects/`,
+ method: 'POST',
+ body: newProject,
+ }),
+ }),
+ updateProject: builder.mutation, projectId: string }>({
+ query: ({ updatedProject, projectId }) => ({
+ url: `projects/${projectId}`,
+ method: 'PUT',
+ body: updatedProject,
+ })}),
+ deleteProject: builder.mutation({
+ query: (projectId) => ({
+ url: `projects/${projectId}`,
+ method: 'DELETE',
+ }),
+ }),
+ getWorkspace: builder.query({
+ query: (workspaceId) => `workspaces/${workspaceId}`,
+ }),
+ createWorkspace: builder.mutation>({
+ query: (newWorkspace) => ({
+ url: `workspaces/`,
+ method: 'POST',
+ body: newWorkspace,
+ }),
+ }),
+ updateWorkspace: builder.mutation, workspaceId: string }>({
+ query: ({ updatedWorkspace, workspaceId }) => ({
+ url: `workspaces/${workspaceId}`,
+ method: 'PUT',
+ body: updatedWorkspace,
+ })}),
+ deleteWorkspace: builder.mutation({
+ query: (workspaceId) => ({
+ url: `workspaces/${workspaceId}`,
+ method: 'DELETE',
+ }),
+ }),
+ // Project tasks
+ getProjectTasks: builder.query({
+ query: (projectId) => `projects/${projectId}`,
+ }),
+ createProjectTask: builder.mutation }>({
+ query: ({ projectId, task }) => ({
+ url: `projects/${projectId}/tasks`,
+ method: 'POST',
+ body: task,
+ })
+ }),
+ updateProjectTask: builder.mutation }>({
+ query: ({ projectId, taskId, updatedTask }) => ({
+ url: `projects/${projectId}/tasks/${taskId}`,
+ method: 'PUT',
+ body: updatedTask,
+ })}),
+ deleteProjectTask: builder.mutation({
+ query: ({ projectId, taskId }) => ({
+ url: `projects/${projectId}/tasks/${taskId}`,
+ method: 'DELETE',
+ })}),
+ // User
+ getUser: builder.query({
+ query: (userId) => `users/${userId}`,
+ }),
+ updateUser: builder.mutation & { userId: string }>({
+ query: ({ userId, ...patch }) => ({
+ url: `/users/${userId}`,
+ method: 'PATCH',
+ body: patch,
+ }),
+ }),
+ uploadAvatar: builder.mutation<{ avatarUrl: string }, { userId: string, avatar: FormData }>({
+ query: ({ userId, avatar }) => ({
+ url: `/users/${userId}/avatar`,
+ method: 'POST',
+ body: avatar,
+ }),
+ }),
}),
-})
+});
// Export hooks for usage in functional components, which are
// auto-generated based on the defined endpoints
-export const { useGetProjectByIdQuery } = projectApi;
\ No newline at end of file
+export const {
+ useGetProjectQuery,
+ useGetUserWorkspacesQuery,
+ useGetProjectsForWorkspaceQuery,
+ useCreateProjectMutation,
+ useUpdateProjectMutation,
+ useDeleteProjectMutation,
+ useGetWorkspaceQuery,
+ useCreateWorkspaceMutation,
+ useUpdateWorkspaceMutation,
+ useDeleteWorkspaceMutation,
+ useCreateProjectTaskMutation,
+ useDeleteProjectTaskMutation,
+ useUpdateProjectTaskMutation,
+ useGetProjectTasksQuery,
+ useGetUserQuery,
+ useUpdateUserMutation,
+ useUploadAvatarMutation
+ } = projectApi;
\ No newline at end of file
diff --git a/clients/plan-it-web/src/types/Auth.ts b/clients/plan-it-web/src/types/Auth.ts
new file mode 100644
index 0000000..b66be90
--- /dev/null
+++ b/clients/plan-it-web/src/types/Auth.ts
@@ -0,0 +1,24 @@
+import { JwtPayload } from "jwt-decode";
+import { User } from "./User";
+
+export interface LoginCredentials {
+ email: string;
+ password: string;
+ }
+
+ export interface RegisterData {
+ firstName: string;
+ lastName: string;
+ email: string;
+ password: string;
+ }
+
+ export interface AuthResponse {
+ user: User;
+ token: string;
+ }
+
+ export interface JwtInformation extends JwtPayload {
+ given_name: string;
+ family_name: string;
+ }
\ No newline at end of file
diff --git a/clients/plan-it-web/src/types/Project.ts b/clients/plan-it-web/src/types/Project.ts
index 83ebbaa..35bdc31 100644
--- a/clients/plan-it-web/src/types/Project.ts
+++ b/clients/plan-it-web/src/types/Project.ts
@@ -1,11 +1,25 @@
export interface Project {
+ workspaceId: string;
id: string;
name: string;
description: string;
+ projectTasks: ProjectTask[];
}
export interface ProjectTask {
id: string,
name: string,
description: string
+}
+
+export interface Workspace {
+ id: string,
+ name: string,
+ description: string,
+ projectIds: string[]
+}
+
+export interface WorkspaceProjects {
+ id: string,
+ projects: Project[]
}
\ No newline at end of file
diff --git a/clients/plan-it-web/src/types/Task.ts b/clients/plan-it-web/src/types/Task.ts
new file mode 100644
index 0000000..4086b84
--- /dev/null
+++ b/clients/plan-it-web/src/types/Task.ts
@@ -0,0 +1,5 @@
+export interface Task {
+ name: string;
+ description: string;
+ id: string;
+}
\ No newline at end of file
diff --git a/clients/plan-it-web/src/types/User.ts b/clients/plan-it-web/src/types/User.ts
new file mode 100644
index 0000000..7bae863
--- /dev/null
+++ b/clients/plan-it-web/src/types/User.ts
@@ -0,0 +1,7 @@
+export interface User {
+ id: string;
+ email: string;
+ firstName: string;
+ lastName: string;
+ avatarUrl: string | null;
+}
\ No newline at end of file
diff --git a/src/PlanIt.Application/Common/Interfaces/Persistence/IProjectRepository.cs b/src/PlanIt.Application/Common/Interfaces/Persistence/IProjectRepository.cs
index 4651674..f67cacd 100644
--- a/src/PlanIt.Application/Common/Interfaces/Persistence/IProjectRepository.cs
+++ b/src/PlanIt.Application/Common/Interfaces/Persistence/IProjectRepository.cs
@@ -1,14 +1,17 @@
using PlanIt.Domain.ProjectAggregate;
using PlanIt.Domain.ProjectAggregate.ValueObjects;
+using PlanIt.Domain.WorkspaceAggregate.ValueObjects;
namespace PlanIt.Application.Common.Interfaces.Persistence;
public interface IProjectRepository
{
- void Add(Project project);
+ Task AddAsync(Project project);
public Task GetAsync(ProjectId projectId);
+ public Task> GetProjectsForWorkspaceAsync(WorkspaceId workspaceId);
+
public Task UpdateAsync();
public Task DeleteAsync(Project project);
diff --git a/src/PlanIt.Application/Common/Interfaces/Persistence/IUserRepository.cs b/src/PlanIt.Application/Common/Interfaces/Persistence/IUserRepository.cs
index 05992e0..e0d12c3 100644
--- a/src/PlanIt.Application/Common/Interfaces/Persistence/IUserRepository.cs
+++ b/src/PlanIt.Application/Common/Interfaces/Persistence/IUserRepository.cs
@@ -5,8 +5,8 @@ namespace PlanIt.Application.Common.Interfaces.Persistence
{
public interface IUserRepository
{
- public Task GetUserByEmail(string email);
public Task> AddAsync(User user, string email, string password);
+ public Task GetUserByEmail(string email);
public Task SaveChangesAsync();
}
}
\ No newline at end of file
diff --git a/src/PlanIt.Application/Common/Interfaces/Persistence/IWorkspaceRepository.cs b/src/PlanIt.Application/Common/Interfaces/Persistence/IWorkspaceRepository.cs
index 3987f79..b3f06e2 100644
--- a/src/PlanIt.Application/Common/Interfaces/Persistence/IWorkspaceRepository.cs
+++ b/src/PlanIt.Application/Common/Interfaces/Persistence/IWorkspaceRepository.cs
@@ -1,3 +1,4 @@
+using PlanIt.Domain.UserAggregate.ValueObjects;
using PlanIt.Domain.WorkspaceAggregate;
using PlanIt.Domain.WorkspaceAggregate.ValueObjects;
@@ -8,5 +9,6 @@ public interface IWorkspaceRepository
public Task AddAsync(Workspace workspace);
public Task DeleteAsync(Workspace workspace);
public Task GetAsync(WorkspaceId workspaceId);
+ public Task> GetUserWorkspacesAsync(WorkspaceOwnerId userId);
public Task SaveChangesAsync();
}
\ No newline at end of file
diff --git a/src/PlanIt.Application/Projects/Commands/CreateProject/CreateProjectCommand.cs b/src/PlanIt.Application/Projects/Commands/CreateProject/CreateProjectCommand.cs
index 7fdd77a..2ae2917 100644
--- a/src/PlanIt.Application/Projects/Commands/CreateProject/CreateProjectCommand.cs
+++ b/src/PlanIt.Application/Projects/Commands/CreateProject/CreateProjectCommand.cs
@@ -5,7 +5,7 @@
namespace PlanIt.Application.Projects.Commands.CreateProject;
public record CreateProjectCommand(
- string ProjectOwnerId,
+ string WorkspaceId,
string Name,
string Description,
List ProjectTasks
diff --git a/src/PlanIt.Application/Projects/Commands/CreateProject/CreateProjectCommandHandler.cs b/src/PlanIt.Application/Projects/Commands/CreateProject/CreateProjectCommandHandler.cs
index b1f753c..f2585fd 100644
--- a/src/PlanIt.Application/Projects/Commands/CreateProject/CreateProjectCommandHandler.cs
+++ b/src/PlanIt.Application/Projects/Commands/CreateProject/CreateProjectCommandHandler.cs
@@ -5,36 +5,44 @@
using PlanIt.Domain.ProjectAggregate;
using PlanIt.Domain.ProjectAggregate.Entities;
using PlanIt.Domain.ProjectAggregate.ValueObjects;
+using PlanIt.Domain.UserAggregate.ValueObjects;
+using PlanIt.Domain.WorkspaceAggregate.ValueObjects;
namespace PlanIt.Application.Projects.Commands.CreateProject;
public class CreateProjectCommandHandler : IRequestHandler>
{
public readonly IProjectRepository _projectRepository;
+ public readonly IUserContext _userContext;
- public CreateProjectCommandHandler(IProjectRepository projectRepository)
+ public CreateProjectCommandHandler(IProjectRepository projectRepository, IUserContext userContext)
{
_projectRepository = projectRepository;
+ _userContext = userContext;
}
public async Task> Handle(CreateProjectCommand request, CancellationToken cancellationToken)
{
- await Task.CompletedTask;
+ var loggedInUserId = _userContext.TryGetUserId();
+
+ var projectOwnerId = ProjectOwnerId.FromString(loggedInUserId);
+ var taskOwnerId = TaskOwnerId.FromString(loggedInUserId);
// Create Project
var project = Project.Create(
name: request.Name,
description: request.Description,
- projectOwnerId: ProjectOwnerId.Create(new Guid(request.ProjectOwnerId)),
+ workspaceId: WorkspaceId.FromString(request.WorkspaceId),
+ projectOwnerId: projectOwnerId,
projectTasks: request.ProjectTasks.ConvertAll(projectTask => ProjectTask.Create(
- taskOwnerId: TaskOwnerId.Create(new Guid(request.ProjectOwnerId)),
+ taskOwnerId: taskOwnerId,
name: projectTask.Name,
description: projectTask.Description
))
);
// Persist Project
- _projectRepository.Add(project);
+ await _projectRepository.AddAsync(project);
return project;
}
diff --git a/src/PlanIt.Application/Users/Queries/GetUserWorkspacesQuery.cs b/src/PlanIt.Application/Users/Queries/GetUserWorkspacesQuery.cs
new file mode 100644
index 0000000..4c4ce7a
--- /dev/null
+++ b/src/PlanIt.Application/Users/Queries/GetUserWorkspacesQuery.cs
@@ -0,0 +1,10 @@
+using FluentResults;
+using MediatR;
+using PlanIt.Domain.WorkspaceAggregate;
+
+namespace PlanIt.Application.Users.Queries;
+
+public record GetUserWorkspacesQuery
+(
+ string UserId
+) : IRequest>>;
\ No newline at end of file
diff --git a/src/PlanIt.Application/Users/Queries/GetUserWorkspacesQueryHandler.cs b/src/PlanIt.Application/Users/Queries/GetUserWorkspacesQueryHandler.cs
new file mode 100644
index 0000000..97740a8
--- /dev/null
+++ b/src/PlanIt.Application/Users/Queries/GetUserWorkspacesQueryHandler.cs
@@ -0,0 +1,35 @@
+using FluentResults;
+using MediatR;
+using PlanIt.Application.Common.Interfaces.Persistence;
+using PlanIt.Domain.UserAggregate.ValueObjects;
+using PlanIt.Domain.WorkspaceAggregate;
+using PlanIt.Domain.WorkspaceAggregate.ValueObjects;
+
+namespace PlanIt.Application.Users.Queries;
+public class GetUserWorkspacesQueryHandler : IRequestHandler>>
+{
+ private readonly IWorkspaceRepository _workspaceRepository;
+ private readonly IUserRepository _userRepository;
+
+ public GetUserWorkspacesQueryHandler(IWorkspaceRepository workspaceRepository, IUserRepository userRepository)
+ {
+ _workspaceRepository = workspaceRepository;
+ _userRepository = userRepository;
+ }
+
+ public async Task>> Handle(GetUserWorkspacesQuery query, CancellationToken cancellationToken)
+ {
+ var userId = WorkspaceOwnerId.FromString(query.UserId);
+
+ // Get workspaces
+ var workspaces = await _workspaceRepository.GetUserWorkspacesAsync(userId);
+
+ if (workspaces is null)
+ {
+ return Result.Fail>(new NotFoundError($"Couldn't find workspaces for User with id: ${userId.Value}"));
+ }
+
+ // Return it
+ return workspaces;
+ }
+}
\ No newline at end of file
diff --git a/src/PlanIt.Application/Workspaces/Commands/CreateWorkspace/CreateWorkspaceCommandHandler.cs b/src/PlanIt.Application/Workspaces/Commands/CreateWorkspace/CreateWorkspaceCommandHandler.cs
index f7b61b6..734c619 100644
--- a/src/PlanIt.Application/Workspaces/Commands/CreateWorkspace/CreateWorkspaceCommandHandler.cs
+++ b/src/PlanIt.Application/Workspaces/Commands/CreateWorkspace/CreateWorkspaceCommandHandler.cs
@@ -11,7 +11,7 @@ public class CreateWorkspaceCommandHandler : IRequestHandler> Handle(CreateWorkspaceCommand command, Canc
{
var userId = _userContext.TryGetUserId();
- var workspace = Workspace.Create(command.Name, command.Description, WorkspaceOwnerId.Create(new Guid(userId)));
+ var workspace = Workspace.Create(
+ name: command.Name,
+ description: command.Description,
+ workspaceOwnerId: WorkspaceOwnerId.Create(new Guid(userId)));
await _workspaceRepository.AddAsync(workspace);
diff --git a/src/PlanIt.Application/Workspaces/Queries/GetWorkspace/GetWorkspaceQuery.cs b/src/PlanIt.Application/Workspaces/Queries/GetWorkspace/GetWorkspaceQuery.cs
new file mode 100644
index 0000000..0ccb414
--- /dev/null
+++ b/src/PlanIt.Application/Workspaces/Queries/GetWorkspace/GetWorkspaceQuery.cs
@@ -0,0 +1,10 @@
+using FluentResults;
+using MediatR;
+using PlanIt.Domain.WorkspaceAggregate;
+
+namespace PlanIt.Application.Workspaces.Queries.GetWorkspace;
+
+public record GetWorkspaceQuery
+(
+ string WorkspaceId
+) : IRequest>;
\ No newline at end of file
diff --git a/src/PlanIt.Application/Workspaces/Queries/GetWorkspace/GetWorkspaceQueryHandler.cs b/src/PlanIt.Application/Workspaces/Queries/GetWorkspace/GetWorkspaceQueryHandler.cs
new file mode 100644
index 0000000..b63ac74
--- /dev/null
+++ b/src/PlanIt.Application/Workspaces/Queries/GetWorkspace/GetWorkspaceQueryHandler.cs
@@ -0,0 +1,32 @@
+using FluentResults;
+using MediatR;
+using PlanIt.Application.Common.Interfaces.Persistence;
+using PlanIt.Application.Workspaces.Queries.GetWorkspace;
+using PlanIt.Domain.WorkspaceAggregate;
+using PlanIt.Domain.WorkspaceAggregate.ValueObjects;
+
+public class GetWorkspaceQueryHandler : IRequestHandler>
+{
+ private readonly IWorkspaceRepository _workspaceRepository;
+
+ public GetWorkspaceQueryHandler(IWorkspaceRepository workspaceRepository)
+ {
+ _workspaceRepository = workspaceRepository;
+ }
+
+ public async Task> Handle(GetWorkspaceQuery query, CancellationToken cancellationToken)
+ {
+ var workspaceId = WorkspaceId.FromString(query.WorkspaceId);
+
+ // Get workspace
+ var workspace = await _workspaceRepository.GetAsync(workspaceId);
+
+ if (workspace is null)
+ {
+ return Result.Fail(new NotFoundError($"Couldn't find a workspace with id: ${workspaceId.Value}"));
+ }
+
+ // Return it
+ return workspace;
+ }
+}
\ No newline at end of file
diff --git a/src/PlanIt.Application/Workspaces/Queries/GetWorkspaceProjects/GetWorkspaceProjectsQuery.cs b/src/PlanIt.Application/Workspaces/Queries/GetWorkspaceProjects/GetWorkspaceProjectsQuery.cs
new file mode 100644
index 0000000..9b3c263
--- /dev/null
+++ b/src/PlanIt.Application/Workspaces/Queries/GetWorkspaceProjects/GetWorkspaceProjectsQuery.cs
@@ -0,0 +1,9 @@
+using FluentResults;
+using MediatR;
+using PlanIt.Domain.ProjectAggregate;
+
+namespace PlanIt.Application.Workspaces.Queries.GetWorkspaceProjects;
+
+public record GetWorkspaceProjectsQuery(
+ string WorkspaceId
+) : IRequest>>;
\ No newline at end of file
diff --git a/src/PlanIt.Application/Workspaces/Queries/GetWorkspaceProjects/GetWorkspaceProjectsQueryHandler.cs b/src/PlanIt.Application/Workspaces/Queries/GetWorkspaceProjects/GetWorkspaceProjectsQueryHandler.cs
new file mode 100644
index 0000000..228132f
--- /dev/null
+++ b/src/PlanIt.Application/Workspaces/Queries/GetWorkspaceProjects/GetWorkspaceProjectsQueryHandler.cs
@@ -0,0 +1,32 @@
+using FluentResults;
+using MediatR;
+using PlanIt.Application.Common.Interfaces.Persistence;
+using PlanIt.Domain.ProjectAggregate;
+using PlanIt.Domain.WorkspaceAggregate.ValueObjects;
+
+namespace PlanIt.Application.Workspaces.Queries.GetWorkspaceProjects;
+
+public class GetWorkspaceProjectsQueryHandler : IRequestHandler>>
+{
+ private readonly IProjectRepository _projectRepository;
+
+ public GetWorkspaceProjectsQueryHandler(IProjectRepository projectRepository)
+ {
+ _projectRepository = projectRepository;
+ }
+
+ public async Task>> Handle(GetWorkspaceProjectsQuery query, CancellationToken cancellationToken)
+ {
+ var workspaceId = WorkspaceId.FromString(query.WorkspaceId);
+
+ // Get project associated with the workspace
+ var projects = await _projectRepository.GetProjectsForWorkspaceAsync(workspaceId);
+
+ if (projects is null)
+ {
+ return Result.Fail>(new NotFoundError($"Couldn't find project for a workspace with id: ${workspaceId.Value}"));
+ }
+
+ return projects;
+ }
+}
\ No newline at end of file
diff --git a/src/PlanIt.Contracts/Projects/Requests/CreateProjectRequest.cs b/src/PlanIt.Contracts/Projects/Requests/CreateProjectRequest.cs
index e039d61..067c803 100644
--- a/src/PlanIt.Contracts/Projects/Requests/CreateProjectRequest.cs
+++ b/src/PlanIt.Contracts/Projects/Requests/CreateProjectRequest.cs
@@ -1,6 +1,7 @@
namespace PlanIt.Contracts.Projects.Requests;
public record CreateProjectRequest(
+ string WorkspaceId,
string Name,
string Description,
List ProjectTasks
diff --git a/src/PlanIt.Contracts/Workspace/Responses/WorkspaceProjectsResponse.cs b/src/PlanIt.Contracts/Workspace/Responses/WorkspaceProjectsResponse.cs
new file mode 100644
index 0000000..cd61c26
--- /dev/null
+++ b/src/PlanIt.Contracts/Workspace/Responses/WorkspaceProjectsResponse.cs
@@ -0,0 +1,9 @@
+using PlanIt.Contracts.Projects.Responses;
+
+namespace PlanIt.Contracts.Workspace.Responses;
+
+public record WorkspaceProjectsResponse
+(
+ string WorkspaceId,
+ List Projects
+);
\ No newline at end of file
diff --git a/src/PlanIt.Contracts/Workspace/Responses/WorkspaceResponse.cs b/src/PlanIt.Contracts/Workspace/Responses/WorkspaceResponse.cs
index 37d5659..fbd1ef1 100644
--- a/src/PlanIt.Contracts/Workspace/Responses/WorkspaceResponse.cs
+++ b/src/PlanIt.Contracts/Workspace/Responses/WorkspaceResponse.cs
@@ -1,6 +1,7 @@
namespace PlanIt.Contracts.Workspace.Responses;
public record WorkspaceResponse(
+ string Id,
string Name,
string Description
);
\ No newline at end of file
diff --git a/src/PlanIt.Domain/ProjectAggregate/Project.cs b/src/PlanIt.Domain/ProjectAggregate/Project.cs
index 73270d8..fe6d965 100644
--- a/src/PlanIt.Domain/ProjectAggregate/Project.cs
+++ b/src/PlanIt.Domain/ProjectAggregate/Project.cs
@@ -3,6 +3,7 @@
using PlanIt.Domain.ProjectAggregate.Entities;
using PlanIt.Domain.ProjectAggregate.Events;
using PlanIt.Domain.ProjectAggregate.ValueObjects;
+using PlanIt.Domain.WorkspaceAggregate.ValueObjects;
namespace PlanIt.Domain.ProjectAggregate;
@@ -10,6 +11,7 @@ public sealed class Project : AggregateRoot
{
private Project(
ProjectId id,
+ WorkspaceId workspaceId,
string name,
string description,
ProjectOwnerId projectOwnerId,
@@ -20,6 +22,7 @@ private Project(
Name = name;
Description = description;
_projectTasks = projectTasks;
+ WorkspaceId = workspaceId;
ProjectOwnerId = projectOwnerId;
CreatedDateTime = createdDateTime;
UpdatedDateTime = updatedDateTime;
@@ -35,6 +38,7 @@ private Project()
private readonly List _projectTasks;
public string Name { get; private set; }
public string Description { get; private set; }
+ public WorkspaceId WorkspaceId {get; private set; }
public ProjectOwnerId ProjectOwnerId { get; private set; }
public DateTime CreatedDateTime { get; private set; }
public DateTime UpdatedDateTime { get; private set; }
@@ -72,13 +76,16 @@ public void ChangeDescription(string newDescription)
return task;
}
- public static Project Create(string name,
+ public static Project Create(
+ string name,
string description,
+ WorkspaceId workspaceId,
ProjectOwnerId projectOwnerId,
List projectTasks)
{
var project = new Project(
ProjectId.CreateUnique(),
+ workspaceId,
name,
description,
projectOwnerId,
diff --git a/src/PlanIt.Domain/ProjectAggregate/ValueObjects/TaskOwnerId.cs b/src/PlanIt.Domain/ProjectAggregate/ValueObjects/TaskOwnerId.cs
index ea70cdc..b96805e 100644
--- a/src/PlanIt.Domain/ProjectAggregate/ValueObjects/TaskOwnerId.cs
+++ b/src/PlanIt.Domain/ProjectAggregate/ValueObjects/TaskOwnerId.cs
@@ -21,6 +21,11 @@ public static TaskOwnerId Create(Guid id)
return new TaskOwnerId(id);
}
+ public static TaskOwnerId FromString(string id)
+ {
+ return new TaskOwnerId(new Guid(id));
+ }
+
public override IEnumerable