feat(export): MIN-162 select annotation

src/models/fixtures/statisticsFixture.ts

+import { ZOD_SEED } from '@/constants';
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { createFixture } from 'zod-fixture';
+import { statisticsSchema } from '../statisticsSchema';
+
+export const statisticsFixture = createFixture(statisticsSchema, {
+  seed: ZOD_SEED,
+});

src/models/statisticsSchema.ts

+import { z } from 'zod';
+
+export const statisticsSchema = z.object({
+  elementAnnotations: z.record(z.string(), z.number()),
+  publications: z.number(),
+  reactionAnnotations: z.record(z.string(), z.number()),
+});

src/redux/apiPath.ts

@@ -34,4 +34,5 @@ export const apiPath = {
   getConfigurationOptions: (): string => 'configuration/options/',
   getOverlayBioEntity: ({ overlayId, modelId }: { overlayId: number; modelId: number }): string =>
     `projects/${PROJECT_ID}/overlays/${overlayId}/models/${modelId}/bioEntities/`,
+  getStatisticsById: (projectId: string): string => `projects/${projectId}/statistics/`,
 };

src/redux/drawer/drawerFixture.ts

@@ -69,3 +69,17 @@ export const drawerSearchChemicalsStepTwoFixture: DrawerState = {
   reactionDrawerState: {},
   bioEntityDrawerState: {},
 };
+
+export const openedExportDrawerFixture: DrawerState = {
+  isOpen: true,
+  drawerName: 'export',
+  searchDrawerState: {
+    currentStep: 0,
+    stepType: 'none',
+    selectedValue: undefined,
+    listOfBioEnitites: [],
+    selectedSearchElement: '',
+  },
+  reactionDrawerState: {},
+  bioEntityDrawerState: {},
+};

src/redux/root/init.thunks.ts

@@ -18,6 +18,7 @@ import { getSearchData } from '../search/search.thunks';
 import { setPerfectMatch } from '../search/search.slice';
 import { getSessionValid } from '../user/user.thunks';
 import { getConfigurationOptions } from '../configuration/configuration.thunks';
+import { getStatisticsById } from '../statistics/statistics.thunks';
 
 interface InitializeAppParams {
   queryData: QueryData;
@@ -48,6 +49,9 @@ export const fetchInitialAppData = createAsyncThunk<
   // Check if auth token is valid
   dispatch(getSessionValid());
 
+  // Fetch data needed for export
+  dispatch(getStatisticsById(PROJECT_ID));
+
   /** Trigger search */
   if (queryData.searchValue) {
     dispatch(setPerfectMatch(queryData.perfectMatch));

src/redux/root/root.fixtures.ts

@@ -16,6 +16,7 @@ import { REACTIONS_STATE_INITIAL_MOCK } from '../reactions/reactions.mock';
 import { SEARCH_STATE_INITIAL_MOCK } from '../search/search.mock';
 import { RootState } from '../store';
 import { USER_INITIAL_STATE_MOCK } from '../user/user.mock';
+import { STATISTICS_STATE_INITIAL_MOCK } from '../statistics/statistics.mock';
 
 export const INITIAL_STORE_STATE_MOCK: RootState = {
   search: SEARCH_STATE_INITIAL_MOCK,
@@ -35,4 +36,5 @@ export const INITIAL_STORE_STATE_MOCK: RootState = {
   contextMenu: CONTEXT_MENU_INITIAL_STATE,
   cookieBanner: COOKIE_BANNER_INITIAL_STATE_MOCK,
   user: USER_INITIAL_STATE_MOCK,
+  statistics: STATISTICS_STATE_INITIAL_MOCK,
 };

src/redux/statistics/statistics.mock.ts

+import { DEFAULT_ERROR } from '@/constants/errors';
+import { StatisticsState } from './statistics.types';
+
+export const STATISTICS_STATE_INITIAL_MOCK: StatisticsState = {
+  data: undefined,
+  loading: 'idle',
+  error: DEFAULT_ERROR,
+};

src/redux/statistics/statistics.reducers.test.ts

+import { PROJECT_ID } from '@/constants';
+import {
+  ToolkitStoreWithSingleSlice,
+  createStoreInstanceUsingSliceReducer,
+} from '@/utils/createStoreInstanceUsingSliceReducer';
+import { mockNetworkResponse } from '@/utils/mockNetworkResponse';
+import { HttpStatusCode } from 'axios';
+import { waitFor } from '@testing-library/react';
+import { statisticsFixture } from '@/models/fixtures/statisticsFixture';
+import { StatisticsState } from './statistics.types';
+import statisticsReducer from './statistics.slice';
+import { apiPath } from '../apiPath';
+import { getStatisticsById } from './statistics.thunks';
+
+const mockedAxiosClient = mockNetworkResponse();
+
+const INITIAL_STATE: StatisticsState = {
+  data: undefined,
+  loading: 'idle',
+  error: { name: '', message: '' },
+};
+
+describe('statistics reducer', () => {
+  let store = {} as ToolkitStoreWithSingleSlice<StatisticsState>;
+  beforeEach(() => {
+    store = createStoreInstanceUsingSliceReducer('statistics', statisticsReducer);
+  });
+
+  it('should match initial state', () => {
+    const action = { type: 'unknown' };
+
+    expect(statisticsReducer(undefined, action)).toEqual(INITIAL_STATE);
+  });
+
+  it('should update store after successful getStatisticById query', async () => {
+    mockedAxiosClient
+      .onGet(apiPath.getStatisticsById(PROJECT_ID))
+      .reply(HttpStatusCode.Ok, statisticsFixture);
+
+    const { type } = await store.dispatch(getStatisticsById(PROJECT_ID));
+    const { data, loading, error } = store.getState().statistics;
+
+    expect(type).toBe('statistics/getStatisticsById/fulfilled');
+
+    waitFor(() => {
+      expect(loading).toEqual('pending');
+    });
+
+    expect(loading).toEqual('succeeded');
+    expect(error).toEqual({ message: '', name: '' });
+    expect(data).toEqual(statisticsFixture);
+  });
+
+  it('should update store after failed getStatisticById query', async () => {
+    mockedAxiosClient
+      .onGet(apiPath.getStatisticsById(PROJECT_ID))
+      .reply(HttpStatusCode.NotFound, undefined);
+
+    const { type } = await store.dispatch(getStatisticsById(PROJECT_ID));
+    const { loading } = store.getState().statistics;
+
+    expect(type).toBe('statistics/getStatisticsById/rejected');
+
+    waitFor(() => {
+      expect(loading).toEqual('pending');
+    });
+
+    expect(loading).toEqual('failed');
+  });
+});

src/redux/statistics/statistics.reducers.ts

+import { ActionReducerMapBuilder } from '@reduxjs/toolkit';
+import { StatisticsState } from './statistics.types';
+import { getStatisticsById } from './statistics.thunks';
+
+export const getStatisticsByIdReducer = (
+  builder: ActionReducerMapBuilder<StatisticsState>,
+): void => {
+  builder.addCase(getStatisticsById.pending, state => {
+    state.loading = 'pending';
+  });
+  builder.addCase(getStatisticsById.fulfilled, (state, action) => {
+    state.data = action.payload;
+    state.loading = 'succeeded';
+  });
+  builder.addCase(getStatisticsById.rejected, state => {
+    state.loading = 'failed';
+  });
+};

src/redux/statistics/statistics.selectors.ts

+import { createSelector } from '@reduxjs/toolkit';
+import { rootSelector } from '../root/root.selectors';
+
+export const statisticsSelector = createSelector(rootSelector, state => state.statistics);
+
+export const loadingStatisticsSelector = createSelector(statisticsSelector, state => state.loading);
+
+export const statisticsDataSelector = createSelector(
+  statisticsSelector,
+  statistics => statistics?.data,
+);
+
+export const elementAnnotationsSelector = createSelector(
+  statisticsDataSelector,
+  statistics => statistics?.elementAnnotations,
+);

src/redux/statistics/statistics.slice.ts

+import { createSlice } from '@reduxjs/toolkit';
+import { StatisticsState } from './statistics.types';
+import { getStatisticsByIdReducer } from './statistics.reducers';
+
+const initialState: StatisticsState = {
+  data: undefined,
+  loading: 'idle',
+  error: { name: '', message: '' },
+};
+
+export const statisticsSlice = createSlice({
+  name: 'statistics',
+  initialState,
+  reducers: {},
+  extraReducers: builder => {
+    getStatisticsByIdReducer(builder);
+  },
+});
+
+export default statisticsSlice.reducer;

src/redux/statistics/statistics.thunks.ts

+import { axiosInstance } from '@/services/api/utils/axiosInstance';
+import { Statistics } from '@/types/models';
+import { validateDataUsingZodSchema } from '@/utils/validateDataUsingZodSchema';
+import { createAsyncThunk } from '@reduxjs/toolkit';
+import { statisticsSchema } from '@/models/statisticsSchema';
+import { apiPath } from '../apiPath';
+
+export const getStatisticsById = createAsyncThunk(
+  'statistics/getStatisticsById',
+  async (id: string): Promise<Statistics | undefined> => {
+    const response = await axiosInstance.get<Statistics>(apiPath.getStatisticsById(id));
+
+    const isDataValid = validateDataUsingZodSchema(response.data, statisticsSchema);
+
+    return isDataValid ? response.data : undefined;
+  },
+);

src/redux/statistics/statistics.types.ts

+import { FetchDataState } from '@/types/fetchDataState';
+import { Statistics } from '@/types/models';
+
+export type StatisticsState = FetchDataState<Statistics>;

src/redux/store.ts

@@ -23,6 +23,7 @@ import {
   configureStore,
 } from '@reduxjs/toolkit';
 import { mapListenerMiddleware } from './map/middleware/map.middleware';
+import statisticsReducer from './statistics/statistics.slice';
 
 export const reducers = {
   search: searchReducer,
@@ -42,6 +43,7 @@ export const reducers = {
   user: userReducer,
   configuration: configurationReducer,
   overlayBioEntity: overlayBioEntityReducer,
+  statistics: statisticsReducer,
 };
 
 export const middlewares = [mapListenerMiddleware.middleware];

src/types/models.ts

@@ -24,6 +24,7 @@ import { reactionSchema } from '@/models/reaction';
 import { reactionLineSchema } from '@/models/reactionLineSchema';
 import { referenceSchema } from '@/models/referenceSchema';
 import { sessionSchemaValid } from '@/models/sessionValidSchema';
+import { statisticsSchema } from '@/models/statisticsSchema';
 import { targetSchema } from '@/models/targetSchema';
 import { z } from 'zod';
 
@@ -53,3 +54,4 @@ export type Login = z.infer<typeof loginSchema>;
 export type ConfigurationOption = z.infer<typeof configurationOptionSchema>;
 export type OverlayBioEntity = z.infer<typeof overlayBioEntitySchema>;
 export type Color = z.infer<typeof colorSchema>;
+export type Statistics = z.infer<typeof statisticsSchema>;