[redux-toolkit] /basis/group 적용

src/_redux/features/basis/group/groupSlice.ts

@@ -0,0 +1,76 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { IGetJoinGroupListRs, initGroup } from './groupState';
+import {
+  createGroupId,
+  getAprvList,
+  getAvailGroupList,
+  getGroupDetail,
+  getGroupList,
+  getJoinGroupList,
+  getMyGroupList,
+  getUserList
+} from './groupThunk';
+
+const groupSlice = createSlice({
+  name: 'groupSlice',
+  initialState: initGroup,
+  reducers: {
+    clientSelectAprvGroup: (state, action) => {
+      const selectData = action.payload;
+      state.aprvSelect = selectData;
+    },
+    clientSelectUserGroup: (state, action) => {
+      const selectData = action.payload;
+      state.userSelect = selectData;
+    }
+  },
+  extraReducers: builder => {
+    builder
+      .addCase(getGroupList.fulfilled, (state, action) => {
+        const { data, count } = action.payload;
+        state.groupList = data;
+        state.groupListCount = count;
+      })
+      .addCase(getAvailGroupList.fulfilled, (state, action) => {
+        const { data, count } = action.payload;
+        state.joinList = data;
+        state.joinListCount = count;
+      })
+      .addCase(getMyGroupList.fulfilled, (state, action) => {
+        const { data, count } = action.payload;
+        state.myList = data;
+        state.myListCount = count;
+      })
+      .addCase(getJoinGroupList.fulfilled, (state, action) => {
+        const { data } = action.payload;
+
+        const agreeList = data.filter((res: IGetJoinGroupListRs) => {
+          if (res.aprvlYn === 'Y') return res;
+        });
+        state.joinList = agreeList;
+        state.joinListCount = agreeList.length;
+      })
+      .addCase(getGroupDetail.fulfilled, (state, action) => {
+        state.groupDetail = action.payload;
+      })
+      .addCase(createGroupId.fulfilled, (state, action) => {
+        state.newGroupId = action.payload;
+      })
+      .addCase(getAprvList.fulfilled, (state, action) => {
+        const { data, count, total } = action.payload;
+        state.aprvList = data;
+        state.count = count;
+        state.total = total;
+      })
+      .addCase(getUserList.fulfilled, (state, action) => {
+        const { data, count, total } = action.payload;
+        state.userList = data;
+        state.count = count;
+        state.total = total;
+      });
+  }
+});
+
+export const { clientSelectAprvGroup, clientSelectUserGroup } =
+  groupSlice.actions;
+export const groupReducer2 = groupSlice.reducer;

src/_redux/features/basis/group/groupState.ts

@@ -0,0 +1,192 @@
+import { ErrorModel } from '@src/modules/models/ComnModel';
+
+export const initGroup: IGroupState = {
+  groupList: undefined,
+  groupListCount: 0,
+
+  myList: undefined,
+  myListCount: 0,
+
+  joinList: undefined,
+  joinListCount: 0,
+
+  aprvList: undefined,
+  aprvCount: 0,
+  aprvSelect: undefined,
+
+  userList: undefined,
+  userCount: 0,
+  userSelect: undefined,
+
+  groupId: '',
+  newGroupId: '',
+
+  groupDetail: undefined,
+
+  searchParams: '',
+  count: 0,
+  total: 0,
+  page: 1,
+  error: undefined
+};
+
+export interface IGroupState {
+  groupList: IGetGroupListRs[] | undefined;
+  groupListCount: number | 0;
+
+  myList: IGetMyGroupListRs[] | undefined;
+  myListCount: number | 0;
+
+  joinList: IGetJoinGroupListRs[] | undefined;
+  joinListCount: number | 0;
+
+  aprvList: IGetApprovalListRs[] | undefined;
+  aprvCount: number | 0;
+  aprvSelect: ISelectGroup | undefined;
+
+  userList: IGetUserListRs[] | undefined;
+  userCount: number | 0;
+  userSelect: ISelectGroup | undefined;
+
+  groupId: string | '';
+  newGroupId: String | '';
+
+  groupDetail: IGroup | undefined;
+
+  searchParams: string | '';
+  count: number | 0;
+  total: number | 0;
+  page: number | 1;
+  error: ErrorModel | undefined;
+}
+
+export interface ISelectGroup {
+  groupId: string;
+  groupNm: string;
+}
+
+export interface IGetGroupListRs {
+  cstmrGroupSno: number;
+  groupId: string;
+  groupNm: string;
+  aprvlYn: string;
+  joinYn: string;
+  groupAuthCd: string;
+  createDt: Date;
+  myGroupAuthCd: string;
+}
+
+export interface IGetAvailGroupListRs {
+  cstmrGroupSno: number;
+  groupId: string;
+  groupNm: string;
+  groupTypeCd: string;
+  cstmrSno: number;
+  aprvlYn: string;
+  joinYn: string;
+  joinDt: Date;
+  aprvlDt: Date;
+  groupAuthCd: string;
+  createDt: Date;
+  updateDt: Date;
+}
+
+export interface IGetMyGroupListRs {
+  groupId: string;
+  groupNm: string;
+  groupTypeCd: string;
+  cstmrSno: number;
+  createDt: Date;
+  updateDt: Date;
+}
+
+export interface IGetJoinGroupListRs {
+  cstmrGroupSno: number;
+  groupId: string;
+  groupNm: string;
+  groupTypeCd: string;
+  cstmrSno: number;
+  aprvlYn: string;
+  joinYn: string;
+  joinDt: Date;
+  aprvlDt: Date;
+  groupAuthCd: string;
+  createDt: Date;
+  updateDt: Date;
+}
+
+export interface IGroup {
+  groupId: string;
+  groupNm: string;
+  groupTypeCd: string;
+  cstmrSno: number;
+  createDt: Date;
+  updateDt: Date;
+}
+
+export interface ICreateGroupRq {
+  groupId: string;
+  groupNm: string;
+  groupTypeCd: string;
+  cstmrSno: string;
+}
+
+export interface IUpdateGroupRq {
+  groupId: string;
+  groupNm: string;
+  groupTypeCd: string;
+}
+
+export interface IJoinGroupRq {
+  cstmrSno: number;
+  groupAuthCd: string;
+  groupId: string;
+}
+
+export interface ILeaveGroupRq {
+  cstmrGroupSno: number;
+  joinYn: string;
+}
+
+export interface IGetApprovalListRs {
+  cstmrGroupSno: number;
+  groupId: string;
+  groupNm: string;
+  groupTypeCd: string;
+  cstmrSno: number;
+  aprvlYn: string;
+  joinYn: string;
+  memberName: string;
+  userId: string;
+  aprvlDt: Date;
+  joinDt: Date;
+  groupAuthCd?: string;
+}
+
+export interface IUpdateApprovalRq {
+  cstmrGroupSno: number;
+  aprvlYn: string;
+  groupAuthCd: string;
+  aprvUserId: string;
+  trmnlId: string;
+}
+
+export interface IGetUserListRs {
+  cstmrGroupSno: number;
+  groupId: string;
+  groupNm: string;
+  groupTypeCd: string;
+  cstmrSno: number;
+  memberName: string;
+  userId: string;
+  aprvlDt: Date;
+  joinDt: Date;
+  joinYn: string;
+  groupAuthCd: string;
+}
+
+export interface IUpdateUserAccessRq {
+  cstmrGroupSno: number;
+  groupAuthCd: string;
+  joinYn: string;
+}

src/_redux/features/basis/group/groupThunk.ts

@@ -0,0 +1,516 @@
+import axios from '../../../../modules/utils/customAxiosUtil';
+import qs from 'qs';
+
+import { createAsyncThunk } from '@reduxjs/toolkit';
+
+import { isError, isMessage } from '../../comn/message/messageSlice';
+import {
+  ERROR_MESSAGE,
+  SAVE_MESSAGE,
+  DELETE_MESSAGE
+} from '@src/configs/constants';
+import {
+  ICreateGroupRq,
+  IJoinGroupRq,
+  ILeaveGroupRq,
+  IUpdateApprovalRq,
+  IUpdateGroupRq,
+  IUpdateUserAccessRq
+} from './groupState';
+
+/**
+ * 나와 관련된 그룹 조회(생성 + 참여)
+ * super, admin은 모든 그룹 조회
+ */
+export const getGroupList = createAsyncThunk(
+  'basis/getGroupList',
+  async (cstmrSno: number, thunkAPI) => {
+    const { rejectWithValue } = thunkAPI;
+
+    try {
+      const res: any = await axios.get(
+        `api/bas/group/grouplist?cstmrSno=${cstmrSno}`
+      );
+      const { data, count } = res;
+
+      return { data, count };
+    } catch (error) {
+      return rejectWithValue(error);
+    }
+  }
+);
+
+// 가입 가능한 그룹 목록 조회
+export const getAvailGroupList = createAsyncThunk(
+  'basis/getAvailGroupList',
+  async (rq: string, thunkAPI) => {
+    const { rejectWithValue } = thunkAPI;
+
+    try {
+      const queryString = qs.stringify(rq, {
+        addQueryPrefix: true,
+        arrayFormat: 'repeat'
+      });
+      const res: any = await axios.get(`api/bas/group/join/list${queryString}`);
+      const { data, count } = res;
+
+      return { data, count };
+    } catch (error) {
+      return rejectWithValue(error);
+    }
+  }
+);
+
+// 생성한 그룹 목록 조회
+export const getMyGroupList = createAsyncThunk(
+  'basis/getMyGroupList',
+  async (cstmrSno: number, thunkAPI) => {
+    const { rejectWithValue } = thunkAPI;
+
+    try {
+      const res: any = await axios.get(
+        `api/bas/group/mylist?cstmrSno=${cstmrSno}`
+      );
+      const { data, count, errorCode } = res;
+
+      if (errorCode) {
+        thunkAPI.dispatch(
+          isError({
+            errorCode: errorCode,
+            errorMessage: '처리중 오류가 발생하였습니다',
+            isHistoryBack: false,
+            isRefresh: false
+          })
+        );
+        throw Error;
+      }
+
+      return {
+        data,
+        count
+      };
+    } catch (error) {
+      return rejectWithValue(error);
+    }
+  }
+);
+
+// 가입한 그룹 목록 조회
+export const getJoinGroupList = createAsyncThunk(
+  'basis/getJoinGroupList',
+  async (cstmrSno: number, thunkAPI) => {
+    const { rejectWithValue } = thunkAPI;
+    try {
+      const res: any = await axios.get(
+        `api/bas/group/joinlist?cstmrSno=${cstmrSno}`
+      );
+      const { data, count, errorCode } = res;
+
+      if (errorCode) {
+        thunkAPI.dispatch(
+          isError({
+            errorCode: errorCode,
+            errorMessage: '처리중 오류가 발생하였습니다',
+            isHistoryBack: false,
+            isRefresh: false
+          })
+        );
+        throw Error;
+      }
+
+      return {
+        data,
+        count
+      };
+    } catch (error) {
+      return rejectWithValue(error);
+    }
+  }
+);
+
+// 그룹 상세 조회
+export const getGroupDetail = createAsyncThunk(
+  'basis/getGroupDetail',
+  async (id: string, thunkAPI) => {
+    const { rejectWithValue } = thunkAPI;
+
+    try {
+      const { data } = await axios.get(`api/bas/group/detail/${id}`);
+      return data;
+    } catch (error) {
+      return rejectWithValue(error);
+    }
+  }
+);
+
+// 그룹 생성
+export const createGroup = createAsyncThunk(
+  'basis/createGroup',
+  async (rq: ICreateGroupRq, thunkAPI) => {
+    const { rejectWithValue } = thunkAPI;
+
+    try {
+      const { data } = await axios.post('api/bas/group/create', rq);
+
+      if (data.result) {
+        thunkAPI.dispatch(
+          isMessage({
+            messageCode: SAVE_MESSAGE.code,
+            message: SAVE_MESSAGE.message,
+            isHistoryBack: true,
+            isRefresh: false
+          })
+        );
+      } else {
+        if (data.errorCode === 'DT002') {
+          thunkAPI.dispatch(
+            isError({
+              errorCode: ERROR_MESSAGE.code,
+              errorMessage: data.errorMessage + ' (그룹명)',
+              isHistoryBack: false,
+              isRefresh: false
+            })
+          );
+        }
+        throw Error;
+      }
+    } catch (error) {
+      thunkAPI.dispatch(
+        isError({
+          errorCode: ERROR_MESSAGE.code,
+          errorMessage: ERROR_MESSAGE.message,
+          isHistoryBack: false,
+          isRefresh: false
+        })
+      );
+      return rejectWithValue(error);
+    }
+  }
+);
+
+// 그룹 수정
+export const updateGroup = createAsyncThunk(
+  'basis/updateGroup',
+  async (rq: IUpdateGroupRq, thunkAPI) => {
+    const { rejectWithValue } = thunkAPI;
+
+    try {
+      const { data } = await axios.put('api/bas/group/update', rq);
+
+      if (data.result) {
+        thunkAPI.dispatch(
+          isMessage({
+            messageCode: SAVE_MESSAGE.code,
+            message: SAVE_MESSAGE.message,
+            isHistoryBack: true,
+            isRefresh: false
+          })
+        );
+      } else {
+        if (data.errorCode === 'DT002') {
+          thunkAPI.dispatch(
+            isError({
+              errorCode: ERROR_MESSAGE.code,
+              errorMessage: data.errorMessage + ' (그룹명)',
+              isHistoryBack: false,
+              isRefresh: false
+            })
+          );
+        }
+        throw Error;
+      }
+    } catch (error) {
+      thunkAPI.dispatch(
+        isError({
+          errorCode: ERROR_MESSAGE.code,
+          errorMessage: ERROR_MESSAGE.message,
+          isHistoryBack: false,
+          isRefresh: false
+        })
+      );
+      return rejectWithValue(error);
+    }
+  }
+);
+
+// 그룹 삭제
+export const deleteGroup = createAsyncThunk(
+  'basis/deleteGroup',
+  async (id: string, thunkAPI) => {
+    const { rejectWithValue } = thunkAPI;
+
+    try {
+      const { data } = await axios.delete(`api/bas/group/delete/${id}`);
+
+      if (data.result) {
+        thunkAPI.dispatch(
+          isMessage({
+            messageCode: DELETE_MESSAGE.code,
+            message: DELETE_MESSAGE.message,
+            isHistoryBack: true,
+            isRefresh: false
+          })
+        );
+      } else {
+        throw Error;
+      }
+    } catch (error) {
+      thunkAPI.dispatch(
+        isError({
+          errorCode: ERROR_MESSAGE.code,
+          errorMessage: ERROR_MESSAGE.message,
+          isHistoryBack: false,
+          isRefresh: false
+        })
+      );
+      return rejectWithValue(error);
+    }
+  }
+);
+
+// 그룹 코드 생성
+export const createGroupId = createAsyncThunk(
+  'basis/createGroupId',
+  async (_, thunkAPI) => {
+    const { rejectWithValue } = thunkAPI;
+    try {
+      const { data } = await axios.get('api/bas/group/createid');
+      return data.result;
+    } catch (error) {
+      return rejectWithValue(error);
+    }
+  }
+);
+
+// 그룹 가입 요청
+export const joinGroup = createAsyncThunk(
+  'basis/joinGroup',
+  async (rq: IJoinGroupRq, thunkAPI) => {
+    const { rejectWithValue } = thunkAPI;
+
+    try {
+      const { data } = await axios.post('api/bas/group/join/create', rq);
+
+      if (data.result) {
+        thunkAPI.dispatch(
+          isMessage({
+            messageCode: SAVE_MESSAGE.code,
+            message: SAVE_MESSAGE.message,
+            isHistoryBack: true,
+            isRefresh: false
+          })
+        );
+      } else {
+        throw Error;
+      }
+    } catch (error) {
+      thunkAPI.dispatch(
+        isError({
+          errorCode: ERROR_MESSAGE.code,
+          errorMessage: ERROR_MESSAGE.message,
+          isHistoryBack: false,
+          isRefresh: false
+        })
+      );
+      return rejectWithValue(error);
+    }
+  }
+);
+
+// 가입한 그룹 상태값 변경
+export const leaveGroup = createAsyncThunk(
+  'basis/leaveGroup',
+  async (rq: ILeaveGroupRq, thunkAPI) => {
+    const { rejectWithValue } = thunkAPI;
+
+    try {
+      const { data } = await axios.put('api/bas/group/join/update', rq);
+
+      if (data.result) {
+        thunkAPI.dispatch(
+          isMessage({
+            messageCode: SAVE_MESSAGE.code,
+            message: SAVE_MESSAGE.message,
+            isHistoryBack: false,
+            isRefresh: true
+          })
+        );
+      } else {
+        throw Error;
+      }
+    } catch (error) {
+      thunkAPI.dispatch(
+        isError({
+          errorCode: ERROR_MESSAGE.code,
+          errorMessage: ERROR_MESSAGE.message,
+          isHistoryBack: false,
+          isRefresh: false
+        })
+      );
+      return rejectWithValue(error);
+    }
+  }
+);
+
+// 승인관리 목록
+export const getAprvList = createAsyncThunk(
+  'basis/getAprvList',
+  async (data: string, thunkAPI) => {
+    const { rejectWithValue } = thunkAPI;
+
+    try {
+      const queryString = qs.stringify(data, {
+        addQueryPrefix: true,
+        arrayFormat: 'repeat'
+      });
+      const res: any = await axios.get(`api/bas/group/aprv/list${queryString}`);
+
+      const {
+        data: { items, total },
+        count
+      } = res;
+
+      return {
+        data: items,
+        count,
+        total
+      };
+    } catch (error) {
+      return rejectWithValue(error);
+    }
+  }
+);
+
+// 승인처리
+export const updateAprv = createAsyncThunk(
+  'basis/updateAprv',
+  async (rq: IUpdateApprovalRq, thunkAPI) => {
+    const { rejectWithValue } = thunkAPI;
+
+    try {
+      const { data } = await axios.put('api/bas/group/aprv/update', rq);
+
+      if (data.result) {
+        thunkAPI.dispatch(
+          isMessage({
+            messageCode: SAVE_MESSAGE.code,
+            message: SAVE_MESSAGE.message,
+            isHistoryBack: false,
+            isRefresh: true
+          })
+        );
+      } else {
+        throw Error;
+      }
+    } catch (error) {
+      thunkAPI.dispatch(
+        isError({
+          errorCode: ERROR_MESSAGE.code,
+          errorMessage: ERROR_MESSAGE.message,
+          isHistoryBack: false,
+          isRefresh: false
+        })
+      );
+      return rejectWithValue(error);
+    }
+  }
+);
+
+// 사용자관리 목록
+export const getUserList = createAsyncThunk(
+  'basis/getUserList',
+  async (rq: string, thunkAPI) => {
+    const { rejectWithValue } = thunkAPI;
+
+    try {
+      const queryString = qs.stringify(rq, {
+        addQueryPrefix: true,
+        arrayFormat: 'repeat'
+      });
+      const res: any = await axios.get(`api/bas/group/user/list${queryString}`);
+
+      const {
+        data: { items, total },
+        count
+      } = res;
+
+      return {
+        data: items,
+        count,
+        total
+      };
+    } catch (error) {
+      return rejectWithValue(error);
+    }
+  }
+);
+
+// 사용자 권한 수정
+export const updateUserAccess = createAsyncThunk(
+  'basis/updateUserAccess',
+  async (rq: IUpdateUserAccessRq, thunkAPI) => {
+    const { rejectWithValue } = thunkAPI;
+
+    try {
+      const { data } = await axios.put('api/bas/group/user/update', rq);
+
+      if (data.result) {
+        thunkAPI.dispatch(
+          isMessage({
+            messageCode: SAVE_MESSAGE.code,
+            message: SAVE_MESSAGE.message,
+            isHistoryBack: false,
+            isRefresh: true
+          })
+        );
+      } else {
+        throw Error;
+      }
+    } catch (error) {
+      thunkAPI.dispatch(
+        isError({
+          errorCode: ERROR_MESSAGE.code,
+          errorMessage: ERROR_MESSAGE.message,
+          isHistoryBack: false,
+          isRefresh: false
+        })
+      );
+      return rejectWithValue(error);
+    }
+  }
+);
+
+// master 권한 위임
+export const delegateUser = createAsyncThunk(
+  'basis/delegateUser',
+  async (rq: IUpdateUserAccessRq[], thunkAPI) => {
+    const { rejectWithValue } = thunkAPI;
+
+    try {
+      const { data } = await axios.put('api/bas/group/user/delegate', rq);
+
+      if (data.result) {
+        thunkAPI.dispatch(
+          isMessage({
+            messageCode: SAVE_MESSAGE.code,
+            message: SAVE_MESSAGE.message,
+            isHistoryBack: false,
+            isRefresh: true
+          })
+        );
+      } else {
+        throw Error;
+      }
+    } catch (error) {
+      thunkAPI.dispatch(
+        isError({
+          errorCode: ERROR_MESSAGE.code,
+          errorMessage: ERROR_MESSAGE.message,
+          isHistoryBack: false,
+          isRefresh: false
+        })
+      );
+      return rejectWithValue(error);
+    }
+  }
+);

src/_redux/rootReducer.ts

@@ -6,6 +6,7 @@ import { laancReducer } from './features/laanc/laancSlice';
 import { messageReducer2 } from './features/comn/message/messageSlice';
 import { historyReducer } from './features/analysis/history/historySlice';
 import { faqReducer } from './features/customerService/faq/faqSlice';
+import { groupReducer2 } from './features/basis/group/groupSlice';
 
 const rootReducer = (state: any, action: any) => {
   const combineReducer = combineReducers({
@@ -15,7 +16,8 @@ const rootReducer = (state: any, action: any) => {
     laanc: laancReducer,
     message: messageReducer2,
     history: historyReducer,
-    faq: faqReducer
+    faq: faqReducer,
+    group: groupReducer2
   });
 
   return combineReducer(state, action);

src/components/map/mapbox/dron/DronMarker.js

@@ -1,3 +1,7 @@
+import {
+  useDispatch as useDispatch2,
+  useSelector as useSelector2
+} from '@src/redux/storeConfig/store';
 import { useEffect, useState } from 'react';
 import { useDispatch, useSelector, shallowEqual } from 'react-redux';
 import '../../../../assets/css/custom.css';
@@ -15,10 +19,12 @@ import {
   objectClickAction,
   objectUnClickAction
 } from '../../../../modules/control/map/actions/controlMapActions';
-import { getJoinGroupList } from '../../../../modules/basis/group/actions';
+import { getJoinGroupList } from '@src/_redux/features/basis/group/groupThunk';
+// import { getJoinGroupList } from '../../../../modules/basis/group/actions';
 
 export const DronMarker = props => {
-  const dispatch = useDispatch();
+  const originDispatch = useDispatch();
+  const dispatch = useDispatch2();
 
   const { controlGpList, controlGroupAuthInfo } = useSelector(
     state => state.controlGpState
@@ -36,7 +42,7 @@ export const DronMarker = props => {
   const { user } = useSelector(state => state.authState);
 
   // 유저가 가입한 그룹 목록
-  const { joinList } = useSelector(state => state.groupState);
+  const { joinList } = useSelector2(state => state.groupState2);
 
   // 마커, 데이터 블록 배열
   const [arrMarkers, setArrMarkers] = useState([]);
@@ -50,17 +56,18 @@ export const DronMarker = props => {
 
   // 유저가 속한 그룹 리스트 알아냄
   useEffect(() => {
-    dispatch(
-      getJoinGroupList.request({
-        cstmrSno: user?.cstmrSno
-      })
-    );
+    // originDispatch(
+    //   getJoinGroupList.request({
+    //     cstmrSno: user?.cstmrSno
+    //   })
+    // );
+    dispatch(getJoinGroupList(user?.cstmrSno));
   }, []);
 
   // 비행 기체 개수 계산
   useEffect(() => {
     if (count.drone.length > 0 || count.flight.length > 0) {
-      dispatch(
+      originDispatch(
         controlGpCountAction.request({
           count
         })
@@ -70,7 +77,7 @@ export const DronMarker = props => {
         drone: [],
         flight: []
       };
-      dispatch(
+      originDispatch(
         controlGpCountAction.request({
           count
         })
@@ -202,8 +209,8 @@ export const DronMarker = props => {
     marker.gps = gps;
     marker.position = position;
 
-    dispatch(controlGpFlightPlanAction.request(marker.id)); //예상경로
-    // dispatch(controlGpHisAction.request({ id: marker.controlId })); //진행경로;
+    originDispatch(controlGpFlightPlanAction.request(marker.id)); //예상경로
+    // originDispatch(controlGpHisAction.request({ id: marker.controlId })); //진행경로;
 
     /** drone 상세보기 */
     marker.getElement().addEventListener('click', function (e) {
@@ -217,8 +224,8 @@ export const DronMarker = props => {
 
   // 마커 클릭 시 드론 상세 정보 표출
   const handlerDronClick = marker => {
-    dispatch(objectClickAction(marker.controlId));
-    dispatch(controlGpDtlAction.request(marker.controlId));
+    originDispatch(objectClickAction(marker.controlId));
+    originDispatch(controlGpDtlAction.request(marker.controlId));
   };
 
   //마커 삭제
@@ -306,7 +313,7 @@ export const DronMarker = props => {
 
           removeArrMarkers(arrData);
           if (marker.controlId === objectId) {
-            dispatch(objectUnClickAction());
+            originDispatch(objectUnClickAction());
           }
         }
       });

src/containers/basis/BasisContainer.js

@@ -1,4 +1,5 @@
 import { CustomMainLayout } from '../../components/layout/CustomMainLayout';
+import { useSelector as useSelector2 } from '@src/redux/storeConfig/store';
 import { shallowEqual, useSelector } from 'react-redux';
 import { BasisGroupGrid } from '../../components/basis/BasisGroupGrid';
 import { Fragment } from 'react';
@@ -12,7 +13,7 @@ export const BasisContainer = props => {
     joinListCount, // 참여그룹목록 수
     groupList, // 전체그룹목록
     groupListCount // 전체그룹목록 수
-  } = useSelector(state => state.groupState);
+  } = useSelector2(state => state.groupState2);
 
   return (
     <CustomMainLayout title={props.titleName}>

src/containers/basis/dron/BasisDronContainer.js

@@ -1,7 +1,7 @@
 import { useEffect, useState } from 'react';
-import { shallowEqual, useDispatch, useSelector } from 'react-redux';
+import { shallowEqual, useSelector } from 'react-redux';
 import {
-  useDispatch as useDispatch2,
+  useDispatch,
   useSelector as useSelector2
 } from '@src/redux/storeConfig/store';
 import { useHistory, Link } from 'react-router-dom';
@@ -17,10 +17,13 @@ import {
   clientResetIdntf,
   clientSelectGroup
 } from '@src/_redux/features/basis/drone/droneSlice';
+import {
+  getGroupList,
+  getJoinGroupList
+} from '@src/_redux/features/basis/group/groupThunk';
 
 export const BasisDronContainer = props => {
-  const originDispatch = useDispatch();
-  const dispatch = useDispatch2();
+  const dispatch = useDispatch();
 
   const history = useHistory();
 
@@ -172,15 +175,17 @@ export const BasisDronContainer = props => {
         cstmrSno: user?.cstmrSno
       });
       if (user.authId === 'SUPER' || user.authId === 'ADMIN') {
-        originDispatch(
-          GroupActions.getGroupList.request({ cstmrSno: user?.cstmrSno })
-        );
+        // originDispatch(
+        //   GroupActions.getGroupList.request({ cstmrSno: user?.cstmrSno })
+        // );
+        dispatch(getGroupList(user?.cstmrSno));
       } else {
-        originDispatch(
-          GroupActions.getJoinGroupList.request({
-            cstmrSno: user?.cstmrSno
-          })
-        );
+        // originDispatch(
+        //   GroupActions.getJoinGroupList.request({
+        //     cstmrSno: user?.cstmrSno
+        //   })
+        // );
+        dispatch(getJoinGroupList(user?.cstmrSno));
       }
     }
   }, [user]);

src/containers/basis/group/BasisGroupApprovalContainer.js

@@ -1,5 +1,9 @@
+import {
+  useDispatch,
+  useSelector as useSelector2
+} from '@src/redux/storeConfig/store';
 import { useEffect, useState } from 'react';
-import { useDispatch, useSelector } from 'react-redux';
+import { useSelector } from 'react-redux';
 import { Button } from '@component/ui';
 import { BasisGroupApprovalSearch } from '../../../components/basis/group/BasisGroupApprovalSearch';
 import { ConfirmModal } from '../../../components/modal/ConfirmModal';
@@ -7,6 +11,13 @@ import * as Actions from '../../../modules/basis/group/actions';
 import InfoModal from '../../../components/modal/InfoModal';
 import { BasisContainer } from '../BasisContainer';
 import { BasisDataGrid } from '../../../components/basis/BasisDataGrid';
+import {
+  getAprvList,
+  getGroupList,
+  getJoinGroupList,
+  updateAprv
+} from '@src/_redux/features/basis/group/groupThunk';
+import { clientSelectAprvGroup } from '@src/_redux/features/basis/group/groupSlice';
 
 export const BasisGroupApprovalContainer = props => {
   const dispatch = useDispatch();
@@ -31,7 +42,7 @@ export const BasisGroupApprovalContainer = props => {
     // selectData,
     aprvSelect, // 상세보기한 그룹
     total // 목록에 표출되는 사용자 수
-  } = useSelector(state => state.groupState);
+  } = useSelector2(state => state.groupState2);
 
   // 승인요청 초기 데이터
   const [saveData, setSaveData] = useState({
@@ -239,15 +250,17 @@ export const BasisGroupApprovalContainer = props => {
         aprvYn: ''
       });
       if (user.authId === 'SUPER' || user.authId === 'ADMIN') {
-        dispatch(Actions.getGroupList.request({ cstmrSno: user?.cstmrSno }));
+        // originDispatch(Actions.getGroupList.request({ cstmrSno: user?.cstmrSno }));
+        dispatch(getGroupList(user?.cstmrSno));
       } else {
-        dispatch(
-          Actions.getJoinGroupList.request({
-            cstmrSno: user?.cstmrSno,
-            // groupId: selectData?.groupId
-            groupId: aprvSelect?.groupId
-          })
-        );
+        // originDispatch(
+        //   Actions.getJoinGroupList.request({
+        //     cstmrSno: user?.cstmrSno,
+        //     // groupId: selectData?.groupId
+        //     groupId: aprvSelect?.groupId
+        //   })
+        // );
+        dispatch(getJoinGroupList(user?.cstmrSno));
       }
     }
   }, [user]);
@@ -262,10 +275,10 @@ export const BasisGroupApprovalContainer = props => {
       (user.authId === 'USER' && groupAuthCd === 'MASTER') ||
       (user.authId === 'USER' && aprvlYn === 'Y' && groupAuthCd === 'LEADER')
     ) {
-      // dispatch(Actions.SELECT({ groupId: groupId, groupNm: groupNm }));
-      dispatch(
-        Actions.clientSelectAprvGroup({ groupId: groupId, groupNm: groupNm })
-      );
+      // originDispatch(
+      //   Actions.clientSelectAprvGroup({ groupId: groupId, groupNm: groupNm })
+      // );
+      dispatch(clientSelectAprvGroup({ groupId: groupId, groupNm: groupNm }));
 
       if (user?.cstmrSno) {
         setParams({
@@ -274,14 +287,22 @@ export const BasisGroupApprovalContainer = props => {
           groupId: groupId
         });
 
+        // originDispatch(
+        //   Actions.getApprovalList.request({
+        //     searchParams: {
+        //       ...params,
+        //       cstmrSno: user?.cstmrSno,
+        //       groupId: groupId,
+        //       page: 1
+        //     }
+        //   })
+        // );
         dispatch(
-          Actions.getApprovalList.request({
-            searchParams: {
-              ...params,
-              cstmrSno: user?.cstmrSno,
-              groupId: groupId,
-              page: 1
-            }
+          getAprvList({
+            ...params,
+            cstmrSno: user?.cstmrSno,
+            groupId: groupId,
+            page: 1
           })
         );
       }
@@ -297,8 +318,8 @@ export const BasisGroupApprovalContainer = props => {
 
   // 상세보기 선택취소 시
   const handlerCancel = () => {
-    // dispatch(Actions.SELECT());
-    dispatch(Actions.clientSelectAprvGroup());
+    // originDispatch(Actions.clientSelectAprvGroup());
+    dispatch(clientSelectAprvGroup());
 
     setParams({
       ...params,
@@ -318,14 +339,16 @@ export const BasisGroupApprovalContainer = props => {
   const handlerSearch = () => {
     const param = params;
     param.page = 1;
-    dispatch(Actions.getApprovalList.request({ searchParams: param }));
+    // originDispatch(Actions.getApprovalList.request({ searchParams: param }));
+    dispatch(getAprvList(param));
   };
 
   // 승인관리 페이지 이동 시 새 목록 요청
   const onChangePage = page => {
     const param = params;
     param.page = page;
-    dispatch(Actions.getApprovalList.request({ searchParams: param }));
+    // originDispatch(Actions.getApprovalList.request({ searchParams: param }));
+    dispatch(getAprvList(param));
   };
 
   // 사용자 승인처리
@@ -347,7 +370,8 @@ export const BasisGroupApprovalContainer = props => {
 
   // 사용자 승인처리 요청
   const handlerAprvSave = () => {
-    dispatch(Actions.updateApproval.request(saveData));
+    // originDispatch(Actions.updateApproval.request(saveData));
+    dispatch(updateAprv(saveData));
   };
 
   // 사용자 승인취소

src/containers/basis/group/BasisGroupContainer.js

@@ -1,11 +1,20 @@
+import {
+  useDispatch,
+  useSelector as useSelector2
+} from '@src/redux/storeConfig/store';
 import { useEffect, useState } from 'react';
-import { useDispatch, useSelector } from 'react-redux';
+import { useSelector } from 'react-redux';
 import { Link, useHistory } from 'react-router-dom';
 import { Button } from '@component/ui';
 import { CustomMainLayout } from '../../../components/layout/CustomMainLayout';
 import { ConfirmModal } from '../../../components/modal/ConfirmModal';
 import * as Actions from '../../../modules/basis/group/actions';
 import { BasisGroupGrid } from '../../../components/basis/BasisGroupGrid';
+import {
+  getJoinGroupList,
+  getMyGroupList,
+  leaveGroup
+} from '@src/_redux/features/basis/group/groupThunk';
 
 export const BasisGroupContainer = props => {
   const dispatch = useDispatch();
@@ -14,8 +23,8 @@ export const BasisGroupContainer = props => {
   const [saveParams, setSaveParams] = useState({});
 
   // 나의그룹목록, 가입그룹목록
-  const { myList, myListCount, joinList, joinListCount } = useSelector(
-    state => state.groupState
+  const { myList, myListCount, joinList, joinListCount } = useSelector2(
+    state => state.groupState2
   );
 
   // 유저 정보
@@ -158,8 +167,10 @@ export const BasisGroupContainer = props => {
   // 그룹목록, 참여그룹목록 요청
   const handlerSearch = () => {
     if (user?.cstmrSno) {
-      dispatch(Actions.getMyGroupList.request({ cstmrSno: user?.cstmrSno }));
-      dispatch(Actions.getJoinGroupList.request({ cstmrSno: user?.cstmrSno }));
+      // originDispatch(Actions.getMyGroupList.request({ cstmrSno: user?.cstmrSno }));
+      // originDispatch(Actions.getJoinGroupList.request({ cstmrSno: user?.cstmrSno }));
+      dispatch(getMyGroupList(user?.cstmrSno));
+      dispatch(getJoinGroupList(user?.cstmrSno));
     }
   };
 
@@ -184,7 +195,8 @@ export const BasisGroupContainer = props => {
 
   // 그룹 탈퇴 확인
   const handlerWithDrawalConfirm = () => {
-    dispatch(Actions.leaveGroup.request(saveParams));
+    // originDispatch(Actions.leaveGroup.request(saveParams));
+    dispatch(leaveGroup(saveParams));
   };
 
   // 그룹 가입 페이지로 이동

src/containers/basis/group/BasisGroupDetailContainer.js

@@ -1,10 +1,21 @@
+import {
+  useDispatch,
+  useSelector as useSelector2
+} from '@src/redux/storeConfig/store';
 import { useEffect, useState } from 'react';
-import { useDispatch, useSelector } from 'react-redux';
+import { useSelector } from 'react-redux';
 import { useParams } from 'react-router-dom';
 import { BasisGroupForm } from '../../../components/basis/group/BaisGroupForm';
 import { CustomDetailLayout } from '../../../components/layout/CustomDetailLayout';
 import { ConfirmModal } from '../../../components/modal/ConfirmModal';
 import * as Actions from '../../../modules/basis/group/actions';
+import {
+  createGroup,
+  createGroupId,
+  deleteGroup,
+  getGroupDetail,
+  updateGroup
+} from '@src/_redux/features/basis/group/groupThunk';
 
 export const BasisGroupDetailContainer = () => {
   const dispatch = useDispatch();
@@ -12,7 +23,7 @@ export const BasisGroupDetailContainer = () => {
   const titleName = '그룹 관리';
 
   // 그룹 상세정보, 그룹 랜덤 ID
-  const { groupDetail, newGroupId } = useSelector(state => state.groupState);
+  const { groupDetail, newGroupId } = useSelector2(state => state.groupState2);
 
   // 유저 정보
   const { user } = useSelector(state => state.authState);
@@ -63,12 +74,14 @@ export const BasisGroupDetailContainer = () => {
 
   // 그룹 랜덤 ID 생성 요청
   const handlerCreateId = () => {
-    dispatch(Actions.createGroupId.request());
+    // originDispatch(Actions.createGroupId.request());
+    dispatch(createGroupId());
   };
 
   // 그룹 상세정보 요청
   const handlerSearch = () => {
-    dispatch(Actions.getGroupDetail.request(id));
+    // originDispatch(Actions.getGroupDetail.request(id));
+    dispatch(getGroupDetail(id));
   };
 
   // 그룹 생성
@@ -83,8 +96,9 @@ export const BasisGroupDetailContainer = () => {
       type: groupData.type,
       updateDt: ''
     };
-    // dispatch(Actions.createGroup.request(groupData));
-    dispatch(Actions.createGroup.request(saveData));
+    // // originDispatch(Actions.createGroup.request(groupData));
+    // originDispatch(Actions.createGroup.request(saveData));
+    dispatch(createGroup(saveData));
   };
 
   // 그룹 수정
@@ -98,13 +112,15 @@ export const BasisGroupDetailContainer = () => {
       type: groupData.type,
       updateDt: groupData.updateDt
     };
-    // dispatch(Actions.updateGroup.request(groupData));
-    dispatch(Actions.updateGroup.request(saveData));
+    // // originDispatch(Actions.updateGroup.request(groupData));
+    // originDispatch(Actions.updateGroup.request(saveData));
+    dispatch(updateGroup(saveData));
   };
 
   // 그룹 삭제
   const handlerDelete = () => {
-    dispatch(Actions.deleteGroup.request(groupData.groupId));
+    // originDispatch(Actions.deleteGroup.request(groupData.groupId));
+    dispatch(deleteGroup(groupData.groupId));
   };
 
   // 삭제 버튼 클릭시 모달 표출

src/containers/basis/group/BasisGroupDetailJoinContainer.js

@@ -1,11 +1,19 @@
+import {
+  useDispatch,
+  useSelector as useSelector2
+} from '@src/redux/storeConfig/store';
 import { useEffect, useState } from 'react';
-import { useDispatch, useSelector } from 'react-redux';
+import { useSelector } from 'react-redux';
 import { Button } from '@component/ui';
 import { BasisGroupDetailJoinSearch } from '../../../components/basis/group/BasisGroupDetailJoinSearch';
 import { CustomDetailLayout } from '../../../components/layout/CustomDetailLayout';
 import { ConfirmModal } from '../../../components/modal/ConfirmModal';
 import * as Actions from '../../../modules/basis/group/actions';
 import { BasisGroupGrid } from '../../../components/basis/BasisGroupGrid';
+import {
+  getAvailGroupList,
+  joinGroup
+} from '@src/_redux/features/basis/group/groupThunk';
 
 export const BasisGroupDetailJoinContainer = props => {
   const dispatch = useDispatch();
@@ -15,7 +23,7 @@ export const BasisGroupDetailJoinContainer = props => {
   const { user } = useSelector(state => state.authState);
 
   // 그룹가입목록, 그룹가입목록 수
-  const { joinList, joinListCount } = useSelector(state => state.groupState);
+  const { joinList, joinListCount } = useSelector2(state => state.groupState2);
 
   // 검색 조건 초기값
   const [params, setParams] = useState({
@@ -131,11 +139,12 @@ export const BasisGroupDetailJoinContainer = props => {
   // 그룹가입목록 요청
   useEffect(() => {
     if (params.cstmrSno && user?.cstmrSno) {
-      dispatch(
-        Actions.getAvailGroupList.request({
-          searchParams: { cstmrSno: user?.cstmrSno }
-        })
-      );
+      // originDispatch(
+      //   Actions.getAvailGroupList.request({
+      //     searchParams: { cstmrSno: user?.cstmrSno }
+      //   })
+      // );
+      dispatch(getAvailGroupList({ cstmrSno: user?.cstmrSno }));
     }
   }, [user]);
 
@@ -148,7 +157,8 @@ export const BasisGroupDetailJoinContainer = props => {
 
   // 그룹 검색 핸들러
   const handlerSearch = () => {
-    dispatch(Actions.getAvailGroupList.request({ searchParams: params }));
+    // originDispatch(Actions.getAvailGroupList.request({ searchParams: params }));
+    dispatch(getAvailGroupList(params));
   };
 
   // 가입 버튼 클릭시 모달 표출
@@ -168,7 +178,8 @@ export const BasisGroupDetailJoinContainer = props => {
 
   // 그룹 가입
   const handlerConfirm = () => {
-    dispatch(Actions.joinGroup.request(joinData));
+    // originDispatch(Actions.joinGroup.request(joinData));
+    dispatch(joinGroup(joinData));
   };
 
   // 검색조건 입력

src/containers/basis/group/BasisGroupUsersContainer.js

@@ -1,11 +1,23 @@
+import {
+  useDispatch,
+  useSelector as useSelector2
+} from '@src/redux/storeConfig/store';
 import { useEffect, useState } from 'react';
-import { useDispatch, useSelector } from 'react-redux';
+import { useSelector } from 'react-redux';
 import { Button } from '@component/ui';
 import { BasisGroupUsersSearch } from '../../../components/basis/group/BasisGroupUsersSearch';
 import { ConfirmModal } from '../../../components/modal/ConfirmModal';
 import * as Actions from '../../../modules/basis/group/actions';
 import { BasisContainer } from '../BasisContainer';
 import { BasisDataGrid } from '../../../components/basis/BasisDataGrid';
+import {
+  delegateUser,
+  getGroupList,
+  getJoinGroupList,
+  getUserList,
+  updateUserAccess
+} from '@src/_redux/features/basis/group/groupThunk';
+import { clientSelectUserGroup } from '@src/_redux/features/basis/group/groupSlice';
 
 export const BasisGroupUsersContainer = props => {
   const dispatch = useDispatch();
@@ -20,7 +32,7 @@ export const BasisGroupUsersContainer = props => {
     userList, // 선택한 그룹의 사용자목록
     total, // 선택한 그룹의 사용자목록 수
     count
-  } = useSelector(state => state.groupState);
+  } = useSelector2(state => state.groupState2);
 
   // 유저 정보
   const { user } = useSelector(state => state.authState);
@@ -310,15 +322,17 @@ export const BasisGroupUsersContainer = props => {
         cstmrSno: user?.cstmrSno
       });
       if (user.authId === 'SUPER' || user.authId === 'ADMIN') {
-        dispatch(Actions.getGroupList.request({ cstmrSno: user?.cstmrSno }));
+        // originDispatch(Actions.getGroupList.request({ cstmrSno: user?.cstmrSno }));
+        dispatch(getGroupList(user?.cstmrSno));
       } else {
-        dispatch(
-          Actions.getJoinGroupList.request({
-            cstmrSno: user.cstmrSno,
-            // groupId: selectData?.groupId
-            groupId: userSelect?.groupId
-          })
-        );
+        // originDispatch(
+        //   Actions.getJoinGroupList.request({
+        //     cstmrSno: user.cstmrSno,
+        //     // groupId: selectData?.groupId
+        //     groupId: userSelect?.groupId
+        //   })
+        // );
+        dispatch(getJoinGroupList(user?.cstmrSno));
       }
     }
   }, [user]);
@@ -328,12 +342,13 @@ export const BasisGroupUsersContainer = props => {
    */
   const handlerSearch = () => {
     if (params.cstmrSno && user?.cstmrSno) {
-      dispatch(
-        Actions.getUserList.request({
-          searchParams: params,
-          cstmrSno: user?.cstmrSno
-        })
-      );
+      // originDispatch(
+      //   Actions.getUserList.request({
+      //     searchParams: params,
+      //     cstmrSno: user?.cstmrSno
+      //   })
+      // );
+      dispatch(getUserList(params));
     }
   };
 
@@ -344,27 +359,29 @@ export const BasisGroupUsersContainer = props => {
    */
   const handlerDetail = (groupId, groupNm) => {
     //권한 상관없이 조회 가능
-    dispatch(
-      Actions.clientSelectUserGroup({ groupId: groupId, groupNm, groupNm })
-    );
+    // originDispatch(
+    //   Actions.clientSelectUserGroup({ groupId: groupId, groupNm, groupNm })
+    // );
+    dispatch(clientSelectUserGroup({ groupId, groupNm }));
     const param = params;
     param.groupId = groupId;
     param.memberNm = '';
     param.page = 1;
 
-    dispatch(
-      Actions.getUserList.request({
-        searchParams: param
-      })
-    );
+    // originDispatch(
+    //   Actions.getUserList.request({
+    //     searchParams: param
+    //   })
+    // );
+    dispatch(getUserList(params));
   };
 
   /**
    * 상세보기 선택취소
    */
   const handlerCancel = () => {
-    // dispatch(Actions.SELECT());
-    dispatch(Actions.clientSelectUserGroup());
+    // originDispatch(Actions.clientSelectUserGroup());
+    dispatch(clientSelectUserGroup());
     setParams({
       ...params,
       groupId: '',
@@ -465,9 +482,11 @@ export const BasisGroupUsersContainer = props => {
    */
   const handlerAuthSave = async () => {
     if (saveData.length === 2) {
-      dispatch(Actions.delegateUser.request(saveData));
+      // originDispatch(Actions.delegateUser.request(saveData));
+      dispatch(delegateUser(saveData));
     } else {
-      dispatch(Actions.updateUserAccess.request(saveData));
+      // originDispatch(Actions.updateUserAccess.request(saveData));
+      dispatch(updateUserAccess(saveData));
     }
   };
 
@@ -498,7 +517,8 @@ export const BasisGroupUsersContainer = props => {
   const handlerPageChange = page => {
     const param = params;
     param.page = page;
-    dispatch(Actions.getUserList.request({ searchParams: param }));
+    // originDispatch(Actions.getUserList.request({ searchParams: param }));
+    dispatch(getUserList(params));
   };
 
   return (

src/modules/basis/group/reducers/index.ts

@@ -7,6 +7,20 @@ import { IGroupState, initGroup } from '../models';
 export const groupReducer = createReducer<IGroupState, Actions.GroupAction>(
   initGroup
 )
+  .handleAction(Actions.getGroupList.success, (state, action) =>
+    produce(state, draft => {
+      const { data, count } = action.payload;
+      draft.groupList = data;
+      draft.groupListCount = count;
+    })
+  )
+  .handleAction(Actions.getAvailGroupList.success, (state, action) =>
+    produce(state, draft => {
+      const { data, count } = action.payload;
+      draft.joinList = data;
+      draft.joinListCount = count;
+    })
+  )
   .handleAction(Actions.getMyGroupList.success, (state, action) =>
     produce(state, draft => {
       const { data, count } = action.payload;
@@ -27,32 +41,19 @@ export const groupReducer = createReducer<IGroupState, Actions.GroupAction>(
       draft.joinListCount = agreeList.length;
     })
   )
-  .handleAction(Actions.createGroupId.success, (state, action) =>
-    produce(state, draft => {
-      const result = action.payload;
-      draft.newGroupId = result;
-    })
-  )
   .handleAction(Actions.getGroupDetail.success, (state, action) =>
     produce(state, draft => {
       const data = action.payload;
       draft.groupDetail = data;
     })
   )
-  .handleAction(Actions.getGroupList.success, (state, action) =>
-    produce(state, draft => {
-      const { data, count } = action.payload;
-      draft.groupList = data;
-      draft.groupListCount = count;
-    })
-  )
-  .handleAction(Actions.getAvailGroupList.success, (state, action) =>
+  .handleAction(Actions.createGroupId.success, (state, action) =>
     produce(state, draft => {
-      const { data, count } = action.payload;
-      draft.joinList = data;
-      draft.joinListCount = count;
+      const result = action.payload;
+      draft.newGroupId = result;
     })
   )
+
   .handleAction(Actions.getApprovalList.success, (state, action) =>
     produce(state, draft => {
       const { data, count, total } = action.payload;

src/redux/reducers/rootReducer.ts

@@ -44,6 +44,7 @@ import { historyReducer } from '@src/_redux/features/analysis/history/historySli
 import { messageReducer2 } from '../../_redux/features/comn/message/messageSlice';
 import { dashboardReducer } from '../../_redux/features/dashboard/dashboardSlice';
 import { faqReducer } from '../../_redux/features/customerService/faq/faqSlice';
+import { groupReducer2 } from '@src/_redux/features/basis/group/groupSlice';
 
 export function* saga() {
   yield all([fork(controlGpSaga)]);
@@ -88,7 +89,8 @@ const rootReducer = combineReducers({
   droneState: droneReducer,
   layoutState: layoutReducer,
   messageState2: messageReducer2,
-  faqState: faqReducer
+  faqState: faqReducer,
+  groupState2: groupReducer2
 });
 
 export default rootReducer;