|
|
// Copyright (C) 2020-2022 Intel Corporation
|
|
|
// Copyright (C) 2022-2023 CVAT.ai Corporation
|
|
|
//
|
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
|
|
import { AnyAction } from 'redux';
|
|
|
|
|
|
import { AuthActionTypes } from 'actions/auth-actions';
|
|
|
import { FormatsActionTypes } from 'actions/formats-actions';
|
|
|
import { ModelsActionTypes } from 'actions/models-actions';
|
|
|
import { ShareActionTypes } from 'actions/share-actions';
|
|
|
import { TasksActionTypes } from 'actions/tasks-actions';
|
|
|
import { ProjectsActionTypes } from 'actions/projects-actions';
|
|
|
import { AboutActionTypes } from 'actions/about-actions';
|
|
|
import { AnnotationActionTypes } from 'actions/annotation-actions';
|
|
|
import { NotificationsActionType } from 'actions/notification-actions';
|
|
|
import { BoundariesActionTypes } from 'actions/boundaries-actions';
|
|
|
import { UserAgreementsActionTypes } from 'actions/useragreements-actions';
|
|
|
import { ReviewActionTypes } from 'actions/review-actions';
|
|
|
import { ExportActionTypes } from 'actions/export-actions';
|
|
|
import { ImportActionTypes } from 'actions/import-actions';
|
|
|
import { CloudStorageActionTypes } from 'actions/cloud-storage-actions';
|
|
|
import { OrganizationActionsTypes } from 'actions/organization-actions';
|
|
|
import { JobsActionTypes } from 'actions/jobs-actions';
|
|
|
import { WebhooksActionsTypes } from 'actions/webhooks-actions';
|
|
|
|
|
|
import { NotificationsState } from '.';
|
|
|
|
|
|
const defaultState: NotificationsState = {
|
|
|
errors: {
|
|
|
auth: {
|
|
|
authorized: null,
|
|
|
login: null,
|
|
|
logout: null,
|
|
|
register: null,
|
|
|
changePassword: null,
|
|
|
requestPasswordReset: null,
|
|
|
resetPassword: null,
|
|
|
loadAuthActions: null,
|
|
|
},
|
|
|
projects: {
|
|
|
fetching: null,
|
|
|
updating: null,
|
|
|
deleting: null,
|
|
|
creating: null,
|
|
|
restoring: null,
|
|
|
backuping: null,
|
|
|
},
|
|
|
tasks: {
|
|
|
fetching: null,
|
|
|
updating: null,
|
|
|
dumping: null,
|
|
|
loading: null,
|
|
|
exportingAsDataset: null,
|
|
|
deleting: null,
|
|
|
creating: null,
|
|
|
exporting: null,
|
|
|
importing: null,
|
|
|
moving: null,
|
|
|
},
|
|
|
jobs: {
|
|
|
updating: null,
|
|
|
fetching: null,
|
|
|
},
|
|
|
formats: {
|
|
|
fetching: null,
|
|
|
},
|
|
|
users: {
|
|
|
fetching: null,
|
|
|
},
|
|
|
about: {
|
|
|
fetching: null,
|
|
|
},
|
|
|
share: {
|
|
|
fetching: null,
|
|
|
},
|
|
|
models: {
|
|
|
starting: null,
|
|
|
fetching: null,
|
|
|
canceling: null,
|
|
|
metaFetching: null,
|
|
|
inferenceStatusFetching: null,
|
|
|
},
|
|
|
annotation: {
|
|
|
saving: null,
|
|
|
jobFetching: null,
|
|
|
frameFetching: null,
|
|
|
changingLabelColor: null,
|
|
|
updating: null,
|
|
|
creating: null,
|
|
|
merging: null,
|
|
|
grouping: null,
|
|
|
splitting: null,
|
|
|
removing: null,
|
|
|
propagating: null,
|
|
|
collectingStatistics: null,
|
|
|
savingJob: null,
|
|
|
uploadAnnotations: null,
|
|
|
removeAnnotations: null,
|
|
|
fetchingAnnotations: null,
|
|
|
undo: null,
|
|
|
redo: null,
|
|
|
search: null,
|
|
|
searchEmptyFrame: null,
|
|
|
deleteFrame: null,
|
|
|
restoreFrame: null,
|
|
|
savingLogs: null,
|
|
|
},
|
|
|
boundaries: {
|
|
|
resetError: null,
|
|
|
},
|
|
|
userAgreements: {
|
|
|
fetching: null,
|
|
|
},
|
|
|
review: {
|
|
|
commentingIssue: null,
|
|
|
finishingIssue: null,
|
|
|
reopeningIssue: null,
|
|
|
resolvingIssue: null,
|
|
|
submittingReview: null,
|
|
|
deletingIssue: null,
|
|
|
},
|
|
|
predictor: {
|
|
|
prediction: null,
|
|
|
},
|
|
|
exporting: {
|
|
|
dataset: null,
|
|
|
annotation: null,
|
|
|
backup: null,
|
|
|
},
|
|
|
importing: {
|
|
|
dataset: null,
|
|
|
annotation: null,
|
|
|
backup: null,
|
|
|
},
|
|
|
cloudStorages: {
|
|
|
creating: null,
|
|
|
fetching: null,
|
|
|
updating: null,
|
|
|
deleting: null,
|
|
|
},
|
|
|
organizations: {
|
|
|
fetching: null,
|
|
|
creating: null,
|
|
|
updating: null,
|
|
|
activation: null,
|
|
|
deleting: null,
|
|
|
leaving: null,
|
|
|
inviting: null,
|
|
|
updatingMembership: null,
|
|
|
removingMembership: null,
|
|
|
},
|
|
|
webhooks: {
|
|
|
fetching: null,
|
|
|
creating: null,
|
|
|
updating: null,
|
|
|
deleting: null,
|
|
|
},
|
|
|
},
|
|
|
messages: {
|
|
|
tasks: {
|
|
|
loadingDone: '',
|
|
|
importingDone: '',
|
|
|
movingDone: '',
|
|
|
},
|
|
|
models: {
|
|
|
inferenceDone: '',
|
|
|
},
|
|
|
auth: {
|
|
|
changePasswordDone: '',
|
|
|
registerDone: '',
|
|
|
requestPasswordResetDone: '',
|
|
|
resetPasswordDone: '',
|
|
|
},
|
|
|
projects: {
|
|
|
restoringDone: '',
|
|
|
},
|
|
|
exporting: {
|
|
|
dataset: '',
|
|
|
annotation: '',
|
|
|
backup: '',
|
|
|
},
|
|
|
importing: {
|
|
|
dataset: '',
|
|
|
annotation: '',
|
|
|
backup: '',
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
|
|
|
export default function (state = defaultState, action: AnyAction): NotificationsState {
|
|
|
switch (action.type) {
|
|
|
case AuthActionTypes.AUTHORIZED_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
auth: {
|
|
|
...state.errors.auth,
|
|
|
authorized: {
|
|
|
message: 'Could not check authorization on the server',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AuthActionTypes.LOGIN_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
auth: {
|
|
|
...state.errors.auth,
|
|
|
login: {
|
|
|
message: 'Could not login on the server',
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-login-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AuthActionTypes.LOGOUT_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
auth: {
|
|
|
...state.errors.auth,
|
|
|
logout: {
|
|
|
message: 'Could not logout from the server',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AuthActionTypes.REGISTER_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
auth: {
|
|
|
...state.errors.auth,
|
|
|
register: {
|
|
|
message: 'Could not register on the server',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AuthActionTypes.REGISTER_SUCCESS: {
|
|
|
if (!action.payload.user.isVerified) {
|
|
|
return {
|
|
|
...state,
|
|
|
messages: {
|
|
|
...state.messages,
|
|
|
auth: {
|
|
|
...state.messages.auth,
|
|
|
registerDone: `To use your account, you need to confirm the email address. \
|
|
|
We have sent an email with a confirmation link to ${action.payload.user.email}.`,
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
|
|
|
return {
|
|
|
...state,
|
|
|
};
|
|
|
}
|
|
|
case AuthActionTypes.CHANGE_PASSWORD_SUCCESS: {
|
|
|
return {
|
|
|
...state,
|
|
|
messages: {
|
|
|
...state.messages,
|
|
|
auth: {
|
|
|
...state.messages.auth,
|
|
|
changePasswordDone: 'New password has been saved.',
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AuthActionTypes.CHANGE_PASSWORD_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
auth: {
|
|
|
...state.errors.auth,
|
|
|
changePassword: {
|
|
|
message: 'Could not change password',
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-change-password-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AuthActionTypes.REQUEST_PASSWORD_RESET_SUCCESS: {
|
|
|
return {
|
|
|
...state,
|
|
|
messages: {
|
|
|
...state.messages,
|
|
|
auth: {
|
|
|
...state.messages.auth,
|
|
|
requestPasswordResetDone: `Check your email for a link to reset your password.
|
|
|
If it doesn’t appear within a few minutes, check your spam folder.`,
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AuthActionTypes.REQUEST_PASSWORD_RESET_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
auth: {
|
|
|
...state.errors.auth,
|
|
|
requestPasswordReset: {
|
|
|
message: 'Could not reset password on the server.',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AuthActionTypes.RESET_PASSWORD_SUCCESS: {
|
|
|
return {
|
|
|
...state,
|
|
|
messages: {
|
|
|
...state.messages,
|
|
|
auth: {
|
|
|
...state.messages.auth,
|
|
|
resetPasswordDone: 'Password has been reset with the new password.',
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AuthActionTypes.RESET_PASSWORD_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
auth: {
|
|
|
...state.errors.auth,
|
|
|
resetPassword: {
|
|
|
message: 'Could not set new password on the server.',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AuthActionTypes.LOAD_AUTH_ACTIONS_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
auth: {
|
|
|
...state.errors.auth,
|
|
|
loadAuthActions: {
|
|
|
message: 'Could not check available auth actions',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case ExportActionTypes.EXPORT_DATASET_FAILED: {
|
|
|
const { instance, instanceType } = action.payload;
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
exporting: {
|
|
|
...state.errors.exporting,
|
|
|
dataset: {
|
|
|
message:
|
|
|
'Could not export dataset for the ' +
|
|
|
`[${instanceType} ${instance.id}](/${instanceType}s/${instance.id})`,
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case ExportActionTypes.EXPORT_DATASET_SUCCESS: {
|
|
|
const {
|
|
|
instance, instanceType, isLocal, resource,
|
|
|
} = action.payload;
|
|
|
const auxiliaryVerb = resource === 'Dataset' ? 'has' : 'have';
|
|
|
return {
|
|
|
...state,
|
|
|
messages: {
|
|
|
...state.messages,
|
|
|
exporting: {
|
|
|
...state.messages.exporting,
|
|
|
dataset:
|
|
|
`${resource} for ${instanceType} ${instance.id} ` +
|
|
|
`${auxiliaryVerb} been ${(isLocal) ? 'downloaded' : 'uploaded'} ` +
|
|
|
`${(isLocal) ? 'locally' : 'to cloud storage'}`,
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case ExportActionTypes.EXPORT_BACKUP_FAILED: {
|
|
|
const { instance, instanceType } = action.payload;
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
exporting: {
|
|
|
...state.errors.exporting,
|
|
|
backup: {
|
|
|
message:
|
|
|
`Could not export the ${instanceType} №${instance.id}`,
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case ExportActionTypes.EXPORT_BACKUP_SUCCESS: {
|
|
|
const { instance, instanceType, isLocal } = action.payload;
|
|
|
return {
|
|
|
...state,
|
|
|
messages: {
|
|
|
...state.messages,
|
|
|
exporting: {
|
|
|
...state.messages.exporting,
|
|
|
backup:
|
|
|
`Backup for the ${instanceType} №${instance.id} ` +
|
|
|
`has been ${(isLocal) ? 'downloaded' : 'uploaded'} ` +
|
|
|
`${(isLocal) ? 'locally' : 'to cloud storage'}`,
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case ImportActionTypes.IMPORT_DATASET_SUCCESS: {
|
|
|
const { instance, resource } = action.payload;
|
|
|
const message = resource === 'annotation' ?
|
|
|
'Annotations have been loaded to the ' +
|
|
|
`[task ${instance.taskId || instance.id}](/tasks/${instance.taskId || instance.id}) ` :
|
|
|
`Dataset was imported to the [project ${instance.id}](/projects/${instance.id})`;
|
|
|
return {
|
|
|
...state,
|
|
|
messages: {
|
|
|
...state.messages,
|
|
|
importing: {
|
|
|
...state.messages.importing,
|
|
|
[resource]: message,
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case ImportActionTypes.IMPORT_DATASET_FAILED: {
|
|
|
const { instance, resource } = action.payload;
|
|
|
const message = resource === 'annotation' ?
|
|
|
'Could not upload annotation for the ' +
|
|
|
`[task ${instance.taskId || instance.id}](/tasks/${instance.taskId || instance.id})` :
|
|
|
`Could not import dataset to the [project ${instance.id}](/projects/${instance.id})`;
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
importing: {
|
|
|
...state.errors.importing,
|
|
|
dataset: {
|
|
|
message,
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-' +
|
|
|
`${resource === 'annotation' ? 'load-annotation' : 'import-dataset'}-failed`,
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case ImportActionTypes.IMPORT_BACKUP_SUCCESS: {
|
|
|
const { instanceId, instanceType } = action.payload;
|
|
|
return {
|
|
|
...state,
|
|
|
messages: {
|
|
|
...state.messages,
|
|
|
importing: {
|
|
|
...state.messages.importing,
|
|
|
backup:
|
|
|
`The ${instanceType} has been restored successfully.
|
|
|
Click [here](/${instanceType}s/${instanceId}) to open`,
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case ImportActionTypes.IMPORT_BACKUP_FAILED: {
|
|
|
const { instanceType } = action.payload;
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
importing: {
|
|
|
...state.errors.importing,
|
|
|
backup: {
|
|
|
message:
|
|
|
`Could not restore ${instanceType} backup.`,
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case TasksActionTypes.GET_TASKS_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
tasks: {
|
|
|
...state.errors.tasks,
|
|
|
fetching: {
|
|
|
message: 'Could not fetch tasks',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case TasksActionTypes.UPDATE_TASK_FAILED: {
|
|
|
const taskID = action.payload.task.id;
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
tasks: {
|
|
|
...state.errors.tasks,
|
|
|
updating: {
|
|
|
message: `Could not update [task ${taskID}](/tasks/${taskID})`,
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-update-task-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case TasksActionTypes.DELETE_TASK_FAILED: {
|
|
|
const { taskID } = action.payload;
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
tasks: {
|
|
|
...state.errors.tasks,
|
|
|
deleting: {
|
|
|
message: `Could not delete the [task ${taskID}](/tasks/${taskID})`,
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-delete-task-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case TasksActionTypes.CREATE_TASK_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
tasks: {
|
|
|
...state.errors.tasks,
|
|
|
creating: {
|
|
|
message: 'Could not create the task',
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-create-task-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case TasksActionTypes.UPDATE_JOB_FAILED: {
|
|
|
const jobID = action.payload.jobInstance.id;
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
jobs: {
|
|
|
...state.errors.jobs,
|
|
|
updating: {
|
|
|
message: `Could not update job with ID #${jobID}`,
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-update-job-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case ProjectsActionTypes.GET_PROJECTS_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
projects: {
|
|
|
...state.errors.projects,
|
|
|
fetching: {
|
|
|
message: 'Could not fetch projects',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case ProjectsActionTypes.CREATE_PROJECT_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
projects: {
|
|
|
...state.errors.projects,
|
|
|
creating: {
|
|
|
message: 'Could not create the project',
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-create-project-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case ProjectsActionTypes.UPDATE_PROJECT_FAILED: {
|
|
|
const { id: projectId } = action.payload.project;
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
projects: {
|
|
|
...state.errors.projects,
|
|
|
updating: {
|
|
|
message: `Could not update [project ${projectId}](/project/${projectId})`,
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-update-project-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case ProjectsActionTypes.DELETE_PROJECT_FAILED: {
|
|
|
const { projectId } = action.payload;
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
projects: {
|
|
|
...state.errors.projects,
|
|
|
updating: {
|
|
|
message: `Could not delete [project ${projectId}](/project/${projectId})`,
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-delete-project-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case FormatsActionTypes.GET_FORMATS_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
formats: {
|
|
|
...state.errors.formats,
|
|
|
fetching: {
|
|
|
message: 'Could not get formats from the server',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AboutActionTypes.GET_ABOUT_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
about: {
|
|
|
...state.errors.about,
|
|
|
fetching: {
|
|
|
message: 'Could not get info about the server',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case ShareActionTypes.LOAD_SHARE_DATA_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
share: {
|
|
|
...state.errors.share,
|
|
|
fetching: {
|
|
|
message: 'Could not load share data from the server',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case ModelsActionTypes.GET_INFERENCE_STATUS_SUCCESS: {
|
|
|
if (action.payload.activeInference.status === 'finished') {
|
|
|
const { taskID } = action.payload;
|
|
|
return {
|
|
|
...state,
|
|
|
messages: {
|
|
|
...state.messages,
|
|
|
models: {
|
|
|
...state.messages.models,
|
|
|
inferenceDone: 'Automatic annotation accomplished for the ' +
|
|
|
`[task ${taskID}](/tasks/${taskID})`,
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
|
|
|
return {
|
|
|
...state,
|
|
|
};
|
|
|
}
|
|
|
case ModelsActionTypes.FETCH_META_FAILED: {
|
|
|
if (action.payload.error.code === 403) {
|
|
|
return state;
|
|
|
}
|
|
|
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
models: {
|
|
|
...state.errors.models,
|
|
|
metaFetching: {
|
|
|
message: 'Could not fetch models meta information',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case ModelsActionTypes.GET_INFERENCE_STATUS_FAILED: {
|
|
|
const { taskID } = action.payload;
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
models: {
|
|
|
...state.errors.models,
|
|
|
inferenceStatusFetching: {
|
|
|
message: `Fetching inference status for the [task ${taskID}](/tasks/${taskID})`,
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case ModelsActionTypes.GET_MODELS_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
models: {
|
|
|
...state.errors.models,
|
|
|
fetching: {
|
|
|
message: 'Could not get models from the server',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case ModelsActionTypes.START_INFERENCE_FAILED: {
|
|
|
const { taskID } = action.payload;
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
models: {
|
|
|
...state.errors.models,
|
|
|
starting: {
|
|
|
message: `Could not infer model for the [task ${taskID}](/tasks/${taskID})`,
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case ModelsActionTypes.CANCEL_INFERENCE_FAILED: {
|
|
|
const { taskID } = action.payload;
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
models: {
|
|
|
...state.errors.models,
|
|
|
canceling: {
|
|
|
message: `Could not cancel model inference for the [task ${taskID}](/tasks/${taskID})`,
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AnnotationActionTypes.GET_JOB_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
annotation: {
|
|
|
...state.errors.annotation,
|
|
|
jobFetching: {
|
|
|
message: 'Error during fetching a job',
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-fetch-job-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AnnotationActionTypes.CHANGE_FRAME_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
annotation: {
|
|
|
...state.errors.annotation,
|
|
|
frameFetching: {
|
|
|
message: `Could not receive frame ${action.payload.number}`,
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AnnotationActionTypes.SAVE_ANNOTATIONS_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
annotation: {
|
|
|
...state.errors.annotation,
|
|
|
saving: {
|
|
|
message: 'Could not save annotations',
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-save-annotations-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AnnotationActionTypes.UPDATE_ANNOTATIONS_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
annotation: {
|
|
|
...state.errors.annotation,
|
|
|
updating: {
|
|
|
message: 'Could not update annotations',
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-update-annotations-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AnnotationActionTypes.CREATE_ANNOTATIONS_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
annotation: {
|
|
|
...state.errors.annotation,
|
|
|
creating: {
|
|
|
message: 'Could not create annotations',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AnnotationActionTypes.MERGE_ANNOTATIONS_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
annotation: {
|
|
|
...state.errors.annotation,
|
|
|
merging: {
|
|
|
message: 'Could not merge annotations',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AnnotationActionTypes.GROUP_ANNOTATIONS_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
annotation: {
|
|
|
...state.errors.annotation,
|
|
|
grouping: {
|
|
|
message: 'Could not group annotations',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AnnotationActionTypes.SPLIT_ANNOTATIONS_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
annotation: {
|
|
|
...state.errors.annotation,
|
|
|
splitting: {
|
|
|
message: 'Could not split the track',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AnnotationActionTypes.REMOVE_OBJECT_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
annotation: {
|
|
|
...state.errors.annotation,
|
|
|
removing: {
|
|
|
message: 'Could not remove the object',
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-remove-object-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AnnotationActionTypes.PROPAGATE_OBJECT_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
annotation: {
|
|
|
...state.errors.annotation,
|
|
|
propagating: {
|
|
|
message: 'Could not propagate the object',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AnnotationActionTypes.COLLECT_STATISTICS_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
annotation: {
|
|
|
...state.errors.annotation,
|
|
|
collectingStatistics: {
|
|
|
message: 'Could not collect annotations statistics',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AnnotationActionTypes.UPLOAD_JOB_ANNOTATIONS_FAILED: {
|
|
|
const { job, error } = action.payload;
|
|
|
|
|
|
const {
|
|
|
id: jobID,
|
|
|
taskId: taskID,
|
|
|
} = job;
|
|
|
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
annotation: {
|
|
|
...state.errors.annotation,
|
|
|
uploadAnnotations: {
|
|
|
message:
|
|
|
`Could not upload annotations for the [job ${jobID}](/tasks/${taskID}/jobs/${jobID})`,
|
|
|
reason: error.toString(),
|
|
|
className: 'cvat-notification-notice-upload-annotations-fail',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AnnotationActionTypes.REMOVE_JOB_ANNOTATIONS_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
annotation: {
|
|
|
...state.errors.annotation,
|
|
|
removeAnnotations: {
|
|
|
message: 'Could not remove annotations',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AnnotationActionTypes.FETCH_ANNOTATIONS_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
annotation: {
|
|
|
...state.errors.annotation,
|
|
|
fetchingAnnotations: {
|
|
|
message: 'Could not fetch annotations',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AnnotationActionTypes.REDO_ACTION_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
annotation: {
|
|
|
...state.errors.annotation,
|
|
|
redo: {
|
|
|
message: 'Could not redo',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AnnotationActionTypes.UNDO_ACTION_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
annotation: {
|
|
|
...state.errors.annotation,
|
|
|
undo: {
|
|
|
message: 'Could not undo',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AnnotationActionTypes.SEARCH_ANNOTATIONS_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
annotation: {
|
|
|
...state.errors.annotation,
|
|
|
search: {
|
|
|
message: 'Could not execute search annotations',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AnnotationActionTypes.SEARCH_EMPTY_FRAME_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
annotation: {
|
|
|
...state.errors.annotation,
|
|
|
searchEmptyFrame: {
|
|
|
message: 'Could not search an empty frame',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AnnotationActionTypes.SAVE_LOGS_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
annotation: {
|
|
|
...state.errors.annotation,
|
|
|
savingLogs: {
|
|
|
message: 'Could not send logs to the server',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case BoundariesActionTypes.THROW_RESET_ERROR: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
boundaries: {
|
|
|
...state.errors.annotation,
|
|
|
resetError: {
|
|
|
message: 'Could not reset the state',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case UserAgreementsActionTypes.GET_USER_AGREEMENTS_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
userAgreements: {
|
|
|
...state.errors.userAgreements,
|
|
|
fetching: {
|
|
|
message: 'Could not get user agreements from the server',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case ReviewActionTypes.FINISH_ISSUE_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
review: {
|
|
|
...state.errors.review,
|
|
|
finishingIssue: {
|
|
|
message: 'Could not open a new issue',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case ReviewActionTypes.RESOLVE_ISSUE_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
review: {
|
|
|
...state.errors.review,
|
|
|
resolvingIssue: {
|
|
|
message: 'Could not resolve the issue',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case ReviewActionTypes.REOPEN_ISSUE_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
review: {
|
|
|
...state.errors.review,
|
|
|
reopeningIssue: {
|
|
|
message: 'Could not reopen the issue',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case ReviewActionTypes.COMMENT_ISSUE_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
review: {
|
|
|
...state.errors.review,
|
|
|
commentingIssue: {
|
|
|
message: 'Could not comment the issue',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case ReviewActionTypes.SUBMIT_REVIEW_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
review: {
|
|
|
...state.errors.review,
|
|
|
submittingReview: {
|
|
|
message: `Could not submit review for the job ${action.payload.jobId}`,
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case ReviewActionTypes.REMOVE_ISSUE_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
review: {
|
|
|
...state.errors.review,
|
|
|
deletingIssue: {
|
|
|
message: 'Could not remove issue from the server',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case NotificationsActionType.RESET_ERRORS: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...defaultState.errors,
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case NotificationsActionType.RESET_MESSAGES: {
|
|
|
return {
|
|
|
...state,
|
|
|
messages: {
|
|
|
...defaultState.messages,
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AnnotationActionTypes.GET_DATA_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
annotation: {
|
|
|
...state.errors.annotation,
|
|
|
jobFetching: {
|
|
|
message: 'Could not fetch frame data from the server',
|
|
|
reason: action.payload.error,
|
|
|
className: 'cvat-notification-notice-fetch-frame-data-from-the-server-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AnnotationActionTypes.GET_PREDICTIONS_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
predictor: {
|
|
|
...state.errors.predictor,
|
|
|
prediction: {
|
|
|
message: 'Could not fetch prediction data',
|
|
|
reason: action.payload.error,
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AnnotationActionTypes.DELETE_FRAME_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
annotation: {
|
|
|
...state.errors.annotation,
|
|
|
deleteFrame: {
|
|
|
message: 'Could not delete frame',
|
|
|
reason: action.payload.error,
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case AnnotationActionTypes.RESTORE_FRAME_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
annotation: {
|
|
|
...state.errors.annotation,
|
|
|
restoreFrame: {
|
|
|
message: 'Could not restore frame',
|
|
|
reason: action.payload.error,
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case CloudStorageActionTypes.GET_CLOUD_STORAGE_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
cloudStorages: {
|
|
|
...state.errors.cloudStorages,
|
|
|
fetching: {
|
|
|
message: 'Could not fetch cloud storage',
|
|
|
reason: action.payload.error.toString(),
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case CloudStorageActionTypes.CREATE_CLOUD_STORAGE_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
cloudStorages: {
|
|
|
...state.errors.cloudStorages,
|
|
|
creating: {
|
|
|
message: 'Could not create the cloud storage',
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-create-cloud-storage-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case CloudStorageActionTypes.UPDATE_CLOUD_STORAGE_FAILED: {
|
|
|
const { cloudStorage, error } = action.payload;
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
cloudStorages: {
|
|
|
...state.errors.cloudStorages,
|
|
|
updating: {
|
|
|
message: `Could not update cloud storage #${cloudStorage.id}`,
|
|
|
reason: error.toString(),
|
|
|
className: 'cvat-notification-notice-update-cloud-storage-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case CloudStorageActionTypes.DELETE_CLOUD_STORAGE_FAILED: {
|
|
|
const { cloudStorageID } = action.payload;
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
cloudStorages: {
|
|
|
...state.errors.cloudStorages,
|
|
|
deleting: {
|
|
|
message:
|
|
|
`Could not delete cloud storage ${cloudStorageID}`,
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-delete-cloud-storage-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case CloudStorageActionTypes.LOAD_CLOUD_STORAGE_CONTENT_FAILED: {
|
|
|
const { cloudStorageID } = action.payload;
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
cloudStorages: {
|
|
|
...state.errors.cloudStorages,
|
|
|
fetching: {
|
|
|
message: `Could not fetch content for cloud storage #${cloudStorageID}`,
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-fetch-cloud-storage-content-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case CloudStorageActionTypes.GET_CLOUD_STORAGE_STATUS_FAILED: {
|
|
|
const { cloudStorageID } = action.payload;
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
cloudStorages: {
|
|
|
...state.errors.cloudStorages,
|
|
|
fetching: {
|
|
|
message: `Could not fetch cloud storage #${cloudStorageID} status`,
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-fetch-cloud-storage-status-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
|
|
|
case CloudStorageActionTypes.GET_CLOUD_STORAGE_PREVIEW_FAILED: {
|
|
|
const { cloudStorageID } = action.payload;
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
cloudStorages: {
|
|
|
...state.errors.cloudStorages,
|
|
|
fetching: {
|
|
|
message: `Could not fetch preview for cloud storage #${cloudStorageID}`,
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-fetch-cloud-storage-preview-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case OrganizationActionsTypes.GET_ORGANIZATIONS_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
organizations: {
|
|
|
...state.errors.organizations,
|
|
|
fetching: {
|
|
|
message: 'Could not fetch organizations list',
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-fetch-organizations-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case OrganizationActionsTypes.CREATE_ORGANIZATION_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
organizations: {
|
|
|
...state.errors.organizations,
|
|
|
creating: {
|
|
|
message: `Could not create organization ${action.payload.slug}`,
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-create-organization-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case OrganizationActionsTypes.UPDATE_ORGANIZATION_FAILED: {
|
|
|
const { slug } = action.payload;
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
organizations: {
|
|
|
...state.errors.organizations,
|
|
|
updating: {
|
|
|
message: `Could not update organization "${slug}"`,
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-update-organization-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case OrganizationActionsTypes.ACTIVATE_ORGANIZATION_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
organizations: {
|
|
|
...state.errors.organizations,
|
|
|
activation: {
|
|
|
message: `Could not activate organization ${action.payload.slug || ''}`,
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-activate-organization-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case OrganizationActionsTypes.REMOVE_ORGANIZATION_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
organizations: {
|
|
|
...state.errors.organizations,
|
|
|
deleting: {
|
|
|
message: `Could not remove organization ${action.payload.slug}`,
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-remove-organization-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case OrganizationActionsTypes.INVITE_ORGANIZATION_MEMBERS_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
organizations: {
|
|
|
...state.errors.organizations,
|
|
|
inviting: {
|
|
|
message: 'Could not invite organization members',
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-invite-organization-members-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case OrganizationActionsTypes.INVITE_ORGANIZATION_MEMBER_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
organizations: {
|
|
|
...state.errors.organizations,
|
|
|
inviting: {
|
|
|
message: `Could not invite this member "${action.payload.email}" to the organization`,
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-invite-organization-member-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case OrganizationActionsTypes.LEAVE_ORGANIZATION_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
organizations: {
|
|
|
...state.errors.organizations,
|
|
|
leaving: {
|
|
|
message: 'Could not leave the organization',
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-leave-organization-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case OrganizationActionsTypes.REMOVE_ORGANIZATION_MEMBER_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
organizations: {
|
|
|
...state.errors.organizations,
|
|
|
removingMembership: {
|
|
|
message: `Could not remove member "${action.payload.username}" from the organization`,
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-remove-organization-member-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case OrganizationActionsTypes.UPDATE_ORGANIZATION_MEMBER_FAILED: {
|
|
|
const { role, username } = action.payload;
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
organizations: {
|
|
|
...state.errors.organizations,
|
|
|
updatingMembership: {
|
|
|
message: `Could not assign role "${role}" to the user "${username}"`,
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-update-organization-membership-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case JobsActionTypes.GET_JOBS_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
jobs: {
|
|
|
...state.errors.jobs,
|
|
|
fetching: {
|
|
|
message: 'Could not fetch a list of jobs',
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-update-organization-membership-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case WebhooksActionsTypes.GET_WEBHOOKS_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
webhooks: {
|
|
|
...state.errors.webhooks,
|
|
|
fetching: {
|
|
|
message: 'Could not fetch a list of webhooks',
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-get-webhooks-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case WebhooksActionsTypes.CREATE_WEBHOOK_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
webhooks: {
|
|
|
...state.errors.webhooks,
|
|
|
creating: {
|
|
|
message: 'Could not create webhook',
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-create-webhook-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case WebhooksActionsTypes.UPDATE_WEBHOOK_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
webhooks: {
|
|
|
...state.errors.webhooks,
|
|
|
updating: {
|
|
|
message: 'Could not update webhook',
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-update-webhook-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case WebhooksActionsTypes.DELETE_WEBHOOK_FAILED: {
|
|
|
return {
|
|
|
...state,
|
|
|
errors: {
|
|
|
...state.errors,
|
|
|
webhooks: {
|
|
|
...state.errors.webhooks,
|
|
|
deleting: {
|
|
|
message: 'Could not delete webhook',
|
|
|
reason: action.payload.error.toString(),
|
|
|
className: 'cvat-notification-notice-delete-webhook-failed',
|
|
|
},
|
|
|
},
|
|
|
},
|
|
|
};
|
|
|
}
|
|
|
case BoundariesActionTypes.RESET_AFTER_ERROR:
|
|
|
case AuthActionTypes.LOGOUT_SUCCESS: {
|
|
|
return { ...defaultState };
|
|
|
}
|
|
|
default: {
|
|
|
return state;
|
|
|
}
|
|
|
}
|
|
|
}
|