src/reducers/EditNewsReducer.js

+import { CLEAR_WRITE, SELECT_NEWS, WRITE_NEWS } from '../actions/types';
+
+const INITIAL_STATE = {};
+
+export default (state = INITIAL_STATE, action) => {
+  switch (action.type) {
+    case SELECT_NEWS:
+      return action.payload;
+    case WRITE_NEWS:
+      return { ...state, [action.target]: action.payload };
+    case CLEAR_WRITE:
+      return INITIAL_STATE;
+    default:
+      return state;
+  }
+};

src/reducers/EditTaskReducer.js

+import {
+  CLEAR_WRITE,
+  SELECT_TASK,
+  WRITE_TASK,
+  WRITE_TASK_DEADLINE,
+} from '../actions/types';
+
+const INITIAL_STATE = {};
+
+export default (state = INITIAL_STATE, action) => {
+  switch (action.type) {
+    case SELECT_TASK:
+      return action.payload;
+    case WRITE_TASK:
+      return { ...state, [action.target]: action.payload };
+    case WRITE_TASK_DEADLINE:
+      return { ...state, [action.target]: action.payload };
+    case CLEAR_WRITE:
+      return INITIAL_STATE;
+    default:
+      return state;
+  }
+};

src/reducers/EventReducer.js

+import {
+  ABSENT_CHANGE,
+  ADD_EVENT,
+  CHANGE_NO,
+  CLEAR_WRITE,
+  DELETE_EVENT,
+  GET_EVENTS,
+  GET_EVENT_BY_ID,
+  VISITOR_CHANGE,
+  WRITE_EVENT,
+} from '../actions/types';
+
+const INITIAL_STATE = { events: [], newEvent: {} };
+
+export default (state = INITIAL_STATE, action) => {
+  switch (action.type) {
+    case GET_EVENTS:
+      return { ...state, events: [...action.payload] };
+    case GET_EVENT_BY_ID:
+      return { ...state, selectedEvent: action.payload };
+    case VISITOR_CHANGE:
+      if (state.selectedEvent.visitors.includes(action.payload)) {
+        // Benne van nem kell megváltoztatni
+        return { ...state };
+      }
+      if (state.selectedEvent.absent.indexOf(action.payload) > -1) {
+        // Ha az absentbe van ki kell venni
+        state.selectedEvent.absent.splice(
+          state.selectedEvent.absent.indexOf(action.payload),
+          1
+        );
+      }
+      state.selectedEvent.visitors.push(action.payload);
+      return {
+        ...state,
+        selectedEvent: {
+          ...state.selectedEvent,
+          visitors: state.selectedEvent.visitors,
+          absent: state.selectedEvent.absent,
+        },
+      };
+    case ABSENT_CHANGE:
+      if (state.selectedEvent.absent.includes(action.payload)) {
+        return { ...state };
+      }
+      if (state.selectedEvent.visitors.indexOf(action.payload) > -1) {
+        state.selectedEvent.visitors.splice(
+          state.selectedEvent.visitors.indexOf(action.payload),
+          1
+        );
+      }
+      state.selectedEvent.absent.push(action.payload);
+      return {
+        ...state,
+        selectedEvent: {
+          ...state.selectedEvent,
+          visitors: state.selectedEvent.visitors,
+          absent: state.selectedEvent.absent,
+        },
+      };
+    case CHANGE_NO:
+      if (state.selectedEvent.visitors.indexOf(action.payload) > -1) {
+        state.selectedEvent.visitors.splice(
+          state.selectedEvent.visitors.indexOf(action.payload),
+          1
+        );
+      }
+      if (state.selectedEvent.absent.indexOf(action.payload) > -1) {
+        // Ha az absentbe van ki kell venni
+        state.selectedEvent.absent.splice(
+          state.selectedEvent.absent.indexOf(action.payload),
+          1
+        );
+      }
+      return {
+        ...state,
+        selectedEvent: {
+          ...state.selectedEvent,
+          visitors: state.selectedEvent.visitors,
+          absent: state.selectedEvent.absent,
+        },
+      };
+    case WRITE_EVENT:
+      return {
+        ...state,
+        newEvent: { ...state.newEvent, [action.target]: action.payload },
+      };
+    case ADD_EVENT:
+      return { ...state, events: [...state.events, action.payload] };
+    case DELETE_EVENT:
+      state.events.splice(state.events.indexOf(action.payload), 1);
+      return { ...state, events: [...state.events] };
+    case CLEAR_WRITE:
+      return { ...state, newEvent: {} };
+    default:
+      return state;
+  }
+};

src/reducers/TodoReducer.js → src/reducers/GroupsReducer.js

-import {
-  ADD_TODO,
-} from '../actions/types';
+import { GET_GROUPS } from '../actions/types';
 
-const INITIAL_STATE = {
-  todos: [{ data: 'hello' }],
-};
+const INITIAL_STATE = [];
 
 export default (state = INITIAL_STATE, action) => {
   switch (action.type) {
-    case ADD_TODO:
-      return { todos: [...state.todos, { data: action.payload }] };
+    case GET_GROUPS:
+      return action.payload;
     default:
       return state;
   }

src/reducers/HomeworksReducer.js

+/* eslint-disable no-case-declarations */
+import {
+  ADD_SOLUTION,
+  ADD_TASK,
+  CORRECT_SOLUTION,
+  DELETE_TASK,
+  EDIT_TASK,
+  GET_DOCUMENTS,
+  GET_PROFILES,
+  GET_SOLUTIONS,
+  GET_TASKS,
+} from '../actions/types';
+
+const INITIAL_STATE = {
+  id: 0,
+  tasks: [],
+  solutions: [],
+  profiles: [],
+  documents: [],
+};
+
+export default (state = INITIAL_STATE, action) => {
+  switch (action.type) {
+    case GET_TASKS:
+      return { ...state, tasks: action.payload };
+    case GET_SOLUTIONS:
+      return { ...state, solutions: action.payload };
+    case CORRECT_SOLUTION:
+      const modifiedSolution = state.solutions.find(
+        (sol) => sol.id === action.payload.id
+      );
+      const modifiedSolutions = state.solutions.slice();
+      modifiedSolutions.splice(
+        state.solutions.indexOf(modifiedSolution),
+        1,
+        action.payload
+      );
+      return { ...state, solutions: [...modifiedSolutions] };
+    case ADD_SOLUTION:
+      return {
+        ...state,
+        solutions: [action.payload, ...state.solutions],
+        id: action.payload.id,
+      };
+    case ADD_TASK:
+      return { ...state, tasks: [action.payload, ...state.tasks] };
+    case DELETE_TASK:
+      return {
+        ...state,
+        tasks: [
+          ...state.tasks.slice(0, state.tasks.indexOf(action.payload)),
+          ...state.tasks.slice(state.tasks.indexOf(action.payload) + 1),
+        ],
+      };
+    case EDIT_TASK:
+      return {
+        ...state,
+        tasks: [
+          ...state.tasks.map((task) => {
+            if (task.id !== action.payload.id) {
+              return task;
+            }
+            return action.payload;
+          }),
+        ],
+      };
+    case GET_PROFILES:
+      return { ...state, profiles: action.payload };
+    case GET_DOCUMENTS:
+      return { ...state, documents: action.payload };
+    default:
+      return state;
+  }
+};

src/reducers/ImagesReducer.js

+import { GET_IMAGES } from '../actions/types';
+
+const INITIAL_STATE = [];
+
+export default (state = INITIAL_STATE, action) => {
+  switch (action.type) {
+    case GET_IMAGES:
+      return action.payload;
+    default:
+      return state;
+  }
+};

src/reducers/MentorsReducer.js

+import { GET_MENTORS } from '../actions/types';
+
+const INITIAL_STATE = [];
+
+export default (state = INITIAL_STATE, action) => {
+  switch (action.type) {
+    case GET_MENTORS:
+      return action.payload;
+    default:
+      return state;
+  }
+};

src/reducers/NewsReducer.js

+import { ADD_NEWS, DELETE_NEWS, EDIT_NEWS, GET_NEWS } from '../actions/types';
+
+const INITIAL_STATE = [];
+
+export default (state = INITIAL_STATE, action) => {
+  switch (action.type) {
+    case GET_NEWS:
+      return action.payload;
+    case ADD_NEWS:
+      return [action.payload, ...state];
+    case EDIT_NEWS:
+      const array = state.filter((item) => item.id === action.payload.id);
+      state.splice(state.indexOf(array.pop()), 1, action.payload);
+      return [...state];
+    case DELETE_NEWS:
+      state.splice(state.indexOf(action.payload), 1);
+      return [...state];
+    default:
+      return state;
+  }
+};

src/reducers/NoteReducer.js

+import {
+  ADD_EVENT_NOTE,
+  CLEAR_WRITE,
+  GET_NOTES_BY_EVENT,
+  WRITE_NOTE,
+} from '../actions/types';
+
+const INITIAL_STATE = { eventNotes: [], actualNote: {} };
+
+export default (state = INITIAL_STATE, action) => {
+  switch (action.type) {
+    case GET_NOTES_BY_EVENT:
+      return { ...state, eventNotes: action.payload };
+    case WRITE_NOTE:
+      return {
+        ...state,
+        actualNote: { ...state.actualNote, note: action.payload },
+      };
+    case ADD_EVENT_NOTE:
+      return { ...state, eventNotes: [...state.eventNotes, action.payload] };
+    case CLEAR_WRITE:
+      return { ...state, actualNote: { note: '' } };
+    default:
+      return state;
+  }
+};

src/reducers/TraineeReducer.js

+import {
+  GET_PROFILES,
+  GET_SELECTED_PROFILE,
+  GET_TRAINEES,
+  SET_STATUS,
+} from '../actions/types';
+
+const INITIAL_STATE = { profiles: [], selectedProfile: {} };
+
+export default (state = INITIAL_STATE, action) => {
+  switch (action.type) {
+    case GET_TRAINEES:
+      return { ...state, trainees: [...action.payload] };
+    case GET_PROFILES:
+      return { ...state, profiles: [...action.payload] };
+    case GET_SELECTED_PROFILE:
+      return { ...state, selectedProfile: action.payload };
+    case SET_STATUS:
+      const index = state.profiles.findIndex(
+        (item) => item.id === action.payload.id
+      );
+      state.profiles.splice(index, 1, action.payload);
+      if (action.payload.id === state.selectedProfile.id) {
+        return {
+          ...state,
+          profiles: [...state.profiles],
+          selectedProfile: action.payload,
+        };
+      }
+      return { ...state, profiles: [...state.profiles] };
+    default:
+      return state;
+  }
+};

src/reducers/UserReducer.js

+import {
+  GET_DEADLINE,
+  GET_USERDATA,
+  GROUP_CHANGE,
+  PROFILE_CHANGE,
+} from '../actions/types';
+
+const INITIAL_STATE = {};
+
+export default (state = INITIAL_STATE, action) => {
+  switch (action.type) {
+    case GET_USERDATA:
+      return { ...state, ...action.payload };
+    case GET_DEADLINE:
+      return { ...state, ...action.payload };
+    case PROFILE_CHANGE:
+      return { ...state, [action.target]: action.payload };
+    case GROUP_CHANGE:
+      return { ...state, groups: action.payload };
+    default:
+      return state;
+  }
+};

src/reducers/index.js

+import AddNewsReducer from './AddNewsReducer';
+import AddSolutionReducer from './AddSolutionReducer';
+import AddTaskReducer from './AddTaskReducer';
+import CorrectSolutionReducer from './CorrectSolutionReducer';
+import EditNewsReducer from './EditNewsReducer';
+import EditTaskReducer from './EditTaskReducer';
+import EventReducer from './EventReducer';
+import GroupsReducer from './GroupsReducer';
+import HomeworksReducer from './HomeworksReducer';
+import ImagesReducer from './ImagesReducer';
+import MentorsReducer from './MentorsReducer';
+import NewsReducer from './NewsReducer';
+import NoteReducer from './NoteReducer';
+import TraineeReducer from './TraineeReducer';
+import UserReducer from './UserReducer';
 import { combineReducers } from 'redux';
-import { routerReducer } from 'react-router-redux';
-import TodoReducer from './TodoReducer';
 
 const rootReducer = combineReducers({
-  routing: routerReducer,
-  todos: TodoReducer,
+  user: UserReducer,
+  news: NewsReducer,
+  newNews: AddNewsReducer,
+  selectedNews: EditNewsReducer,
+  homeworks: HomeworksReducer,
+  correction: CorrectSolutionReducer,
+  newTask: AddTaskReducer,
+  selectedTask: EditTaskReducer,
+  newSolution: AddSolutionReducer,
+  events: EventReducer,
+  trainees: TraineeReducer,
+  notes: NoteReducer,
+  groups: GroupsReducer,
+  mentors: MentorsReducer,
+  images: ImagesReducer,
 });
 
 export default rootReducer;

src/registerServiceWorker.js

+/* eslint-disable no-param-reassign */
+/* eslint-disable no-use-before-define */
 // In production, we register a service worker to serve assets from local cache.
 
 // This lets the app load faster on subsequent visits in production, and gives
@@ -46,7 +48,7 @@ export default function register() {
 function registerValidSW(swUrl) {
   navigator.serviceWorker
     .register(swUrl)
-    .then(registration => {
+    .then((registration) => {
       registration.onupdatefound = () => {
         const installingWorker = registration.installing;
         installingWorker.onstatechange = () => {
@@ -67,7 +69,7 @@ function registerValidSW(swUrl) {
         };
       };
     })
-    .catch(error => {
+    .catch((error) => {
       console.error('Error during service worker registration:', error);
     });
 }
@@ -75,14 +77,14 @@ function registerValidSW(swUrl) {
 function checkValidServiceWorker(swUrl) {
   // Check if the service worker can be found. If it can't reload the page.
   fetch(swUrl)
-    .then(response => {
+    .then((response) => {
       // Ensure service worker exists, and that we really are getting a JS file.
       if (
         response.status === 404 ||
         response.headers.get('content-type').indexOf('javascript') === -1
       ) {
         // No service worker found. Probably a different app. Reload the page.
-        navigator.serviceWorker.ready.then(registration => {
+        navigator.serviceWorker.ready.then((registration) => {
           registration.unregister().then(() => {
             window.location.reload();
           });
@@ -101,7 +103,7 @@ function checkValidServiceWorker(swUrl) {
 
 export function unregister() {
   if ('serviceWorker' in navigator) {
-    navigator.serviceWorker.ready.then(registration => {
+    navigator.serviceWorker.ready.then((registration) => {
       registration.unregister();
     });
   }

src/setupProxy.js

+const { createProxyMiddleware } = require("http-proxy-middleware");
+
+module.exports = function (app) {
+  app.use(
+    "/api",
+    createProxyMiddleware({
+      target: "http://localhost:8000",
+      changeOrigin: true,
+    }),
+  );
+  app.use(
+    "/admin",
+    createProxyMiddleware({
+      target: "http://localhost:8000",
+      changeOrigin: true,
+    }),
+  );
+  app.use(
+    "/staticfiles",
+    createProxyMiddleware({
+      target: "http://localhost:8000",
+      changeOrigin: true,
+    }),
+  );
+  app.use(
+    "/mediafiles",
+    createProxyMiddleware({
+      target: "http://localhost:8000",
+      changeOrigin: true,
+    }),
+  );
+  app.use(
+    "/oidc",
+    createProxyMiddleware({
+      target: "http://localhost:8000",
+      changeOrigin: true,
+    }),
+  );
+};