wangchunlin
/
cvat
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

More types in actions and reducers (#1166)

Browse Source
main
Boris Sekachev 6 years ago committed by GitHub
parent a376ee76fd
commit f208cfeaf5
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 130 additions and 186 deletions
Show Stats Download Patch File Download Diff File

1
cvat-ui/.eslintrc.js
Unescape Escape View File

@ -34,6 +34,7 @@ module.exports = {
'jsx-quotes': ['error', 'prefer-single'],
'arrow-parens': ['error', 'always'],
'@typescript-eslint/no-explicit-any': [0],
'@typescript-eslint/explicit-function-return-type': ['warn', { allowExpressions: true }],
'no-restricted-syntax': [0, {'selector': 'ForOfStatement'}],
'no-plusplus': [0],
'lines-between-class-members': 0,

4
cvat-ui/src/actions/about-actions.ts
Unescape Escape View File

@ -1,5 +1,5 @@
import { ActionUnion, createAction, ThunkAction } from 'utils/redux';
import getCore from 'cvat-core';
import { ActionUnion, createAction, ThunkAction } from '../utils/redux';
const core = getCore();
@ -17,7 +17,7 @@ const aboutActions = {
export type AboutActions = ActionUnion<typeof aboutActions>;
export const getAboutAsync = (): ThunkAction => async (dispatch) => {
export const getAboutAsync = (): ThunkAction => async (dispatch): Promise<void> => {
dispatch(aboutActions.getAbout());
try {

2
cvat-ui/src/actions/auth-actions.ts
Unescape Escape View File

@ -1,5 +1,5 @@
import { ActionUnion, createAction, ThunkAction } from 'utils/redux';
import getCore from 'cvat-core';
import { ActionUnion, createAction, ThunkAction } from '../utils/redux';
const cvat = getCore();

60
cvat-ui/src/actions/formats-actions.ts
Unescape Escape View File

@ -1,6 +1,4 @@
import { AnyAction, Dispatch, ActionCreator } from 'redux';
import { ThunkAction } from 'redux-thunk';
import { ActionUnion, createAction, ThunkAction } from 'utils/redux';
import getCore from 'cvat-core';
const cvat = getCore();
@ -11,48 +9,36 @@ export enum FormatsActionTypes {
GET_FORMATS_FAILED = 'GET_FORMATS_FAILED',
}
function getFormats(): AnyAction {
return {
type: FormatsActionTypes.GET_FORMATS,
payload: {},
};
}
function getFormatsSuccess(
annotationFormats: any[],
datasetFormats: any[],
): AnyAction {
return {
type: FormatsActionTypes.GET_FORMATS_SUCCESS,
payload: {
const formatsActions = {
getFormats: () => createAction(FormatsActionTypes.GET_FORMATS),
getFormatsSuccess: (annotationFormats: any[], datasetFormats: any[]) => (
createAction(FormatsActionTypes.GET_FORMATS_SUCCESS, {
annotationFormats,
datasetFormats,
},
};
}
function getFormatsFailed(error: any): AnyAction {
return {
type: FormatsActionTypes.GET_FORMATS_FAILED,
payload: {
error,
},
};
}
export function getFormatsAsync(): ThunkAction<Promise<void>, {}, {}, AnyAction> {
return async (dispatch: ActionCreator<Dispatch>): Promise<void> => {
dispatch(getFormats());
})
),
getFormatsFailed: (error: any) => (
createAction(FormatsActionTypes.GET_FORMATS_FAILED, { error })
),
};
export type FormatsActions = ActionUnion<typeof formatsActions>;
export function getFormatsAsync(): ThunkAction {
return async (dispatch): Promise<void> => {
dispatch(formatsActions.getFormats());
let annotationFormats = null;
let datasetFormats = null;
try {
annotationFormats = await cvat.server.formats();
datasetFormats = await cvat.server.datasetFormats();
dispatch(
formatsActions.getFormatsSuccess(annotationFormats, datasetFormats),
);
} catch (error) {
dispatch(getFormatsFailed(error));
return;
dispatch(formatsActions.getFormatsFailed(error));
}
dispatch(getFormatsSuccess(annotationFormats, datasetFormats));
};
}

77
cvat-ui/src/actions/plugins-actions.ts
Unescape Escape View File

@ -1,5 +1,4 @@
import { AnyAction, Dispatch, ActionCreator } from 'redux';
import { ThunkAction } from 'redux-thunk';
import { ActionUnion, createAction, ThunkAction } from 'utils/redux';
import { SupportedPlugins } from 'reducers/interfaces';
import PluginChecker from 'utils/plugin-checker';
@ -8,49 +7,45 @@ export enum PluginsActionTypes {
CHECKED_ALL_PLUGINS = 'CHECKED_ALL_PLUGINS'
}
interface PluginObjects {
[plugin: string]: boolean;
}
function checkPlugins(): AnyAction {
const action = {
type: PluginsActionTypes.CHECK_PLUGINS,
payload: {},
};
return action;
}
type PluginObjects = Record<SupportedPlugins, boolean>;
function checkedAllPlugins(list: PluginObjects): AnyAction {
const action = {
type: PluginsActionTypes.CHECKED_ALL_PLUGINS,
payload: {
const pluginActions = {
checkPlugins: () => createAction(PluginsActionTypes.CHECK_PLUGINS),
checkedAllPlugins: (list: PluginObjects) => (
createAction(PluginsActionTypes.CHECKED_ALL_PLUGINS, {
list,
},
};
return action;
}
export function checkPluginsAsync():
ThunkAction<Promise<void>, {}, {}, AnyAction> {
return async (dispatch: ActionCreator<Dispatch>): Promise<void> => {
dispatch(checkPlugins());
const plugins: PluginObjects = {};
const promises: Promise<boolean>[] = [];
const keys = Object.keys(SupportedPlugins);
for (const key of keys) {
const plugin = SupportedPlugins[key as any];
promises.push(PluginChecker.check(plugin as SupportedPlugins));
}
})
),
};
export type PluginActions = ActionUnion<typeof pluginActions>;
export function checkPluginsAsync(): ThunkAction {
return async (dispatch): Promise<void> => {
dispatch(pluginActions.checkPlugins());
const plugins: PluginObjects = {
ANALYTICS: false,
AUTO_ANNOTATION: false,
GIT_INTEGRATION: false,
TF_ANNOTATION: false,
TF_SEGMENTATION: false,
};
const promises: Promise<boolean>[] = [
PluginChecker.check(SupportedPlugins.ANALYTICS),
PluginChecker.check(SupportedPlugins.AUTO_ANNOTATION),
PluginChecker.check(SupportedPlugins.GIT_INTEGRATION),
PluginChecker.check(SupportedPlugins.TF_ANNOTATION),
PluginChecker.check(SupportedPlugins.TF_SEGMENTATION),
];
const values = await Promise.all(promises);
let i = 0;
for (const key of keys) {
plugins[key] = values[i++];
}
[plugins.ANALYTICS] = values;
[, plugins.AUTO_ANNOTATION] = values;
[,, plugins.GIT_INTEGRATION] = values;
[,,, plugins.TF_ANNOTATION] = values;
[,,,, plugins.TF_SEGMENTATION] = values;
dispatch(checkedAllPlugins(plugins));
dispatch(pluginActions.checkedAllPlugins(plugins));
};
}

63
cvat-ui/src/actions/share-actions.ts
Unescape Escape View File

@ -1,8 +1,7 @@
import { AnyAction, Dispatch, ActionCreator } from 'redux';
import { ThunkAction } from 'redux-thunk';
import { ActionUnion, createAction, ThunkAction } from 'utils/redux';
import getCore from 'cvat-core';
import { ShareFileInfo } from 'reducers/interfaces';
import getCore from 'cvat-core';
const core = getCore();
@ -12,49 +11,35 @@ export enum ShareActionTypes {
LOAD_SHARE_DATA_FAILED = 'LOAD_SHARE_DATA_FAILED',
}
function loadShareData(): AnyAction {
const action = {
type: ShareActionTypes.LOAD_SHARE_DATA,
payload: {},
};
return action;
}
function loadShareDataSuccess(values: ShareFileInfo[], directory: string): AnyAction {
const action = {
type: ShareActionTypes.LOAD_SHARE_DATA_SUCCESS,
payload: {
const shareActions = {
loadShareData: () => createAction(ShareActionTypes.LOAD_SHARE_DATA),
loadShareDataSuccess: (values: ShareFileInfo[], directory: string) => (
createAction(ShareActionTypes.LOAD_SHARE_DATA_SUCCESS, {
values,
directory,
},
};
return action;
}
function loadShareDataFailed(error: any): AnyAction {
const action = {
type: ShareActionTypes.LOAD_SHARE_DATA_FAILED,
payload: {
error,
},
};
return action;
}
export function loadShareDataAsync(directory: string, success: () => void, failure: () => void):
ThunkAction<Promise<void>, {}, {}, AnyAction> {
return async (dispatch: ActionCreator<Dispatch>): Promise<void> => {
})
),
loadShareDataFailed: (error: any) => (
createAction(ShareActionTypes.LOAD_SHARE_DATA_FAILED, { error })
),
};
export type ShareActions = ActionUnion<typeof shareActions>;
export function loadShareDataAsync(
directory: string,
success: () => void,
failure: () => void,
): ThunkAction {
return async (dispatch): Promise<void> => {
try {
dispatch(loadShareData());
dispatch(shareActions.loadShareData());
const values = await core.server.share(directory);
success();
dispatch(loadShareDataSuccess(values as ShareFileInfo[], directory));
dispatch(shareActions.loadShareDataSuccess(values as ShareFileInfo[], directory));
} catch (error) {
dispatch(loadShareDataFailed(error));
failure();
dispatch(shareActions.loadShareDataFailed(error));
}
};
}

52
cvat-ui/src/actions/users-actions.ts
Unescape Escape View File

@ -1,6 +1,4 @@
import { AnyAction, Dispatch, ActionCreator } from 'redux';
import { ThunkAction } from 'redux-thunk';
import { ActionUnion, createAction, ThunkAction } from 'utils/redux';
import getCore from 'cvat-core';
const core = getCore();
@ -11,47 +9,25 @@ export enum UsersActionTypes {
GET_USERS_FAILED = 'GET_USERS_FAILED',
}
function getUsers(): AnyAction {
const action = {
type: UsersActionTypes.GET_USERS,
payload: {},
};
return action;
}
function getUsersSuccess(users: any[]): AnyAction {
const action = {
type: UsersActionTypes.GET_USERS_SUCCESS,
payload: { users },
};
const usersActions = {
getUsers: () => createAction(UsersActionTypes.GET_USERS),
getUsersSuccess: (users: any[]) => createAction(UsersActionTypes.GET_USERS_SUCCESS, { users }),
getUsersFailed: (error: any) => createAction(UsersActionTypes.GET_USERS_FAILED, { error }),
};
return action;
}
function getUsersFailed(error: any): AnyAction {
const action = {
type: UsersActionTypes.GET_USERS_FAILED,
payload: { error },
};
return action;
}
export type UsersActions = ActionUnion<typeof usersActions>;
export function getUsersAsync():
ThunkAction<Promise<void>, {}, {}, AnyAction> {
return async (dispatch: ActionCreator<Dispatch>): Promise<void> => {
dispatch(getUsers());
export function getUsersAsync(): ThunkAction {
return async (dispatch): Promise<void> => {
dispatch(usersActions.getUsers());
try {
const users = await core.users.get();
dispatch(
getUsersSuccess(
users.map((userData: any): any => new core.classes.User(userData)),
),
);
const wrappedUsers = users
.map((userData: any): any => new core.classes.User(userData));
dispatch(usersActions.getUsersSuccess(wrappedUsers));
} catch (error) {
dispatch(getUsersFailed(error));
dispatch(usersActions.getUsersFailed(error));
}
};
}

4
cvat-ui/src/reducers/auth-reducer.ts
Unescape Escape View File

@ -7,7 +7,7 @@ const defaultState: AuthState = {
user: null,
};
export default (state = defaultState, action: AuthActions): AuthState => {
export default function (state = defaultState, action: AuthActions): AuthState {
switch (action.type) {
case AuthActionTypes.AUTHORIZED_SUCCESS:
return {
@ -67,4 +67,4 @@ export default (state = defaultState, action: AuthActions): AuthState => {
default:
return state;
}
};
}

10
cvat-ui/src/reducers/formats-reducer.ts
Unescape Escape View File

@ -1,6 +1,5 @@
import { AnyAction } from 'redux';
import { FormatsActionTypes } from 'actions/formats-actions';
import { AuthActionTypes } from 'actions/auth-actions';
import { FormatsActionTypes, FormatsActions } from 'actions/formats-actions';
import { AuthActionTypes, AuthActions } from 'actions/auth-actions';
import { FormatsState } from './interfaces';
@ -11,7 +10,10 @@ const defaultState: FormatsState = {
fetching: false,
};
export default (state = defaultState, action: AnyAction): FormatsState => {
export default (
state: FormatsState = defaultState,
action: FormatsActions | AuthActions,
): FormatsState => {
switch (action.type) {
case FormatsActionTypes.GET_FORMATS: {
return {

17
cvat-ui/src/reducers/plugins-reducer.ts
Unescape Escape View File

@ -1,13 +1,9 @@
import { AnyAction } from 'redux';
import { PluginsActionTypes } from 'actions/plugins-actions';
import { AuthActionTypes } from 'actions/auth-actions';
import { PluginsActionTypes, PluginActions } from 'actions/plugins-actions';
import { registerGitPlugin } from 'utils/git-utils';
import {
PluginsState,
} from './interfaces';
const defaultState: PluginsState = {
fetching: false,
initialized: false,
@ -19,7 +15,11 @@ const defaultState: PluginsState = {
ANALYTICS: false,
},
};
export default function (state = defaultState, action: AnyAction): PluginsState {
export default function (
state: PluginsState = defaultState,
action: PluginActions,
): PluginsState {
switch (action.type) {
case PluginsActionTypes.CHECK_PLUGINS: {
return {
@ -42,11 +42,6 @@ export default function (state = defaultState, action: AnyAction): PluginsState
list,
};
}
case AuthActionTypes.LOGOUT_SUCCESS: {
return {
...defaultState,
};
}
default:
return state;
}

11
cvat-ui/src/reducers/share-reducer.ts
Unescape Escape View File

@ -1,7 +1,5 @@
import { AnyAction } from 'redux';
import { ShareActionTypes } from 'actions/share-actions';
import { AuthActionTypes } from 'actions/auth-actions';
import { ShareActionTypes, ShareActions } from 'actions/share-actions';
import { AuthActionTypes, AuthActions } from 'actions/auth-actions';
import {
ShareState,
ShareFileInfo,
@ -16,7 +14,10 @@ const defaultState: ShareState = {
},
};
export default function (state = defaultState, action: AnyAction): ShareState {
export default function (
state: ShareState = defaultState,
action: ShareActions | AuthActions,
): ShareState {
switch (action.type) {
case ShareActionTypes.LOAD_SHARE_DATA_SUCCESS: {
const { values } = action.payload;

11
cvat-ui/src/reducers/users-reducer.ts
Unescape Escape View File

@ -1,7 +1,5 @@
import { AnyAction } from 'redux';
import { AuthActionTypes } from 'actions/auth-actions';
import { UsersActionTypes } from 'actions/users-actions';
import { AuthActionTypes, AuthActions } from 'actions/auth-actions';
import { UsersActionTypes, UsersActions } from 'actions/users-actions';
import { UsersState } from './interfaces';
const defaultState: UsersState = {
@ -10,7 +8,10 @@ const defaultState: UsersState = {
initialized: false,
};
export default function (state: UsersState = defaultState, action: AnyAction): UsersState {
export default function (
state: UsersState = defaultState,
action: UsersActions | AuthActions,
): UsersState {
switch (action.type) {
case UsersActionTypes.GET_USERS: {
return {

4
cvat-ui/src/utils/redux.ts
Unescape Escape View File

@ -8,7 +8,9 @@ export interface ActionWithPayload<T, P> extends Action<T> {
export function createAction<T extends string>(type: T): Action<T>;
export function createAction<T extends string, P>(type: T, payload: P): ActionWithPayload<T, P>;
export function createAction<T extends string, P>(type: T, payload?: P) {
export function createAction<T extends string, P>(
type: T, payload?: P,
): Action<T> | ActionWithPayload<T, P> {
return typeof payload === 'undefined' ? { type } : { type, payload };
}

Write Preview
Loading…
Cancel
Save