{
const snapshotId = match && match.params && match.params.snapshotId;
const projectId = match && match.params && match.params.projectId;
- // const isActionRestoring = useSelector(state => state.trackingReducers.isActionRestoring);
-
const { isLoading, setIsLoading } = useContext(LoadingContext);
const [state, setState] = useState();
diff --git a/js/components/toast/ToastProvider.js b/js/components/toast/ToastProvider.js
index 2539e3497..9c893cde0 100644
--- a/js/components/toast/ToastProvider.js
+++ b/js/components/toast/ToastProvider.js
@@ -74,7 +74,23 @@ export const ToastProvider = memo(props => {
const infoOptions = {
variant: 'info'
};
- toast(text, { ...infoOptions, ...options });
+ const message = options.link ? (
+ <>
+
{text} {' '}
+
{
+ options.link.linkAction(...options.link.linkParams);
+ }}
+ >
+ {options.link.linkText}
+
+
+ ) : (
+ { text }
+ );
+ options.link ? toast(message, { ...infoOptions, ...options }) : toast(text, { ...infoOptions, ...options });
+ // toast(text, { ...infoOptions, ...options });
};
return (
diff --git a/js/components/tracking/EditableText.js b/js/components/tracking/EditableText.js
deleted file mode 100644
index 91549d9de..000000000
--- a/js/components/tracking/EditableText.js
+++ /dev/null
@@ -1,68 +0,0 @@
-import React, { useState, useRef, useEffect } from 'react';
-import { makeStyles, TextField, IconButton, Tooltip, Grid } from '@material-ui/core';
-import { Edit } from '@material-ui/icons';
-
-const useStyles = makeStyles(theme => ({
- search: {
- width: '100%'
- },
- fontSizeSmall: {
- fontSize: '0.82rem'
- }
-}));
-
-const EditableInput = ({ dataText, index, updateText }) => {
- const inputRef = useRef(null);
- const [inputVisible, setInputVisible] = useState(false);
- const [text, setText] = useState(dataText);
- const classes = useStyles();
-
- const onClickOutSide = e => {
- if (inputRef.current && !inputRef.current.contains(e.target)) {
- setInputVisible(false);
- if (updateText && text !== dataText) {
- updateText(text);
- }
- }
- };
-
- useEffect(() => {
- // Handle outside clicks on mounted state
- if (inputVisible) {
- document.addEventListener('mousedown', onClickOutSide);
- }
-
- // This is a necessary step to "dismount" unnecessary events when we destroy the component
- return () => {
- document.removeEventListener('mousedown', onClickOutSide);
- };
- });
-
- return (
-
- {inputVisible ? (
- {
- setText(e.target.value);
- }}
- />
- ) : (
-
- { setInputVisible(true)}>{text} }
- {
- setInputVisible(true)}>
-
-
-
- }
-
- )}
-
- );
-};
-
-export default EditableInput;
diff --git a/js/components/tracking/timelineView.js b/js/components/tracking/timelineView.js
deleted file mode 100644
index 527d1a41d..000000000
--- a/js/components/tracking/timelineView.js
+++ /dev/null
@@ -1,228 +0,0 @@
-import React, { useState, useRef, memo } from 'react';
-import { useDispatch, useSelector } from 'react-redux';
-import { makeStyles, IconButton, Tooltip, Grid, Box, Chip } from '@material-ui/core';
-import { Check, Clear, Warning, Favorite, Star } from '@material-ui/icons';
-import { actionAnnotation } from '../../reducers/tracking/constants';
-import { TimelineEvent } from 'react-event-timeline';
-import EditableText from './EditableText';
-import palette from '../../theme/palette';
-import { updateTrackingActions } from '../../reducers/tracking/dispatchActions';
-import { actionType } from '../../reducers/tracking/constants';
-import Gallery from 'react-grid-gallery';
-
-const useStyles = makeStyles(theme => ({
- headerGrid: {
- height: '15px'
- },
- grid: {
- height: 'inherit'
- },
- iconButton: {
- padding: '6px',
- paddingTop: '0px'
- },
- timelineEvent: {
- borderBottom: '1px dashed ' + palette.divider,
- paddingBottom: '10px'
- },
- title: {
- position: 'relative',
- paddingLeft: '45px',
- textAlign: 'left',
- fontWeight: 'bold'
- },
- titleMargin: {
- marginRight: '5px'
- }
-}));
-
-const TimelineView = memo(({ data, index }) => {
- const dispatch = useDispatch();
- const classes = useStyles();
-
- const currentSnapshotID = useSelector(state => state.projectReducers.currentSnapshot.id);
- let isSelected = currentSnapshotID === data.object_id;
-
- const ref = useRef(null);
- const [isHovering, setIsHovering] = useState(false);
- const [updatedIcon, setUpdatedIcon] = useState(null);
-
- const getActionIcon = annotation => {
- if (annotation) {
- switch (annotation) {
- case actionAnnotation.CHECK:
- return
;
- case actionAnnotation.CLEAR:
- return
;
- case actionAnnotation.WARNING:
- return
;
- case actionAnnotation.FAVORITE:
- return
;
- case actionAnnotation.STAR:
- return
;
- default:
- return
;
- }
- } else {
- return
;
- }
- };
-
- const annotationActions = [
-
{
- setUpdatedIcon(actionAnnotation.CHECK);
- updateDataAnnotation(actionAnnotation.CHECK);
- }}
- >
-
-
- ,
-
{
- setUpdatedIcon(actionAnnotation.CLEAR);
- updateDataAnnotation(actionAnnotation.CLEAR);
- }}
- >
-
-
- ,
-
{
- setUpdatedIcon(actionAnnotation.WARNING);
- updateDataAnnotation(actionAnnotation.WARNING);
- }}
- >
-
-
- ,
-
{
- setUpdatedIcon(actionAnnotation.FAVORITE);
- updateDataAnnotation(actionAnnotation.FAVORITE);
- }}
- >
-
-
- ,
-
{
- setUpdatedIcon(actionAnnotation.STAR);
- updateDataAnnotation(actionAnnotation.STAR);
- }}
- >
-
-
-
- ];
-
- const updateDataText = text => {
- data.text = text;
- dispatch(updateTrackingActions(data));
- };
-
- const updateDataAnnotation = annotation => {
- data.annotation = annotation;
- dispatch(updateTrackingActions(data));
- };
-
- const images = [
- {
- src: data.image,
- thumbnail: data.image,
- thumbnailWidth: 0,
- thumbnailHeight: 0,
- caption: data.object_name
- }
- ];
-
- return (
-
setIsHovering(true)} onMouseLeave={() => setIsHovering(false)}>
- {data.type && data.type === actionType.SNAPSHOT ? (
- <>
-
- {isSelected && (
-
-
- )}
- {
-
- {`${data.text}`}
-
- }
- {
-
-
- }
-
-
- ) : (
- <>
-
-
- {
-
-
- }
- {isHovering && (
-
- {annotationActions &&
- annotationActions.map((action, index) => (
-
- {action}
-
- ))}
-
- )}
-
-
- }
- createdAt={new Date(data.timestamp).toLocaleString()}
- icon={updatedIcon && updatedIcon != null ? getActionIcon(updatedIcon) : getActionIcon(data.annotation)}
- iconColor={palette.primary.main}
- className={classes.timelineEvent}
- >
-
- )}
-
- );
-});
-
-TimelineView.displayName = 'TimelineView';
-export default TimelineView;
diff --git a/js/components/tracking/trackingModal.js b/js/components/tracking/trackingModal.js
deleted file mode 100644
index 032135214..000000000
--- a/js/components/tracking/trackingModal.js
+++ /dev/null
@@ -1,105 +0,0 @@
-import React, { memo, useCallback, useEffect, useRef } from 'react';
-import { useSelector, useDispatch } from 'react-redux';
-import Modal from '../common/Modal';
-import { Grid, makeStyles, IconButton, Tooltip } from '@material-ui/core';
-import { Timeline } from 'react-event-timeline';
-import { Close } from '@material-ui/icons';
-import { Panel } from '../common';
-import TimelineView from './timelineView';
-import { setProjectTrackingActions } from '../../reducers/tracking/dispatchActions';
-
-const useStyles = makeStyles(theme => ({
- customModal: {
- width: '70%',
- height: '90%'
- },
- customContentModal: {
- height: '100%'
- },
-
- divContainer: {
- height: '100%',
- width: '100%',
- paddingTop: theme.spacing(1) / 2
- },
- divScrollable: {
- height: '100%',
- width: '100%',
- overflow: 'auto'
- },
- containerExpanded: { height: '100%' }
-}));
-
-export const TrackingModal = memo(({ openModal, onModalClose }) => {
- const classes = useStyles();
- const dispatch = useDispatch();
- const bottomRef = useRef();
-
- const actionList = useSelector(state => state.trackingReducers.project_actions_list);
- const orderedActionList = (actionList && actionList.sort((a, b) => a.timestamp - b.timestamp)) || [];
-
- const loadAllActions = useCallback(() => {
- if (openModal === true) {
- dispatch(setProjectTrackingActions());
- }
- }, [dispatch, openModal]);
-
- const scrollToBottom = () => {
- if (bottomRef.current != null) {
- bottomRef.current.scrollIntoView({
- behavior: 'auto',
- block: 'nearest',
- inline: 'nearest'
- });
- }
- };
-
- useEffect(() => {
- loadAllActions();
- }, [loadAllActions]);
-
- if (openModal === undefined) {
- console.log('undefined openModal');
- onModalClose();
- }
-
- const actions = [
-
onModalClose()}>
-
-
-
- ];
-
- return (
-
onModalClose()}
- >
-
-
-
-
-
- {orderedActionList &&
- orderedActionList.map((data, index) => {
- if (data && data != null) {
- return
-
{
- bottomRef.current = el;
- scrollToBottom();
- }}
- >
-
-
-
-
- );
-});
diff --git a/js/components/userFeedback/browserApi.js b/js/components/userFeedback/browserApi.js
index cbb7c0c33..afa59899f 100644
--- a/js/components/userFeedback/browserApi.js
+++ b/js/components/userFeedback/browserApi.js
@@ -1,5 +1,4 @@
import { setImageSource, setIsOpenForm } from './redux/actions';
-import { setTrackingImageSource } from '../../reducers/tracking/actions';
import html2canvas from 'html2canvas';
/* Getting image from screen capture or */
@@ -85,6 +84,6 @@ export const captureScreen = () => async dispatch => {
export const captureScreenOfSnapshot = () => async dispatch => {
html2canvas(document.body).then(canvas => {
- dispatch(setTrackingImageSource(canvas.toDataURL()));
+ // dispatch(setTrackingImageSource(canvas.toDataURL()));
});
};
diff --git a/js/index.js b/js/index.js
index 223efe894..cba0b3263 100644
--- a/js/index.js
+++ b/js/index.js
@@ -10,15 +10,11 @@ import { applyMiddleware, createStore } from 'redux';
import { rootReducer } from './reducers/rootReducer';
import { saveStore } from './components/helpers/globalStore';
import thunkMiddleware from 'redux-thunk';
-import trackingMiddleware from './reducers/tracking/trackingMiddleware';
-import nglTrackingMiddleware from './reducers/nglTracking/nglTrackingMiddleware';
import { composeWithDevTools } from 'redux-devtools-extension';
const middlewareEnhancer = applyMiddleware(
//loggerMiddleware,
- thunkMiddleware,
- trackingMiddleware,
- nglTrackingMiddleware
+ thunkMiddleware
);
const enhancers = [middlewareEnhancer];
const composedEnhancers = composeWithDevTools(...enhancers);
diff --git a/js/reducers/actions.js b/js/reducers/actions.js
new file mode 100644
index 000000000..31188db11
--- /dev/null
+++ b/js/reducers/actions.js
@@ -0,0 +1,8 @@
+import { constants } from './constants';
+
+export const setEntireState = newState => {
+ return {
+ type: constants.SET_ENTIRE_STATE,
+ newState: newState
+ };
+};
diff --git a/js/reducers/api/actions.js b/js/reducers/api/actions.js
index f21069edb..08ebe6857 100644
--- a/js/reducers/api/actions.js
+++ b/js/reducers/api/actions.js
@@ -394,3 +394,45 @@ export const setIsSnapshot = (isSnapshot, skipTracking = true) => {
skipTracking
};
};
+
+export const setLHSDataIsLoading = lhsDataIsLoading => {
+ return {
+ type: constants.SET_LHS_DATA_IS_LOADING,
+ lhsDataIsLoading: lhsDataIsLoading
+ };
+};
+
+export const setLHSDataIsLoaded = lhsDataIsLoaded => {
+ return {
+ type: constants.SET_LHS_DATA_IS_LOADED,
+ lhsDataIsLoaded: lhsDataIsLoaded
+ };
+};
+
+export const setRHSDataIsLoading = rhsDataIsLoading => {
+ return {
+ type: constants.SET_RHS_DATA_IS_LOADING,
+ rhsDataIsLoading: rhsDataIsLoading
+ };
+};
+
+export const setRHSDataIsLoaded = rhsDataIsLoaded => {
+ return {
+ type: constants.SET_RHS_DATA_IS_LOADED,
+ rhsDataIsLoaded: rhsDataIsLoaded
+ };
+};
+
+export const setProteinIsLoading = proteinIsLoading => {
+ return {
+ type: constants.SET_PROTEIN_IS_LOADING,
+ proteinIsLoading: proteinIsLoading
+ };
+};
+
+export const setProteinIsLoaded = proteinIsLoaded => {
+ return {
+ type: constants.SET_PROTEIN_IS_LOADED,
+ proteinIsLoaded: proteinIsLoaded
+ };
+};
diff --git a/js/reducers/api/apiReducers.js b/js/reducers/api/apiReducers.js
index a2ce50660..92f2c2481 100644
--- a/js/reducers/api/apiReducers.js
+++ b/js/reducers/api/apiReducers.js
@@ -52,7 +52,13 @@ export const INITIAL_STATE = {
target_data_loading_in_progress: false,
all_data_loaded: false,
isSnapshot: false,
- lhs_compounds_list: []
+ lhs_compounds_list: [],
+ lhsDataIsLoading: false,
+ lhsDataIsLoaded: false,
+ rhsDataIsLoading: false,
+ rhsDataIsLoaded: false,
+ proteinIsLoading: false,
+ proteinIsLoaded: false
};
export const RESET_TARGET_STATE = {
@@ -99,6 +105,24 @@ export const RESET_TARGET_STATE = {
export default function apiReducers(state = INITIAL_STATE, action = {}) {
switch (action.type) {
+ case constants.SET_LHS_DATA_IS_LOADING:
+ return { ...state, lhsDataIsLoading: action.lhsDataIsLoading };
+
+ case constants.SET_LHS_DATA_IS_LOADED:
+ return { ...state, lhsDataIsLoaded: action.lhsDataIsLoaded };
+
+ case constants.SET_RHS_DATA_IS_LOADING:
+ return { ...state, rhsDataIsLoading: action.rhsDataIsLoading };
+
+ case constants.SET_RHS_DATA_IS_LOADED:
+ return { ...state, rhsDataIsLoaded: action.rhsDataIsLoaded };
+
+ case constants.SET_PROTEIN_IS_LOADING:
+ return { ...state, proteinIsLoading: action.proteinIsLoading };
+
+ case constants.SET_PROTEIN_IS_LOADED:
+ return { ...state, proteinIsLoaded: action.proteinIsLoaded };
+
case constants.SET_OPEN_DISCOURSE_ERROR_MODAL:
return Object.assign({}, state, { open_discourse_error_modal: action.payload });
@@ -302,7 +326,7 @@ export default function apiReducers(state = INITIAL_STATE, action = {}) {
case constants.SET_SESSION_ID_LIST:
let sessionSummaryNew = [];
- for (var key in action.sessionIdList) {
+ for (const key in action.sessionIdList) {
sessionSummaryNew.push({
id: action.sessionIdList[key].id,
uuid: action.sessionIdList[key].uuid,
@@ -320,7 +344,7 @@ export default function apiReducers(state = INITIAL_STATE, action = {}) {
case constants.UPDATE_SESSION_ID_LIST:
let sessionSummary = [];
- for (var key in action.sessionIdList) {
+ for (const key in action.sessionIdList) {
sessionSummary.push({
id: action.sessionIdList[key].id,
uuid: action.sessionIdList[key].uuid,
diff --git a/js/reducers/api/constants.js b/js/reducers/api/constants.js
index 40d150168..c8ae1a86f 100644
--- a/js/reducers/api/constants.js
+++ b/js/reducers/api/constants.js
@@ -56,5 +56,11 @@ export const constants = {
SET_LHS_COMPOUNDS_LIST: prefix + 'SET_LHS_COMPOUNDS_LIST',
UPDATE_LHS_COMPOUND: prefix + 'UPDATE_LHS_COMPOUND',
REMOVE_LHS_COMPOUND: prefix + 'REMOVE_LHS_COMPOUND',
- REPLACE_TARGET: prefix + 'REPLACE_TARGET'
+ REPLACE_TARGET: prefix + 'REPLACE_TARGET',
+ SET_LHS_DATA_IS_LOADING: prefix + 'SET_LHS_DATA_IS_LOADING',
+ SET_LHS_DATA_IS_LOADED: prefix + 'SET_LHS_DATA_IS_LOADED',
+ SET_RHS_DATA_IS_LOADING: prefix + 'SET_RHS_DATA_IS_LOADING',
+ SET_RHS_DATA_IS_LOADED: prefix + 'SET_RHS_DATA_IS_LOADED',
+ SET_PROTEIN_IS_LOADING: prefix + 'SET_PROTEIN_IS_LOADING',
+ SET_PROTEIN_IS_LOADED: prefix + 'SET_PROTEIN_IS_LOADED'
};
diff --git a/js/reducers/constants.js b/js/reducers/constants.js
new file mode 100644
index 000000000..5f2652136
--- /dev/null
+++ b/js/reducers/constants.js
@@ -0,0 +1,4 @@
+const prefix = 'REDUCERS_ROOT_';
+export const constants = {
+ SET_ENTIRE_STATE: prefix + 'SET_ENTIRE_STATE'
+};
diff --git a/js/reducers/ngl/actions.js b/js/reducers/ngl/actions.js
index 7c58ae185..ef3054f8d 100644
--- a/js/reducers/ngl/actions.js
+++ b/js/reducers/ngl/actions.js
@@ -265,3 +265,23 @@ export const addToQualityCache = (name, cacheItem) => ({
type: CONSTANTS.ADD_TO_QUALITY_CACHE,
payload: { name: name, cacheItem: cacheItem }
});
+
+export const setSkipOrientationChange = skip => ({
+ type: CONSTANTS.SET_SKIP_ORIENTATION_CHANGE,
+ skip: skip
+});
+
+export const setNglViewFromSnapshotRendered = rendered => ({
+ type: CONSTANTS.SET_NGL_VIEW_FROM_SNAPSHOT_RENDERED,
+ rendered
+});
+
+export const setSnapshotOrientationApplied = applied => ({
+ type: CONSTANTS.SET_SNAPSHOT_ORIENTATION_APPLIED,
+ applied
+});
+
+export const setReapplyOrientation = reapply => ({
+ type: CONSTANTS.SET_REAPPLY_ORIENTATION,
+ reapply
+});
diff --git a/js/reducers/ngl/constants.js b/js/reducers/ngl/constants.js
index 5fdde957a..3fa64dedf 100644
--- a/js/reducers/ngl/constants.js
+++ b/js/reducers/ngl/constants.js
@@ -58,10 +58,26 @@ export const CONSTANTS = {
SET_WARNING_ICON: prefix + 'SET_WARNING_ICON',
SET_ELECTRON_COLOR_DENSITY: prefix + 'SET_ELECTRON_COLOR' + MAP_TYPE.event,
SET_ELECTRON_COLOR_DENSITY_MAP_sigmaa: prefix + 'SET_ELECTRON_COLOR' + MAP_TYPE.sigmaa,
- SET_ELECTRON_COLOR_DENSITY_MAP_diff: prefix + 'SET_ELECTRONCOLOR' + MAP_TYPE.diff
+ SET_ELECTRON_COLOR_DENSITY_MAP_diff: prefix + 'SET_ELECTRONCOLOR' + MAP_TYPE.diff,
+
+ SET_SKIP_ORIENTATION_CHANGE: prefix + 'SET_SKIP_ORIENTATION_CHANGE',
+ SET_NGL_VIEW_FROM_SNAPSHOT_RENDERED: prefix + 'SET_NGL_VIEW_FROM_SNAPSHOT_RENDERED',
+ SET_SNAPSHOT_ORIENTATION_APPLIED: prefix + 'SET_SNAPSHOT_ORIENTATION_APPLIED',
+ SET_REAPPLY_ORIENTATION: prefix + 'SET_REAPPLY_ORIENTATION'
};
export const SCENES = {
defaultScene: 'defaultScene',
sessionScene: 'sessionScene'
};
+
+export const NGL_OBJECTS = {
+ PROTEIN: 'PROTEIN',
+ LIGAND: 'LIGAND',
+ SURFACE: 'SURFACE',
+ DENSITY: 'DENSITY',
+ DENSITY_CUSTOM: 'DENSITY_CUSTOM',
+ VECTOR: 'VECTOR',
+ COMPLEX: 'COMPLEX',
+ QUALITY: 'QUALITY'
+};
diff --git a/js/reducers/ngl/dispatchActions.js b/js/reducers/ngl/dispatchActions.js
index c15f95588..ada75f6b4 100644
--- a/js/reducers/ngl/dispatchActions.js
+++ b/js/reducers/ngl/dispatchActions.js
@@ -53,7 +53,7 @@ export const loadObject = ({
console.log('loadObject - entry');
if (stage) {
const state = getState();
- const actionRestoring = state.trackingReducers.isActionRestoring;
+ const actionRestoring = false; //state.trackingReducers.isActionRestoring;
dispatch(incrementCountOfPendingNglObjects(target.display_div));
const versionFixedTarget = JSON.parse(JSON.stringify(target));
@@ -210,7 +210,7 @@ export const setOrientationByInteraction = (div_id, orientation) => (dispatch, g
export const centerOnLigandByMoleculeID = (stage, moleculeID) => (dispatch, getState) => {
if (moleculeID && stage) {
const state = getState();
- const skipOrientation = state.trackingReducers.skipOrientationChange;
+ const skipOrientation = false; //state.trackingReducers.skipOrientationChange;
if (!skipOrientation) {
const storedOrientation = state.nglReducers.moleculeOrientations[moleculeID];
console.count(`Before applying orientation centerOnLigandByMoleculeID`);
@@ -257,7 +257,7 @@ export const reloadNglViewFromSnapshot = (stage, display_div, snapshot) => (disp
});
const state = getState();
- const skipOrientation = state.trackingReducers.skipOrientationChange;
+ const skipOrientation = false; //state.trackingReducers.skipOrientationChange;
// nglOrientations
if (!skipOrientation) {
const newOrientation = snapshot.nglOrientations[display_div];
@@ -368,7 +368,7 @@ export const isDensityMapVisible = (type, stage) => {
export const restoreNglOrientation = (orientation, oldOrientation, div_id, stages) => (dispatch, getState) => {
const state = getState();
- const skipOrientation = state.trackingReducers.skipOrientationChange;
+ const skipOrientation = false; //state.trackingReducers.skipOrientationChange;
if (!skipOrientation) {
const view = stages.find(view => view.id === div_id);
diff --git a/js/reducers/ngl/nglReducers.js b/js/reducers/ngl/nglReducers.js
index 1cf6a2d46..bce6f2297 100644
--- a/js/reducers/ngl/nglReducers.js
+++ b/js/reducers/ngl/nglReducers.js
@@ -45,13 +45,29 @@ export const INITIAL_STATE = {
qualityCache: {},
electronDensityColor_event: 'blue',
electronDensityColor_sigmaa: 'blue',
- electronDensityColor_diff: 'blue'
+ electronDensityColor_diff: 'blue',
+ skipOrientationChange: false,
+ nglViewFromSnapshotRendered: false,
+ snapshotOrientationApplied: false,
+ reapplyOrientation: false
};
export default function nglReducers(state = INITIAL_STATE, action = {}) {
switch (action.type) {
// Defined in initialState - but may be needed if we want to load a different structure
+ case CONSTANTS.SET_SKIP_ORIENTATION_CHANGE:
+ return { ...state, skipOrientationChange: action.skip };
+
+ case CONSTANTS.SET_REAPPLY_ORIENTATION:
+ return { ...state, reapplyOrientation: action.reapply };
+
+ case CONSTANTS.SET_NGL_VIEW_FROM_SNAPSHOT_RENDERED:
+ return { ...state, nglViewFromSnapshotRendered: { ...action.rendered } };
+
+ case CONSTANTS.SET_SNAPSHOT_ORIENTATION_APPLIED:
+ return { ...state, snapshotOrientationApplied: action.applied };
+
case CONSTANTS.LOAD_OBJECT:
// at first check if object was already stashed
const objectsInViewStashTemp = JSON.parse(JSON.stringify(state.objectsInViewStash));
@@ -117,7 +133,10 @@ export default function nglReducers(state = INITIAL_STATE, action = {}) {
// stash state of the object
let newObjectsInViewStash = JSON.parse(JSON.stringify(state.objectsInViewStash));
if (objectsInViewTemp.hasOwnProperty(action.target.name)) {
- newObjectsInViewStash[action.target.name] = { ...objectsInViewTemp[action.target.name], representations: objectsInViewTemp[action.target.name].representations };
+ newObjectsInViewStash[action.target.name] = {
+ ...objectsInViewTemp[action.target.name],
+ representations: objectsInViewTemp[action.target.name].representations
+ };
}
delete objectsInViewTemp[action.target.name];
@@ -195,9 +214,9 @@ export default function nglReducers(state = INITIAL_STATE, action = {}) {
case CONSTANTS.APPEND_MOLECULE_ORIENTATION:
const newMoleculeOrientations = Object.assign({}, state.moleculeOrientations);
- if (newMoleculeOrientations[action.payload.moleculeID] === undefined) {
- newMoleculeOrientations[action.payload.moleculeID] = action.payload.orientation;
- }
+ // if (newMoleculeOrientations[action.payload.moleculeID] === undefined) {
+ newMoleculeOrientations[action.payload.moleculeID] = action.payload.orientation;
+ // }
return Object.assign({}, state, { moleculeOrientations: newMoleculeOrientations });
case CONSTANTS.REMOVE_MOLECULE_ORIENTATION:
diff --git a/js/reducers/ngl/useDisplayComplexLHS.js b/js/reducers/ngl/useDisplayComplexLHS.js
new file mode 100644
index 000000000..48603c6a7
--- /dev/null
+++ b/js/reducers/ngl/useDisplayComplexLHS.js
@@ -0,0 +1,87 @@
+import { useCallback, useContext, useEffect } from 'react';
+import { useDispatch, useSelector } from 'react-redux';
+import { NGL_OBJECTS } from './constants';
+import { appendComplexList, removeFromComplexList, removeFromToBeDisplayedList } from '../selection/actions';
+import { generateComplexObject, generateMoleculeId } from '../../components/nglView/generatingObjects';
+import { VIEWS } from '../../constants/constants';
+import { NglContext } from '../../components/nglView/nglProvider';
+import { getRandomColor } from '../../components/preview/molecule/utils/color';
+import { deleteObject, loadObject, setOrientation } from './dispatchActions';
+import { base_url } from '../../components/routes/constants';
+import { getToBeDisplayedStructures } from './utils';
+
+export const useDisplayComplexLHS = () => {
+ const dispatch = useDispatch();
+
+ const toBeDisplayedList = useSelector(state => state.selectionReducers.toBeDisplayedList);
+ const displayedComplexes = useSelector(state => state.selectionReducers.complexList);
+ const allObservations = useSelector(state => state.apiReducers.all_mol_lists);
+
+ const { getNglView } = useContext(NglContext);
+ const stage = getNglView(VIEWS.MAJOR_VIEW) && getNglView(VIEWS.MAJOR_VIEW).stage;
+
+ const displayComplex = useCallback(
+ complexData => {
+ const data = allObservations.find(obs => obs.id === complexData.id);
+ if (!data) return;
+ const colourToggle = getRandomColor(data);
+
+ dispatch(appendComplexList(generateMoleculeId(data)));
+ return dispatch(
+ loadObject({
+ target: Object.assign({ display_div: VIEWS.MAJOR_VIEW }, generateComplexObject(data, colourToggle, base_url)),
+ stage,
+ previousRepresentations: complexData.representations,
+ orientationMatrix: null,
+ preserveColour: complexData.preserveColour
+ })
+ ).finally(() => {
+ const currentOrientation = stage.viewerControls.getOrientation();
+ dispatch(setOrientation(VIEWS.MAJOR_VIEW, currentOrientation));
+ });
+ },
+ [allObservations, dispatch, stage]
+ );
+
+ const removeComplex = useCallback(
+ complexData => {
+ const data = allObservations.find(obs => obs.id === complexData.id);
+ if (!data) return;
+ const colourToggle = getRandomColor(data);
+
+ dispatch(
+ deleteObject(
+ Object.assign({ display_div: VIEWS.MAJOR_VIEW }, generateComplexObject(data, colourToggle, base_url)),
+ stage
+ )
+ );
+ dispatch(removeFromComplexList(generateMoleculeId(data)));
+
+ dispatch(removeFromToBeDisplayedList({ id: complexData.id, type: NGL_OBJECTS.COMPLEX }));
+ },
+ [allObservations, dispatch, stage]
+ );
+
+ useEffect(() => {
+ const toBeDisplayedComplexes = getToBeDisplayedStructures(
+ toBeDisplayedList,
+ displayedComplexes,
+ NGL_OBJECTS.COMPLEX
+ );
+ toBeDisplayedComplexes?.forEach(data => {
+ displayComplex(data);
+ });
+
+ const toBeRemovedComplexes = getToBeDisplayedStructures(
+ toBeDisplayedList,
+ displayedComplexes,
+ NGL_OBJECTS.COMPLEX,
+ true
+ );
+ toBeRemovedComplexes?.forEach(data => {
+ removeComplex(data);
+ });
+ }, [toBeDisplayedList, displayComplex, dispatch, stage, removeComplex, displayedComplexes]);
+
+ return {};
+};
diff --git a/js/reducers/ngl/useDisplayComplexRHS.js b/js/reducers/ngl/useDisplayComplexRHS.js
new file mode 100644
index 000000000..ecc3726a2
--- /dev/null
+++ b/js/reducers/ngl/useDisplayComplexRHS.js
@@ -0,0 +1,99 @@
+import { useCallback, useContext, useEffect } from 'react';
+import { useDispatch, useSelector } from 'react-redux';
+import { NglContext } from '../../components/nglView/nglProvider';
+import { VIEWS } from '../../constants/constants';
+import { NGL_OBJECTS } from './constants';
+import { getToBeDisplayedStructuresDataset } from './utils';
+import { getRandomColor } from '../../components/preview/molecule/utils/color';
+import {
+ appendComplexList,
+ removeFromComplexList,
+ removeFromToBeDisplayedListForDataset
+} from '../../components/datasets/redux/actions';
+import { generateComplexObject, generateMoleculeCompoundId } from '../../components/nglView/generatingObjects';
+import { deleteObject, loadObject, setOrientation } from './dispatchActions';
+import { base_url } from '../../components/routes/constants';
+
+export const useDisplayComplexRHS = () => {
+ const dispatch = useDispatch();
+
+ const toBeDisplayedList = useSelector(state => state.datasetsReducers.toBeDisplayedList);
+ const displayedComplexes = useSelector(state => state.datasetsReducers.complexLists);
+ const allCompounds = useSelector(state => state.datasetsReducers.moleculeLists);
+
+ const { getNglView } = useContext(NglContext);
+ const stage = getNglView(VIEWS.MAJOR_VIEW) && getNglView(VIEWS.MAJOR_VIEW).stage;
+
+ const displayComplex = useCallback(
+ complexData => {
+ const datasetCompounds = allCompounds[complexData.datasetID];
+ const data = datasetCompounds?.find(obs => obs.id === complexData.id);
+ if (!data) return;
+ const colourToggle = getRandomColor(data);
+ const datasetID = complexData.datasetID;
+
+ dispatch(appendComplexList(datasetID, generateMoleculeCompoundId(data)));
+ return dispatch(
+ loadObject({
+ target: Object.assign(
+ { display_div: VIEWS.MAJOR_VIEW },
+ generateComplexObject(data, colourToggle, base_url, datasetID)
+ ),
+ stage,
+ previousRepresentations: complexData.representations,
+ orientationMatrix: null
+ })
+ ).finally(() => {
+ const currentOrientation = stage.viewerControls.getOrientation();
+ dispatch(setOrientation(VIEWS.MAJOR_VIEW, currentOrientation));
+ });
+ },
+ [allCompounds, dispatch, stage]
+ );
+
+ const removeComplex = useCallback(
+ complexData => {
+ const datasetCompounds = allCompounds[complexData.datasetID];
+ const data = datasetCompounds?.find(obs => obs.id === complexData.id);
+ if (!data) return;
+ const datasetID = complexData.datasetID;
+ const colourToggle = getRandomColor(data);
+
+ dispatch(
+ deleteObject(
+ Object.assign(
+ { display_div: VIEWS.MAJOR_VIEW },
+ generateComplexObject(data, colourToggle, base_url, datasetID)
+ ),
+ stage
+ )
+ );
+ dispatch(removeFromComplexList(datasetID, generateMoleculeCompoundId(data)));
+
+ dispatch(removeFromToBeDisplayedListForDataset(datasetID, { id: complexData.id, type: NGL_OBJECTS.COMPLEX }));
+ },
+ [allCompounds, dispatch, stage]
+ );
+
+ useEffect(() => {
+ const toBeRemovedComplexes = getToBeDisplayedStructuresDataset(
+ toBeDisplayedList,
+ displayedComplexes,
+ NGL_OBJECTS.COMPLEX,
+ true
+ );
+ toBeRemovedComplexes?.forEach(data => {
+ removeComplex(data);
+ });
+ const toBeDisplayedComplexes = getToBeDisplayedStructuresDataset(
+ toBeDisplayedList,
+ displayedComplexes,
+ NGL_OBJECTS.COMPLEX
+ );
+ toBeDisplayedComplexes?.forEach(data => {
+ displayComplex(data);
+ });
+ }, [toBeDisplayedList, displayedComplexes, displayComplex, dispatch, stage, removeComplex]);
+
+ return {};
+};
diff --git a/js/reducers/ngl/useDisplayDensityLHS.js b/js/reducers/ngl/useDisplayDensityLHS.js
new file mode 100644
index 000000000..1b14e10fc
--- /dev/null
+++ b/js/reducers/ngl/useDisplayDensityLHS.js
@@ -0,0 +1,214 @@
+import { useCallback, useContext, useEffect } from 'react';
+import { useDispatch, useSelector } from 'react-redux';
+import { NGL_OBJECTS } from './constants';
+import {
+ appendDensityList,
+ appendDensityListCustom,
+ appendToBeDisplayedList,
+ appendToDensityListType,
+ removeFromDensityList,
+ removeFromDensityListCustom,
+ removeFromDensityListType,
+ removeFromToBeDisplayedList
+} from '../selection/actions';
+import { generateDensityObject, generateMoleculeId } from '../../components/nglView/generatingObjects';
+import { VIEWS } from '../../constants/constants';
+import { NglContext } from '../../components/nglView/nglProvider';
+import { getRandomColor } from '../../components/preview/molecule/utils/color';
+import { loadObject, setOrientation } from './dispatchActions';
+import { base_url } from '../../components/routes/constants';
+import { getToBeDisplayedStructures } from './utils';
+import {
+ addQuality,
+ deleteDensityObject,
+ getDensityChangedParams,
+ getDensityMapData,
+ getProteinData,
+ removeQuality,
+ toggleDensityWireframe
+} from '../../components/preview/molecule/redux/dispatchActions';
+
+export const useDisplayDensityLHS = () => {
+ const dispatch = useDispatch();
+
+ const toBeDisplayedList = useSelector(state => state.selectionReducers.toBeDisplayedList);
+ const displayedDensities = useSelector(state => state.selectionReducers.densityList);
+ const displayedCustomDensities = useSelector(state => state.selectionReducers.densityListCustom);
+ const allObservations = useSelector(state => state.apiReducers.all_mol_lists);
+
+ const { getNglView } = useContext(NglContext);
+ const stage = getNglView(VIEWS.MAJOR_VIEW) && getNglView(VIEWS.MAJOR_VIEW).stage;
+
+ const displayDensity = useCallback(
+ async densityData => {
+ const data = allObservations.find(obs => obs.id === densityData.id);
+ if (!data) return;
+ const colourToggle = getRandomColor(data);
+
+ if (!data.proteinData) {
+ await dispatch(getDensityMapData(data));
+ }
+
+ const prepParams = dispatch(getDensityChangedParams(densityData.isWireframeStyle));
+ const densityObject = generateDensityObject(data, colourToggle, base_url, densityData.isWireframeStyle);
+ const combinedObject = { ...prepParams, ...densityObject };
+ dispatch(
+ loadObject({
+ target: Object.assign({ display_div: VIEWS.MAJOR_VIEW }, combinedObject),
+ stage,
+ previousRepresentations: densityData.representations,
+ orientationMatrix: null
+ })
+ ).finally(() => {
+ const currentOrientation = stage.viewerControls.getOrientation();
+ dispatch(setOrientation(VIEWS.MAJOR_VIEW, currentOrientation));
+ let molDataId = generateMoleculeId(data);
+ if (!data.proteinData) {
+ dispatch(getProteinData(data)).then(i => {
+ const proteinData = i;
+ data.proteinData = proteinData;
+
+ molDataId['render_event'] = data.proteinData.render_event;
+ molDataId['render_sigmaa'] = data.proteinData.render_sigmaa;
+ molDataId['render_diff'] = data.proteinData.render_diff;
+ molDataId['render_quality'] = data.proteinData.render_quality;
+
+ dispatch(appendDensityList(generateMoleculeId(data)));
+ dispatch(appendToDensityListType(molDataId));
+ if (data.proteinData.render_quality) {
+ return dispatch(addQuality(stage, data, colourToggle, true));
+ }
+ });
+ } else {
+ molDataId['render_event'] = data.proteinData.render_event;
+ molDataId['render_sigmaa'] = data.proteinData.render_sigmaa;
+ molDataId['render_diff'] = data.proteinData.render_diff;
+ molDataId['render_quality'] = data.proteinData.render_quality;
+
+ dispatch(appendDensityList(generateMoleculeId(data)));
+ dispatch(appendToDensityListType(molDataId));
+ if (data.proteinData.render_quality) {
+ return dispatch(addQuality(stage, data, colourToggle, true));
+ }
+ }
+ });
+ },
+ [allObservations, dispatch, stage]
+ );
+
+ const displayCustomDensity = useCallback(
+ async densityData => {
+ const data = allObservations.find(obs => obs.id === densityData.id);
+ if (!data) return;
+ const colourToggle = getRandomColor(data);
+
+ if (!data.proteinData) {
+ await dispatch(getDensityMapData(data));
+ }
+
+ let densityObject = dispatch(getDensityChangedParams());
+ densityObject = dispatch(toggleDensityWireframe(densityData.isWireframeStyle, densityObject));
+ const oldDensityData = dispatch(deleteDensityObject(data, colourToggle, stage, !densityData.isWireframeStyle));
+ densityObject = { ...densityObject, ...oldDensityData };
+ const molId = generateMoleculeId(data);
+ dispatch(removeFromDensityList(molId, true));
+ //here we need to remove density but we don't know if it is custom or not so we remove both
+ dispatch(removeFromToBeDisplayedList({ id: densityData.id, type: NGL_OBJECTS.DENSITY }));
+ dispatch(removeFromToBeDisplayedList({ id: densityData.id, type: NGL_OBJECTS.DENSITY_CUSTOM }));
+ //and then re-add it as custom
+ dispatch(appendDensityListCustom(generateMoleculeId(data)));
+ dispatch(
+ appendToBeDisplayedList({
+ ...densityData
+ })
+ );
+ // dispatch(removeFromDensityListType(molId, true));
+
+ return dispatch(
+ loadObject({
+ target: Object.assign({ display_div: VIEWS.MAJOR_VIEW }, densityObject),
+ stage,
+ previousRepresentations: densityData.representations,
+ orientationMatrix: null
+ })
+ ).finally(() => {
+ const currentOrientation = stage.viewerControls.getOrientation();
+ dispatch(setOrientation(VIEWS.MAJOR_VIEW, currentOrientation));
+ });
+ },
+ [allObservations, dispatch, stage]
+ );
+
+ const removeDensity = useCallback(
+ densityData => {
+ const data = allObservations.find(obs => obs.id === densityData.id);
+ const colourToggle = getRandomColor(data);
+
+ dispatch(toggleDensityWireframe(densityData.isWireframeStyle));
+ dispatch(deleteDensityObject(data, colourToggle, stage, densityData.isWireframeStyle));
+
+ const molId = generateMoleculeId(data);
+ dispatch(removeFromDensityList(molId));
+ dispatch(removeFromDensityListCustom(molId, true));
+ dispatch(removeFromDensityListType(molId));
+ if (data.proteinData.render_quality) {
+ dispatch(removeQuality(stage, data, colourToggle, true));
+ }
+
+ dispatch(removeFromToBeDisplayedList({ id: densityData.id, type: NGL_OBJECTS.DENSITY }));
+ dispatch(removeFromToBeDisplayedList({ id: densityData.id, type: NGL_OBJECTS.DENSITY_CUSTOM }));
+ },
+ [allObservations, dispatch, stage]
+ );
+
+ useEffect(() => {
+ const toBeDisplayedDensities = getToBeDisplayedStructures(
+ toBeDisplayedList,
+ displayedDensities,
+ NGL_OBJECTS.DENSITY
+ );
+ toBeDisplayedDensities?.forEach(data => {
+ displayDensity(data);
+ });
+
+ const toBeDisplayedCustomDensities = getToBeDisplayedStructures(
+ toBeDisplayedList,
+ displayedCustomDensities,
+ NGL_OBJECTS.DENSITY_CUSTOM
+ );
+ toBeDisplayedCustomDensities?.forEach(data => {
+ displayCustomDensity(data);
+ });
+
+ const toBeRemovedDensities = getToBeDisplayedStructures(
+ toBeDisplayedList,
+ displayedDensities,
+ NGL_OBJECTS.DENSITY,
+ true
+ );
+ toBeRemovedDensities?.forEach(data => {
+ removeDensity(data);
+ });
+
+ const toBeRemovedCustomDensities = getToBeDisplayedStructures(
+ toBeDisplayedList,
+ displayedCustomDensities,
+ NGL_OBJECTS.DENSITY_CUSTOM,
+ true
+ );
+ toBeRemovedCustomDensities?.forEach(data => {
+ removeDensity(data);
+ });
+ }, [
+ toBeDisplayedList,
+ displayDensity,
+ dispatch,
+ stage,
+ removeDensity,
+ displayedDensities,
+ displayedCustomDensities,
+ displayCustomDensity
+ ]);
+
+ return {};
+};
diff --git a/js/reducers/ngl/useDisplayLigandLHS.js b/js/reducers/ngl/useDisplayLigandLHS.js
new file mode 100644
index 000000000..d9f74742b
--- /dev/null
+++ b/js/reducers/ngl/useDisplayLigandLHS.js
@@ -0,0 +1,118 @@
+import { useCallback, useContext, useEffect } from 'react';
+import { useDispatch, useSelector } from 'react-redux';
+import { NGL_OBJECTS } from './constants';
+import {
+ appendFragmentDisplayList,
+ appendQualityList,
+ removeFromFragmentDisplayList,
+ removeFromQualityList,
+ removeFromToBeDisplayedList
+} from '../selection/actions';
+import { generateMoleculeId, generateMoleculeObject } from '../../components/nglView/generatingObjects';
+import { VIEWS } from '../../constants/constants';
+import { NglContext } from '../../components/nglView/nglProvider';
+import { getRandomColor } from '../../components/preview/molecule/utils/color';
+import { readQualityInformation } from '../../components/nglView/renderingHelpers';
+import { deleteObject, loadObject, setOrientation } from './dispatchActions';
+import { appendMoleculeOrientation, setNglViewFromSnapshotRendered } from './actions';
+import { removeVector } from '../../components/preview/molecule/redux/dispatchActions';
+import { getToBeDisplayedStructures } from './utils';
+
+export const useDisplayLigandLHS = () => {
+ const dispatch = useDispatch();
+
+ const toBeDisplayedList = useSelector(state => state.selectionReducers.toBeDisplayedList);
+ const displayedLigands = useSelector(state => state.selectionReducers.fragmentDisplayList);
+ const allObservations = useSelector(state => state.apiReducers.all_mol_lists);
+ const skipOrientationChange = useSelector(state => state.nglReducers.skipOrientationChange);
+
+ const { getNglView } = useContext(NglContext);
+ const stage = getNglView(VIEWS.MAJOR_VIEW) && getNglView(VIEWS.MAJOR_VIEW).stage;
+
+ // const isLoadingCurrentSnapshot = useSelector(state => state.projectReducers.isLoadingCurrentSnapshot);
+
+ const displayLigand = useCallback(
+ ligandData => {
+ const data = allObservations.find(obs => obs.id === ligandData.id);
+ if (!data) return;
+ const colourToggle = getRandomColor(data);
+ const currentOrientation = stage.viewerControls.getOrientation();
+
+ dispatch(appendFragmentDisplayList(generateMoleculeId(data)));
+
+ let moleculeObject = generateMoleculeObject(data, colourToggle);
+ let qualityInformation = dispatch(readQualityInformation(moleculeObject.name, moleculeObject.sdf_info));
+
+ let hasAdditionalInformation =
+ ligandData.withQuality === true &&
+ qualityInformation &&
+ qualityInformation.badids &&
+ qualityInformation.badids.length !== 0;
+ if (hasAdditionalInformation) {
+ dispatch(appendQualityList(generateMoleculeId(data)));
+ }
+
+ return dispatch(
+ loadObject({
+ target: Object.assign({ display_div: VIEWS.MAJOR_VIEW }, moleculeObject),
+ stage,
+ previousRepresentations: ligandData.representations,
+ loadQuality: hasAdditionalInformation,
+ quality: qualityInformation
+ })
+ ).then(() => {
+ const skipOrientation = skipOrientationChange;
+ if (!skipOrientation /* || isLoadingCurrentSnapshot*/) {
+ const ligandOrientation = stage.viewerControls.getOrientation();
+ dispatch(setOrientation(VIEWS.MAJOR_VIEW, ligandOrientation));
+
+ dispatch(appendMoleculeOrientation(data?.id, ligandOrientation));
+ if (!ligandData.center) {
+ // keep current orientation of NGL View
+ console.count(`Before applying orientation matrix after loading ligand.`);
+ stage.viewerControls.orient(currentOrientation);
+ console.count(`After applying orientation matrix after loading ligand.`);
+ }
+ }
+ // dispatch(setNglViewFromSnapshotRendered(false));
+ });
+ },
+ // eslint-disable-next-line react-hooks/exhaustive-deps
+ [allObservations, dispatch, stage] //skipOrientationChange and isLoadingCurrentSnapshot are not included in the dependencies by desing
+ );
+
+ const removeLigand = useCallback(
+ ligandData => {
+ const data = allObservations.find(obs => obs.id === ligandData.id);
+ if (!data) return;
+ dispatch(deleteObject(Object.assign({ display_div: VIEWS.MAJOR_VIEW }, generateMoleculeObject(data)), stage));
+ dispatch(removeFromFragmentDisplayList(generateMoleculeId(data)));
+ dispatch(removeFromQualityList(generateMoleculeId(data)));
+ if (ligandData.withVector === true) {
+ // remove vector
+ dispatch(removeVector(stage, data));
+ }
+
+ dispatch(removeFromToBeDisplayedList({ id: ligandData.id, type: NGL_OBJECTS.LIGAND }));
+ },
+ [allObservations, dispatch, stage]
+ );
+
+ useEffect(() => {
+ const toBeRemovedLigands = getToBeDisplayedStructures(
+ toBeDisplayedList,
+ displayedLigands,
+ NGL_OBJECTS.LIGAND,
+ true
+ );
+ toBeRemovedLigands?.forEach(data => {
+ removeLigand(data);
+ });
+ const toBeDisplayedLigands = getToBeDisplayedStructures(toBeDisplayedList, displayedLigands, NGL_OBJECTS.LIGAND);
+ toBeDisplayedLigands?.forEach(data => {
+ displayLigand(data);
+ });
+ }, [toBeDisplayedList, displayedLigands, displayLigand, dispatch, stage, removeLigand]);
+
+ return {};
+};
diff --git a/js/reducers/ngl/useDisplayLigandRHS.js b/js/reducers/ngl/useDisplayLigandRHS.js
new file mode 100644
index 000000000..e80e689ef
--- /dev/null
+++ b/js/reducers/ngl/useDisplayLigandRHS.js
@@ -0,0 +1,112 @@
+import { useCallback, useContext, useEffect } from 'react';
+import { useDispatch, useSelector } from 'react-redux';
+import { NglContext } from '../../components/nglView/nglProvider';
+import { VIEWS } from '../../constants/constants';
+import { NGL_OBJECTS } from './constants';
+import { getToBeDisplayedStructuresDataset } from './utils';
+import { getRandomColor } from '../../components/preview/molecule/utils/color';
+import {
+ appendLigandList,
+ removeFromLigandList,
+ removeFromToBeDisplayedListForDataset
+} from '../../components/datasets/redux/actions';
+import { generateMoleculeCompoundId, generateMoleculeObject } from '../../components/nglView/generatingObjects';
+import { deleteObject, loadObject, setOrientation } from './dispatchActions';
+import { appendMoleculeOrientation, setNglViewFromSnapshotRendered } from './actions';
+import { getDatasetMoleculeID } from '../../components/datasets/redux/dispatchActions';
+
+export const useDisplayLigandRHS = () => {
+ const dispatch = useDispatch();
+
+ const toBeDisplayedList = useSelector(state => state.datasetsReducers.toBeDisplayedList);
+ const displayedLigands = useSelector(state => state.datasetsReducers.ligandLists);
+ const allCompounds = useSelector(state => state.datasetsReducers.moleculeLists);
+ const skipOrientationChange = useSelector(state => state.nglReducers.skipOrientationChange);
+
+ const { getNglView } = useContext(NglContext);
+ const stage = getNglView(VIEWS.MAJOR_VIEW) && getNglView(VIEWS.MAJOR_VIEW).stage;
+
+ const displayLigand = useCallback(
+ ligandData => {
+ const datasetCompounds = allCompounds[ligandData.datasetID];
+ const data = datasetCompounds?.find(obs => obs.id === ligandData.id);
+ if (!data) return;
+ const colourToggle = getRandomColor(data);
+ const datasetID = ligandData.datasetID;
+
+ dispatch(appendLigandList(datasetID, generateMoleculeCompoundId(data)));
+ console.count(`Grabbed orientation before loading dataset ligand`);
+ const currentOrientation = stage.viewerControls.getOrientation();
+ return dispatch(
+ loadObject({
+ target: Object.assign(
+ { display_div: VIEWS.MAJOR_VIEW },
+ generateMoleculeObject(data, colourToggle, datasetID)
+ ),
+ stage,
+ previousRepresentations: ligandData.representations,
+ markAsRightSideLigand: true
+ })
+ ).finally(() => {
+ const skipOrientation = skipOrientationChange;
+ if (!skipOrientation) {
+ const ligandOrientation = stage.viewerControls.getOrientation();
+ dispatch(setOrientation(VIEWS.MAJOR_VIEW, ligandOrientation));
+
+ dispatch(appendMoleculeOrientation(getDatasetMoleculeID(datasetID, data?.id), ligandOrientation));
+
+ // keep current orientation of NGL View
+ if (!skipOrientation) {
+ console.count(`Before applying orientation after loading dataset ligand.`);
+ stage.viewerControls.orient(currentOrientation);
+ console.count(`After applying orientation after loading dataset ligand.`);
+ }
+ // dispatch(setNglViewFromSnapshotRendered(false));
+ }
+ });
+ },
+ [allCompounds, dispatch, skipOrientationChange, stage]
+ );
+
+ const removeLigand = useCallback(
+ ligandData => {
+ const datasetCompounds = allCompounds[ligandData.datasetID];
+ const data = datasetCompounds?.find(obs => obs.id === ligandData.id);
+ if (!data) return;
+ const datasetID = ligandData.datasetID;
+
+ dispatch(
+ deleteObject(
+ Object.assign({ display_div: VIEWS.MAJOR_VIEW }, generateMoleculeObject(data, undefined, datasetID)),
+ stage
+ )
+ );
+ dispatch(removeFromLigandList(datasetID, generateMoleculeCompoundId(data)));
+
+ dispatch(removeFromToBeDisplayedListForDataset(datasetID, { id: ligandData.id, type: NGL_OBJECTS.LIGAND }));
+ },
+ [allCompounds, dispatch, stage]
+ );
+
+ useEffect(() => {
+ const toBeRemovedLigands = getToBeDisplayedStructuresDataset(
+ toBeDisplayedList,
+ displayedLigands,
+ NGL_OBJECTS.LIGAND,
+ true
+ );
+ toBeRemovedLigands?.forEach(data => {
+ removeLigand(data);
+ });
+ const toBeDisplayedLigands = getToBeDisplayedStructuresDataset(
+ toBeDisplayedList,
+ displayedLigands,
+ NGL_OBJECTS.LIGAND
+ );
+ toBeDisplayedLigands?.forEach(data => {
+ displayLigand(data);
+ });
+ }, [toBeDisplayedList, displayedLigands, displayLigand, dispatch, stage, removeLigand]);
+
+ return {};
+};
diff --git a/js/reducers/ngl/useDisplayProteinLHS.js b/js/reducers/ngl/useDisplayProteinLHS.js
new file mode 100644
index 000000000..4b792f5d4
--- /dev/null
+++ b/js/reducers/ngl/useDisplayProteinLHS.js
@@ -0,0 +1,101 @@
+import { useCallback, useContext, useEffect } from 'react';
+import { useDispatch, useSelector } from 'react-redux';
+import { NGL_OBJECTS } from './constants';
+import {
+ appendProteinList,
+ appendQualityList,
+ removeFromProteinList,
+ removeFromToBeDisplayedList
+} from '../selection/actions';
+import { generateHitProteinObject, generateMoleculeId } from '../../components/nglView/generatingObjects';
+import { VIEWS } from '../../constants/constants';
+import { NglContext } from '../../components/nglView/nglProvider';
+import { getRandomColor } from '../../components/preview/molecule/utils/color';
+import { readQualityInformation } from '../../components/nglView/renderingHelpers';
+import { deleteObject, loadObject, setOrientation } from './dispatchActions';
+import { base_url } from '../../components/routes/constants';
+import { getToBeDisplayedStructures } from './utils';
+
+export const useDisplayProteinLHS = () => {
+ const dispatch = useDispatch();
+
+ const toBeDisplayedList = useSelector(state => state.selectionReducers.toBeDisplayedList);
+ const displayedProteins = useSelector(state => state.selectionReducers.proteinList);
+ const allObservations = useSelector(state => state.apiReducers.all_mol_lists);
+
+ const { getNglView } = useContext(NglContext);
+ const stage = getNglView(VIEWS.MAJOR_VIEW) && getNglView(VIEWS.MAJOR_VIEW).stage;
+
+ const displayProtein = useCallback(
+ proteinData => {
+ const data = allObservations.find(obs => obs.id === proteinData.id);
+ if (!data) return;
+ const colourToggle = getRandomColor(data);
+
+ dispatch(appendProteinList(generateMoleculeId(data)));
+ const hitProteinObject = generateHitProteinObject(data, colourToggle, base_url);
+ const qualityInformation = dispatch(readQualityInformation(hitProteinObject.name, hitProteinObject.sdf_info));
+
+ let hasAdditionalInformation =
+ proteinData.withQuality === true &&
+ qualityInformation &&
+ qualityInformation.badproteinids &&
+ qualityInformation.badproteinids.length !== 0;
+ if (hasAdditionalInformation) {
+ dispatch(appendQualityList(generateMoleculeId(data), true));
+ }
+
+ return dispatch(
+ loadObject({
+ target: Object.assign({ display_div: VIEWS.MAJOR_VIEW }, hitProteinObject),
+ stage,
+ previousRepresentations: proteinData.representations,
+ orientationMatrix: null,
+ loadQuality: hasAdditionalInformation,
+ quality: qualityInformation,
+ preserveColour: proteinData.preserveColour
+ })
+ ).finally(() => {
+ const currentOrientation = stage.viewerControls.getOrientation();
+ dispatch(setOrientation(VIEWS.MAJOR_VIEW, currentOrientation));
+ });
+ },
+ [allObservations, dispatch, stage]
+ );
+
+ const removeProtein = useCallback(
+ proteinData => {
+ const data = allObservations.find(obs => obs.id === proteinData.id);
+ if (!data) return;
+ const colourToggle = getRandomColor(data);
+ dispatch(
+ deleteObject(
+ Object.assign({ display_div: VIEWS.MAJOR_VIEW }, generateHitProteinObject(data, colourToggle, base_url)),
+ stage
+ )
+ );
+ dispatch(removeFromProteinList(generateMoleculeId(data)));
+ dispatch(removeFromToBeDisplayedList({ id: proteinData.id, type: NGL_OBJECTS.PROTEIN }));
+ },
+ [allObservations, dispatch, stage]
+ );
+
+ useEffect(() => {
+ const toBeDisplayedProteins = getToBeDisplayedStructures(toBeDisplayedList, displayedProteins, NGL_OBJECTS.PROTEIN);
+ toBeDisplayedProteins?.forEach(data => {
+ displayProtein(data);
+ });
+
+ const toBeRemovedProteins = getToBeDisplayedStructures(
+ toBeDisplayedList,
+ displayedProteins,
+ NGL_OBJECTS.PROTEIN,
+ true
+ );
+ toBeRemovedProteins?.forEach(data => {
+ removeProtein(data);
+ });
+ }, [toBeDisplayedList, displayProtein, dispatch, stage, removeProtein, displayedProteins]);
+
+ return {};
+};
diff --git a/js/reducers/ngl/useDisplayProteinRHS.js b/js/reducers/ngl/useDisplayProteinRHS.js
new file mode 100644
index 000000000..2f4e4503a
--- /dev/null
+++ b/js/reducers/ngl/useDisplayProteinRHS.js
@@ -0,0 +1,99 @@
+import { useCallback, useContext, useEffect } from 'react';
+import { useDispatch, useSelector } from 'react-redux';
+import { NglContext } from '../../components/nglView/nglProvider';
+import { VIEWS } from '../../constants/constants';
+import { NGL_OBJECTS } from './constants';
+import { getToBeDisplayedStructuresDataset } from './utils';
+import { getRandomColor } from '../../components/preview/molecule/utils/color';
+import {
+ appendProteinList,
+ removeFromProteinList,
+ removeFromToBeDisplayedListForDataset
+} from '../../components/datasets/redux/actions';
+import { generateHitProteinObject, generateMoleculeCompoundId } from '../../components/nglView/generatingObjects';
+import { deleteObject, loadObject, setOrientation } from './dispatchActions';
+import { base_url } from '../../components/routes/constants';
+
+export const useDisplayProteinRHS = () => {
+ const dispatch = useDispatch();
+
+ const toBeDisplayedList = useSelector(state => state.datasetsReducers.toBeDisplayedList);
+ const displayedProteins = useSelector(state => state.datasetsReducers.proteinLists);
+ const allCompounds = useSelector(state => state.datasetsReducers.moleculeLists);
+
+ const { getNglView } = useContext(NglContext);
+ const stage = getNglView(VIEWS.MAJOR_VIEW) && getNglView(VIEWS.MAJOR_VIEW).stage;
+
+ const displayProtein = useCallback(
+ proteinData => {
+ const datasetCompounds = allCompounds[proteinData.datasetID];
+ const data = datasetCompounds?.find(obs => obs.id === proteinData.id);
+ if (!data) return;
+ const colourToggle = getRandomColor(data);
+ const datasetID = proteinData.datasetID;
+
+ dispatch(appendProteinList(datasetID, generateMoleculeCompoundId(data)));
+ return dispatch(
+ loadObject({
+ target: Object.assign(
+ { display_div: VIEWS.MAJOR_VIEW },
+ generateHitProteinObject(data, colourToggle, base_url, datasetID)
+ ),
+ stage,
+ previousRepresentations: proteinData.representations,
+ orientationMatrix: null
+ })
+ ).finally(() => {
+ const currentOrientation = stage.viewerControls.getOrientation();
+ dispatch(setOrientation(VIEWS.MAJOR_VIEW, currentOrientation));
+ });
+ },
+ [allCompounds, dispatch, stage]
+ );
+
+ const removeProtein = useCallback(
+ proteinData => {
+ const datasetCompounds = allCompounds[proteinData.datasetID];
+ const data = datasetCompounds?.find(obs => obs.id === proteinData.id);
+ if (!data) return;
+ const datasetID = proteinData.datasetID;
+ const colourToggle = getRandomColor(data);
+
+ dispatch(
+ deleteObject(
+ Object.assign(
+ { display_div: VIEWS.MAJOR_VIEW },
+ generateHitProteinObject(data, colourToggle, base_url, datasetID)
+ ),
+ stage
+ )
+ );
+ dispatch(removeFromProteinList(datasetID, generateMoleculeCompoundId(data)));
+
+ dispatch(removeFromToBeDisplayedListForDataset(datasetID, { id: proteinData.id, type: NGL_OBJECTS.PROTEIN }));
+ },
+ [allCompounds, dispatch, stage]
+ );
+
+ useEffect(() => {
+ const toBeRemovedProteins = getToBeDisplayedStructuresDataset(
+ toBeDisplayedList,
+ displayedProteins,
+ NGL_OBJECTS.PROTEIN,
+ true
+ );
+ toBeRemovedProteins?.forEach(data => {
+ removeProtein(data);
+ });
+ const toBeDisplayedProteins = getToBeDisplayedStructuresDataset(
+ toBeDisplayedList,
+ displayedProteins,
+ NGL_OBJECTS.PROTEIN
+ );
+ toBeDisplayedProteins?.forEach(data => {
+ displayProtein(data);
+ });
+ }, [toBeDisplayedList, displayedProteins, displayProtein, dispatch, stage, removeProtein]);
+
+ return {};
+};
diff --git a/js/reducers/ngl/useDisplaySurfaceRHS.js b/js/reducers/ngl/useDisplaySurfaceRHS.js
new file mode 100644
index 000000000..fa9ef9194
--- /dev/null
+++ b/js/reducers/ngl/useDisplaySurfaceRHS.js
@@ -0,0 +1,99 @@
+import { useCallback, useContext, useEffect } from 'react';
+import { useDispatch, useSelector } from 'react-redux';
+import { NglContext } from '../../components/nglView/nglProvider';
+import { VIEWS } from '../../constants/constants';
+import { NGL_OBJECTS } from './constants';
+import { getToBeDisplayedStructuresDataset } from './utils';
+import { getRandomColor } from '../../components/preview/molecule/utils/color';
+import {
+ appendSurfaceList,
+ removeFromSurfaceList,
+ removeFromToBeDisplayedListForDataset
+} from '../../components/datasets/redux/actions';
+import { generateMoleculeCompoundId, generateSurfaceObject } from '../../components/nglView/generatingObjects';
+import { deleteObject, loadObject, setOrientation } from './dispatchActions';
+import { base_url } from '../../components/routes/constants';
+
+export const useDisplaySurfaceRHS = () => {
+ const dispatch = useDispatch();
+
+ const toBeDisplayedList = useSelector(state => state.datasetsReducers.toBeDisplayedList);
+ const displayedSurfaces = useSelector(state => state.datasetsReducers.surfaceLists);
+ const allCompounds = useSelector(state => state.datasetsReducers.moleculeLists);
+
+ const { getNglView } = useContext(NglContext);
+ const stage = getNglView(VIEWS.MAJOR_VIEW) && getNglView(VIEWS.MAJOR_VIEW).stage;
+
+ const displaySurface = useCallback(
+ surfaceData => {
+ const datasetCompounds = allCompounds[surfaceData.datasetID];
+ const data = datasetCompounds?.find(obs => obs.id === surfaceData.id);
+ if (!data) return;
+ const colourToggle = getRandomColor(data);
+ const datasetID = surfaceData.datasetID;
+
+ dispatch(appendSurfaceList(datasetID, generateMoleculeCompoundId(data)));
+ return dispatch(
+ loadObject({
+ target: Object.assign(
+ { display_div: VIEWS.MAJOR_VIEW },
+ generateSurfaceObject(data, colourToggle, base_url, datasetID)
+ ),
+ stage,
+ previousRepresentations: surfaceData.representations,
+ orientationMatrix: null
+ })
+ ).finally(() => {
+ const currentOrientation = stage.viewerControls.getOrientation();
+ dispatch(setOrientation(VIEWS.MAJOR_VIEW, currentOrientation));
+ });
+ },
+ [allCompounds, dispatch, stage]
+ );
+
+ const removeSurface = useCallback(
+ surfaceData => {
+ const datasetCompounds = allCompounds[surfaceData.datasetID];
+ const data = datasetCompounds?.find(obs => obs.id === surfaceData.id);
+ if (!data) return;
+ const datasetID = surfaceData.datasetID;
+ const colourToggle = getRandomColor(data);
+
+ dispatch(
+ deleteObject(
+ Object.assign(
+ { display_div: VIEWS.MAJOR_VIEW },
+ generateSurfaceObject(data, colourToggle, base_url, datasetID)
+ ),
+ stage
+ )
+ );
+ dispatch(removeFromSurfaceList(datasetID, generateMoleculeCompoundId(data)));
+
+ dispatch(removeFromToBeDisplayedListForDataset(datasetID, { id: surfaceData.id, type: NGL_OBJECTS.SURFACE }));
+ },
+ [allCompounds, dispatch, stage]
+ );
+
+ useEffect(() => {
+ const toBeRemovedSurfaces = getToBeDisplayedStructuresDataset(
+ toBeDisplayedList,
+ displayedSurfaces,
+ NGL_OBJECTS.SURFACE,
+ true
+ );
+ toBeRemovedSurfaces?.forEach(data => {
+ removeSurface(data);
+ });
+ const toBeDisplayedSurfaces = getToBeDisplayedStructuresDataset(
+ toBeDisplayedList,
+ displayedSurfaces,
+ NGL_OBJECTS.SURFACE
+ );
+ toBeDisplayedSurfaces?.forEach(data => {
+ displaySurface(data);
+ });
+ }, [toBeDisplayedList, displayedSurfaces, displaySurface, dispatch, stage, removeSurface]);
+
+ return {};
+};
diff --git a/js/reducers/ngl/useDisplaySurfacesLHS.js b/js/reducers/ngl/useDisplaySurfacesLHS.js
new file mode 100644
index 000000000..d7db21a0e
--- /dev/null
+++ b/js/reducers/ngl/useDisplaySurfacesLHS.js
@@ -0,0 +1,83 @@
+import { useCallback, useContext, useEffect } from 'react';
+import { useDispatch, useSelector } from 'react-redux';
+import { NGL_OBJECTS } from './constants';
+import { appendSurfaceList, removeFromSurfaceList, removeFromToBeDisplayedList } from '../selection/actions';
+import { generateMoleculeId, generateSurfaceObject } from '../../components/nglView/generatingObjects';
+import { VIEWS } from '../../constants/constants';
+import { NglContext } from '../../components/nglView/nglProvider';
+import { getRandomColor } from '../../components/preview/molecule/utils/color';
+import { deleteObject, loadObject, setOrientation } from './dispatchActions';
+import { base_url } from '../../components/routes/constants';
+import { getToBeDisplayedStructures } from './utils';
+
+export const useDisplaySurfaceLHS = () => {
+ const dispatch = useDispatch();
+
+ const toBeDisplayedList = useSelector(state => state.selectionReducers.toBeDisplayedList);
+ const displayedSurfaces = useSelector(state => state.selectionReducers.surfaceList);
+ const allObservations = useSelector(state => state.apiReducers.all_mol_lists);
+
+ const { getNglView } = useContext(NglContext);
+ const stage = getNglView(VIEWS.MAJOR_VIEW) && getNglView(VIEWS.MAJOR_VIEW).stage;
+
+ const displaySurface = useCallback(
+ surfaceData => {
+ const data = allObservations.find(obs => obs.id === surfaceData.id);
+ if (!data) return;
+ const colourToggle = getRandomColor(data);
+
+ dispatch(appendSurfaceList(generateMoleculeId(data)));
+ return dispatch(
+ loadObject({
+ target: Object.assign({ display_div: VIEWS.MAJOR_VIEW }, generateSurfaceObject(data, colourToggle, base_url)),
+ stage,
+ previousRepresentations: surfaceData.representations,
+ orientationMatrix: null,
+ preserveColour: surfaceData.preserveColour
+ })
+ ).finally(() => {
+ const currentOrientation = stage.viewerControls.getOrientation();
+ dispatch(setOrientation(VIEWS.MAJOR_VIEW, currentOrientation));
+ });
+ },
+ [allObservations, dispatch, stage]
+ );
+
+ const removeSurface = useCallback(
+ surfaceData => {
+ const data = allObservations.find(obs => obs.id === surfaceData.id);
+ if (!data) return;
+ const colourToggle = getRandomColor(data);
+
+ dispatch(
+ deleteObject(
+ Object.assign({ display_div: VIEWS.MAJOR_VIEW }, generateSurfaceObject(data, colourToggle, base_url)),
+ stage
+ )
+ );
+ dispatch(removeFromSurfaceList(generateMoleculeId(data)));
+
+ dispatch(removeFromToBeDisplayedList({ id: surfaceData.id, type: NGL_OBJECTS.SURFACE }));
+ },
+ [allObservations, dispatch, stage]
+ );
+
+ useEffect(() => {
+ const toBeDisplayedSurfaces = getToBeDisplayedStructures(toBeDisplayedList, displayedSurfaces, NGL_OBJECTS.SURFACE);
+ toBeDisplayedSurfaces?.forEach(data => {
+ displaySurface(data);
+ });
+
+ const toBeRemovedSurfaces = getToBeDisplayedStructures(
+ toBeDisplayedList,
+ displayedSurfaces,
+ NGL_OBJECTS.SURFACE,
+ true
+ );
+ toBeRemovedSurfaces?.forEach(data => {
+ removeSurface(data);
+ });
+ }, [toBeDisplayedList, displaySurface, dispatch, stage, removeSurface, displayedSurfaces]);
+
+ return {};
+};
diff --git a/js/reducers/ngl/useDisplayVectorLHS.js b/js/reducers/ngl/useDisplayVectorLHS.js
new file mode 100644
index 000000000..e90a30481
--- /dev/null
+++ b/js/reducers/ngl/useDisplayVectorLHS.js
@@ -0,0 +1,116 @@
+import { useCallback, useContext, useEffect } from 'react';
+import { useDispatch, useSelector } from 'react-redux';
+import { NGL_OBJECTS } from './constants';
+import {
+ appendVectorOnList,
+ removeFromToBeDisplayedList,
+ removeFromVectorOnList,
+ setVectorList,
+ updateBondColorMapOfCompounds,
+ updateVectorCompounds
+} from '../selection/actions';
+import { generateMoleculeId } from '../../components/nglView/generatingObjects';
+import { VIEWS } from '../../constants/constants';
+import { NglContext } from '../../components/nglView/nglProvider';
+import { deleteObject, setOrientation } from './dispatchActions';
+import { base_url } from '../../components/routes/constants';
+import { getToBeDisplayedStructures } from './utils';
+import { selectVectorAndResetCompounds } from '../selection/dispatchActions';
+import { api } from '../../utils/api';
+import { getViewUrl, handleVector, removeCurrentVector } from '../../components/preview/molecule/redux/dispatchActions';
+
+export const useDisplayVectorLHS = () => {
+ const dispatch = useDispatch();
+
+ const toBeDisplayedList = useSelector(state => state.selectionReducers.toBeDisplayedList);
+ const displayedVectors = useSelector(state => state.selectionReducers.vectorOnList);
+ const allObservations = useSelector(state => state.apiReducers.all_mol_lists);
+ const currentVector = useSelector(state => state.selectionReducers.currentVector);
+ const vector_list = useSelector(state => state.selectionReducers.vector_list);
+
+ const { getNglView } = useContext(NglContext);
+ const stage = getNglView(VIEWS.MAJOR_VIEW) && getNglView(VIEWS.MAJOR_VIEW).stage;
+
+ const displayVector = useCallback(
+ vectorData => {
+ const data = allObservations.find(obs => obs.id === vectorData.id);
+ if (!data) return;
+
+ dispatch(appendVectorOnList(generateMoleculeId(data)));
+ dispatch(selectVectorAndResetCompounds(currentVector));
+
+ return api({ url: getViewUrl('graph', data) })
+ .then(response => {
+ const result = response.data.graph;
+ const new_dict = {};
+ // Uniquify
+ if (result) {
+ Object.keys(result).forEach(key => {
+ const smiSet = new Set();
+ new_dict[key] = {};
+ new_dict[key]['addition'] = [];
+ new_dict[key]['vector'] = result[key]['vector'];
+ Object.keys(result[key]['addition']).forEach(index => {
+ const newSmi = result[key]['addition'][index]['end'];
+ if (smiSet.has(newSmi) !== true) {
+ new_dict[key]['addition'].push(result[key]['addition'][index]);
+ smiSet.add(newSmi);
+ }
+ });
+ });
+ }
+ return dispatch(updateVectorCompounds(data.smiles, new_dict));
+ })
+ .then(() => api({ url: new URL(base_url + '/api/vector/?id=' + data.id) }))
+ .then(response => {
+ dispatch(handleVector(response.data?.results[0]?.vectors, stage, data));
+ })
+ .finally(() => {
+ const currentOrientation = stage.viewerControls.getOrientation();
+ dispatch(setOrientation(VIEWS.MAJOR_VIEW, currentOrientation));
+ });
+ },
+ [allObservations, currentVector, dispatch, stage]
+ );
+
+ const removeVector = useCallback(
+ vectorData => {
+ const data = allObservations.find(obs => obs.id === vectorData.id);
+ if (!data) return;
+
+ vector_list
+ .filter(item => item.moleculeId === data.id)
+ .forEach(item => dispatch(deleteObject(Object.assign({ display_div: VIEWS.MAJOR_VIEW }, item), stage)));
+
+ dispatch(removeCurrentVector(data.smiles));
+
+ dispatch(updateVectorCompounds(data.smiles, undefined));
+ dispatch(updateBondColorMapOfCompounds(data.smiles, undefined));
+ dispatch(removeFromVectorOnList(generateMoleculeId(data)));
+
+ dispatch(setVectorList(vector_list.filter(item => item.moleculeId !== data.id)));
+
+ dispatch(removeFromToBeDisplayedList({ id: vectorData.id, type: NGL_OBJECTS.VECTOR }));
+ },
+ [allObservations, dispatch, stage, vector_list]
+ );
+
+ useEffect(() => {
+ const toBeDisplayedVectors = getToBeDisplayedStructures(toBeDisplayedList, displayedVectors, NGL_OBJECTS.VECTOR);
+ toBeDisplayedVectors?.forEach(data => {
+ displayVector(data);
+ });
+
+ const toBeRemovedVectors = getToBeDisplayedStructures(
+ toBeDisplayedList,
+ displayedVectors,
+ NGL_OBJECTS.VECTOR,
+ true
+ );
+ toBeRemovedVectors?.forEach(data => {
+ removeVector(data);
+ });
+ }, [toBeDisplayedList, displayVector, dispatch, stage, removeVector, displayedVectors]);
+
+ return {};
+};
diff --git a/js/reducers/ngl/utils.js b/js/reducers/ngl/utils.js
new file mode 100644
index 000000000..b00e209d3
--- /dev/null
+++ b/js/reducers/ngl/utils.js
@@ -0,0 +1,28 @@
+export const getToBeDisplayedStructures = (toBeDisplayed, displayedList, type, toBeRemoved = false) => {
+ let structures = [];
+
+ structures = toBeDisplayed.filter(
+ struct =>
+ struct.type === type &&
+ struct.display === !toBeRemoved &&
+ (toBeRemoved || !displayedList.find(id => id === struct.id))
+ );
+
+ return structures;
+};
+
+export const getToBeDisplayedStructuresDataset = (toBeDisplayed, displayedList, type, toBeRemoved = false) => {
+ let result = [];
+
+ Object.keys(toBeDisplayed).forEach(datasetID => {
+ const displayedDatasetLigands = displayedList[datasetID] || [];
+ const toBeDisplayedDataset = toBeDisplayed[datasetID] || [];
+ result = [
+ ...result,
+ ...getToBeDisplayedStructures(toBeDisplayedDataset, displayedDatasetLigands, type, toBeRemoved)
+ ];
+ // result.push(...getToBeDisplayedStructures(toBeDisplayedDataset, displayedDatasetLigands, type, toBeRemoved));
+ });
+
+ return result;
+};
diff --git a/js/reducers/nglTracking/actions.js b/js/reducers/nglTracking/actions.js
deleted file mode 100644
index be6c9f05e..000000000
--- a/js/reducers/nglTracking/actions.js
+++ /dev/null
@@ -1,150 +0,0 @@
-import { constants, undoConstants } from './constants';
-
-export const setActionsList = function(track_actions_list) {
- return {
- type: constants.SET_ACTIONS_LIST,
- track_actions_list: track_actions_list
- };
-};
-
-export const appendToActionList = function(track_action) {
- return {
- type: constants.APPEND_ACTIONS_LIST,
- track_action: track_action
- };
-};
-
-export const appendToUndoRedoActionList = function(track_action) {
- return {
- type: constants.APPEND_UNDO_REDO_ACTIONS_LIST,
- track_action: track_action
- };
-};
-
-export const setUndoRedoActionList = (undo_redo_actions_list) => {
- return {
- type: constants.SET_UNDO_REDO_ACTIONS_LIST,
- undo_redo_actions_list: undo_redo_actions_list
- };
-}
-
-export const setCurrentActionsList = function(current_actions_list) {
- return {
- type: constants.SET_CURRENT_ACTIONS_LIST,
- current_actions_list: current_actions_list
- };
-};
-
-export const setIsTrackingMoleculesRestoring = function(isTrackingMoleculesRestoring) {
- return {
- type: constants.SET_IS_TRACKING_MOLECULES_RESTORING,
- isTrackingMoleculesRestoring: isTrackingMoleculesRestoring
- };
-};
-
-export const setIsTrackingCompoundsRestoring = function(isTrackingCompoundsRestoring) {
- return {
- type: constants.SET_IS_TRACKING_COMPOUNDS_RESTORING,
- isTrackingCompoundsRestoring: isTrackingCompoundsRestoring
- };
-};
-
-export const setIsUndoRedoAction = function(isUndoRedoAction) {
- return {
- type: constants.SET_IS_UNDO_REDO_ACTION,
- isUndoRedoAction: isUndoRedoAction
- };
-};
-
-export const setIsActionsSending = function(isActionsSending) {
- return {
- type: constants.SET_IS_ACTIONS_SENDING,
- isActionsSending: isActionsSending
- };
-};
-
-export const setIsActionsLoading = function(isActionsLoading) {
- return {
- type: constants.SET_IS_ACTIONS_LOADING,
- isActionsLoading: isActionsLoading
- };
-};
-
-export const setSendActionsList = function(track_actions_list) {
- return {
- type: constants.SET_SEND_ACTIONS_LIST,
- send_actions_list: track_actions_list
- };
-};
-
-export const appendToSendActionList = function(track_action) {
- return {
- type: constants.APPEND_SEND_ACTIONS_LIST,
- track_action: track_action
- };
-};
-
-export const setProjectActionList = function(project_actions_list) {
- return {
- type: constants.SET_PROJECT_ACTIONS_LIST,
- project_actions_list: project_actions_list
- };
-};
-
-export const setSnapshotImageActionList = function(snapshotActionImageList) {
- return {
- type: constants.SET_SNAPSOT_IMAGE_ACTIONS_LIST,
- snapshotActionImageList: snapshotActionImageList
- };
-};
-
-export const setIsActionsSaving = function(isActionSaving) {
- return {
- type: constants.SET_IS_ACTIONS_SAVING,
- isActionSaving: isActionSaving
- };
-};
-
-export const setIsActionsRestoring = function(isActionRestoring, isActionRestored) {
- return {
- type: constants.SET_IS_ACTIONS_RESTORING,
- isActionRestoring: isActionRestoring,
- isActionRestored: isActionRestored
- };
-};
-
-export const setIsActionTracking = function(isActionTracking) {
- return {
- type: constants.SET_IS_ACTION_TRACKING,
- isActionTracking: isActionTracking
- };
-};
-
-export const resetTrackingState = function() {
- return {
- type: constants.RESET_TRACKING_STATE
- };
-};
-
-export const setTrackingImageSource = imageSource => ({
- type: constants.SET_TRACKING_IMAGE_SOURCE,
- payload: imageSource
-});
-
-export const nglTrackingUndo = function() {
- return {
- type: undoConstants.NGL_TRACKING_UNDO
- };
-}
-
-export const nglTrackingRedo = function() {
- return {
- type: undoConstants.NGL_TRACKING_REDO
- };
-}
-
-export const nglClearHistory = function() {
- return {
- type: undoConstants.NGL_CLEAR_HISTORY
- }
-}
\ No newline at end of file
diff --git a/js/reducers/nglTracking/constants.js b/js/reducers/nglTracking/constants.js
deleted file mode 100644
index e1bd6318d..000000000
--- a/js/reducers/nglTracking/constants.js
+++ /dev/null
@@ -1,115 +0,0 @@
-const prefix = 'REDUCERS_NGL_TRACKING_';
-
-export const constants = {
- SET_ACTIONS_LIST: prefix + 'SET_ACTIONS_LIST',
- APPEND_ACTIONS_LIST: prefix + 'APPEND_ACTIONS_LIST',
- SET_CURRENT_ACTIONS_LIST: prefix + 'SET_CURRENT_ACTIONS_LIST',
- SET_IS_TRACKING_COMPOUNDS_RESTORING: prefix + 'SET_IS_TRACKING_COMPOUNDS_RESTORING',
- SET_IS_TRACKING_MOLECULES_RESTORING: prefix + 'SET_IS_TRACKING_MOLECULES_RESTORING',
- SET_IS_UNDO_REDO_ACTION: prefix + 'SET_IS_UNDO_REDO_ACTION',
- SET_SEND_ACTIONS_LIST: prefix + 'SET_SEND_ACTIONS_LIST',
- APPEND_SEND_ACTIONS_LIST: prefix + 'APPEND_SEND_ACTIONS_LIST',
- SET_IS_ACTIONS_SENDING: prefix + 'SET_IS_ACTIONS_SENDING',
- SET_IS_ACTIONS_LOADING: prefix + 'SET_IS_ACTIONS_LOADING',
- SET_PROJECT_ACTIONS_LIST: prefix + 'SET_PROJECT_ACTIONS_LIST',
- SET_IS_ACTIONS_SAVING: prefix + 'SET_IS_ACTIONS_SAVING',
- SET_IS_ACTIONS_RESTORING: prefix + 'SET_IS_ACTIONS_RESTORING',
- SET_IS_ACTION_TRACKING: prefix + 'SET_IS_ACTION_TRACKING',
- RESET_TRACKING_STATE: prefix + 'RESET_TRACKING_STATE',
- SET_TRACKING_IMAGE_SOURCE: prefix + 'SET_TRACKING_IMAGE_SOURCE',
- SET_SNAPSOT_IMAGE_ACTIONS_LIST: prefix + 'SET_SNAPSOT_IMAGE_ACTIONS_LIST',
- APPEND_UNDO_REDO_ACTIONS_LIST: prefix + 'APPEND_UNDO_REDO_ACTIONS_LIST',
- SET_UNDO_REDO_ACTIONS_LIST: prefix + 'SET_UNDO_REDO_ACTIONS_LIST'
-};
-
-export const actionType = {
- TARGET_LOADED: 'TARGET_LOADED',
- SITE_TURNED_ON: 'SITE_TURNED_ON',
- SITE_TURNED_OFF: 'SITE_TURNED_OFF',
- LIGAND_TURNED_ON: 'LIGAND_TURNED_ON',
- LIGAND_TURNED_OFF: 'LIGAND_TURNED_OFF',
- SIDECHAINS_TURNED_ON: 'SIDECHAINS_TURNED_ON',
- SIDECHAINS_TURNED_OFF: 'SIDECHAINS_TURNED_OFF',
- INTERACTIONS_TURNED_ON: 'INTERACTIONS_TURNED_ON',
- INTERACTIONS_TURNED_OFF: 'INTERACTIONS_TURNED_OFF',
- SURFACE_TURNED_ON: 'SURFACE_TURNED_ON',
- SURFACE_TURNED_OFF: 'SURFACE_TURNED_OFF',
- VECTORS_TURNED_ON: 'VECTORS_TURNED_ON',
- VECTORS_TURNED_OFF: 'VECTORS_TURNED_OFF',
- VECTOR_SELECTED: 'VECTOR_SELECTED',
- VECTOR_DESELECTED: 'VECTOR_DESELECTED',
- MOLECULE_ADDED_TO_SHOPPING_CART: 'MOLECULE_ADDED_TO_SHOPPING_CART',
- MOLECULE_REMOVED_FROM_SHOPPING_CART: 'MOLECULE_REMOVED_FROM_SHOPPING_CART',
- COMPOUND_SELECTED: 'COMPOUND_SELECTED',
- COMPOUND_DESELECTED: 'COMPOUND_DESELECTED',
- REPRESENTATION_UPDATED: 'REPRESENTATION_UPDATED',
- REPRESENTATION_ADDED: 'REPRESENTATION_ADDED',
- REPRESENTATION_REMOVED: 'REPRESENTATION_REMOVED',
- REPRESENTATION_CHANGED: 'REPRESENTATION_CHANGED',
- NGL_STATE: 'NGL_STATE',
- UNDO: 'UNDO',
- REDO: 'REDO',
- SNAPSHOT: 'SNAPSHOT',
- ALL_HIDE: 'ALL_HIDE',
- ALL_TURNED_ON: 'ALL_TURNED_ON',
- ALL_TURNED_OFF: 'ALL_TURNED_OFF',
- ALL_TURNED_ON_BY_TYPE: 'ALL_TURNED_ON_BY_TYPE',
- ALL_TURNED_OFF_BY_TYPE: 'ALL_TURNED_OFF_BY_TYPE',
- BACKGROUND_COLOR_CHANGED: 'BACKGROUND_COLOR_CHANGED',
- CLIP_NEAR: 'CLIP_NEAR',
- ORIENTATION: 'ORIENTATION'
-};
-
-export const actionDescription = {
- LOADED: 'was loaded',
- TURNED_ON: 'was turned on',
- TURNED_OFF: 'was turned off',
- SELECTED: 'was selected',
- DESELECTED: 'was deselected',
- HIDDEN: 'hidden',
- CANCELED: 'canceled',
- ADDED: 'was added',
- REMOVED: 'was removed',
- CHANGED: 'was changed',
- UPDATED: 'was updated',
- TO_SHOPPING_CART: 'to shopping cart',
- FROM_SHOPPING_CART: 'from shopping cart',
- LIGAND: 'Ligand',
- SIDECHAIN: 'Sidechain',
- INTERACTION: 'Interaction',
- VECTOR: 'Vector',
- SURFACE: 'Surface',
- SITE: 'Site',
- TARGET: 'Target',
- ALL: 'All',
- LIGANDS: 'Ligands',
- SIDECHAINS: 'Sidechains',
- INTERACTIONS: 'Interactions'
-};
-
-export const actionObjectType = {
- TARGET: 'TARGET',
- SITE: 'SITE',
- MOLECULE: 'MOLECULE',
- COMPOUND: 'COMPOUND',
- INSPIRATION: 'INSPIRATION',
- CROSS_REFERENCE: 'CROSS_REFERENCE',
- REPRESENTATION: 'REPRESENTATION',
- VIEWER_SETTINGS: 'VIEWER_SETTINGS'
-};
-
-export const actionAnnotation = {
- CHECK: 'CHECK',
- CLEAR: 'CLEAR',
- WARNING: 'WARNING',
- FAVORITE: 'FAVORITE',
- STAR: 'STAR'
-};
-
-export const NUM_OF_SECONDS_TO_IGNORE_MERGE = 5;
-
-export const undoConstants = {
- NGL_TRACKING_UNDO: prefix + 'UNDO',
- NGL_TRACKING_REDO: prefix + 'REDO',
- NGL_CLEAR_HISTORY: prefix + 'CLEAR_HISTORY'
-}
\ No newline at end of file
diff --git a/js/reducers/nglTracking/dispatchActions.js b/js/reducers/nglTracking/dispatchActions.js
deleted file mode 100644
index 90eaf8289..000000000
--- a/js/reducers/nglTracking/dispatchActions.js
+++ /dev/null
@@ -1,1606 +0,0 @@
-import {
- setCurrentActionsList,
- setIsTrackingMoleculesRestoring,
- setIsTrackingCompoundsRestoring,
- setIsUndoRedoAction,
- nglClearHistory
-} from './actions';
-import { createInitAction } from './trackingActions';
-import { actionType, actionObjectType, NUM_OF_SECONDS_TO_IGNORE_MERGE } from './constants';
-import { VIEWS } from '../../../js/constants/constants';
-import { setCurrentVector, appendToBuyList } from '../selection/actions';
-import {
- resetReducersForRestoringActions,
- loadProteinOfRestoringActions
-} from '../../components/preview/redux/dispatchActions';
-import { setCurrentProject } from '../../components/projects/redux/actions';
-import {
- selectMoleculeGroup,
- loadMoleculeGroupsOfTarget
-} from '../../components/preview/moleculeGroups/redux/dispatchActions';
-import { loadTargetList } from '../../components/target/redux/dispatchActions';
-import { resetTargetState, setTargetOn } from '../api/actions';
-import {
- addComplex,
- addLigand,
- addHitProtein,
- addSurface,
- addVector,
- removeComplex,
- removeLigand,
- removeHitProtein,
- removeSurface,
- removeVector
-} from '../../components/preview/molecule/redux/dispatchActions';
-import { colourList } from '../../components/preview/molecule/utils/color';
-import {
- addDatasetComplex,
- addDatasetLigand,
- addDatasetHitProtein,
- addDatasetSurface,
- removeDatasetComplex,
- removeDatasetLigand,
- removeDatasetHitProtein,
- removeDatasetSurface,
- loadDataSets,
- loadDatasetCompoundsWithScores
-} from '../../components/datasets/redux/dispatchActions';
-import {
- appendMoleculeToCompoundsOfDatasetToBuy,
- setMoleculeListIsLoading
-} from '../../components/datasets/redux/actions';
-import { getUrl, loadAllMolsFromMolGroup } from '../../../js/utils/genericList';
-import { addComponentRepresentation, updateComponentRepresentation } from '../../../js/reducers/ngl/actions';
-import * as listType from '../../constants/listTypes';
-import { assignRepresentationToComp } from '../../components/nglView/generatingObjects';
-import { setOrientation, restoreNglOrientation } from '../../../js/reducers/ngl/dispatchActions';
-import {
- setSendActionsList,
- setIsActionsSending,
- setIsActionsLoading,
- setActionsList,
- setSnapshotImageActionList,
- setUndoRedoActionList
-} from './actions';
-import { api, METHOD } from '../../../js/utils/api';
-import { base_url } from '../../components/routes/constants';
-import { CONSTANTS } from '../../../js/constants/constants';
-import moment from 'moment';
-import {
- appendToSendActionList,
- setProjectActionList,
- setIsActionsSaving,
- setIsActionsRestoring,
- resetTrackingState,
- setIsActionTracking
-} from './actions';
-import { setSelectedAll, setSelectedAllByType } from '../../../js/reducers/selection/actions';
-import {
- setSelectedAll as setSelectedAllOfDataset,
- setSelectedAllByType as setSelectedAllByTypeOfDataset
-} from '../../components/datasets/redux/actions';
-import { addSelectedTag, loadMoleculesAndTagsNew } from '../../components/preview/tags/redux/dispatchActions';
-
-export const addCurrentActionsListToSnapshot = (snapshot, project, nglViewList) => async dispatch => {
- let projectID = project && project.projectID;
- let actionList = await dispatch(getTrackingActions(projectID));
-
- await dispatch(setSnapshotToActions(actionList, snapshot, projectID, project, nglViewList, true));
-};
-
-export const saveCurrentActionsList = (snapshot, project, nglViewList, all = false) => async dispatch => {
- let projectID = project && project.projectID;
- let actionList = await dispatch(getTrackingActions(projectID));
-
- if (all === false) {
- dispatch(setSnapshotToActions(actionList, snapshot, projectID, project, nglViewList, false));
- } else {
- dispatch(setSnapshotToAllActions(actionList, snapshot, projectID));
- }
- await dispatch(saveActionsList(project, snapshot, actionList, nglViewList));
-};
-
-const saveActionsList = (project, snapshot, actionList, nglViewList) => async (dispatch, getState) => {
- const state = getState();
-
- const currentTargetOn = state.apiReducers.target_on;
- const currentSites = state.selectionReducers.mol_group_selection;
- const currentLigands = state.selectionReducers.fragmentDisplayList;
- const currentProteins = state.selectionReducers.proteinList;
- const currentComplexes = state.selectionReducers.complexList;
- const currentSelectionAll = state.selectionReducers.moleculeAllSelection;
-
- const currentDatasetLigands = state.datasetsReducers.ligandLists;
- const currentDatasetProteins = state.datasetsReducers.proteinLists;
- const currentDatasetComplexes = state.datasetsReducers.complexLists;
- const currentDatasetSelectionAll = state.datasetsReducers.moleculeAllSelection;
-
- const currentTargets = (currentTargetOn && [currentTargetOn]) || [];
-
- let orderedActionList = actionList.reverse((a, b) => a.timestamp - b.timestamp);
-
- let currentActions = [];
-
- getCurrentActionList(orderedActionList, actionType.TARGET_LOADED, getCollection(currentTargets), currentActions);
- getCurrentActionList(orderedActionList, actionType.SITE_TURNED_ON, getCollection(currentSites), currentActions);
- getCurrentActionList(orderedActionList, actionType.LIGAND_TURNED_ON, getCollection(currentLigands), currentActions);
-
- getCurrentActionListOfAllSelection(
- orderedActionList,
- actionType.ALL_TURNED_ON,
- getCollection(currentSelectionAll),
- currentActions,
- getCollection(currentLigands),
- getCollection(currentProteins),
- getCollection(currentComplexes)
- );
-
- getCurrentActionListOfAllSelectionByType(
- orderedActionList,
- actionType.ALL_TURNED_ON_BY_TYPE,
- 'ligand',
- getCollection(currentLigands),
- currentActions
- );
-
- getCurrentActionListOfAllSelectionByType(
- orderedActionList,
- actionType.ALL_TURNED_ON_BY_TYPE,
- 'protein',
- getCollection(currentProteins),
- currentActions
- );
-
- getCurrentActionListOfAllSelectionByType(
- orderedActionList,
- actionType.ALL_TURNED_ON_BY_TYPE,
- 'complex',
- getCollection(currentComplexes),
- currentActions
- );
-
- getCurrentActionListOfAllSelectionByTypeOfDataset(
- orderedActionList,
- actionType.ALL_TURNED_ON_BY_TYPE,
- 'ligand',
- getCollectionOfDataset(currentDatasetLigands),
- currentActions
- );
-
- getCurrentActionListOfAllSelectionByTypeOfDataset(
- orderedActionList,
- actionType.ALL_TURNED_ON_BY_TYPE,
- 'protein',
- getCollectionOfDataset(currentDatasetProteins),
- currentActions
- );
-
- getCurrentActionListOfAllSelectionByTypeOfDataset(
- orderedActionList,
- actionType.ALL_TURNED_ON_BY_TYPE,
- 'complex',
- getCollectionOfDataset(currentDatasetComplexes),
- currentActions
- );
-
- getCurrentActionListOfAllSelection(
- orderedActionList,
- actionType.ALL_TURNED_ON,
- getCollectionOfDataset(currentDatasetSelectionAll),
- currentActions,
- getCollectionOfDataset(currentDatasetLigands),
- getCollectionOfDataset(currentDatasetProteins),
- getCollectionOfDataset(currentDatasetComplexes)
- );
-
- getCurrentActionList(
- orderedActionList,
- actionType.SIDECHAINS_TURNED_ON,
- getCollection(currentProteins),
- currentActions
- );
- const snapshotID = snapshot && snapshot.id;
- if (snapshotID) {
- const currentTargetOn = state.apiReducers.target_on;
- const currentSites = state.selectionReducers.mol_group_selection;
- const currentLigands = state.selectionReducers.fragmentDisplayList;
- const currentProteins = state.selectionReducers.proteinList;
- const currentComplexes = state.selectionReducers.complexList;
- const currentSurfaces = state.selectionReducers.surfaceList;
- const currentVectors = state.selectionReducers.vectorOnList;
- const currentBuyList = state.selectionReducers.to_buy_list;
- const currentVector = state.selectionReducers.currentVector;
- const currentSelectionAll = state.selectionReducers.moleculeAllSelection;
-
- const currentDatasetLigands = state.datasetsReducers.ligandLists;
- const currentDatasetProteins = state.datasetsReducers.proteinLists;
- const currentDatasetComplexes = state.datasetsReducers.complexLists;
- const currentDatasetSurfaces = state.datasetsReducers.surfaceLists;
- const currentDatasetSelectionAll = state.datasetsReducers.moleculeAllSelection;
-
- const currentDatasetBuyList = state.datasetsReducers.compoundsToBuyDatasetMap;
- const currentobjectsInView = state.nglReducers.objectsInView;
-
- const currentTargets = (currentTargetOn && [currentTargetOn]) || [];
- const currentVectorSmiles = (currentVector && [currentVector]) || [];
-
- let orderedActionList = actionList.reverse((a, b) => a.timestamp - b.timestamp);
-
- let currentActions = [];
-
- getCurrentActionList(orderedActionList, actionType.TARGET_LOADED, getCollection(currentTargets), currentActions);
- getCurrentActionList(orderedActionList, actionType.SITE_TURNED_ON, getCollection(currentSites), currentActions);
- getCurrentActionList(orderedActionList, actionType.LIGAND_TURNED_ON, getCollection(currentLigands), currentActions);
-
- getCurrentActionList(
- orderedActionList,
- actionType.ALL_TURNED_ON,
- getCollection(currentSelectionAll),
- currentActions
- );
- getCurrentActionList(
- orderedActionList,
- actionType.ALL_TURNED_ON,
- getCollectionOfDataset(currentDatasetSelectionAll),
- currentActions
- );
-
- getCurrentActionList(
- orderedActionList,
- actionType.SIDECHAINS_TURNED_ON,
- getCollection(currentProteins),
- currentActions
- );
-
- getCurrentActionList(
- orderedActionList,
- actionType.INTERACTIONS_TURNED_ON,
- getCollection(currentComplexes),
- currentActions
- );
- getCurrentActionList(
- orderedActionList,
- actionType.SURFACE_TURNED_ON,
- getCollection(currentSurfaces),
- currentActions
- );
- getCurrentActionList(
- orderedActionList,
- actionType.VECTORS_TURNED_ON,
- getCollection(currentVectors),
- currentActions
- );
- getCurrentActionList(
- orderedActionList,
- actionType.VECTOR_SELECTED,
- getCollection(currentVectorSmiles),
- currentActions
- );
-
- getCurrentActionList(
- orderedActionList,
- actionType.MOLECULE_ADDED_TO_SHOPPING_CART,
- getCollectionOfShoppingCart(currentBuyList),
- currentActions
- );
-
- getCurrentActionList(
- orderedActionList,
- actionType.LIGAND_TURNED_ON,
- getCollectionOfDataset(currentDatasetLigands),
- currentActions
- );
-
- getCurrentActionList(
- orderedActionList,
- actionType.SIDECHAINS_TURNED_ON,
- getCollectionOfDataset(currentDatasetProteins),
- currentActions
- );
-
- getCurrentActionList(
- orderedActionList,
- actionType.INTERACTIONS_TURNED_ON,
- getCollectionOfDataset(currentDatasetComplexes),
- currentActions
- );
-
- getCurrentActionList(
- orderedActionList,
- actionType.SURFACE_TURNED_ON,
- getCollectionOfDataset(currentDatasetSurfaces),
- currentActions
- );
-
- getCurrentActionList(
- orderedActionList,
- actionType.COMPOUND_SELECTED,
- getCollectionOfDataset(currentDatasetBuyList),
- currentActions
- );
-
- getCurrentActionList(
- orderedActionList,
- actionType.REPRESENTATION_ADDED,
- getCollectionOfDatasetOfRepresentation(currentobjectsInView),
- currentActions
- );
-
- getCurrentActionList(
- orderedActionList,
- actionType.REPRESENTATION_UPDATED,
- getCollectionOfDatasetOfRepresentation(currentobjectsInView),
- currentActions
- );
-
- if (nglViewList) {
- let nglStateList = nglViewList.map(nglView => {
- return { id: nglView.id, orientation: nglView.stage.viewerControls.getOrientation() };
- });
-
- let trackAction = {
- type: actionType.NGL_STATE,
- timestamp: Date.now(),
- nglStateList: nglStateList
- };
-
- currentActions.push(Object.assign({ ...trackAction }));
- }
-
- await dispatch(saveSnapshotAction(snapshot, project, currentActions));
- await dispatch(saveTrackingActions(currentActions, snapshotID));
- dispatch(setCurrentActionsList(currentActions));
- }
-};
-
-const saveSnapshotAction = (snapshot, project, currentActions) => async (dispatch, getState) => {
- const state = getState();
- const trackingImageSource = state.nglTrackingReducers.trackingImageSource;
-
- let sendActions = [];
- let snapshotAction = {
- type: actionType.SNAPSHOT,
- timestamp: Date.now(),
- object_name: snapshot.title,
- object_id: snapshot.id,
- snapshotId: snapshot.id,
- text: `Snapshot: ${snapshot.id} - ${snapshot.title}`,
- image: trackingImageSource
- };
- sendActions.push(snapshotAction);
- currentActions.push(snapshotAction);
- await dispatch(sendTrackingActions(sendActions, project));
-};
-
-const setSnapshotToActions = (
- actionList,
- snapshot,
- projectID,
- project,
- nglViewList,
- addToSnapshot
-) => async dispatch => {
- if (actionList && snapshot) {
- let actionsWithoutSnapshot = actionList.filter(a => a.snapshotId === null || a.snapshotId === undefined);
- let updatedActions = actionsWithoutSnapshot.map(obj => ({ ...obj, snapshotId: snapshot.id }));
- dispatch(setAndUpdateTrackingActions(updatedActions, projectID));
-
- if (addToSnapshot === true) {
- await dispatch(saveActionsList(project, snapshot, updatedActions, nglViewList));
- }
- }
-};
-
-const setSnapshotToAllActions = (actionList, snapshot, projectID) => async dispatch => {
- if (actionList && snapshot) {
- let updatedActions = actionList.map(obj => ({ ...obj, snapshotId: snapshot.id }));
- dispatch(setAndUpdateTrackingActions(updatedActions, projectID));
- }
-};
-
-export const saveTrackingActions = (currentActions, snapshotID) => async (dispatch, getState) => {
- const state = getState();
- const project = state.projectReducers.currentProject;
- const projectID = project && project.projectID;
-
- if (snapshotID) {
- dispatch(setIsActionsSaving(true));
-
- const dataToSend = {
- session_project: projectID,
- author: project.authorID,
- snapshot: snapshotID,
- last_update_date: moment().format(),
- actions: JSON.stringify(currentActions)
- };
- return api({
- url: `${base_url}/api/snapshot-actions/`,
- method: METHOD.POST,
- data: JSON.stringify(dataToSend)
- })
- .then(() => {
- dispatch(setCurrentActionsList([]));
- })
- .catch(error => {
- throw new Error(error);
- })
- .finally(() => {
- dispatch(setIsActionsSaving(false));
- });
- } else {
- return Promise.resolve();
- }
-};
-
-const getCurrentActionList = (orderedActionList, type, collection, currentActions) => {
- let actionList = orderedActionList.filter(action => action.type === type);
-
- if (collection) {
- collection.forEach(data => {
- let action = actionList.find(action => action.object_id === data.id && action.dataset_id === data.datasetId);
-
- if (action) {
- currentActions.push(Object.assign({ ...action }));
- }
- });
- }
-};
-
-const getCurrentActionListOfAllSelection = (
- orderedActionList,
- type,
- collection,
- currentActions,
- ligandList,
- proteinList,
- complexList
-) => {
- let actionList = orderedActionList.filter(action => action.type === type);
-
- if (collection) {
- collection.forEach(data => {
- let action = actionList.find(action => action.object_id === data.id && action.dataset_id === data.datasetId);
-
- if (action) {
- let ligandAction = ligandList.find(
- data => data.id === action.object_id && action.dataset_id === data.datasetId
- );
- let proteinAction = proteinList.find(
- data => data.id === action.object_id && action.dataset_id === data.datasetId
- );
- let complexAction = complexList.find(
- data => data.id === action.object_id && action.dataset_id === data.datasetId
- );
-
- let isLigand = ligandAction && ligandAction != null ? true : false;
- let isProtein = proteinAction && proteinAction != null ? true : false;
- let isComplex = complexAction && complexAction != null ? true : false;
- currentActions.push(
- Object.assign({ ...action, isLigand: isLigand, isProtein: isProtein, isComplex: isComplex })
- );
- }
- });
- }
-};
-
-const getCurrentActionListOfAllSelectionByType = (orderedActionList, type, controlType, collection, currentActions) => {
- let action = orderedActionList.find(
- action =>
- action.type === type &&
- action.control_type === controlType &&
- (action.object_type === actionObjectType.MOLECULE || action.object_type === actionObjectType.INSPIRATION)
- );
- if (action && collection) {
- let actionItems = action.items;
- let items = [];
- collection.forEach(data => {
- let item = actionItems.find(action => action.id === data.id && action.dataset_id === data.datasetId);
- if (item) {
- items.push(item);
- }
- });
-
- currentActions.push(Object.assign({ ...action, items: items }));
- }
-};
-
-const getCurrentActionListOfAllSelectionByTypeOfDataset = (
- orderedActionList,
- type,
- controlType,
- collection,
- currentActions
-) => {
- let action = orderedActionList.find(
- action =>
- action.type === type &&
- action.control_type === controlType &&
- (action.object_type === actionObjectType.COMPOUND || action.object_type === actionObjectType.CROSS_REFERENCE)
- );
- if (action && collection) {
- let actionItems = action.items;
- let items = [];
- collection.forEach(data => {
- let item = actionItems.find(item => item.molecule.id === data.id && item.datasetID === data.datasetId);
- if (item) {
- items.push(item);
- }
- });
-
- currentActions.push(Object.assign({ ...action, items: items }));
- }
-};
-
-const getCollection = dataList => {
- let list = [];
- if (dataList) {
- var result = dataList.map(value => ({ id: value }));
- list.push(...result);
- }
- return list;
-};
-
-const getCollectionOfDataset = dataList => {
- let list = [];
- if (dataList) {
- for (const datasetId in dataList) {
- let values = dataList[datasetId];
- if (values) {
- var result = values.map(value => ({ id: value, datasetId: datasetId }));
- list.push(...result);
- }
- }
- }
- return list;
-};
-
-const getCollectionOfShoppingCart = dataList => {
- let list = [];
- if (dataList) {
- dataList.forEach(data => {
- let value = data.vector;
- if (value) {
- list.push({ id: value });
- }
- });
- }
- return list;
-};
-
-const getCollectionOfDatasetOfRepresentation = dataList => {
- let list = [];
- for (const view in dataList) {
- let objectView = dataList[view];
- if (objectView && objectView !== null && objectView.display_div === VIEWS.MAJOR_VIEW) {
- let value = dataList[view].name;
- if (value) {
- list.push({ id: value });
- }
- }
- }
- return list;
-};
-
-export const resetRestoringState = () => dispatch => {
- dispatch(setActionsList([]));
- dispatch(setProjectActionList([]));
- dispatch(setSendActionsList([]));
-
- dispatch(setTargetOn(undefined));
- dispatch(setIsActionsRestoring(false, false));
-};
-
-export const restoreCurrentActionsList = snapshotID => async dispatch => {
- dispatch(resetTrackingState());
- dispatch(setIsActionsRestoring(true, false));
-
- await dispatch(restoreTrackingActions(snapshotID));
- dispatch(setIsTrackingMoleculesRestoring(true));
- dispatch(setIsTrackingCompoundsRestoring(true));
- dispatch(resetTargetState());
- dispatch(resetReducersForRestoringActions());
- dispatch(restoreStateBySavedActionList());
-};
-
-const restoreTrackingActions = snapshotID => async dispatch => {
- if (snapshotID) {
- try {
- const response = await api({
- url: `${base_url}/api/snapshot-actions/?snapshot=${snapshotID}`
- });
- let results = response.data.results;
- let listToSet = [];
- results.forEach(r => {
- let resultActions = JSON.parse(r.actions);
- listToSet.push(...resultActions);
- });
-
- let snapshotActions = [...listToSet];
- dispatch(setCurrentActionsList(snapshotActions));
- } catch (error) {
- throw new Error(error);
- }
- } else {
- return Promise.resolve();
- }
-};
-
-const restoreStateBySavedActionList = () => (dispatch, getState) => {
- const state = getState();
-
- const currentActionList = state.nglTrackingReducers.current_actions_list;
- const orderedActionList = currentActionList.sort((a, b) => a.timestamp - b.timestamp);
-
- let onCancel = () => {};
- dispatch(loadTargetList(onCancel))
- .then(() => dispatch(restoreTargetActions(orderedActionList)))
- .catch(error => {
- throw new Error(error);
- });
- return () => {
- onCancel();
- };
-};
-
-const restoreTargetActions = orderedActionList => (dispatch, getState) => {
- const state = getState();
-
- let targetAction = orderedActionList.find(action => action.type === actionType.TARGET_LOADED);
- if (targetAction) {
- let target = getTarget(targetAction.object_name, state);
- if (target) {
- dispatch(setTargetOn(target.id));
- }
- }
-};
-
-export const restoreAfterTargetActions = (stages, projectId) => async (dispatch, getState) => {
- const state = getState();
-
- const currentActionList = state.nglTrackingReducers.current_actions_list;
- const orderedActionList = currentActionList.sort((a, b) => a.timestamp - b.timestamp);
- const targetId = state.apiReducers.target_on;
-
- if (targetId && stages && stages.length > 0) {
- const majorView = stages.find(view => view.id === VIEWS.MAJOR_VIEW);
- // const summaryView = stages.find(view => view.id === VIEWS.SUMMARY_VIEW);
-
- await dispatch(loadProteinOfRestoringActions({ nglViewList: stages }));
-
- await dispatch(
- loadMoleculeGroupsOfTarget({
- isStateLoaded: false,
- setOldUrl: () => {},
- target_on: targetId
- })
- )
- .catch(error => {
- throw error;
- })
- .finally(() => {});
-
- await dispatch(restoreSitesActions(orderedActionList, null));
- await dispatch(loadData(orderedActionList, targetId, majorView));
- await dispatch(restoreActions(orderedActionList, majorView.stage));
- await dispatch(restoreRepresentationActions(orderedActionList, stages));
- await dispatch(restoreProject(projectId));
- dispatch(restoreSnapshotImageActions(projectId));
- dispatch(restoreNglStateAction(orderedActionList, stages));
- dispatch(setIsActionsRestoring(false, true));
- }
-};
-
-const restoreNglStateAction = (orderedActionList, stages) => (dispatch, getState) => {
- const state = getState();
- const skipOrientation = state.trackingReducers.skipOrientationChange;
-
- if (!skipOrientation) {
- let actions = orderedActionList.filter(action => action.type === actionType.NGL_STATE);
- let action = [...actions].pop();
- if (action && action.nglStateList) {
- action.nglStateList.forEach(nglView => {
- dispatch(setOrientation(nglView.id, nglView.orientation));
- let viewStage = stages.find(s => s.id === nglView.id);
- if (viewStage) {
- console.count(`Before restoring orientation - restoreNglStateAction - nglTracking`);
- viewStage.stage.viewerControls.orient(nglView.orientation.elements);
- console.count(`After restoring orientation - restoreNglStateAction - nglTracking`);
- }
- });
- }
- }
-};
-
-const restoreActions = (orderedActionList, stage) => dispatch => {
- dispatch(restoreMoleculesActions(orderedActionList, stage));
-};
-
-const loadData = (orderedActionList, targetId, majorView) => async dispatch => {
- await dispatch(loadAllMolecules(targetId));
- await dispatch(loadAllDatasets(orderedActionList, targetId, majorView.stage));
-};
-
-const loadAllDatasets = (orderedActionList, target_on, stage) => async dispatch => {
- dispatch(setMoleculeListIsLoading(true));
-
- await dispatch(loadDataSets(target_on));
- await dispatch(loadDatasetCompoundsWithScores());
- dispatch(setMoleculeListIsLoading(false));
-
- dispatch(restoreCompoundsActions(orderedActionList, stage));
-};
-
-const loadAllMolecules = target_on => async (dispatch, getState) => {
- await dispatch(loadMoleculesAndTagsNew(target_on));
-};
-
-const restoreSitesActions = (orderedActionList, summaryView) => (dispatch, getState) => {
- const state = getState();
-
- let sitesAction = orderedActionList.filter(action => action.type === actionType.SITE_TURNED_ON);
- if (sitesAction && summaryView) {
- sitesAction.forEach(action => {
- const tag = getTag(action.object_id, state);
- if (tag) {
- dispatch(addSelectedTag(tag));
- }
- });
- }
-};
-
-const getTag = (tagId, state) => {
- const tagList = state.apiReducers.tagList;
- const tag = tagList.find(t => t.id === tagId);
- return tag;
-};
-
-const restoreMoleculesActions = (orderedActionList, stage) => (dispatch, getState) => {
- const state = getState();
- let moleculesAction = orderedActionList.filter(
- action => action.object_type === actionObjectType.MOLECULE || action.object_type === actionObjectType.INSPIRATION
- );
-
- if (moleculesAction) {
- dispatch(addNewType(moleculesAction, actionType.LIGAND_TURNED_ON, 'ligand', stage, state));
- dispatch(addNewType(moleculesAction, actionType.SIDECHAINS_TURNED_ON, 'protein', stage, state));
- dispatch(addNewType(moleculesAction, actionType.INTERACTIONS_TURNED_ON, 'complex', stage, state));
- dispatch(addNewType(moleculesAction, actionType.SURFACE_TURNED_ON, 'surface', stage, state));
- dispatch(addNewType(moleculesAction, actionType.VECTORS_TURNED_ON, 'vector', stage, state));
- }
-
- let vectorAction = orderedActionList.find(action => action.type === actionType.VECTOR_SELECTED);
- if (vectorAction) {
- dispatch(setCurrentVector(vectorAction.object_name));
- }
-
- dispatch(restoreCartActions(moleculesAction));
- dispatch(restoreAllSelectionActions(orderedActionList, stage, true));
- dispatch(restoreAllSelectionByTypeActions(orderedActionList, stage, true));
- dispatch(setIsTrackingMoleculesRestoring(false));
-};
-
-const restoreCartActions = moleculesAction => dispatch => {
- let shoppingCartActions = moleculesAction.filter(
- action => action.type === actionType.MOLECULE_ADDED_TO_SHOPPING_CART
- );
- if (shoppingCartActions) {
- shoppingCartActions.forEach(action => {
- let data = action.item;
- if (data) {
- dispatch(appendToBuyList(data));
- }
- });
- }
-};
-
-const restoreAllSelectionActions = (moleculesAction, stage, isSelection) => (dispatch, getState) => {
- let state = getState();
-
- let actions =
- isSelection === true
- ? moleculesAction.filter(
- action =>
- action.type === actionType.ALL_TURNED_ON &&
- (action.object_type === actionObjectType.INSPIRATION || action.object_type === actionObjectType.MOLECULE)
- )
- : moleculesAction.filter(
- action =>
- action.type === actionType.ALL_TURNED_ON &&
- (action.object_type === actionObjectType.CROSS_REFERENCE ||
- action.object_type === actionObjectType.COMPOUND)
- );
-
- if (actions) {
- actions.forEach(action => {
- if (action) {
- if (isSelection) {
- dispatch(setSelectedAll(action.item, action.isLigand, action.isProtein, action.isComplex));
- } else {
- dispatch(
- setSelectedAllOfDataset(action.dataset_id, action.item, action.isLigand, action.isProtein, action.isComplex)
- );
- }
-
- if (action.isLigand) {
- dispatch(handleMoleculeAction(action, 'ligand', true, stage, state, true));
- }
-
- if (action.isProtein) {
- dispatch(handleMoleculeAction(action, 'protein', true, stage, state, true));
- }
-
- if (action.isComplex) {
- dispatch(handleMoleculeAction(action, 'complex', true, stage, state, true));
- }
- }
- });
- }
-};
-
-const restoreAllSelectionByTypeActions = (moleculesAction, stage, isSelection) => dispatch => {
- let actions =
- isSelection === true
- ? moleculesAction.filter(
- action =>
- action.type === actionType.ALL_TURNED_ON_BY_TYPE &&
- (action.object_type === actionObjectType.INSPIRATION || action.object_type === actionObjectType.MOLECULE)
- )
- : moleculesAction.filter(
- action =>
- action.type === actionType.ALL_TURNED_ON_BY_TYPE &&
- (action.object_type === actionObjectType.CROSS_REFERENCE ||
- action.object_type === actionObjectType.COMPOUND)
- );
-
- if (actions) {
- actions.forEach(action => {
- if (action) {
- let actionItems = action.items;
- let type = action.control_type;
-
- if (isSelection) {
- dispatch(setSelectedAllByType(type, actionItems, action.object_type === actionObjectType.INSPIRATION));
-
- actionItems.forEach(data => {
- if (data) {
- if (type === 'ligand') {
- dispatch(addType[type](stage, data, colourList[data.id % colourList.length], true, true));
- } else {
- dispatch(addType[type](stage, data, colourList[data.id % colourList.length], true));
- }
- }
- });
- } else {
- dispatch(
- setSelectedAllByTypeOfDataset(
- type,
- action.dataset_id,
- actionItems,
- action.object_type === actionObjectType.CROSS_REFERENCE
- )
- );
-
- actionItems.forEach(data => {
- if (data && data.molecule) {
- dispatch(
- addTypeCompound[type](
- stage,
- data.molecule,
- colourList[data.molecule.id % colourList.length],
- data.datasetID,
- true
- )
- );
- }
- });
- }
- }
- });
- }
-};
-
-const restoreRepresentationActions = (moleculesAction, stages) => dispatch => {
- const nglView = stages.find(view => view.id === VIEWS.MAJOR_VIEW);
-
- let representationsActions = moleculesAction.filter(action => action.type === actionType.REPRESENTATION_ADDED);
- if (representationsActions) {
- representationsActions.forEach(action => {
- dispatch(addRepresentation(action.object_id, action.representation, nglView));
- });
- }
-
- let representationsChangesActions = moleculesAction.filter(
- action => action.type === actionType.REPRESENTATION_UPDATED
- );
- if (representationsChangesActions) {
- representationsChangesActions.forEach(action => {
- dispatch(updateRepresentation(true, action.change, action.object_id, action.representation, nglView));
- });
- }
-};
-
-const restoreSnapshotImageActions = projectID => async dispatch => {
- let actionList = await dispatch(getTrackingActions(projectID));
-
- let snapshotActions = actionList.filter(action => action.type === actionType.SNAPSHOT);
- if (snapshotActions) {
- let actions = snapshotActions.map(s => {
- return { id: s.object_id, image: s.image, title: s.object_name, timestamp: s.timestamp };
- });
- const key = 'object_id';
- const arrayUniqueByKey = [...new Map(actions.map(item => [item[key], item])).values()];
- dispatch(setSnapshotImageActionList(arrayUniqueByKey));
- }
-};
-
-const restoreProject = projectId => dispatch => {
- if (projectId !== undefined) {
- return api({ url: `${base_url}/api/session-projects/${projectId}/` }).then(response => {
- let promises = [];
- promises.push(
- dispatch(
- setCurrentProject({
- projectID: response.data.id,
- authorID: response.data.author || null,
- title: response.data.title,
- description: response.data.description,
- targetID: response.data.target.id,
- tags: JSON.parse(response.data.tags)
- })
- )
- );
- return Promise.all(promises);
- });
- }
-};
-
-const restoreCompoundsActions = (orderedActionList, stage) => (dispatch, getState) => {
- const state = getState();
-
- let compoundsAction = orderedActionList.filter(
- action =>
- action.object_type === actionObjectType.COMPOUND || action.object_type === actionObjectType.CROSS_REFERENCE
- );
-
- if (compoundsAction) {
- dispatch(addNewTypeCompound(compoundsAction, actionType.LIGAND_TURNED_ON, 'ligand', stage, state));
- dispatch(addNewTypeCompound(compoundsAction, actionType.SIDECHAINS_TURNED_ON, 'protein', stage, state));
- dispatch(addNewTypeCompound(compoundsAction, actionType.INTERACTIONS_TURNED_ON, 'complex', stage, state));
- dispatch(addNewTypeCompound(compoundsAction, actionType.SURFACE_TURNED_ON, 'surface', stage, state));
- }
-
- let compoundsSelectedAction = compoundsAction.filter(action => action.type === actionType.COMPOUND_SELECTED);
-
- compoundsSelectedAction.forEach(action => {
- let data = getCompound(action, state);
- if (data) {
- dispatch(appendMoleculeToCompoundsOfDatasetToBuy(action.dataset_id, data.id, data.name));
- }
- });
-
- dispatch(restoreAllSelectionActions(orderedActionList, stage, false));
- dispatch(restoreAllSelectionByTypeActions(orderedActionList, stage, false));
- dispatch(setIsTrackingCompoundsRestoring(false));
-};
-
-const addType = {
- ligand: addLigand,
- protein: addHitProtein,
- complex: addComplex,
- surface: addSurface,
- vector: addVector
-};
-
-const addTypeCompound = {
- ligand: addDatasetLigand,
- protein: addDatasetHitProtein,
- complex: addDatasetComplex,
- surface: addDatasetSurface
-};
-
-const addNewType = (moleculesAction, actionType, type, stage, state, skipTracking = false) => dispatch => {
- let actions = moleculesAction.filter(action => action.type === actionType);
- if (actions) {
- actions.forEach(action => {
- let data = getMolecule(action.object_name, state);
- if (data) {
- if (type === 'ligand') {
- dispatch(addType[type](stage, data, colourList[data.id % colourList.length], true, skipTracking));
- } else {
- dispatch(addType[type](stage, data, colourList[data.id % colourList.length], skipTracking));
- }
- }
- });
- }
-};
-
-const addNewTypeOfAction = (action, type, stage, state, skipTracking = false) => dispatch => {
- if (action) {
- let data = getMolecule(action.object_name, state);
- if (data) {
- if (type === 'ligand') {
- dispatch(addType[type](stage, data, colourList[data.id % colourList.length], true, skipTracking));
- } else {
- dispatch(addType[type](stage, data, colourList[data.id % colourList.length], skipTracking));
- }
- }
- }
-};
-
-const addNewTypeCompound = (moleculesAction, actionType, type, stage, state, skipTracking = false) => dispatch => {
- let actions = moleculesAction.filter(action => action.type === actionType);
- if (actions) {
- actions.forEach(action => {
- let data = getCompound(action, state);
- if (data) {
- dispatch(
- addTypeCompound[type](stage, data, colourList[data.id % colourList.length], action.dataset_id, skipTracking)
- );
- }
- });
- }
-};
-
-const addNewTypeCompoundOfAction = (action, type, stage, state, skipTracking = false) => dispatch => {
- if (action) {
- let data = getCompound(action, state);
- if (data) {
- dispatch(
- addTypeCompound[type](stage, data, colourList[data.id % colourList.length], action.dataset_id, skipTracking)
- );
- }
- }
-};
-
-const getTarget = (targetName, state) => {
- let targetList = state.apiReducers.target_id_list;
- let target = targetList.find(target => target.title === targetName);
- return target;
-};
-
-const getMolGroup = (molGroupName, state) => {
- let molGroupList = state.apiReducers.mol_group_list;
- let molGroup = molGroupList.find(group => group.description === molGroupName);
- return molGroup;
-};
-
-const getMolecule = (moleculeName, state) => {
- let moleculeList = state.apiReducers.all_mol_lists;
- let molecule = null;
-
- molecule = moleculeList.find(m => m.code === moleculeName);
-
- return molecule;
-};
-
-const getCompound = (action, state) => {
- let moleculeList = state.datasetsReducers.moleculeLists;
- let molecule = null;
-
- let name = action.object_name;
- let datasetID = action.dataset_id;
-
- if (moleculeList) {
- let moleculeListOfDataset = moleculeList[datasetID];
- if (moleculeListOfDataset) {
- molecule = moleculeListOfDataset.find(m => m.name === name);
- }
- }
- return molecule;
-};
-
-export const undoAction = (stages = []) => dispatch => {
- dispatch(setIsUndoRedoAction(true));
- let action = dispatch(getUndoAction());
- if (action) {
- Promise.resolve(dispatch(handleUndoAction(action, stages))).then(() => {
- dispatch(setIsUndoRedoAction(false));
- });
- }
-};
-
-const getUndoAction = () => (dispatch, getState) => {
- const state = getState();
- const actionUndoList = state.undoableNglTrackingReducers.future;
-
- let action = { text: '' };
- let actions = actionUndoList && actionUndoList[0];
- if (actions) {
- let actionsLenght = actions.undo_redo_actions_list.length;
- actionsLenght = actionsLenght > 0 ? actionsLenght - 1 : actionsLenght;
- action = actions.undo_redo_actions_list[actionsLenght];
- }
-
- return action;
-};
-
-const getRedoAction = () => (dispatch, getState) => {
- const state = getState();
- const actions = state.undoableNglTrackingReducers.present;
-
- let action = { text: '' };
- if (actions) {
- let actionsLenght = actions.undo_redo_actions_list.length;
- actionsLenght = actionsLenght > 0 ? actionsLenght - 1 : actionsLenght;
- action = actions.undo_redo_actions_list[actionsLenght];
- }
-
- return action;
-};
-
-const getNextUndoAction = () => (dispatch, getState) => {
- const state = getState();
- const actionUndoList = state.undoableNglTrackingReducers.present;
-
- let action = { text: '' };
- let actions = actionUndoList && actionUndoList.undo_redo_actions_list;
- if (actions) {
- let actionsLenght = actions.length;
- actionsLenght = actionsLenght > 0 ? actionsLenght - 1 : actionsLenght;
- action = actions[actionsLenght];
- }
-
- return action;
-};
-
-const getNextRedoAction = () => (dispatch, getState) => {
- const state = getState();
- const actionUndoList = state.undoableNglTrackingReducers.future;
-
- let action = { text: '' };
- let actionss = actionUndoList && actionUndoList[0];
-
- let actions = actionss && actionss.undo_redo_actions_list;
- if (actions) {
- let actionsLenght = actions.length;
- actionsLenght = actionsLenght > 0 ? actionsLenght - 1 : actionsLenght;
- action = actions[actionsLenght];
- }
-
- return action;
-};
-
-export const redoAction = (stages = []) => dispatch => {
- dispatch(setIsUndoRedoAction(true));
- let action = dispatch(getRedoAction());
- if (action) {
- Promise.resolve(dispatch(dispatch(handleRedoAction(action, stages)))).then(() => {
- dispatch(setIsUndoRedoAction(false));
- });
- }
-};
-
-const handleUndoAction = (action, stages) => (dispatch, getState) => {
- if (action) {
- const type = action.type;
- switch (type) {
- case actionType.ORIENTATION:
- dispatch(restoreNglOrientation(action.oldSetting, action.newSetting, action.div_id, stages));
- break;
- default:
- break;
- }
- }
-};
-
-const handleRedoAction = (action, stages) => (dispatch, getState) => {
- if (action) {
- const type = action.type;
- switch (type) {
- case actionType.ORIENTATION:
- dispatch(restoreNglOrientation(action.newSetting, action.oldSetting, action.div_id, stages));
- break;
- default:
- break;
- }
- }
-};
-
-const addRepresentation = (action, parentKey, representation, nglView, update, skipTracking = false) => dispatch => {
- const oldRepresentation = representation;
- const newRepresentationType = oldRepresentation.type;
- const comp = nglView.stage.getComponentsByName(parentKey).first;
- const newRepresentation = assignRepresentationToComp(
- newRepresentationType,
- oldRepresentation.params,
- comp,
- oldRepresentation.lastKnownID
- );
- action.representation = newRepresentation;
- if (update === true) {
- action.newRepresentation = newRepresentation;
- } else {
- action.oldRepresentation = newRepresentation;
- }
- dispatch(addComponentRepresentation(parentKey, newRepresentation, skipTracking));
-};
-
-const updateRepresentation = (isAdd, change, parentKey, representation, nglView) => dispatch => {
- const comp = nglView.stage.getComponentsByName(parentKey).first;
- const r = comp.reprList.find(rep => rep.uuid === representation.uuid || rep.uuid === representation.lastKnownID);
- if (r && change) {
- let key = change.key;
- let value = isAdd ? change.value : change.oldValue;
-
- r.setParameters({ [key]: value });
- representation.params[key] = value;
-
- dispatch(updateComponentRepresentation(parentKey, representation.uuid, representation));
- }
-};
-
-const handleMoleculeAction = (action, type, isAdd, stage, state, skipTracking) => dispatch => {
- if (action.object_type === actionObjectType.MOLECULE || action.object_type === actionObjectType.INSPIRATION) {
- if (isAdd) {
- dispatch(addNewTypeOfAction(action, type, stage, state, skipTracking));
- } else {
- dispatch(removeNewType(action, type, stage, state, skipTracking));
- }
- } else if (
- action.object_type === actionObjectType.COMPOUND ||
- action.object_type === actionObjectType.CROSS_REFERENCE
- ) {
- if (isAdd) {
- dispatch(addNewTypeCompoundOfAction(action, type, stage, state, skipTracking));
- } else {
- dispatch(removeNewTypeCompound(action, type, stage, state, skipTracking));
- }
- }
-};
-
-const removeType = {
- ligand: removeLigand,
- protein: removeHitProtein,
- complex: removeComplex,
- surface: removeSurface,
- vector: removeVector
-};
-
-const removeTypeCompound = {
- ligand: removeDatasetLigand,
- protein: removeDatasetHitProtein,
- complex: removeDatasetComplex,
- surface: removeDatasetSurface
-};
-
-const removeNewType = (action, type, stage, state, skipTracking) => dispatch => {
- if (action) {
- let data = getMolecule(action.object_name, state);
- if (data) {
- if (type === 'ligand') {
- dispatch(removeType[type](stage, data, skipTracking));
- } else {
- dispatch(removeType[type](stage, data, colourList[data.id % colourList.length], skipTracking));
- }
- }
- }
-};
-
-const removeNewTypeCompound = (action, type, stage, state, skipTracking) => dispatch => {
- if (action) {
- let data = getCompound(action, state);
- if (data) {
- dispatch(
- removeTypeCompound[type](stage, data, colourList[data.id % colourList.length], action.dataset_id, skipTracking)
- );
- }
- }
-};
-
-export const getUndoActionText = () => dispatch => {
- let action = dispatch(getNextUndoAction());
- return action?.text ?? '';
-};
-
-export const getRedoActionText = () => dispatch => {
- let action = dispatch(getNextRedoAction());
- return action?.text ?? '';
-};
-
-export const appendAndSendTrackingActions = trackAction => (dispatch, getState) => {
- const state = getState();
- const isUndoRedoAction = state.nglTrackingReducers.isUndoRedoAction;
- dispatch(setIsActionTracking(true));
-
- if (trackAction && trackAction !== null) {
- const actionList = state.nglTrackingReducers.track_actions_list;
- const sendActionList = state.nglTrackingReducers.send_actions_list;
- const mergedActionList = mergeActions(trackAction, [...actionList]);
- const mergedSendActionList = mergeActions(trackAction, [...sendActionList]);
- dispatch(setActionsList(mergedActionList));
- dispatch(setSendActionsList(mergedSendActionList));
-
- if (isUndoRedoAction === false) {
- const undoRedoActionList = state.nglTrackingReducers.undo_redo_actions_list;
- const mergedUndoRedoActionList = mergeActions(trackAction, [...undoRedoActionList]);
- dispatch(setUndoRedoActionList(mergedUndoRedoActionList));
- }
- }
- dispatch(setIsActionTracking(false));
- dispatch(checkSendTrackingActions());
-};
-
-export const mergeActions = (trackAction, list) => {
- return [...list, trackAction];
-};
-
-export const manageSendTrackingActions = (projectID, copy) => dispatch => {
- if (copy) {
- dispatch(checkActionsProject(projectID));
- } else {
- dispatch(checkSendTrackingActions(true));
- }
-};
-
-export const checkSendTrackingActions = (save = false) => (dispatch, getState) => {
- const state = getState();
- const currentProject = state.projectReducers.currentProject;
- const sendActions = state.nglTrackingReducers.send_actions_list;
- const length = sendActions.length;
-
- if (length >= CONSTANTS.COUNT_SEND_TRACK_ACTIONS || save) {
- dispatch(sendTrackingActions(sendActions, currentProject));
- }
-};
-
-const sendTrackingActions = (sendActions, project, clear = true) => async dispatch => {
- if (project) {
- const projectID = project && project.projectID;
-
- if (projectID && sendActions && sendActions.length > 0) {
- dispatch(setIsActionsSending(true));
-
- const dataToSend = {
- session_project: projectID,
- author: project.authorID,
- last_update_date: moment().format(),
- actions: JSON.stringify(sendActions)
- };
- return api({
- url: `${base_url}/api/session-actions/`,
- method: METHOD.POST,
- data: JSON.stringify(dataToSend)
- })
- .then(() => {
- if (clear === true) {
- dispatch(setSendActionsList([]));
- }
- })
- .catch(error => {
- throw new Error(error);
- })
- .finally(() => {
- dispatch(setIsActionsSending(false));
- });
- } else {
- return Promise.resolve();
- }
- } else {
- return Promise.resolve();
- }
-};
-
-export const setProjectTrackingActions = () => (dispatch, getState) => {
- const state = getState();
- const currentProject = state.projectReducers.currentProject;
- const projectID = currentProject && currentProject.projectID;
- dispatch(setProjectActionList([]));
- dispatch(getTrackingActions(projectID, true));
-};
-
-const getTrackingActions = (projectID, withTreeSeparation) => (dispatch, getState) => {
- const state = getState();
- const sendActions = state.nglTrackingReducers.send_actions_list;
-
- if (projectID) {
- dispatch(setIsActionsLoading(true));
- return api({
- url: `${base_url}/api/session-actions/?session_project=${projectID}`
- })
- .then(response => {
- let results = response.data.results;
- let listToSet = [];
- results.forEach(r => {
- let resultActions = JSON.parse(r.actions);
- let actions = resultActions.map(obj => ({ ...obj, actionId: r.id }));
- listToSet.push(...actions);
- });
-
- if (withTreeSeparation === true) {
- listToSet = dispatch(separateTrackkingActionBySnapshotTree(listToSet));
-
- let actionsWithoutSnapshot = listToSet.filter(action => action.type !== actionType.SNAPSHOT);
- let snapshotActions = listToSet.filter(action => action.type === actionType.SNAPSHOT);
- if (snapshotActions) {
- const key = 'object_id';
- const arrayUniqueByKey = [...new Map(snapshotActions.map(item => [item[key], item])).values()];
- actionsWithoutSnapshot.push(...arrayUniqueByKey);
- listToSet = actionsWithoutSnapshot;
- }
- }
-
- let projectActions = [...listToSet, ...sendActions];
- dispatch(setProjectActionList(projectActions));
- return Promise.resolve(projectActions);
- })
- .catch(error => {
- throw new Error(error);
- })
- .finally(() => {
- dispatch(setIsActionsLoading(false));
- });
- } else {
- let projectActions = [...sendActions];
- dispatch(setProjectActionList(projectActions));
- return Promise.resolve(projectActions);
- }
-};
-
-const separateTrackkingActionBySnapshotTree = actionList => (dispatch, getState) => {
- const state = getState();
- const snapshotID = state.projectReducers.currentSnapshot && state.projectReducers.currentSnapshot.id;
- const currentSnapshotTree = state.projectReducers.currentSnapshotTree;
- const currentSnapshotList = state.projectReducers.currentSnapshotList;
-
- if (snapshotID && currentSnapshotTree != null) {
- let treeActionList = [];
- let snapshotIdList = [];
- snapshotIdList.push(currentSnapshotTree.id);
-
- if (currentSnapshotList != null) {
- for (const id in currentSnapshotList) {
- let snapshot = currentSnapshotList[id];
- let snapshotChildren = snapshot.children;
-
- if (
- (snapshotChildren && snapshotChildren !== null && snapshotChildren.includes(snapshotID)) ||
- snapshot.id === snapshotID
- ) {
- snapshotIdList.push(snapshot.id);
- }
- }
- }
-
- treeActionList = actionList.filter(
- a => snapshotIdList.includes(a.snapshotId) || a.snapshotId === null || a.snapshotId === undefined
- );
- return treeActionList;
- } else {
- return actionList;
- }
-};
-
-const checkActionsProject = projectID => async (dispatch, getState) => {
- const state = getState();
- const currentProject = state.projectReducers.currentProject;
- const currentProjectID = currentProject && currentProject.projectID;
-
- await dispatch(getTrackingActions(projectID));
- await dispatch(
- copyActionsToProject(currentProject, true, currentProjectID && currentProjectID != null ? true : false)
- );
-};
-
-const copyActionsToProject = (toProject, setActionList = true, clearSendList = true) => async (dispatch, getState) => {
- const state = getState();
- const actionList = state.nglTrackingReducers.project_actions_list;
-
- if (toProject) {
- let newActionsList = [];
-
- actionList.forEach(r => {
- newActionsList.push(Object.assign({ ...r }));
- });
-
- if (setActionList === true) {
- dispatch(setActionsList(newActionsList));
- }
- await dispatch(sendTrackingActions(newActionsList, toProject, clearSendList));
- }
-};
-
-export const sendTrackingActionsByProjectId = (projectID, authorID) => async (dispatch, getState) => {
- const state = getState();
- const currentProject = state.projectReducers.currentProject;
- const currentProjectID = currentProject && currentProject.projectID;
-
- const project = { projectID, authorID };
-
- await dispatch(getTrackingActions(currentProjectID));
- await dispatch(copyActionsToProject(project, false, currentProjectID && currentProjectID != null ? true : false));
-};
-
-export const sendInitTrackingActionByProjectId = target_on => (dispatch, getState) => {
- const state = getState();
- const snapshotID = state.projectReducers.currentSnapshot && state.projectReducers.currentSnapshot.id;
-
- let trackAction = dispatch(createInitAction(target_on));
- if (trackAction && trackAction != null) {
- let actions = [];
- actions.push(trackAction);
- dispatch(appendToSendActionList(trackAction));
- dispatch(checkSendTrackingActions(true));
- dispatch(saveTrackingActions(actions, snapshotID));
- }
-};
-
-export const updateTrackingActions = action => (dispatch, getState) => {
- const state = getState();
- const project = state.projectReducers.currentProject;
- const projectActions = state.nglTrackingReducers.project_actions_list;
- const projectID = project && project.projectID;
- let actionID = action && action.actionId;
-
- if (projectID && actionID && projectActions) {
- let actions = projectActions.filter(a => a.actionId === actionID);
-
- if (actions && actions.length > 0) {
- const dataToSend = {
- session_action_id: actionID,
- session_project: projectID,
- author: project.authorID,
- last_update_date: moment().format(),
- actions: JSON.stringify(actions)
- };
- return api({
- url: `${base_url}/api/session-actions/${actionID}/`,
- method: METHOD.PUT,
- data: JSON.stringify(dataToSend)
- })
- .then(() => {})
- .catch(error => {
- throw new Error(error);
- })
- .finally(() => {});
- } else {
- return Promise.resolve();
- }
- } else {
- return Promise.resolve();
- }
-};
-
-function groupArrayOfObjects(list, key) {
- return list.reduce(function(rv, x) {
- (rv[x[key]] = rv[x[key]] || []).push(x);
- return rv;
- }, {});
-}
-
-export const setAndUpdateTrackingActions = (actionList, projectID) => () => {
- if (projectID) {
- const groupBy = groupArrayOfObjects(actionList, 'actionId');
-
- for (const group in groupBy) {
- let actionID = group;
- let actions = groupBy[group];
- if (actionID && actions && actions.length > 0) {
- const dataToSend = {
- session_action_id: actionID,
- session_project: projectID,
- last_update_date: moment().format(),
- actions: JSON.stringify(actions)
- };
- return api({
- url: `${base_url}/api/session-actions/${actionID}/`,
- method: METHOD.PUT,
- data: JSON.stringify(dataToSend)
- })
- .then(() => {})
- .catch(error => {
- throw new Error(error);
- })
- .finally(() => {});
- } else {
- return Promise.resolve();
- }
- }
- } else {
- return Promise.resolve();
- }
-};
-
-export const resetNglTrackingState = () => (dispatch, getState) => {
- dispatch(resetTrackingState());
- dispatch(nglClearHistory());
-};
diff --git a/js/reducers/nglTracking/nglTrackingMiddleware.js b/js/reducers/nglTracking/nglTrackingMiddleware.js
deleted file mode 100644
index b53ffc788..000000000
--- a/js/reducers/nglTracking/nglTrackingMiddleware.js
+++ /dev/null
@@ -1,26 +0,0 @@
-import { appendAndSendTrackingActions } from './dispatchActions';
-import { constants } from './constants';
-import { findTrackAction } from './trackingActions';
-import { setIsSnapshotDirty } from '../tracking/actions';
-
-const nglTrackingMiddleware = ({ dispatch, getState }) => next => action => {
- //console.log(`Redux Log:`, action);
-
- if (action) {
- const state = getState();
- if (action && action.type && !action.type.includes(constants.APPEND_ACTIONS_LIST)) {
- let trackAction = findTrackAction(action, state);
- if (trackAction && trackAction != null) {
- // const isSnapshotDirty = state.trackingReducers.isSnapshotDirty;
- // if (!isSnapshotDirty) {
- // dispatch(setIsSnapshotDirty(true));
- // }
- dispatch(appendAndSendTrackingActions(trackAction));
- }
- }
-
- next(action);
- }
-};
-
-export default nglTrackingMiddleware;
diff --git a/js/reducers/nglTracking/nglTrackingReducers.js b/js/reducers/nglTracking/nglTrackingReducers.js
deleted file mode 100644
index d68509dc4..000000000
--- a/js/reducers/nglTracking/nglTrackingReducers.js
+++ /dev/null
@@ -1,131 +0,0 @@
-import { constants, undoConstants } from './constants';
-import { undoable } from '../../undoredo/reducer';
-import { includeAction } from '../../undoredo/helpers';
-
-export const INITIAL_STATE = {
- track_actions_list: [],
- undo_redo_actions_list: [],
- current_actions_list: [],
- isTrackingMoleculesRestoring: false,
- isTrackingCompoundsRestoring: false,
- isUndoRedoAction: false,
- isActionsSending: false,
- isActionsLoading: false,
- isActionSaving: false,
- send_actions_list: [],
- project_actions_list: [],
- snapshotActionImageList: [],
- isActionRestoring: false,
- isActionRestored: false,
- isActionTracking: false,
- trackingImageSource: ''
-};
-
-export function nglTrackingReducers(state = INITIAL_STATE, action = {}) {
- switch (action.type) {
- case constants.SET_ACTIONS_LIST:
- return Object.assign({}, state, {
- track_actions_list: action.track_actions_list
- });
-
- case constants.APPEND_ACTIONS_LIST:
- return Object.assign({}, state, {
- track_actions_list: [...new Set([...state.track_actions_list, action.track_action])]
- });
-
- case constants.APPEND_UNDO_REDO_ACTIONS_LIST:
- return Object.assign({}, state, {
- undo_redo_actions_list: [...new Set([...state.undo_redo_actions_list, action.track_action])]
- });
-
- case constants.SET_UNDO_REDO_ACTIONS_LIST:
- return {
- ...state, undo_redo_actions_list: action.undo_redo_actions_list
- };
-
- case constants.SET_CURRENT_ACTIONS_LIST:
- return Object.assign({}, state, {
- current_actions_list: [...action.current_actions_list]
- });
-
- case constants.SET_IS_TRACKING_MOLECULES_RESTORING:
- return Object.assign({}, state, {
- isTrackingMoleculesRestoring: action.isTrackingMoleculesRestoring
- });
-
- case constants.SET_IS_TRACKING_COMPOUNDS_RESTORING:
- return Object.assign({}, state, {
- isTrackingCompoundsRestoring: action.isTrackingCompoundsRestoring
- });
-
- case constants.SET_IS_UNDO_REDO_ACTION:
- return Object.assign({}, state, {
- isUndoRedoAction: action.isUndoRedoAction
- });
-
- case constants.SET_IS_ACTIONS_SENDING:
- return Object.assign({}, state, {
- isActionsSending: action.isActionsSending
- });
-
- case constants.SET_IS_ACTIONS_LOADING:
- return Object.assign({}, state, {
- isActionsLoading: action.isActionsLoading
- });
-
- case constants.SET_SEND_ACTIONS_LIST:
- return Object.assign({}, state, {
- send_actions_list: [...action.send_actions_list]
- });
-
- case constants.APPEND_SEND_ACTIONS_LIST:
- return Object.assign({}, state, {
- send_actions_list: [...new Set([...state.send_actions_list, action.track_action])]
- });
-
- case constants.SET_PROJECT_ACTIONS_LIST:
- return Object.assign({}, state, {
- project_actions_list: action.project_actions_list
- });
-
- case constants.SET_SNAPSOT_IMAGE_ACTIONS_LIST:
- return Object.assign({}, state, {
- snapshotActionImageList: action.snapshotActionImageList
- });
-
- case constants.SET_IS_ACTIONS_SAVING:
- return Object.assign({}, state, {
- isActionSaving: action.isActionSaving
- });
-
- case constants.SET_IS_ACTIONS_RESTORING:
- return Object.assign({}, state, {
- isActionRestoring: action.isActionRestoring,
- isActionRestored: action.isActionRestored
- });
- case constants.SET_IS_ACTION_TRACKING:
- return Object.assign({}, state, {
- isActionTracking: action.isActionTracking
- });
-
- case constants.SET_TRACKING_IMAGE_SOURCE:
- return Object.assign({}, state, {
- trackingImageSource: action.payload
- });
-
- case constants.RESET_TRACKING_STATE:
- return INITIAL_STATE;
-
- default:
- return state;
- }
-}
-
-export const undoableNglTrackingReducers = undoable(nglTrackingReducers, {
- limit: false,
- filter: includeAction(constants.SET_UNDO_REDO_ACTIONS_LIST),
- undoType: undoConstants.NGL_TRACKING_UNDO,
- redoType: undoConstants.NGL_TRACKING_REDO,
- clearHistoryType: undoConstants.NGL_CLEAR_HISTORY
-});
-
\ No newline at end of file
diff --git a/js/reducers/nglTracking/trackingActions.js b/js/reducers/nglTracking/trackingActions.js
deleted file mode 100644
index 5f9e24be9..000000000
--- a/js/reducers/nglTracking/trackingActions.js
+++ /dev/null
@@ -1,60 +0,0 @@
-import { actionType, actionObjectType, actionDescription, actionAnnotation } from './constants';
-import { CONSTANTS as nglConstants } from '../ngl/constants';
-import { DJANGO_CONTEXT } from '../../utils/djangoContext';
-
-export const findTrackAction = (action, state) => {
- const username = DJANGO_CONTEXT['username'];
- const isActionRestoring = state.nglTrackingReducers.isActionRestoring;
-
- let trackAction = null;
- if (isActionRestoring === false && action.skipTracking !== true) {
- if (action.type.includes(nglConstants.SET_ORIENTATION_BY_INTERACTION)) {
- const { oldOrientation: oldSetting, orientation: newSetting, div_id } = action;
-
- trackAction = {
- type: actionType.ORIENTATION,
- merge: true,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: 'NGL',
- object_name: 'NGL',
- oldSetting,
- newSetting,
- div_id,
- getText: function() {
- return 'NGL transformation changed';
- },
- text: 'NGL transformation changed'
- };
- }
- }
- return trackAction;
-};
-
-const getTargetName = (targetId, state) => {
- let targetList = state.apiReducers.target_id_list;
- let target = targetList.find(target => target.id === targetId);
- let targetName = (target && target.title) || '';
- return targetName;
-};
-
-export const createInitAction = target_on => (dispatch, getState) => {
- const state = getState();
- const username = DJANGO_CONTEXT['username'];
-
- if (target_on) {
- let targetName = getTargetName(target_on, state);
- let trackAction = {
- type: actionType.TARGET_LOADED,
- timestamp: Date.now(),
- username: username,
- object_type: actionObjectType.TARGET,
- object_name: targetName,
- object_id: target_on,
- text: `${actionDescription.TARGET} ${targetName} ${actionDescription.LOADED}`
- };
-
- return trackAction;
- }
-};
diff --git a/js/reducers/rootReducer.js b/js/reducers/rootReducer.js
index 3862e8bd7..1c6988301 100644
--- a/js/reducers/rootReducer.js
+++ b/js/reducers/rootReducer.js
@@ -12,11 +12,10 @@ import { projectReducers } from '../components/projects/redux/reducer';
import { issueReducers } from '../components/userFeedback/redux/reducer';
import { datasetsReducers } from '../components/datasets/redux/reducer';
import { jobTableReducer } from '../components/preview/jobTable/redux/reducer';
-import { trackingReducers, undoableTrackingReducers } from './tracking/trackingReducers';
-import { nglTrackingReducers, undoableNglTrackingReducers } from './nglTracking/nglTrackingReducers';
import { layoutReducers } from './layout/layoutReducers';
+import { constants } from './constants';
-const rootReducer = combineReducers({
+const appReducer = combineReducers({
apiReducers,
nglReducers,
selectionReducers,
@@ -26,12 +25,16 @@ const rootReducer = combineReducers({
projectReducers,
issueReducers,
datasetsReducers,
- trackingReducers,
jobTableReducer,
- undoableTrackingReducers,
- nglTrackingReducers,
- undoableNglTrackingReducers,
layoutReducers
});
+const rootReducer = (state, action) => {
+ if (action.type === constants.SET_ENTIRE_STATE) {
+ return action.newState;
+ }
+
+ return appReducer(state, action);
+};
+
export { rootReducer };
diff --git a/js/reducers/selection/actions.js b/js/reducers/selection/actions.js
index 2166e14f7..cb8f6afdd 100644
--- a/js/reducers/selection/actions.js
+++ b/js/reducers/selection/actions.js
@@ -624,3 +624,31 @@ export const setTargetToEdit = target => {
target: target
};
};
+
+export const setToBeDisplayedList = toBeDisplayedList => {
+ return {
+ type: constants.SET_TO_BE_DISPLAYED_LIST,
+ toBeDisplayedList: toBeDisplayedList
+ };
+};
+
+export const appendToBeDisplayedList = item => {
+ return {
+ type: constants.APPEND_TO_BE_DISPLAYED_LIST,
+ item: item
+ };
+};
+
+export const removeFromToBeDisplayedList = item => {
+ return {
+ type: constants.REMOVE_FROM_TO_BE_DISPLAYED_LIST,
+ item: item
+ };
+};
+
+export const updateInToBeDisplayedList = item => {
+ return {
+ type: constants.UPDATE_IN_TO_BE_DISPLAYED_LIST,
+ item: item
+ };
+};
diff --git a/js/reducers/selection/constants.js b/js/reducers/selection/constants.js
index 49b5949c3..b66b797ce 100644
--- a/js/reducers/selection/constants.js
+++ b/js/reducers/selection/constants.js
@@ -105,7 +105,12 @@ export const constants = {
SET_UNSELECT_VISIBLE_POSES: prefix + 'SET_UNSELECT_VISIBLE_POSES',
SET_OBSERVATION_DIALOG_ACTION: prefix + 'SET_OBSERVATION_DIALOG_ACTION',
- SET_TARGET_TO_EDIT: prefix + 'SET_TARGET_TO_EDIT'
+ SET_TARGET_TO_EDIT: prefix + 'SET_TARGET_TO_EDIT',
+
+ SET_TO_BE_DISPLAYED_LIST: prefix + 'SET_TO_BE_DISPLAYED_LIST',
+ APPEND_TO_BE_DISPLAYED_LIST: prefix + 'APPEND_TO_BE_DISPLAYED_LIST',
+ REMOVE_FROM_TO_BE_DISPLAYED_LIST: prefix + 'REMOVE_FROM_TO_BE_DISPLAYED_LIST',
+ UPDATE_IN_TO_BE_DISPLAYED_LIST: prefix + 'UPDATE_IN_TO_BE_DISPLAYED_LIST'
};
export const PREDEFINED_FILTERS = {
diff --git a/js/reducers/selection/selectionReducers.js b/js/reducers/selection/selectionReducers.js
index 05c265feb..982995ec6 100644
--- a/js/reducers/selection/selectionReducers.js
+++ b/js/reducers/selection/selectionReducers.js
@@ -56,11 +56,48 @@ export const INITIAL_STATE = {
areLSHCompoundsInitialized: false,
toastMessages: [],
isScrollFiredForLHS: false,
- targetToEdit: null
+ targetToEdit: null,
+ // Shape of the object in toBeDisplayedList:
+ // {
+ // type: 'L|P|C|S|V|RIBBON|etc...',
+ // id: 1,
+
+ // center: true,
+ // withQuality: true,
+ // representations: [] etc...
+
+ // display: true
+ // }
+ toBeDisplayedList: []
};
export function selectionReducers(state = INITIAL_STATE, action = {}) {
switch (action.type) {
+ case constants.SET_TO_BE_DISPLAYED_LIST:
+ return { ...state, toBeDisplayedList: action.toBeDisplayedList };
+
+ case constants.APPEND_TO_BE_DISPLAYED_LIST:
+ return { ...state, toBeDisplayedList: [...state.toBeDisplayedList, action.item] };
+
+ case constants.REMOVE_FROM_TO_BE_DISPLAYED_LIST:
+ return {
+ ...state,
+ toBeDisplayedList: state.toBeDisplayedList.filter(
+ item => item.id !== action.item.id || item.type !== action.item.type
+ )
+ };
+
+ case constants.UPDATE_IN_TO_BE_DISPLAYED_LIST:
+ return {
+ ...state,
+ toBeDisplayedList: state.toBeDisplayedList.map(item => {
+ if (item.id === action.item.id && item.type === action.item.type) {
+ return { ...item, ...action.item };
+ }
+ return item;
+ })
+ };
+
case constants.SET_SCROLL_FIRED_FOR_LHS: {
return { ...state, isScrollFiredForLHS: action.isFired };
}
diff --git a/js/reducers/tracking/actions.js b/js/reducers/tracking/actions.js
deleted file mode 100644
index baac7b94d..000000000
--- a/js/reducers/tracking/actions.js
+++ /dev/null
@@ -1,160 +0,0 @@
-import { constants } from './constants';
-
-export const setActionsList = function(track_actions_list) {
- return {
- type: constants.SET_ACTIONS_LIST,
- track_actions_list: track_actions_list
- };
-};
-
-export const appendToActionList = function(track_action) {
- return {
- type: constants.APPEND_ACTIONS_LIST,
- track_action: track_action
- };
-};
-
-export const appendToUndoRedoActionList = function(track_action) {
- return {
- type: constants.APPEND_UNDO_REDO_ACTIONS_LIST,
- track_action: track_action
- };
-};
-
-export const setUndoRedoActionList = undo_redo_actions_list => {
- return {
- type: constants.SET_UNDO_REDO_ACTIONS_LIST,
- undo_redo_actions_list: undo_redo_actions_list
- };
-};
-
-export const setCurrentActionsList = function(current_actions_list) {
- return {
- type: constants.SET_CURRENT_ACTIONS_LIST,
- current_actions_list: current_actions_list
- };
-};
-
-export const setIsTrackingMoleculesRestoring = function(isTrackingMoleculesRestoring) {
- return {
- type: constants.SET_IS_TRACKING_MOLECULES_RESTORING,
- isTrackingMoleculesRestoring: isTrackingMoleculesRestoring
- };
-};
-
-export const setIsTrackingCompoundsRestoring = function(isTrackingCompoundsRestoring) {
- return {
- type: constants.SET_IS_TRACKING_COMPOUNDS_RESTORING,
- isTrackingCompoundsRestoring: isTrackingCompoundsRestoring
- };
-};
-
-export const setIsUndoRedoAction = function(isUndoRedoAction) {
- return {
- type: constants.SET_IS_UNDO_REDO_ACTION,
- isUndoRedoAction: isUndoRedoAction
- };
-};
-
-export const setIsActionsSending = function(isActionsSending) {
- return {
- type: constants.SET_IS_ACTIONS_SENDING,
- isActionsSending: isActionsSending
- };
-};
-
-export const setIsActionsLoading = function(isActionsLoading) {
- return {
- type: constants.SET_IS_ACTIONS_LOADING,
- isActionsLoading: isActionsLoading
- };
-};
-
-export const setSendActionsList = function(track_actions_list) {
- return {
- type: constants.SET_SEND_ACTIONS_LIST,
- send_actions_list: track_actions_list
- };
-};
-
-export const appendToSendActionList = function(track_action) {
- return {
- type: constants.APPEND_SEND_ACTIONS_LIST,
- track_action: track_action
- };
-};
-
-export const setProjectActionList = function(project_actions_list) {
- return {
- type: constants.SET_PROJECT_ACTIONS_LIST,
- project_actions_list: project_actions_list
- };
-};
-
-export const setProjectActionListLoaded = isLoaded => {
- return {
- type: constants.SET_PROJECT_ACTIONS_LIST_LOADED,
- isLoaded: isLoaded
- };
-};
-
-export const setSnapshotActionsDownloaded = isDownloaded => {
- return {
- type: constants.SET_SNAPSHOT_ACTIONS_DOWNLOADED,
- isDownloaded: isDownloaded
- };
-};
-
-export const setSnapshotImageActionList = function(snapshotActionImageList) {
- return {
- type: constants.SET_SNAPSOT_IMAGE_ACTIONS_LIST,
- snapshotActionImageList: snapshotActionImageList
- };
-};
-
-export const setIsActionsSaving = function(isActionSaving) {
- return {
- type: constants.SET_IS_ACTIONS_SAVING,
- isActionSaving: isActionSaving
- };
-};
-
-export const setIsActionsRestoring = function(isActionRestoring, isActionRestored) {
- return {
- type: constants.SET_IS_ACTIONS_RESTORING,
- isActionRestoring: isActionRestoring,
- isActionRestored: isActionRestored
- };
-};
-
-export const setIsActionTracking = function(isActionTracking) {
- return {
- type: constants.SET_IS_ACTION_TRACKING,
- isActionTracking: isActionTracking
- };
-};
-
-export const resetTrackingState = function() {
- return {
- type: constants.RESET_TRACKING_STATE
- };
-};
-
-export const setTrackingImageSource = imageSource => ({
- type: constants.SET_TRACKING_IMAGE_SOURCE,
- payload: imageSource
-});
-
-export const setSkipOrientationChange = skipOrientationChange => ({
- type: constants.SET_SKIP_ORIENTATION_CHANGE,
- skipOrientationChange: skipOrientationChange
-});
-
-export const setIsSnapshotDirty = isSnapshotDirty => {
- console.count(`setIsSnapshotDirty with value ${isSnapshotDirty}`);
- return {
- type: constants.SET_IS_SNAPSHOT_DIRTY,
- isSnapshotDirty: isSnapshotDirty,
- skipTracking: true
- };
-};
diff --git a/js/reducers/tracking/constants.js b/js/reducers/tracking/constants.js
deleted file mode 100644
index b5bf429d9..000000000
--- a/js/reducers/tracking/constants.js
+++ /dev/null
@@ -1,223 +0,0 @@
-const prefix = 'REDUCERS_TRACKING_';
-
-export const constants = {
- SET_ACTIONS_LIST: prefix + 'SET_ACTIONS_LIST',
- APPEND_ACTIONS_LIST: prefix + 'APPEND_ACTIONS_LIST',
- SET_CURRENT_ACTIONS_LIST: prefix + 'SET_CURRENT_ACTIONS_LIST',
- SET_IS_TRACKING_COMPOUNDS_RESTORING: prefix + 'SET_IS_TRACKING_COMPOUNDS_RESTORING',
- SET_IS_TRACKING_MOLECULES_RESTORING: prefix + 'SET_IS_TRACKING_MOLECULES_RESTORING',
- SET_IS_UNDO_REDO_ACTION: prefix + 'SET_IS_UNDO_REDO_ACTION',
- SET_SEND_ACTIONS_LIST: prefix + 'SET_SEND_ACTIONS_LIST',
- APPEND_SEND_ACTIONS_LIST: prefix + 'APPEND_SEND_ACTIONS_LIST',
- SET_IS_ACTIONS_SENDING: prefix + 'SET_IS_ACTIONS_SENDING',
- SET_IS_ACTIONS_LOADING: prefix + 'SET_IS_ACTIONS_LOADING',
- SET_PROJECT_ACTIONS_LIST: prefix + 'SET_PROJECT_ACTIONS_LIST',
- SET_IS_ACTIONS_SAVING: prefix + 'SET_IS_ACTIONS_SAVING',
- SET_IS_ACTIONS_RESTORING: prefix + 'SET_IS_ACTIONS_RESTORING',
- SET_IS_ACTION_TRACKING: prefix + 'SET_IS_ACTION_TRACKING',
- RESET_TRACKING_STATE: prefix + 'RESET_TRACKING_STATE',
- SET_TRACKING_IMAGE_SOURCE: prefix + 'SET_TRACKING_IMAGE_SOURCE',
- SET_SNAPSOT_IMAGE_ACTIONS_LIST: prefix + 'SET_SNAPSOT_IMAGE_ACTIONS_LIST',
- APPEND_UNDO_REDO_ACTIONS_LIST: prefix + 'APPEND_UNDO_REDO_ACTIONS_LIST',
- SET_UNDO_REDO_ACTIONS_LIST: prefix + 'SET_UNDO_REDO_ACTIONS_LIST',
- SET_PROJECT_ACTIONS_LIST_LOADED: prefix + 'SET_PROJECT_ACTIONS_LIST_LOADED',
- SET_SKIP_ORIENTATION_CHANGE: prefix + 'SET_SKIP_ORIENTATION_CHANGE', //when snapshot is switched we want to skip orientation change so it doesn't blink through multiple states
- SET_IS_SNAPSHOT_DIRTY: prefix + 'SET_IS_SNAPSHOT_DIRTY',
- SET_SNAPSHOT_ACTIONS_DOWNLOADED: prefix + 'SET_SNAPSHOT_ACTIONS_DOWNLOADED'
-};
-
-export const actionType = {
- TARGET_LOADED: 'TARGET_LOADED',
- SITE_TURNED_ON: 'SITE_TURNED_ON',
- SITE_TURNED_OFF: 'SITE_TURNED_OFF',
- LIGAND_TURNED_ON: 'LIGAND_TURNED_ON',
- LIGAND_TURNED_OFF: 'LIGAND_TURNED_OFF',
- SIDECHAINS_TURNED_ON: 'SIDECHAINS_TURNED_ON',
- SIDECHAINS_TURNED_OFF: 'SIDECHAINS_TURNED_OFF',
- INTERACTIONS_TURNED_ON: 'INTERACTIONS_TURNED_ON',
- INTERACTIONS_TURNED_OFF: 'INTERACTIONS_TURNED_OFF',
- SURFACE_TURNED_ON: 'SURFACE_TURNED_ON',
- SURFACE_TURNED_OFF: 'SURFACE_TURNED_OFF',
- DENSITY_TURNED_ON: 'DENSITY_TURNED_ON',
- DENSITY_TURNED_OFF: 'DENSITY_TURNED_OFF',
- DENSITY_CUSTOM_TURNED_ON: 'DENSITY_CUSTOM_TURNED_ON',
- DENSITY_CUSTOM_TURNED_OFF: 'DENSITY_CUSTOM_TURNED_OFF',
- DENSITY_TYPE_ON: 'DENSITY_TYPE_ON',
- DENSITY_TYPE_OFF: 'DENSITY_TYPE_OFF',
- QUALITY_TURNED_ON: 'QUALITY_TURNED_ON',
- QUALITY_TURNED_OFF: 'QUALITY_TURNED_OFF',
- VECTORS_TURNED_ON: 'VECTORS_TURNED_ON',
- VECTORS_TURNED_OFF: 'VECTORS_TURNED_OFF',
- COLOR_FILTER_TURNED_ON: 'COLOR_FILTER_TURNED_ON',
- COLOR_FILTER_TURNED_OFF: 'COLOR_FILTER_TURNED_OFF',
- CLASS_SELECTED: 'CLASS_SELECTED',
- CLASS_UPDATED: 'CLASS_UPDATED',
- VECTOR_SELECTED: 'VECTOR_SELECTED',
- VECTOR_DESELECTED: 'VECTOR_DESELECTED',
- MOLECULE_ADDED_TO_SHOPPING_CART: 'MOLECULE_ADDED_TO_SHOPPING_CART',
- MOLECULE_ADDED_TO_SHOPPING_CART_ALL: 'MOLECULE_ADDED_TO_SHOPPING_CART_ALL',
- MOLECULE_REMOVED_FROM_SHOPPING_CART: 'MOLECULE_REMOVED_FROM_SHOPPING_CART',
- MOLECULE_REMOVED_FROM_SHOPPING_CART_ALL: 'MOLECULE_REMOVED_FROM_SHOPPING_CART_ALL',
- VECTOR_COUMPOUND_ADDED: 'VECTOR_COUMPOUND_ADDED',
- VECTOR_COUMPOUND_REMOVED: 'VECTOR_COUMPOUND_REMOVED',
- COMPOUND_SELECTED: 'COMPOUND_SELECTED',
- COMPOUND_DESELECTED: 'COMPOUND_DESELECTED',
- REPRESENTATION_UPDATED: 'REPRESENTATION_UPDATED',
- REPRESENTATION_VISIBILITY_UPDATED: 'REPRESENTATION_VISIBILITY_UPDATED',
- REPRESENTATION_VISIBILITY_ALL_UPDATED: 'REPRESENTATION_VISIBILITY_ALL_UPDATED',
- REPRESENTATION_ADDED: 'REPRESENTATION_ADDED',
- REPRESENTATION_REMOVED: 'REPRESENTATION_REMOVED',
- REPRESENTATION_CHANGED: 'REPRESENTATION_CHANGED',
- NGL_STATE: 'NGL_STATE',
- UNDO: 'UNDO',
- REDO: 'REDO',
- ARROW_NAVIGATION: 'ARROW_NAVIGATION',
- SNAPSHOT: 'SNAPSHOT',
- TAB: 'TAB',
- DATASET_INDEX: 'DATASET_INDEX',
- DATASET_FILTER: 'DATASET_FILTER',
- DATASET_FILTER_SCORE: 'DATASET_FILTER_SCORE',
- DRAG_DROP_FINISHED: 'DRAG_DROP_FINISHED',
- ALL_HIDE: 'ALL_HIDE',
- ALL_TURNED_ON: 'ALL_TURNED_ON',
- ALL_TURNED_OFF: 'ALL_TURNED_OFF',
- SELECTED_TURNED_ON_BY_TYPE: 'SELECTED_TURNED_ON_BY_TYPE',
- ALL_TURNED_OFF_BY_TYPE: 'ALL_TURNED_OFF_BY_TYPE',
- BACKGROUND_COLOR_CHANGED: 'BACKGROUND_COLOR_CHANGED',
- CLIP_NEAR: 'CLIP_NEAR',
- CLIP_FAR: 'CLIP_FAR',
- CLIP_DIST: 'CLIP_DIST',
- FOG_NEAR: 'FOG_NEAR',
- FOG_FAR: 'FOG_FAR',
- ISO_LEVEL_EVENT: 'ISO_LEVEL_EVENT',
- BOX_SIZE_EVENT: 'BOX_SIZE_EVENT',
- OPACITY_EVENT: 'OPACITY_EVENT',
- CONTOUR_EVENT: 'CONTOUR_EVENT',
- COLOR_EVENT: 'COLOR_EVENT',
- ISO_LEVEL_SIGMAA: 'ISO_LEVEL_SIGMAA',
- BOX_SIZE_SIGMAA: 'BOX_SIZE_SIGMAA',
- OPACITY_SIGMAA: 'OPACITY_SIGMAA',
- CONTOUR_SIGMAA: 'CONTOUR_SIGMAA',
- COLOR_SIGMAA: 'COLOR_SIGMAA',
- ISO_LEVEL_DIFF: 'ISO_LEVEL_DIFF',
- BOX_SIZE_DIFF: 'BOX_SIZE_DIFF',
- OPACITY_DIFF: 'OPACITY_DIFF',
- CONTOUR_DIFF: 'CONTOUR_DIFF',
- COLOR_DIFF: 'COLOR_DIFF',
- WARNING_ICON: 'WARNING_ICON',
- TAG_SELECTED: 'TAG_SELECTED',
- TAG_UNSELECTED: 'TAG_UNSELECTED',
- TURN_SIDE: 'TURN_SIDE',
- MOLECULE_SELECTED: 'MOLECULE_SELECTED',
- MOLECULE_UNSELECTED: 'MOLECULE_UNSELECTED',
- ALL_MOLECULES_SELECTED: 'ALL_MOLECULES_SELECTED',
- ALL_MOLECULES_UNSELECTED: 'ALL_MOLECULES_UNSELECTED',
- ALL_VISIBLE_HITS_SELECTED: 'ALL_VISIBLE_HITS_SELECTED',
- ALL_VISIBLE_HITS_UNSELECTED: 'ALL_VISIBLE_HITS_UNSELECTED',
- SEARCH_STRING: 'SEARCH_STRING',
- SEARCH_STRING_HIT_NAVIGATOR: 'SEARCH_STRING_HIT_NAVIGATOR',
- COMPOUND_LOCKED: 'COMPOUND_LOCKED',
- COMPOUND_UNLOCKED: 'COMPOUND_UNLOCKED',
- COMPOUND_ADDED_TO_COLOR_GROUP: 'COMPOUND_ADDED_TO_COLOR_GROUP',
- COMPOUND_REMOVED_FROM_COLOR_GROUP: 'COMPOUND_REMOVED_FROM_COLOR_GROUP',
- TAG_DETAIL_VIEW: 'TAG_DETAIL_VIEW',
- SELECT_ALL_DATASET_COMPOUNDS: 'SELECT_ALL_DATASET_COMPOUNDS',
- SELECTED_SELECT_ALL_BUTTON_FOR_DATASET: 'SELECTED_SELECT_ALL_BUTTON_FOR_DATASET',
- ALL_COMPOUNDS_ADDED_TO_COLOR_GROUP: 'ALL_COMPOUNDS_ADDED_TO_COLOR_GROUP',
- ALL_COMPOUNDS_REMOVED_FROM_COLOR_GROUP: 'ALL_COMPOUNDS_REMOVED_FROM_COLOR_GROUP',
- POSE_WINDOW_ACTION: 'POSE_WINDOW_ACTION',
- INSPIRATION_WINDOW_ACTION: 'INSPIRATION_WINDOW_ACTION'
-};
-
-export const snapshotSwitchManualActions = [
- actionType.LIGAND_TURNED_ON,
- actionType.SIDECHAINS_TURNED_ON,
- actionType.SURFACE_TURNED_ON,
- actionType.DENSITY_TURNED_ON,
- actionType.DENSITY_CUSTOM_TURNED_ON,
- // actionType.DENSITY_TYPE_ON, //I don't know what this one is for but it's not processed anywhere
- actionType.QUALITY_TURNED_OFF,
- actionType.VECTORS_TURNED_ON,
- actionType.INTERACTIONS_TURNED_ON,
- actionType.ALL_TURNED_ON
-];
-
-export const actionDescription = {
- LOADED: 'was loaded',
- TURNED_ON: 'was turned on',
- TURNED_OFF: 'was turned off',
- MOVED: 'was moved',
- SELECTED: 'was selected',
- DESELECTED: 'was deselected',
- LOCKED: 'was locked',
- UNLOCKED: 'was unlocked',
- ADDED_TO_COLOR_GROUP: 'was added to color group',
- REMOVED_FROM_COLOR_GROUP: 'was removed from color group',
- HIDDEN: 'hidden',
- VISIBLE: 'visible',
- CANCELED: 'canceled',
- ADDED: 'was added',
- REMOVED: 'was removed',
- CHANGED: 'was changed',
- UPDATED: 'was updated',
- VISIBILITY: 'visiblity',
- TO_SHOPPING_CART: 'to shopping cart',
- FROM_SHOPPING_CART: 'from shopping cart',
- LIGAND: 'Ligand',
- SIDECHAIN: 'Sidechain',
- INTERACTION: 'Interaction',
- DENSITY: 'Density',
- VECTOR: 'Vector',
- COMPOUND: 'Compound',
- MOLECULE: 'Molecule',
- INSPIRATION: 'Inspiration',
- CROSS_REFERENCE: 'Cross reference',
- CLASS: 'Compound colour',
- SURFACE: 'Surface',
- QUALITY: 'Quality',
- SITE: 'Site',
- TARGET: 'Target',
- ALL: 'All',
- SELECTED_TYPE: 'Selected',
- LIGANDS: 'Ligands',
- SIDECHAINS: 'Sidechains',
- TAB: 'Tab',
- DATASET: 'Dataset',
- CUSTOM_VIEW: 'custom view',
- TAG: 'Tag',
- LIST_VIEW: 'list view',
- GRID_VIEW: 'grid view'
-};
-
-export const actionObjectType = {
- TARGET: 'TARGET',
- SITE: 'SITE',
- MOLECULE: 'MOLECULE',
- COMPOUND: 'COMPOUND',
- INSPIRATION: 'INSPIRATION',
- CROSS_REFERENCE: 'CROSS_REFERENCE',
- REPRESENTATION: 'REPRESENTATION',
- VIEWER_SETTINGS: 'VIEWER_SETTINGS',
- TAG: 'TAG'
-};
-
-export const actionAnnotation = {
- CHECK: 'CHECK',
- CLEAR: 'CLEAR',
- WARNING: 'WARNING',
- FAVORITE: 'FAVORITE',
- STAR: 'STAR'
-};
-
-export const mapTypesStrings = {
- EVENT: 'EVENT MAP',
- DIFF: 'DIFF MAP',
- SIGMAA: 'SIGMAA MAP'
-};
-
-export const viewerControlsSides = {
- LHS: 'Left hand side',
- RHS: 'Right hand side'
-};
-
-export const NUM_OF_SECONDS_TO_IGNORE_MERGE = 2;
diff --git a/js/reducers/tracking/dispatchActions.js b/js/reducers/tracking/dispatchActions.js
deleted file mode 100644
index 7d62dc12e..000000000
--- a/js/reducers/tracking/dispatchActions.js
+++ /dev/null
@@ -1,4249 +0,0 @@
-import {
- setCurrentActionsList,
- setIsTrackingMoleculesRestoring,
- setIsTrackingCompoundsRestoring,
- setIsUndoRedoAction,
- setProjectActionListLoaded,
- setIsSnapshotDirty,
- setSnapshotActionsDownloaded
-} from './actions';
-import { createInitAction } from './trackingActions';
-import { actionType, actionObjectType, NUM_OF_SECONDS_TO_IGNORE_MERGE, mapTypesStrings } from './constants';
-import { VIEWS } from '../../../js/constants/constants';
-import {
- setHideAll,
- setArrowUpDown,
- appendToMolListToEdit,
- removeFromMolListToEdit,
- setNextXMolecules,
- setTagDetailView,
- addToastMessage,
- setScrollFiredForLHS
-} from '../selection/actions';
-import {
- resetReducersForRestoringActions,
- shouldLoadProtein,
- loadProteinOfRestoringActions
-} from '../../components/preview/redux/dispatchActions';
-import { setCurrentProject } from '../../components/projects/redux/actions';
-import { setCurrentProject as setProject } from '../../components/target/redux/actions';
-import { loadMoleculeGroupsOfTarget } from '../../components/preview/moleculeGroups/redux/dispatchActions';
-import { loadTargetList } from '../../components/target/redux/dispatchActions';
-import { resetTargetState, setTargetOn } from '../api/actions';
-import {
- addComplex,
- addLigand,
- addHitProtein,
- addSurface,
- addQuality,
- addVector,
- removeComplex,
- removeLigand,
- removeHitProtein,
- removeSurface,
- removeQuality,
- removeVector,
- moveSelectedMolSettings,
- removeSelectedMolTypes,
- hideAllSelectedMolecules,
- addDensity,
- addDensityCustomView,
- removeDensity,
- getProteinData,
- selectAllHits,
- selectAllVisibleObservations
-} from '../../components/preview/molecule/redux/dispatchActions';
-import { setSortDialogOpen, setSearchStringOfHitNavigator } from '../../components/preview/molecule/redux/actions';
-import {
- handleBuyList,
- handleBuyListAll,
- handleShowVectorCompound
-} from '../../components/preview/compounds/redux/dispatchActions';
-import { setCurrentCompoundClass, setCompoundClasses } from '../../components/preview/compounds/redux/actions';
-import { colourList } from '../../components/preview/molecule/utils/color';
-import {
- addDatasetComplex,
- addDatasetLigand,
- addDatasetHitProtein,
- addDatasetSurface,
- removeDatasetComplex,
- removeDatasetLigand,
- removeDatasetHitProtein,
- removeDatasetSurface,
- loadDataSets,
- loadDatasetCompoundsWithScores,
- removeSelectedDatasetMolecules,
- moveSelectedMoleculeSettings,
- moveSelectedInspirations,
- moveMoleculeInspirationsSettings,
- getInspirationsForMol,
- selectScoreProperty
-} from '../../components/datasets/redux/dispatchActions';
-import {
- appendMoleculeToCompoundsOfDatasetToBuy,
- removeMoleculeFromCompoundsOfDatasetToBuy,
- setMoleculeListIsLoading,
- setTabValue,
- setSelectedDatasetIndex,
- setDatasetFilter,
- setFilterProperties,
- setFilterSettings,
- updateFilterShowedScoreProperties,
- setFilterShowedScoreProperties,
- setDragDropState,
- resetDatasetScrolledMap,
- setSearchStringOfCompoundSet,
- appendCompoundToSelectedCompoundsByDataset,
- removeCompoundFromSelectedCompoundsByDataset,
- appendCompoundColorOfDataset,
- removeCompoundColorOfDataset,
- setCompoundToSelectedCompoundsByDataset,
- setSelectAllButtonForDataset,
- appendColorToSelectedColorFilter,
- removeColorFromSelectedColorFilter,
- setIsOpenInspirationDialog,
- setInspirationList,
- setInspirationDialogOpenedForSelectedCompounds,
- setSelectedDatasetScrolled
-} from '../../components/datasets/redux/actions';
-import {
- removeComponentRepresentation,
- addComponentRepresentation,
- updateComponentRepresentation,
- updateComponentRepresentationVisibility,
- updateComponentRepresentationVisibilityAll,
- changeComponentRepresentation
-} from '../../../js/reducers/ngl/actions';
-import { NGL_PARAMS, NGL_VIEW_DEFAULT_VALUES, COMMON_PARAMS } from '../../components/nglView/constants';
-import { assignRepresentationToComp } from '../../components/nglView/generatingObjects';
-import {
- deleteObject,
- setOrientation,
- setNglBckGrndColor,
- setNglClipNear,
- setNglClipFar,
- setNglClipDist,
- setNglFogNear,
- setNglFogFar,
- setIsoLevel,
- setBoxSize,
- setOpacity,
- setContour,
- setWarningIcon,
- setElectronDesityMapColor
-} from '../../../js/reducers/ngl/dispatchActions';
-import {
- setSendActionsList,
- setIsActionsSending,
- setIsActionsLoading,
- setActionsList,
- setSnapshotImageActionList,
- setUndoRedoActionList
-} from './actions';
-import { api, METHOD } from '../../../js/utils/api';
-import { base_url } from '../../components/routes/constants';
-import { CONSTANTS } from '../../../js/constants/constants';
-import moment from 'moment';
-import {
- appendToSendActionList,
- setProjectActionList,
- setIsActionsSaving,
- setIsActionsRestoring,
- resetTrackingState,
- setIsActionTracking
-} from './actions';
-import {
- setSelectedAll,
- setDeselectedAll,
- setSelectedAllByType,
- setDeselectedAllByType,
- setObservationsForLHSCmp,
- setOpenObservationsDialog,
- setPoseIdForObservationsDialog
-} from '../../../js/reducers/selection/actions';
-import {
- setSelectedAll as setSelectedAllOfDataset,
- setDeselectedAll as setDeselectedAllOfDataset,
- setSelectedAllByType as setSelectedAllByTypeOfDataset,
- setDeselectedAllByType as setDeselectedAllByTypeOfDataset,
- setArrowUpDown as setArrowUpDownOfDataset,
- setCrossReferenceCompoundName,
- setInspirationMoleculeDataList
-} from '../../components/datasets/redux/actions';
-import { selectVectorAndResetCompounds } from '../../../js/reducers/selection/dispatchActions';
-import { ActionCreators as UndoActionCreators } from '../../undoredo/actions';
-import { hideShapeRepresentations } from '../../components/nglView/redux/dispatchActions';
-import { MAP_TYPE } from '../ngl/constants';
-import {
- removeSelectedTag,
- addSelectedTag,
- loadMoleculesAndTagsNew
-} from '../../components/preview/tags/redux/dispatchActions';
-import { turnSide } from '../../components/preview/viewerControls/redux/actions';
-import { getQualityOffActions } from './utils';
-import { compoundsColors } from '../../components/preview/compounds/redux/constants';
-import { isEqual, uniqWith } from 'lodash';
-import { TOAST_LEVELS } from '../../components/toast/constants';
-
-export const addCurrentActionsListToSnapshot = (snapshot, project, nglViewList) => async (dispatch, getState) => {
- let projectID = project && project.projectID;
- let actionList = await dispatch(getTrackingActions(projectID));
-
- await dispatch(setSnapshotToActions(actionList, snapshot, projectID, project, nglViewList, true));
-};
-
-export const saveCurrentActionsList = (snapshot, project, nglViewList, all, isAnonymousSnapshot = false) => async (
- dispatch,
- getState
-) => {
- let projectID = project && project.projectID;
- let actionList = await dispatch(getTrackingActions(isAnonymousSnapshot ? null : projectID));
-
- if (!isAnonymousSnapshot) {
- if (all === false) {
- dispatch(setSnapshotToActions(actionList, snapshot, projectID, project, nglViewList, false));
- } else {
- dispatch(setSnapshotToAllActions(actionList, snapshot, projectID));
- }
- }
- await dispatch(saveActionsList(project, snapshot, actionList, nglViewList /*, isAnonymousSnapshot*/));
-};
-
-const saveActionsList = (project, snapshot, actionList, nglViewList, isAnonymousSnapshot = false) => async (
- dispatch,
- getState
-) => {
- const state = getState();
- const snapshotID = snapshot && snapshot.id;
- if (snapshotID) {
- const currentTargetOn = state.apiReducers.target_on;
- const currentSites = state.selectionReducers.mol_group_selection;
- const currentTags =
- state.selectionReducers.selectedTagList && state.selectionReducers.selectedTagList.map(value => value.id);
- const currentLigands = state.selectionReducers.fragmentDisplayList;
- const currentProteins = state.selectionReducers.proteinList;
- const currentComplexes = state.selectionReducers.complexList;
- const currentSurfaces = state.selectionReducers.surfaceList;
- const currentQualities = state.selectionReducers.qualityList;
- const currentDensities = state.selectionReducers.densityList;
- const currentDensitiesCustom = state.selectionReducers.densityListCustom;
- const currentDensitiesType = state.selectionReducers.densityListType;
- const currentVectors = state.selectionReducers.vectorOnList;
- const currentBuyList = state.selectionReducers.to_buy_list;
- const currentVector = state.selectionReducers.currentVector;
- const currentSelectionAll = state.selectionReducers.moleculeAllSelection;
- const selectedMolecules = state.selectionReducers.moleculesToEdit;
-
- const currentDatasetLigands = state.datasetsReducers.ligandLists;
- const currentDatasetProteins = state.datasetsReducers.proteinLists;
- const currentDatasetComplexes = state.datasetsReducers.complexLists;
- const currentDatasetSurfaces = state.datasetsReducers.surfaceLists;
- const currentDatasetSelectionAll = state.datasetsReducers.moleculeAllSelection;
-
- const showedCompoundList = state.previewReducers.compounds.showedCompoundList;
- const currentDatasetBuyList = state.datasetsReducers.compoundsToBuyDatasetMap;
- const currentLockedCompounds = state.datasetsReducers.selectedCompoundsByDataset;
- const currentColorsOfCompounds = state.datasetsReducers.compoundColorByDataset;
- const currentobjectsInView = state.nglReducers.objectsInView;
-
- const currentTargets = (currentTargetOn && [currentTargetOn]) || [];
- const currentVectorSmiles = (currentVector && [currentVector]) || [];
-
- //filter out empty actions - don't know why but they sometimes appear in between activating ligand and protein...
- const filteredActionList = actionList.filter(a => Object.keys(a).length > 0);
-
- let orderedActionList = filteredActionList.reverse((a, b) => a.timestamp - b.timestamp);
-
- let currentActions = [];
-
- getCurrentActionList(orderedActionList, actionType.TARGET_LOADED, getCollection(currentTargets), currentActions);
- getCurrentActionList(orderedActionList, actionType.SITE_TURNED_ON, getCollection(currentSites), currentActions);
- getCurrentActionList(orderedActionList, actionType.TAG_SELECTED, getCollection(currentTags), currentActions);
- getCurrentActionList(orderedActionList, actionType.LIGAND_TURNED_ON, getCollection(currentLigands), currentActions);
-
- getCurrentActionListOfAllSelection(
- orderedActionList,
- actionType.ALL_TURNED_ON,
- getCollection(currentSelectionAll),
- currentActions,
- getCollection(currentLigands),
- getCollection(currentProteins),
- getCollection(currentComplexes)
- );
-
- getCurrentActionListOfAllSelectionByType(
- orderedActionList,
- actionType.SELECTED_TURNED_ON_BY_TYPE,
- 'ligand',
- getCollection(currentLigands),
- currentActions
- );
-
- getCurrentActionListOfAllSelectionByType(
- orderedActionList,
- actionType.SELECTED_TURNED_ON_BY_TYPE,
- 'protein',
- getCollection(currentProteins),
- currentActions
- );
-
- getCurrentActionListOfAllSelectionByType(
- orderedActionList,
- actionType.SELECTED_TURNED_ON_BY_TYPE,
- 'complex',
- getCollection(currentComplexes),
- currentActions
- );
-
- getCurrentActionListOfAllSelectionByTypeOfDataset(
- orderedActionList,
- actionType.SELECTED_TURNED_ON_BY_TYPE,
- 'ligand',
- getCollectionOfDataset(currentDatasetLigands),
- currentActions
- );
-
- getCurrentActionListOfAllSelectionByTypeOfDataset(
- orderedActionList,
- actionType.SELECTED_TURNED_ON_BY_TYPE,
- 'protein',
- getCollectionOfDataset(currentDatasetProteins),
- currentActions
- );
-
- getCurrentActionListOfAllSelectionByTypeOfDataset(
- orderedActionList,
- actionType.SELECTED_TURNED_ON_BY_TYPE,
- 'complex',
- getCollectionOfDataset(currentDatasetComplexes),
- currentActions
- );
-
- getCurrentActionListOfAllSelection(
- orderedActionList,
- actionType.ALL_TURNED_ON,
- getCollectionOfDataset(currentDatasetSelectionAll),
- currentActions,
- getCollectionOfDataset(currentDatasetLigands),
- getCollectionOfDataset(currentDatasetProteins),
- getCollectionOfDataset(currentDatasetComplexes)
- );
-
- getCurrentActionListOfSelectAllMolecules(
- orderedActionList,
- actionType.ALL_MOLECULES_SELECTED,
- getCollection(selectedMolecules),
- currentActions
- );
-
- getCurrentActionListOfSelectAllVisibleHits(
- orderedActionList,
- actionType.ALL_VISIBLE_HITS_SELECTED,
- getCollection(selectedMolecules),
- currentActions
- );
-
- getCurrentActionList(
- orderedActionList,
- actionType.SIDECHAINS_TURNED_ON,
- getCollection(currentProteins),
- currentActions
- );
-
- getCurrentActionList(
- orderedActionList,
- actionType.INTERACTIONS_TURNED_ON,
- getCollection(currentComplexes),
- currentActions
- );
- getCurrentActionList(
- orderedActionList,
- actionType.SURFACE_TURNED_ON,
- getCollection(currentSurfaces),
- currentActions
- );
- dispatch(getQualityOffActions(orderedActionList, currentActions));
- // getCurrentActionList(
- // orderedActionList,
- // actionType.QUALITY_TURNED_OFF,
- // getCollection(currentQualities),
- // currentActions
- // );
- getCurrentActionListDensity(
- orderedActionList,
- actionType.DENSITY_TURNED_ON,
- getCollection(currentDensities),
- currentActions
- );
- getCurrentActionList(
- orderedActionList,
- actionType.MOLECULE_SELECTED,
- getCollection(selectedMolecules),
- currentActions
- );
- getCurrentActionListDensity(orderedActionList, actionType.DENSITY_TYPE_ON, currentDensitiesType, currentActions);
- getCurrentActionListDensity(
- orderedActionList,
- actionType.DENSITY_CUSTOM_TURNED_ON,
- getCollection(currentDensitiesCustom),
- currentActions
- );
- getCurrentActionList(
- orderedActionList,
- actionType.VECTORS_TURNED_ON,
- getCollection(currentVectors),
- currentActions
- );
- getCurrentActionList(
- orderedActionList,
- actionType.VECTOR_SELECTED,
- getCollection(currentVectorSmiles),
- currentActions
- );
-
- getCurrentActionList(
- orderedActionList,
- actionType.VECTOR_COUMPOUND_ADDED,
- getCollection(showedCompoundList),
- currentActions
- );
-
- getCurrentActionListOfShoppingCart(
- orderedActionList,
- actionType.MOLECULE_ADDED_TO_SHOPPING_CART,
- getCollectionOfShoppingCart(currentBuyList),
- currentActions
- );
-
- getCurrentActionListOfAllShopingCart(
- orderedActionList,
- actionType.MOLECULE_ADDED_TO_SHOPPING_CART_ALL,
- getCollectionOfShoppingCart(currentBuyList),
- currentActions
- );
-
- getCurrentActionList(
- orderedActionList,
- actionType.LIGAND_TURNED_ON,
- getCollectionOfDataset(currentDatasetLigands),
- currentActions
- );
-
- getCurrentActionList(
- orderedActionList,
- actionType.SIDECHAINS_TURNED_ON,
- getCollectionOfDataset(currentDatasetProteins),
- currentActions
- );
-
- getCurrentActionList(
- orderedActionList,
- actionType.INTERACTIONS_TURNED_ON,
- getCollectionOfDataset(currentDatasetComplexes),
- currentActions
- );
-
- getCurrentActionList(
- orderedActionList,
- actionType.SURFACE_TURNED_ON,
- getCollectionOfDataset(currentDatasetSurfaces),
- currentActions
- );
-
- getCurrentActionList(
- orderedActionList,
- actionType.COMPOUND_SELECTED,
- getCollectionOfDataset(currentDatasetBuyList),
- currentActions
- );
-
- getCurrentActionList(
- orderedActionList,
- actionType.REPRESENTATION_ADDED,
- getCollectionOfDatasetOfRepresentation(currentobjectsInView),
- currentActions
- );
-
- getCurrentActionList(
- orderedActionList,
- actionType.COMPOUND_LOCKED,
- getCollectionOfDataset(currentLockedCompounds),
- currentActions
- );
-
- getCurrentActionListOfPaintAllMolecules(
- orderedActionList,
- actionType.ALL_COMPOUNDS_ADDED_TO_COLOR_GROUP,
- getCollectionOfDatasetColors(currentColorsOfCompounds),
- currentActions
- );
-
- getCurrentActionList(
- orderedActionList,
- actionType.COMPOUND_ADDED_TO_COLOR_GROUP,
- getCollectionOfDatasetColors(currentColorsOfCompounds),
- currentActions
- );
-
- getCurrentActionList(
- orderedActionList,
- actionType.REPRESENTATION_UPDATED,
- getCollectionOfDatasetOfRepresentation(currentobjectsInView),
- currentActions
- );
-
- getCurrentActionList(
- orderedActionList,
- actionType.REPRESENTATION_CHANGED,
- getCollectionOfDatasetOfRepresentation(currentobjectsInView),
- currentActions
- );
-
- getCommonLastActionByType(orderedActionList, actionType.POSE_WINDOW_ACTION, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.INSPIRATION_WINDOW_ACTION, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.TAB, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.DATASET_INDEX, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.DATASET_FILTER, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.DATASET_FILTER_SCORE, currentActions);
- getLastColorFilterActions(orderedActionList, actionType.COLOR_FILTER_TURNED_OFF, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.CLASS_UPDATED, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.ISO_LEVEL_EVENT, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.BOX_SIZE_EVENT, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.OPACITY_EVENT, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.CONTOUR_EVENT, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.COLOR_EVENT, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.ISO_LEVEL_SIGMAA, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.BOX_SIZE_SIGMAA, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.OPACITY_SIGMAA, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.CONTOUR_SIGMAA, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.COLOR_SIGMAA, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.ISO_LEVEL_DIFF, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.BOX_SIZE_DIFF, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.OPACITY_DIFF, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.CONTOUR_DIFF, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.COLOR_DIFF, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.WARNING_ICON, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.BACKGROUND_COLOR_CHANGED, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.CLIP_NEAR, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.CLIP_FAR, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.CLIP_DIST, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.FOG_NEAR, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.FOG_FAR, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.SEARCH_STRING, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.SEARCH_STRING_HIT_NAVIGATOR, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.TAG_DETAIL_VIEW, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.SELECTED_SELECT_ALL_BUTTON_FOR_DATASET, currentActions);
- getCommonLastActionByType(orderedActionList, actionType.SELECT_ALL_DATASET_COMPOUNDS, currentActions);
-
- // Since drag and drop state can be influenced by filter as well, determine its state by the last influential action
- const action = orderedActionList.find(action =>
- [actionType.DRAG_DROP_FINISHED, actionType.DATASET_FILTER].includes(action.type)
- );
- if (action) {
- currentActions.push({ ...action, type: actionType.DRAG_DROP_FINISHED });
- }
-
- // Sides
- getLastActionByCriteria(orderedActionList, actionType.TURN_SIDE, action => action.side === 'LHS', currentActions);
- getLastActionByCriteria(orderedActionList, actionType.TURN_SIDE, action => action.side === 'RHS', currentActions);
-
- if (nglViewList) {
- let nglStateList = nglViewList.map(nglView => {
- return { id: nglView.id, orientation: nglView.stage.viewerControls.getOrientation() };
- });
-
- let trackAction = {
- type: actionType.NGL_STATE,
- timestamp: Date.now(),
- nglStateList: nglStateList
- };
-
- currentActions.push(Object.assign({ ...trackAction }));
- }
-
- if (!isAnonymousSnapshot) {
- await dispatch(saveSnapshotAction(snapshot, project, currentActions));
- }
- await dispatch(saveTrackingActions(currentActions, snapshotID));
- dispatch(setCurrentActionsList(currentActions));
- }
-};
-
-const saveSnapshotAction = (snapshot, project, currentActions) => async (dispatch, getState) => {
- const state = getState();
- const trackingImageSource = state.trackingReducers.trackingImageSource;
-
- let sendActions = [];
- let snapshotAction = {
- type: actionType.SNAPSHOT,
- timestamp: Date.now(),
- object_name: snapshot.title,
- object_id: snapshot.id,
- snapshotId: snapshot.id,
- text: `Snapshot: ${snapshot.id} - ${snapshot.title}`,
- image: trackingImageSource
- };
- sendActions.push(snapshotAction);
- currentActions.push(snapshotAction);
- await dispatch(sendTrackingActions(sendActions, project));
-};
-
-const setSnapshotToActions = (actionList, snapshot, projectID, project, nglViewList, addToSnapshot) => async (
- dispatch,
- getState
-) => {
- if (actionList && snapshot) {
- let actionsWithoutSnapshot = actionList.filter(a => a.snapshotId === null || a.snapshotId === undefined);
- let updatedActions = actionsWithoutSnapshot.map(obj => ({ ...obj, snapshotId: snapshot.id }));
- dispatch(setAndUpdateTrackingActions(updatedActions, projectID));
-
- if (addToSnapshot === true) {
- await dispatch(saveActionsList(project, snapshot, updatedActions, nglViewList));
- }
- }
-};
-
-const setSnapshotToAllActions = (actionList, snapshot, projectID) => async (dispatch, getState) => {
- if (actionList && snapshot) {
- let updatedActions = actionList.map(obj => ({ ...obj, snapshotId: snapshot.id }));
- dispatch(setAndUpdateTrackingActions(updatedActions, projectID));
- }
-};
-
-export const saveTrackingActions = (currentActions, snapshotID) => async (dispatch, getState) => {
- const state = getState();
- const project = state.projectReducers.currentProject;
- const projectID = project && project.projectID;
-
- if (snapshotID) {
- dispatch(setIsActionsSaving(true));
-
- const dataToSend = {
- session_project: projectID,
- author: project.authorID,
- snapshot: snapshotID,
- last_update_date: moment().format(),
- actions: JSON.stringify(currentActions)
- };
- return api({
- url: `${base_url}/api/snapshot-actions/`,
- method: METHOD.POST,
- data: JSON.stringify(dataToSend)
- })
- .then(response => {
- dispatch(setCurrentActionsList([]));
- })
- .catch(error => {
- throw new Error(error);
- })
- .finally(() => {
- dispatch(setIsActionsSaving(false));
- });
- } else {
- return Promise.resolve();
- }
-};
-
-// const getCurrentActionListForTags = (orderedActionList, type, collection, currentActions) => {
-// let actionList = orderedActionList.filter(action => action.type === type);
-// };
-
-const getCurrentActionList = (orderedActionList, type, collection, currentActions) => {
- let actionList = orderedActionList.filter(action => action.type === type);
-
- if (collection) {
- collection.forEach(data => {
- let actions = [];
- if (data.hasOwnProperty('color')) {
- actions = actionList.filter(
- a => a.object_id === data.id && a.dataset_id === data.datasetId && a.color_class === data.color
- );
- } else {
- actions = actionList.filter(a => a.object_id === data.id && a.dataset_id === data.datasetId);
- }
-
- if (actions.length > 0) {
- actions.forEach(action => currentActions.push(Object.assign({ ...action })));
- }
- });
- }
-};
-
-const getCurrentActionListDensity = (orderedActionList, type, collection, currentActions) => {
- let actionList = orderedActionList.filter(action => action.type === type);
-
- if (collection) {
- collection.forEach(data => {
- const action = actionList.find(a => a.object_id === data.id && a.dataset_id === data.datasetId);
-
- if (action) {
- currentActions.push({ ...action });
- }
- });
- }
-};
-
-const getLastColorFilterActions = (orderedActionList, type, currentActions) => {
- let actionList = orderedActionList.filter(action => action.type === type);
- Object.keys(compoundsColors).forEach(color => {
- let action = actionList.find(action => action.value === color);
- if (action) {
- currentActions.push({ ...action });
- }
- });
-};
-
-const getCommonLastActionByType = (orderedActionList, type, currentActions) => {
- let action = orderedActionList.find(action => action.type === type);
- if (action) {
- currentActions.push(Object.assign({ ...action }));
- }
-};
-
-const getLastActionByCriteria = (orderedActionList, type, criteriaFunction, currentActions) => {
- const action = orderedActionList.find(action => action.type === type && criteriaFunction(action));
- if (action) {
- currentActions.push({ ...action });
- }
-};
-
-const getCurrentActionListOfAllSelection = (
- orderedActionList,
- type,
- collection,
- currentActions,
- ligandList,
- proteinList,
- complexList
-) => {
- let actionList = orderedActionList.filter(action => action.type === type);
-
- if (collection) {
- collection.forEach(data => {
- let action = actionList.find(action => action.object_id === data.id && action.dataset_id === data.datasetId);
-
- if (action) {
- let ligandAction = ligandList.find(
- data => data.id === action.object_id && action.dataset_id === data.datasetId
- );
- let proteinAction = proteinList.find(
- data => data.id === action.object_id && action.dataset_id === data.datasetId
- );
- let complexAction = complexList.find(
- data => data.id === action.object_id && action.dataset_id === data.datasetId
- );
-
- let isLigand = ligandAction && ligandAction != null ? true : false;
- let isProtein = proteinAction && proteinAction != null ? true : false;
- let isComplex = complexAction && complexAction != null ? true : false;
- currentActions.push(
- Object.assign({ ...action, isLigand: isLigand, isProtein: isProtein, isComplex: isComplex })
- );
- }
- });
- }
-};
-
-const getCurrentActionListOfAllSelectionByType = (orderedActionList, type, controlType, collection, currentActions) => {
- let action = orderedActionList.find(
- action =>
- action.type === type &&
- action.control_type === controlType &&
- (action.object_type === actionObjectType.MOLECULE || action.object_type === actionObjectType.INSPIRATION)
- );
- if (action && collection) {
- let actionItems = action.items;
- let items = [];
- collection.forEach(data => {
- let item = actionItems.find(action => action.id === data.id && action.dataset_id === data.datasetId);
- if (item) {
- items.push(item);
- }
- });
-
- currentActions.push(Object.assign({ ...action, items: items }));
- }
-};
-
-const getCurrentActionListOfAllSelectionByTypeOfDataset = (
- orderedActionList,
- type,
- controlType,
- collection,
- currentActions
-) => {
- let action = orderedActionList.find(
- action =>
- action.type === type &&
- action.control_type === controlType &&
- (action.object_type === actionObjectType.COMPOUND || action.object_type === actionObjectType.CROSS_REFERENCE)
- );
- if (action && collection) {
- let actionItems = action.items;
- let items = [];
- collection.forEach(data => {
- let item = actionItems.find(item => item.molecule.id === data.id && item.datasetID === data.datasetId);
- if (item) {
- items.push(item);
- }
- });
-
- currentActions.push(Object.assign({ ...action, items: items }));
- }
-};
-
-const getCurrentActionListOfSelectAllMolecules = (orderedActionList, type, collection, currentActions) => {
- let action = orderedActionList.find(action => action.type === type);
- if (action) {
- let actionItems = action.items;
- let items = [];
- actionItems?.forEach(ai => {
- if (ai.associatedObs && ai.associatedObs.length > 0) {
- items.push(...ai.associatedObs);
- }
- });
-
- currentActions.push(Object.assign({ ...action, items: items }));
- }
-};
-
-const getCurrentActionListOfSelectAllVisibleHits = (orderedActionList, type, collection, currentActions) => {
- let action = orderedActionList.find(action => action.type === type);
- if (action) {
- currentActions.push(Object.assign({ ...action }));
- }
-};
-
-const getCurrentActionListOfPaintAllMolecules = (orderedActionList, type, collection, currentActions) => {
- const definedColors = Object.keys(compoundsColors);
- definedColors.forEach(color => {
- let action = orderedActionList.find(action => action.type === type && action.color === color);
- if (action && collection) {
- const datasetId = action.dataset_id;
- let actionItems = action.items;
- let items = [];
- collection.forEach(data => {
- if (data.datasetId === datasetId && data.color === color) {
- let item = actionItems.find(ai => ai === data.id);
- if (item) {
- items.push(item);
- }
- }
- });
- currentActions.push(Object.assign({ ...action, items: items }));
- }
- });
-};
-
-const getCurrentActionListOfShoppingCart = (orderedActionList, type, collection, currentActions) => {
- let actionList = orderedActionList.filter(action => action.type === type);
-
- if (collection) {
- collection.forEach(data => {
- let action = actionList.find(action => action.object_id === data.id && action.compoundId === data.compoundId);
-
- if (action) {
- currentActions.push(Object.assign({ ...action }));
- }
- });
- }
-};
-
-const getCurrentActionListOfAllShopingCart = (orderedActionList, type, collection, currentActions) => {
- let action = orderedActionList.find(action => action.type === type);
- if (action && collection) {
- let actionItems = action.items;
- let items = [];
- collection.forEach(data => {
- let item = actionItems.find(i => i.vector === data.id && i.compoundId === data.compoundId);
- if (item) {
- items.push(item);
- }
- });
-
- currentActions.push(Object.assign({ ...action, items: items }));
- }
-};
-
-const getCollection = dataList => {
- let list = [];
- if (dataList) {
- var result = dataList.map(value => ({ id: value }));
- list.push(...result);
- }
- return list;
-};
-
-const getCollectionOfDataset = dataList => {
- let list = [];
- if (dataList) {
- for (const datasetId in dataList) {
- let values = dataList[datasetId];
- if (values) {
- var result = values.map(value => ({ id: value, datasetId: datasetId }));
- list.push(...result);
- }
- }
- }
- return list;
-};
-
-const getCollectionOfDatasetColors = dataList => {
- let list = [];
- if (dataList) {
- for (const datasetId in dataList) {
- let values = dataList[datasetId];
- if (values) {
- for (const cmpId in values) {
- const colors = values[cmpId];
- var result = colors?.map(color => ({ id: Number(cmpId), datasetId: datasetId, color: color }));
- list.push(...result);
- }
- }
- }
- }
- return list;
-};
-
-const getCollectionOfShoppingCart = dataList => {
- let list = [];
- if (dataList) {
- dataList.forEach(data => {
- let value = data.vector;
- if (value) {
- list.push({ id: value, compoundId: data.compoundId });
- }
- });
- }
- return list;
-};
-
-const getCollectionOfDatasetOfRepresentation = dataList => {
- let list = [];
- for (const view in dataList) {
- let objectView = dataList[view];
- if (objectView && objectView !== null && objectView.display_div === VIEWS.MAJOR_VIEW) {
- let value = dataList[view].name;
- if (value) {
- list.push({ id: value });
- }
- }
- }
- return list;
-};
-
-export const resetRestoringState = () => (dispatch, getState) => {
- dispatch(setActionsList([]));
- dispatch(setProjectActionList([]));
- dispatch(setSendActionsList([]));
-
- dispatch(setTargetOn(undefined));
- dispatch(setIsActionsRestoring(false, false));
-};
-
-export const restoreCurrentActionsList = snapshotID => async (dispatch, getState) => {
- const state = getState();
- dispatch(resetTrackingState());
- dispatch(resetTargetState());
- dispatch(setTargetOn(undefined));
-
- dispatch(setIsActionsRestoring(true, false));
-
- await dispatch(restoreTrackingActions(snapshotID));
- dispatch(setIsTrackingMoleculesRestoring(true));
- dispatch(setIsTrackingCompoundsRestoring(true));
- dispatch(resetTargetState());
- dispatch(resetReducersForRestoringActions());
- dispatch(restoreStateBySavedActionList());
-};
-
-const restoreTrackingActions = snapshotID => async (dispatch, getState) => {
- const state = getState();
- const areSnapshotActionsDownloaded = state.trackingReducers.areSnapshotActionsDownloaded;
- // console.log(`snapshotDebug - restoreTrackingActions - start`);
- if (snapshotID && !areSnapshotActionsDownloaded) {
- try {
- // console.log(`snapshotDebug - restoreTrackingActions - before getting actions`);
- return api({
- url: `${base_url}/api/snapshot-actions/?snapshot=${snapshotID}`
- }).then(response => {
- // console.log(`snapshotDebug - restoreTrackingActions - after getting actions`);
- let results = response.data.results;
- // console.log(`snapshotDebug - restoreTrackingActions - no. of actions: ${results.length}`);
- let listToSet = [];
- results.forEach(r => {
- let resultActions = JSON.parse(r.actions);
- listToSet.push(...resultActions);
- });
-
- let snapshotActions = [...listToSet];
- dispatch(setCurrentActionsList(snapshotActions));
- dispatch(setSnapshotActionsDownloaded(true));
- // console.log(`snapshotDebug - restoreTrackingActions - end - success`);
- return Promise.resolve(snapshotActions);
- // return Promise.resolve();
- });
- } catch (error) {
- throw new Error(error);
- }
- } else {
- // console.log(`snapshotDebug - restoreTrackingActions - end - no snapshot`);
- return Promise.resolve([]);
- }
-};
-
-export const restoreStateBySavedActionList = () => (dispatch, getState) => {
- const state = getState();
-
- const currentActionList = state.trackingReducers.current_actions_list;
- const orderedActionList = currentActionList.sort((a, b) => a.timestamp - b.timestamp);
-
- let onCancel = () => {};
- dispatch(loadTargetList(onCancel))
- .then(() => {
- dispatch(restoreTargetActions(orderedActionList));
- dispatch(setIsSnapshotDirty(false));
- })
- .catch(error => {
- throw new Error(error);
- });
- return () => {
- onCancel();
- };
-};
-
-const restoreTargetActions = orderedActionList => (dispatch, getState) => {
- const state = getState();
-
- let targetAction = orderedActionList.find(action => action.type === actionType.TARGET_LOADED);
- if (targetAction) {
- let target = getTarget(targetAction.object_name, state);
- if (target) {
- dispatch(setTargetOn(target.id));
- }
- }
-};
-
-export const restoreAfterTargetActions = (stages, projectId, snapshotId) => async (dispatch, getState) => {
- const state = getState();
-
- const areSnapshotActionsDownloaded = state.trackingReducers.areSnapshotActionsDownloaded;
- let currentActionList = [];
- if (!areSnapshotActionsDownloaded) {
- currentActionList = await dispatch(restoreTrackingActions(snapshotId));
- } else {
- currentActionList = state.trackingReducers.current_actions_list;
- }
-
- //for some reason we have empty actions here... sometimes
- currentActionList = currentActionList.filter(a => Object.keys(a).length > 0);
-
- // const currentActionList = state.trackingReducers.current_actions_list;
- let orderedActionList = currentActionList.sort((a, b) => a.timestamp - b.timestamp);
- // console.log(`snapshotDebug - restoreAfterTargetActions - no. of actions: ${orderedActionList.length}`);
- const targetId = state.apiReducers.target_on;
-
- if (targetId && stages && stages.length > 0) {
- const majorView = stages.find(view => view.id === VIEWS.MAJOR_VIEW);
-
- await dispatch(loadProteinOfRestoringActions({ nglViewList: stages }));
-
- await dispatch(
- loadMoleculeGroupsOfTarget({
- isStateLoaded: false,
- setOldUrl: url => {},
- target_on: targetId
- })
- )
- .catch(error => {
- throw error;
- })
- .finally(() => {});
-
- await dispatch(restoreSitesActions(orderedActionList));
- // console.log(`snapshotDebug - restoreAfterTargetActions - before loadData`);
- await dispatch(loadData(orderedActionList, targetId, majorView));
- // console.log(`snapshotDebug - restoreAfterTargetActions - after loadData`);
- // console.log(`snapshotDebug - restoreAfterTargetActions - before restoreTagActions`);
- await dispatch(restoreTagActions(orderedActionList));
- // console.log(`snapshotDebug - restoreAfterTargetActions - after restoreTagActions`);
- await dispatch(restoreMoleculesActions(orderedActionList, majorView.stage));
- await dispatch(restoreRepresentationActions(orderedActionList, stages));
- await dispatch(restoreProject(projectId));
- dispatch(restoreMoleculeSelectionActions(orderedActionList));
- dispatch(restoreTabActions(orderedActionList));
- await dispatch(restoreCartActions(orderedActionList, majorView.stage));
- dispatch(restoreSnapshotImageActions(projectId));
- dispatch(restoreNglStateAction(orderedActionList, stages));
- dispatch(restoreNglSettingsAction(orderedActionList, majorView.stage));
- dispatch(restoreViewerControlActions(orderedActionList));
- dispatch(setIsActionsRestoring(false, true));
- dispatch(resetDatasetScrolledMap()); // Have a look at useScrollToSelected.js
- dispatch(setScrollFiredForLHS(false));
- dispatch(setSelectedDatasetScrolled(false));
- dispatch(setIsSnapshotDirty(false));
- dispatch(restoreSearchString(orderedActionList));
- dispatch(restoreSearchStringHitNavigator(orderedActionList));
- dispatch(restoreTagDetailGrid(orderedActionList));
- dispatch(restoreSelectAllButtonForDataset(orderedActionList));
- dispatch(restoreSelectAllDatasetCompounds(orderedActionList));
- }
-};
-
-export const restoreMoleculeSelectionActions = orderedActionList => (dispatch, getState) => {
- const state = getState();
- let actions = orderedActionList.filter(action => action.type === actionType.MOLECULE_SELECTED);
- if (actions) {
- actions.forEach(a => {
- const mol = getMolecule(a.object_name, state);
- dispatch(appendToMolListToEdit(mol.id));
- });
- }
-};
-
-export const restoreNglViewSettings = stages => (dispatch, getState) => {
- const majorViewStage = stages.find(view => view.id === VIEWS.MAJOR_VIEW).stage;
-
- dispatch(restoreNglSettingsAction([], majorViewStage));
-};
-
-export const restoreNglSettingsAction = (orderedActionList, majorViewStage) => (dispatch, getState) => {
- const state = getState();
- const viewParams = state.nglReducers.viewParams;
-
- let backgroundAction = orderedActionList.find(action => action.type === actionType.BACKGROUND_COLOR_CHANGED);
- if (backgroundAction && backgroundAction.newSetting !== undefined) {
- let value = backgroundAction.newSetting;
- dispatch(setNglBckGrndColor(value, majorViewStage));
- } else {
- dispatch(setNglBckGrndColor(NGL_VIEW_DEFAULT_VALUES[NGL_PARAMS.backgroundColor], majorViewStage));
- }
-
- let clipNearAction = orderedActionList.find(action => action.type === actionType.CLIP_NEAR);
- if (clipNearAction && clipNearAction.newSetting !== undefined) {
- let value = clipNearAction.newSetting;
- dispatch(setNglClipNear(value, viewParams[NGL_PARAMS.clipNear], majorViewStage));
- } else {
- dispatch(
- setNglClipNear(NGL_VIEW_DEFAULT_VALUES[NGL_PARAMS.clipNear], viewParams[NGL_PARAMS.clipNear], majorViewStage)
- );
- }
-
- let clipFarAction = orderedActionList.find(action => action.type === actionType.CLIP_FAR);
- if (clipFarAction && clipFarAction.newSetting !== undefined) {
- let value = clipFarAction.newSetting;
- dispatch(setNglClipFar(value, viewParams[NGL_PARAMS.clipFar], majorViewStage));
- } else {
- dispatch(
- setNglClipFar(NGL_VIEW_DEFAULT_VALUES[NGL_PARAMS.clipFar], viewParams[NGL_PARAMS.clipFar], majorViewStage)
- );
- }
-
- let clipDistAction = orderedActionList.find(action => action.type === actionType.CLIP_DIST);
- if (clipDistAction && clipDistAction.newSetting !== undefined) {
- let value = clipDistAction.newSetting;
- dispatch(setNglClipDist(value, viewParams[NGL_PARAMS.clipDist], majorViewStage));
- } else {
- dispatch(
- setNglClipDist(NGL_VIEW_DEFAULT_VALUES[NGL_PARAMS.clipDist], viewParams[NGL_PARAMS.clipDist], majorViewStage)
- );
- }
-
- let fogNearAction = orderedActionList.find(action => action.type === actionType.FOG_NEAR);
- if (fogNearAction && fogNearAction.newSetting !== undefined) {
- let value = fogNearAction.newSetting;
- dispatch(setNglFogNear(value, viewParams[NGL_PARAMS.fogNear], majorViewStage));
- } else {
- dispatch(
- setNglFogNear(NGL_VIEW_DEFAULT_VALUES[NGL_PARAMS.fogNear], viewParams[NGL_PARAMS.fogNear], majorViewStage)
- );
- }
-
- let fogFarAction = orderedActionList.find(action => action.type === actionType.FOG_FAR);
- if (fogFarAction && fogFarAction.newSetting !== undefined) {
- let value = fogFarAction.newSetting;
- dispatch(setNglFogFar(value, viewParams[NGL_PARAMS.fogFar], majorViewStage));
- } else {
- dispatch(setNglFogFar(NGL_VIEW_DEFAULT_VALUES[NGL_PARAMS.fogFar], viewParams[NGL_PARAMS.fogFar], majorViewStage));
- }
-
- let isoLevelActions = orderedActionList.filter(action => action.type.startsWith('ISO_LEVEL'));
- isoLevelActions &&
- isoLevelActions.forEach(isoLevelAction => {
- if (isoLevelAction && isoLevelAction.newSetting !== undefined) {
- let value = isoLevelAction.newSetting;
- if (isoLevelAction.object_name === mapTypesStrings.EVENT) {
- dispatch(setIsoLevel(MAP_TYPE.event, value, viewParams[NGL_PARAMS.isolevel_DENSITY], majorViewStage));
- } else if (isoLevelAction.object_name === mapTypesStrings.DIFF) {
- dispatch(setIsoLevel(MAP_TYPE.diff, value, viewParams[NGL_PARAMS.isolevel_DENSITY_MAP_diff], majorViewStage));
- } else if (isoLevelAction.object_name === mapTypesStrings.SIGMAA) {
- dispatch(
- setIsoLevel(MAP_TYPE.sigmaa, value, viewParams[NGL_PARAMS.isolevel_DENSITY_MAP_sigmaa], majorViewStage)
- );
- }
- } else {
- if (isoLevelAction && isoLevelAction.object_name === mapTypesStrings.EVENT) {
- dispatch(
- setIsoLevel(
- MAP_TYPE.event,
- NGL_VIEW_DEFAULT_VALUES[NGL_PARAMS.isolevel_DENSITY],
- viewParams[NGL_PARAMS.isolevel_DENSITY],
- majorViewStage
- )
- );
- } else if (isoLevelAction && isoLevelAction.object_name === mapTypesStrings.DIFF) {
- dispatch(
- setIsoLevel(
- MAP_TYPE.diff,
- NGL_VIEW_DEFAULT_VALUES[NGL_PARAMS.isolevel_DENSITY_MAP_diff],
- viewParams[NGL_PARAMS.isolevel_DENSITY_MAP_diff],
- majorViewStage
- )
- );
- } else if (isoLevelAction && isoLevelAction.object_name === mapTypesStrings.SIGMAA) {
- dispatch(
- setIsoLevel(
- MAP_TYPE.sigmaa,
- NGL_VIEW_DEFAULT_VALUES[NGL_PARAMS.isolevel_DENSITY_MAP_sigmaa],
- viewParams[NGL_PARAMS.isolevel_DENSITY_MAP_sigmaa],
- majorViewStage
- )
- );
- }
- }
- });
-
- let boxSizeActions = orderedActionList.filter(action => action.type.startsWith('BOX_SIZE'));
- boxSizeActions &&
- boxSizeActions.forEach(boxSizeAction => {
- if (boxSizeAction && boxSizeAction.newSetting !== undefined) {
- let value = boxSizeAction.newSetting;
- if (boxSizeAction.object_name === mapTypesStrings.EVENT) {
- dispatch(setBoxSize(MAP_TYPE.event, value, viewParams[NGL_PARAMS.boxSize_DENSITY], majorViewStage));
- } else if (boxSizeAction.object_name === mapTypesStrings.DIFF) {
- dispatch(setBoxSize(MAP_TYPE.diff, value, viewParams[NGL_PARAMS.boxSize_DENSITY_MAP_diff], majorViewStage));
- } else if (boxSizeAction.object_name === mapTypesStrings.SIGMAA) {
- dispatch(
- setBoxSize(MAP_TYPE.sigmaa, value, viewParams[NGL_PARAMS.boxSize_DENSITY_MAP_sigmaa], majorViewStage)
- );
- }
- } else {
- if (boxSizeAction && boxSizeAction.object_name === mapTypesStrings.EVENT) {
- dispatch(
- setBoxSize(
- MAP_TYPE.event,
- NGL_VIEW_DEFAULT_VALUES[NGL_PARAMS.boxSize_DENSITY],
- viewParams[NGL_PARAMS.boxSize_DENSITY],
- majorViewStage
- )
- );
- } else if (boxSizeAction && boxSizeAction.object_name === mapTypesStrings.DIFF) {
- dispatch(
- setBoxSize(
- MAP_TYPE.diff,
- NGL_VIEW_DEFAULT_VALUES[NGL_PARAMS.boxSize_DENSITY_MAP_diff],
- viewParams[NGL_PARAMS.boxSize_DENSITY_MAP_diff],
- majorViewStage
- )
- );
- } else if (boxSizeAction && boxSizeAction.object_name === mapTypesStrings.SIGMAA) {
- dispatch(
- setBoxSize(
- MAP_TYPE.sigmaa,
- NGL_VIEW_DEFAULT_VALUES[NGL_PARAMS.boxSize_DENSITY_MAP_sigmaa],
- viewParams[NGL_PARAMS.boxSize_DENSITY_MAP_sigmaa],
- majorViewStage
- )
- );
- }
- }
- });
-
- let opacityActions = orderedActionList.filter(action => action.type.startsWith('OPACITY'));
- opacityActions &&
- opacityActions.forEach(opacityAction => {
- if (opacityAction && opacityAction.newSetting !== undefined) {
- let value = opacityAction.newSetting;
- if (opacityAction.object_name === mapTypesStrings.EVENT) {
- dispatch(setOpacity(MAP_TYPE.event, value, viewParams[NGL_PARAMS.opacity_DENSITY], majorViewStage));
- } else if (opacityAction.object_name === mapTypesStrings.DIFF) {
- dispatch(setOpacity(MAP_TYPE.diff, value, viewParams[NGL_PARAMS.opacity_DENSITY_MAP_diff], majorViewStage));
- } else if (opacityAction.object_name === mapTypesStrings.SIGMAA) {
- dispatch(
- setOpacity(MAP_TYPE.sigmaa, value, viewParams[NGL_PARAMS.opacity_DENSITY_MAP_sigmaa], majorViewStage)
- );
- }
- } else {
- if (opacityAction && opacityAction.object_name === mapTypesStrings.EVENT) {
- dispatch(
- setOpacity(
- MAP_TYPE.event,
- NGL_VIEW_DEFAULT_VALUES[NGL_PARAMS.opacity_DENSITY],
- viewParams[NGL_PARAMS.opacity_DENSITY],
- majorViewStage
- )
- );
- } else if (opacityAction && opacityAction.object_name === mapTypesStrings.DIFF) {
- dispatch(
- setOpacity(
- MAP_TYPE.diff,
- NGL_VIEW_DEFAULT_VALUES[NGL_PARAMS.opacity_DENSITY_MAP_diff],
- viewParams[NGL_PARAMS.opacity_DENSITY_MAP_diff],
- majorViewStage
- )
- );
- } else if (opacityAction && opacityAction.object_name === mapTypesStrings.SIGMAA) {
- dispatch(
- setOpacity(
- MAP_TYPE.sigmaa,
- NGL_VIEW_DEFAULT_VALUES[NGL_PARAMS.opacity_DENSITY_MAP_sigmaa],
- viewParams[NGL_PARAMS.opacity_DENSITY_MAP_sigmaa],
- majorViewStage
- )
- );
- }
- }
- });
-
- let contourActions = orderedActionList.filter(action => action.type.startsWith('CONTOUR'));
- contourActions &&
- contourActions.forEach(contourAction => {
- if (contourAction && contourAction.newSetting !== undefined) {
- let value = contourAction.newSetting;
- if (contourAction.object_name === mapTypesStrings.EVENT) {
- dispatch(setContour(MAP_TYPE.event, value, viewParams[NGL_PARAMS.contour_DENSITY], majorViewStage));
- } else if (contourAction.object_name === mapTypesStrings.DIFF) {
- dispatch(setContour(MAP_TYPE.diff, value, viewParams[NGL_PARAMS.contour_DENSITY_MAP_diff], majorViewStage));
- } else if (contourAction.object_name === mapTypesStrings.SIGMAA) {
- dispatch(
- setContour(MAP_TYPE.sigmaa, value, viewParams[NGL_PARAMS.contour_DENSITY_MAP_sigmaa], majorViewStage)
- );
- }
- } else {
- if (contourAction && contourAction.object_name === mapTypesStrings.EVENT) {
- dispatch(
- setContour(
- MAP_TYPE.event,
- NGL_VIEW_DEFAULT_VALUES[NGL_PARAMS.contour_DENSITY],
- viewParams[NGL_PARAMS.contour_DENSITY],
- majorViewStage
- )
- );
- } else if (contourAction && contourAction.object_name === mapTypesStrings.DIFF) {
- dispatch(
- setContour(
- MAP_TYPE.diff,
- NGL_VIEW_DEFAULT_VALUES[NGL_PARAMS.contour_DENSITY_MAP_diff],
- viewParams[NGL_PARAMS.contour_DENSITY_MAP_sigmaa],
- majorViewStage
- )
- );
- } else if (contourAction && contourAction.object_name === mapTypesStrings.SIGMAA) {
- dispatch(
- setContour(
- MAP_TYPE.sigmaa,
- NGL_VIEW_DEFAULT_VALUES[NGL_PARAMS.contour_DENSITY_MAP_sigmaa],
- viewParams[NGL_PARAMS.contour_DENSITY_MAP_sigmaa],
- majorViewStage
- )
- );
- }
- }
- });
-
- let colorActions = orderedActionList.filter(action => action.type.startsWith('COLOR'));
- colorActions &&
- colorActions.forEach(colorAction => {
- if (colorAction && colorAction.newSetting !== undefined) {
- let value = colorAction.newSetting;
- if (colorAction.object_name === mapTypesStrings.EVENT) {
- dispatch(
- setElectronDesityMapColor(MAP_TYPE.event, value, viewParams[NGL_PARAMS.color_DENSITY], majorViewStage)
- );
- } else if (colorAction.object_name === mapTypesStrings.DIFF) {
- dispatch(
- setElectronDesityMapColor(
- MAP_TYPE.diff,
- value,
- viewParams[NGL_PARAMS.color_DENSITY_MAP_diff],
- majorViewStage
- )
- );
- } else if (colorAction.object_name === mapTypesStrings.SIGMAA) {
- dispatch(
- setElectronDesityMapColor(
- MAP_TYPE.sigmaa,
- value,
- viewParams[NGL_PARAMS.color_DENSITY_MAP_sigmaa],
- majorViewStage
- )
- );
- }
- } else {
- if (colorAction && colorAction.object_name === mapTypesStrings.EVENT) {
- dispatch(
- setElectronDesityMapColor(
- MAP_TYPE.event,
- NGL_VIEW_DEFAULT_VALUES[NGL_PARAMS.color_DENSITY],
- viewParams[NGL_PARAMS.color_DENSITY],
- majorViewStage
- )
- );
- } else if (colorAction && colorAction.object_name === mapTypesStrings.DIFF) {
- dispatch(
- setElectronDesityMapColor(
- MAP_TYPE.diff,
- NGL_VIEW_DEFAULT_VALUES[NGL_PARAMS.color_DENSITY_MAP_diff],
- viewParams[NGL_PARAMS.color_DENSITY_MAP_sigmaa],
- majorViewStage
- )
- );
- } else if (colorAction && colorAction.object_name === mapTypesStrings.SIGMAA) {
- dispatch(
- setElectronDesityMapColor(
- MAP_TYPE.sigmaa,
- NGL_VIEW_DEFAULT_VALUES[NGL_PARAMS.color_DENSITY_MAP_sigmaa],
- viewParams[NGL_PARAMS.color_DENSITY_MAP_sigmaa],
- majorViewStage
- )
- );
- }
- }
- });
-
- let warningIconAction = orderedActionList.find(action => action.type === actionType.WARNING_ICON);
- if (warningIconAction && warningIconAction.newSetting !== undefined) {
- let value = warningIconAction.newSetting;
- dispatch(setWarningIcon(value, viewParams[COMMON_PARAMS.warningIcon], true));
- } else {
- dispatch(
- setWarningIcon(NGL_VIEW_DEFAULT_VALUES[COMMON_PARAMS.warningIcon], viewParams[COMMON_PARAMS.warningIcon], true)
- );
- }
-};
-
-export const restoreNglStateAction = (orderedActionList, stages, animate = false) => async (dispatch, getState) => {
- const state = getState();
- const skipOrientation = state.trackingReducers.skipOrientationChange;
-
- if (!skipOrientation) {
- let actions = orderedActionList.filter(action => action.type === actionType.NGL_STATE);
- let action = [...actions].pop();
- if (action && action.nglStateList) {
- action.nglStateList.forEach(nglView => {
- dispatch(setOrientation(nglView.id, nglView.orientation));
- let viewStage = stages.find(s => s.id === nglView.id);
- if (viewStage) {
- console.count(`Before restoring orientation - restoreNglStateAction - tracking`);
- if (!animate) {
- viewStage.stage.viewerControls.orient(nglView.orientation.elements);
- } else {
- viewStage.stage.animationControls.orient(nglView.orientation.elements, 2000);
- }
- console.count(`After restoring orientation - restoreNglStateAction - tracking`);
- }
- });
- }
- }
-};
-
-export const restoreNglOrientationAnim = (orderedActionList, stages) => async (dispatch, getState) => {
- const state = getState();
- const skipOrientation = state.trackingReducers.skipOrientationChange;
-
- if (!skipOrientation) {
- let actions = orderedActionList.filter(action => action.type === actionType.NGL_STATE);
- let action = [...actions].pop();
- if (action && action.nglStateList) {
- const nglView = action.nglStateList[0];
- dispatch(setOrientation(nglView.id, nglView.orientation));
- let viewStage = stages.find(s => s.id === nglView.id);
- if (viewStage) {
- console.count(`Before restoring orientation - restoreNglStateAction - tracking`);
-
- console.count(`After restoring orientation - restoreNglStateAction - tracking`);
- return viewStage.stage.animationControls.orient(nglView.orientation.elements, 2000);
- }
- }
- }
-};
-
-const loadData = (orderedActionList, targetId, majorView) => async (dispatch, getState) => {
- // console.log(`snapshotDebug - loadData - before loadAllMolecules`);
- await dispatch(loadAllMolecules(targetId));
- // console.log(`snapshotDebug - loadData - after loadAllMolecules`);
- // console.log(`snapshotDebug - loadData - before loadAllDatasets`);
- await dispatch(loadAllDatasets(orderedActionList, targetId, majorView.stage));
- // console.log(`snapshotDebug - loadData - after loadAllDatasets`);
-};
-
-const loadAllDatasets = (orderedActionList, target_on, stage) => async (dispatch, getState) => {
- dispatch(setMoleculeListIsLoading(true));
-
- await dispatch(loadDataSets(target_on));
- await dispatch(loadDatasetCompoundsWithScores());
- dispatch(setMoleculeListIsLoading(false));
-
- dispatch(restoreCompoundsActions(orderedActionList, stage));
-};
-
-const loadAllMolecules = target_on => async (dispatch, getState) => {
- await dispatch(loadMoleculesAndTagsNew(target_on));
-};
-
-export const restoreSitesActions = orderedActionList => (dispatch, getState) => {
- const state = getState();
-
- let sitesAction = orderedActionList.filter(action => action.type === actionType.SITE_TURNED_ON);
- if (sitesAction) {
- sitesAction.forEach(action => {
- //when restoring tags we need to actually use object_id and not object_name because it can be changed by the user in the UI pretty much anytime
- const tag = getTag(action.object_id, state);
- if (tag) {
- dispatch(addSelectedTag(tag));
- if (tag.hidden) {
- dispatch(
- addToastMessage({
- level: TOAST_LEVELS.WARNING,
- text: `Tag ${tag.tag} is selected in the snapshot but it's hidden.`
- })
- );
- }
- }
- });
- }
-};
-
-export const restoreTagActions = orderedActionList => (dispatch, getState) => {
- const state = getState();
-
- let tagActions = orderedActionList.filter(action => action.type === actionType.TAG_SELECTED);
- if (tagActions) {
- tagActions.forEach(action => {
- //when restoring tags we need to actually use object_id and not object_name because it can be changed by the user in the UI pretty much anytime
- const tag = getTag(action.object_id, state);
- if (tag) {
- dispatch(addSelectedTag(tag));
- if (tag.hidden) {
- dispatch(
- addToastMessage({
- level: TOAST_LEVELS.WARNING,
- text: `Tag ${tag.tag} is selected in the snapshot but it's hidden.`
- })
- );
- }
- }
- });
- }
-};
-
-export const restoreMoleculesActions = (orderedActionList, stage) => async (dispatch, getState) => {
- const state = getState();
- let moleculesAction = orderedActionList.filter(
- action => action.object_type === actionObjectType.MOLECULE || action.object_type === actionObjectType.INSPIRATION
- );
-
- if (moleculesAction) {
- await dispatch(addNewType(moleculesAction, actionType.LIGAND_TURNED_ON, 'ligand', stage, state));
- await dispatch(addNewType(moleculesAction, actionType.SIDECHAINS_TURNED_ON, 'protein', stage, state));
- await dispatch(addNewType(moleculesAction, actionType.INTERACTIONS_TURNED_ON, 'complex', stage, state));
- await dispatch(addNewType(moleculesAction, actionType.SURFACE_TURNED_ON, 'surface', stage, state));
- await dispatch(addNewType(moleculesAction, actionType.QUALITY_TURNED_OFF, 'quality', stage, state));
- await dispatch(addNewType(moleculesAction, actionType.VECTORS_TURNED_ON, 'vector', stage, state));
- await dispatch(addNewType(moleculesAction, actionType.DENSITY_TURNED_ON, 'density', stage, state));
- await dispatch(addNewType(moleculesAction, actionType.DENSITY_TYPE_ON, 'density', stage, state));
- await dispatch(addNewType(moleculesAction, actionType.DENSITY_CUSTOM_TURNED_ON, 'densityCustom', stage, state));
- await dispatch(restoreSelectAllMolecules(moleculesAction));
- await dispatch(restoreSelectAllVisibleHits(moleculesAction));
- await dispatch(restorePoseWindow(moleculesAction));
- }
-
- dispatch(restoreAllSelectionActions(orderedActionList, stage, true));
- dispatch(restoreAllSelectionByTypeActions(orderedActionList, stage, true));
- dispatch(setIsTrackingMoleculesRestoring(false));
-};
-
-export const restoreCartActions = (orderedActionList, majorViewStage) => async (dispatch, getState) => {
- let vectorAction = orderedActionList.find(action => action.type === actionType.VECTOR_SELECTED);
- if (vectorAction) {
- await dispatch(selectVectorAndResetCompounds(vectorAction.object_name));
- }
-
- let shoppingCartAllaction = orderedActionList.find(
- action => action.type === actionType.MOLECULE_ADDED_TO_SHOPPING_CART_ALL
- );
-
- let shoppingCartItems = [];
-
- if (shoppingCartAllaction) {
- let allItems = shoppingCartAllaction.items;
- if (allItems) {
- allItems.forEach(i => {
- shoppingCartItems.push(i);
- });
- }
- }
-
- let shoppingCartActions = orderedActionList.filter(
- action => action.type === actionType.MOLECULE_ADDED_TO_SHOPPING_CART
- );
- if (shoppingCartActions) {
- shoppingCartActions.forEach(action => {
- if (action.item) {
- shoppingCartItems.push(action.item);
- }
- });
- }
-
- shoppingCartItems.forEach(item => {
- let data = item;
- if (data) {
- dispatch(handleBuyList({ isSelected: true, data, skipTracking: true }));
- }
- });
-
- let classSelectedAction = orderedActionList.find(action => action.type === actionType.CLASS_SELECTED);
- if (classSelectedAction) {
- dispatch(setCurrentCompoundClass(classSelectedAction.value, classSelectedAction.oldValue));
- }
-
- let classUpdatedAction = orderedActionList.find(action => action.type === actionType.CLASS_UPDATED);
- if (classUpdatedAction) {
- let id = classUpdatedAction.object_id;
- let newValue = classUpdatedAction.newCompoundClasses;
- let oldValue = classUpdatedAction.oldCompoundClasses;
- let value = classUpdatedAction.object_name;
- value = value !== undefined ? value : '';
- dispatch(setCompoundClasses(newValue, oldValue, value, id));
- }
-
- let colorFilterRemoveActions = orderedActionList.filter(action => action.type === actionType.COLOR_FILTER_TURNED_OFF);
- colorFilterRemoveActions?.forEach(action => {
- dispatch(handleColorFilterAction(action, false));
- });
-
- let vectorCompoundActions = orderedActionList.filter(action => action.type === actionType.VECTOR_COUMPOUND_ADDED);
- if (vectorCompoundActions) {
- vectorCompoundActions.forEach(action => {
- let data = action.item;
- dispatch(handleShowVectorCompound({ isSelected: true, data, majorViewStage: majorViewStage }));
- });
- }
-};
-
-const restoreAllSelectionActions = (moleculesAction, stage, isSelection) => (dispatch, getState) => {
- let state = getState();
-
- let actions =
- isSelection === true
- ? moleculesAction.filter(
- action =>
- action.type === actionType.ALL_TURNED_ON &&
- (action.object_type === actionObjectType.INSPIRATION || action.object_type === actionObjectType.MOLECULE)
- )
- : moleculesAction.filter(
- action =>
- action.type === actionType.ALL_TURNED_ON &&
- (action.object_type === actionObjectType.CROSS_REFERENCE ||
- action.object_type === actionObjectType.COMPOUND)
- );
-
- if (actions) {
- actions.forEach(action => {
- if (action) {
- if (isSelection) {
- const mol = getMolecule(action.object_name, state);
- if (mol) {
- dispatch(setSelectedAll(mol, action.isLigand, action.isProtein, action.isComplex));
- }
- } else {
- const compound = getCompound(action, state);
- if (compound) {
- dispatch(
- setSelectedAllOfDataset(
- action.dataset_id,
- action.item,
- action.isLigand,
- action.isProtein,
- action.isComplex
- )
- );
- }
- }
-
- if (action.isLigand) {
- dispatch(handleMoleculeAction(action, 'ligand', true, stage, state, true));
- }
-
- if (action.isProtein) {
- dispatch(handleMoleculeAction(action, 'protein', true, stage, state, true));
- }
-
- if (action.isComplex) {
- dispatch(handleMoleculeAction(action, 'complex', true, stage, state, true));
- }
- }
- });
- }
-};
-
-const restoreSelectAllMolecules = moleculesAction => (dispatch, getState) => {
- let action = moleculesAction.find(ma => ma.type === actionType.ALL_MOLECULES_SELECTED);
- if (action && action.items) {
- const state = getState();
- const allMolecules = state.apiReducers.all_mol_lists;
- dispatch(setNextXMolecules(allMolecules.length));
- action.items.forEach(m => {
- dispatch(handleSelectMoleculeByName(m.code, true));
- });
- }
-};
-
-const restoreSelectAllVisibleHits = moleculesAction => (dispatch, getState) => {
- let action = moleculesAction.find(ma => ma.type === actionType.ALL_VISIBLE_HITS_SELECTED);
- if (action && action.items) {
- const state = getState();
- const allMolecules = state.apiReducers.all_mol_lists;
- dispatch(setNextXMolecules(allMolecules.length));
- action.items.forEach(m => {
- dispatch(handleSelectMoleculeByName(m.code, true));
- });
- }
-};
-
-const restorePoseWindow = moleculesAction => (dispatch, getState) => {
- let action = moleculesAction.find(ma => ma.type === actionType.POSE_WINDOW_ACTION);
- if (action && action.isOpen && action.items?.length > 0) {
- dispatch(handlePoseWindowAction(action, false));
- }
-};
-
-const restoreInspirationsWindow = customDatasetAction => (dispatch, getState) => {
- let action = customDatasetAction.find(ma => ma.type === actionType.INSPIRATION_WINDOW_ACTION);
- if (action && action.isOpen && action.items?.length > 0) {
- if (action.isSelectedList) {
- dispatch(setInspirationDialogOpenedForSelectedCompounds(true));
- }
- dispatch(handleInspirationsWindowAction(action, false));
- }
-};
-
-const restorePaintAllCompounds = compoundActions => (dispatch, getState) => {
- let actions = compoundActions?.filter(ma => ma.type === actionType.ALL_COMPOUNDS_ADDED_TO_COLOR_GROUP);
- actions?.forEach(action => {
- if (action?.items && action?.color && action?.dataset_id) {
- const state = getState();
- action.items.forEach(ai => {
- const cmp = getCompoundById(ai, action.dataset_id, state);
- if (cmp) {
- dispatch(appendCompoundColorOfDataset(action.dataset_id, cmp.id, action.color, cmp.name, true));
- }
- });
- }
- });
-};
-
-const restoreAllSelectionByTypeActions = (moleculesAction, stage, isSelection) => (dispatch, getState) => {
- const state = getState();
- let actions =
- isSelection === true
- ? moleculesAction.filter(
- action =>
- action.type === actionType.SELECTED_TURNED_ON_BY_TYPE &&
- (action.object_type === actionObjectType.INSPIRATION || action.object_type === actionObjectType.MOLECULE)
- )
- : moleculesAction.filter(
- action =>
- action.type === actionType.SELECTED_TURNED_ON_BY_TYPE &&
- (action.object_type === actionObjectType.CROSS_REFERENCE ||
- action.object_type === actionObjectType.COMPOUND)
- );
-
- if (actions) {
- actions.forEach(action => {
- if (action) {
- // let actionItems = action.items;
- let actionItems = [];
- if (isSelection) {
- action.items.forEach(item => {
- const mol = getMolecule(item.code, state);
- if (mol) {
- actionItems.push(mol);
- }
- });
- } else {
- action.items.forEach(item => {
- const mol = getCompoundByName(item.code, action.dataset_id, state);
- if (mol) {
- actionItems.push(mol);
- }
- });
- }
- let type = action.control_type;
-
- if (isSelection) {
- dispatch(setSelectedAllByType(type, actionItems, action.object_type === actionObjectType.INSPIRATION));
-
- actionItems.forEach(data => {
- if (data) {
- if (type === 'ligand') {
- dispatch(addType[type](stage, data, colourList[data.id % colourList.length], true, true, true));
- } else if (type === 'vector') {
- dispatch(addType[type](stage, data, true));
- } else if (type === 'density' || type === 'densityCustom') {
- dispatch(addType[type](stage, data, colourList[data.id % colourList.length], false, true));
- } else {
- dispatch(addType[type](stage, data, colourList[data.id % colourList.length], true));
- }
- }
- });
- } else {
- dispatch(
- setSelectedAllByTypeOfDataset(
- type,
- action.dataset_id,
- actionItems,
- action.object_type === actionObjectType.CROSS_REFERENCE
- )
- );
-
- actionItems.forEach(data => {
- if (data && data.molecule) {
- dispatch(
- addTypeCompound[type](
- stage,
- data.molecule,
- colourList[data.molecule.id % colourList.length],
- data.datasetID,
- true
- )
- );
- }
- });
- }
- }
- });
- }
-};
-
-export const restoreRepresentationActions = (moleculesActions, stages) => async (dispatch, getState) => {
- const nglView = stages.find(view => view.id === VIEWS.MAJOR_VIEW);
- const objectsInView = getState().nglReducers.objectsInView;
-
- let addedRepresentations = [];
- let defaultStructuresMap = {};
- // fetch representations created by default of restored object
- for (const [objectId, object] of Object.entries(objectsInView)) {
- if (object.hasOwnProperty('representations') && object.representations?.length === 1) {
- defaultStructuresMap[objectId] = object.representations[0].uuid;
- }
- }
- // if action points to non existing representation it was probably a default one so try to map it to current default one
- const fixUuid = (representationToCheck, objectId) => {
- const representationExists =
- objectsInView[objectId].representations.some(representation => {
- return representation.uuid === representationToCheck.uuid;
- }) || addedRepresentations.includes(representationToCheck.uuid);
- if (!representationExists && defaultStructuresMap.hasOwnProperty(objectId)) {
- representationToCheck.lastKnownID = defaultStructuresMap[objectId];
- }
- };
-
- // here the object id is actually protein_code_object_type and is identifier in NGL view so it's ok to use object_id in here
- for (const action of moleculesActions) {
- // TODO updates and changes are inconsistent and not working properly
- // TODO maybe we do not need to restore representation actions one by one
- // and just pass final representations from objectsInView and restore them isntead?
- if (action.type === actionType.REPRESENTATION_ADDED) {
- addedRepresentations.push(action.representation.uuid);
- await dispatch(handleRepresentationAction(action, true, nglView));
- } else if (action.type === actionType.REPRESENTATION_UPDATED) {
- fixUuid(action.representation, action.object_id);
- await dispatch(handleUpdateRepresentationAction(action, true, nglView));
- } else if (action.type === actionType.REPRESENTATION_CHANGED) {
- fixUuid(action.newRepresentation, action.object_id);
- fixUuid(action.oldRepresentation, action.object_id);
- await dispatch(changeMolecularRepresentationForSnapshotRestoration(action, nglView));
- }
- }
-};
-
-export const restoreTabActions = moleculesAction => (dispatch, getState) => {
- const state = getState();
- const customDatasets = state.datasetsReducers.datasets;
- let firstCustomDatasetTitle = (customDatasets && customDatasets[0] && customDatasets[0].title) || '';
-
- let action = moleculesAction.find(action => action.type === actionType.TAB);
- if (action) {
- //in here the object id is the tab index on the right hand side so it should be ok. BUT what if the given dataset
- //was deleted? Is it even possible?
- dispatch(setTabValue(action.oldObjectId, action.object_id, action.object_name, action.oldObjectName));
- }
-
- let indexAction = moleculesAction.find(action => action.type === actionType.DATASET_INDEX);
- if (indexAction) {
- dispatch(
- setSelectedDatasetIndex(
- indexAction.oldObjectId,
- indexAction.object_id,
- indexAction.object_name,
- indexAction.oldObjectName
- )
- );
- } else {
- if (action && action.object_id === 2 && action.object_name !== firstCustomDatasetTitle) {
- let dataset = customDatasets.find(d => d.title === action.object_name);
- var index = customDatasets.findIndex(d => d.title === action.object_name);
-
- if (dataset) {
- dispatch(setSelectedDatasetIndex(index, index, dataset.title, dataset.title, true));
- }
- }
- }
-
- const dragDropFinishedAction = moleculesAction.find(action => action.type === actionType.DRAG_DROP_FINISHED);
- if (dragDropFinishedAction) {
- const { datasetID, newDragDropState } = dragDropFinishedAction;
- dispatch(setDragDropState(datasetID, newDragDropState));
- }
-
- let filterAction = moleculesAction.find(action => action.type === actionType.DATASET_FILTER);
- if (filterAction) {
- let datasetID = filterAction.datasetID;
- let newFilterProperties = filterAction.newProperties;
- let newFilterSettings = filterAction.newSettings;
- dispatch(setDatasetFilter(datasetID, newFilterProperties, newFilterSettings, filterAction.key, null));
- dispatch(setFilterProperties(datasetID, newFilterProperties));
- dispatch(setFilterSettings(datasetID, newFilterSettings));
- }
-
- let filterScoreAction = moleculesAction.find(action => action.type === actionType.DATASET_FILTER_SCORE);
- if (filterScoreAction) {
- let datasetID = filterScoreAction.dataset_id;
- dispatch(
- updateFilterShowedScoreProperties({
- datasetID,
- scoreList: filterScoreAction.newScoreList
- })
- );
-
- dispatch(
- setFilterShowedScoreProperties({
- datasetID,
- scoreList: filterScoreAction.newScoreList,
- oldScoreList: filterScoreAction.oldScoreList,
- isChecked: filterScoreAction.isChecked,
- scoreName: filterScoreAction.object_name
- })
- );
- }
-};
-
-const restoreSearchString = moleculesAction => dispatch => {
- let filterSearchString = moleculesAction.find(action => action.type === actionType.SEARCH_STRING);
- if (filterSearchString) {
- let datasetID = filterSearchString.dataset_id;
- dispatch(setSearchStringOfCompoundSet(datasetID, filterSearchString.searchString));
- }
-};
-
-const restoreSearchStringHitNavigator = moleculesAction => (dispatch, getState) => {
- let filterSearchString = moleculesAction.find(action => action.type === actionType.SEARCH_STRING_HIT_NAVIGATOR);
- if (filterSearchString) {
- dispatch(setSearchStringOfHitNavigator(filterSearchString.searchStringHitNavigator));
- }
-};
-
-const restoreTagDetailGrid = moleculesAction => (dispatch, getState) => {
- let tagDetailView = moleculesAction.find(action => action.type === actionType.TAG_DETAIL_VIEW);
- if (tagDetailView) {
- dispatch(setTagDetailView(tagDetailView));
- }
-};
-
-const restoreSelectAllButtonForDataset = moleculesAction => (dispatch, getState) => {
- let selectAllButton = moleculesAction.find(
- action => action.type === actionType.SELECTED_SELECT_ALL_BUTTON_FOR_DATASET
- );
- if (selectAllButton) {
- dispatch(setSelectAllButtonForDataset(selectAllButton.dataset_id));
- }
-};
-
-const restoreSelectAllDatasetCompounds = moleculesAction => (dispatch, getState) => {
- let selectedAllDatasetCompounds = moleculesAction.find(
- action => action.type === actionType.SELECT_ALL_DATASET_COMPOUNDS
- );
- if (selectedAllDatasetCompounds) {
- dispatch(
- setCompoundToSelectedCompoundsByDataset(
- selectedAllDatasetCompounds.selectedAllDatasetCompounds.datasetID,
- selectedAllDatasetCompounds.selectedAllDatasetCompounds.selectedCompounds
- )
- );
- }
-};
-
-export const restoreViewerControlActions = moleculesAction => dispatch => {
- const turnSideActions = moleculesAction.filter(action => action.type === actionType.TURN_SIDE);
- turnSideActions.forEach(action => {
- const { side, open } = action;
- dispatch(turnSide(side, open, true));
- });
-};
-
-export const restoreSnapshotImageActions = projectID => async (dispatch, getState) => {
- const state = getState();
- const isProjectActionListLoaded = state.trackingReducers.isProjectActionListLoaded;
- if (!isProjectActionListLoaded) {
- let actionList = await dispatch(getTrackingActions(projectID));
- let snapshotActions = actionList.filter(action => action.type === actionType.SNAPSHOT);
- if (snapshotActions) {
- let actions = snapshotActions.map(s => {
- return { id: s.object_id, image: s.image, title: s.object_name, timestamp: s.timestamp };
- });
- const key = 'object_id';
- const arrayUniqueByKey = [...new Map(actions.map(item => [item[key], item])).values()];
- dispatch(setSnapshotImageActionList(arrayUniqueByKey));
- }
- }
-};
-
-const restoreProject = projectId => (dispatch, getState) => {
- if (projectId !== undefined) {
- return api({ url: `${base_url}/api/session-projects/${projectId}/` }).then(response => {
- let promises = [];
- promises.push(
- dispatch(
- setCurrentProject({
- projectID: response.data.id,
- authorID: response.data.author || null,
- title: response.data.title,
- description: response.data.description,
- targetID: response.data.target.id,
- tags: JSON.parse(response.data.tags)
- })
- )
- );
- promises.push(dispatch(setProject(response.data.project)));
-
- return Promise.all(promises);
- });
- }
-};
-
-export const restoreCompoundsActions = (orderedActionList, stage) => (dispatch, getState) => {
- const state = getState();
-
- let compoundsAction = orderedActionList.filter(
- action =>
- action.object_type === actionObjectType.COMPOUND || action.object_type === actionObjectType.CROSS_REFERENCE
- );
-
- if (compoundsAction) {
- dispatch(addNewTypeCompound(compoundsAction, actionType.LIGAND_TURNED_ON, 'ligand', stage, state));
- dispatch(addNewTypeCompound(compoundsAction, actionType.SIDECHAINS_TURNED_ON, 'protein', stage, state));
- dispatch(addNewTypeCompound(compoundsAction, actionType.INTERACTIONS_TURNED_ON, 'complex', stage, state));
- dispatch(addNewTypeCompound(compoundsAction, actionType.SURFACE_TURNED_ON, 'surface', stage, state));
- }
-
- let compoundsSelectedAction = compoundsAction?.filter(action => action.type === actionType.COMPOUND_SELECTED);
-
- compoundsSelectedAction.forEach(action => {
- let data = getCompound(action, state);
- if (data) {
- dispatch(appendMoleculeToCompoundsOfDatasetToBuy(action.dataset_id, data.id, data.name));
- }
- });
-
- let compoundsLockedAction = compoundsAction?.filter(action => action.type === actionType.COMPOUND_LOCKED);
-
- compoundsLockedAction.forEach(action => {
- let data = getCompound(action, state);
- if (data) {
- dispatch(appendCompoundToSelectedCompoundsByDataset(action.dataset_id, data.id, data.name));
- }
- });
-
- dispatch(restorePaintAllCompounds(compoundsAction));
-
- let compoundsColorGroupActions = compoundsAction?.filter(
- action => action.type === actionType.COMPOUND_ADDED_TO_COLOR_GROUP
- );
-
- compoundsColorGroupActions.forEach(action => {
- let data = getCompound(action, state);
- if (data) {
- dispatch(appendCompoundColorOfDataset(action.dataset_id, data.id, action.color_class, data.name));
- }
- });
-
- dispatch(restoreAllSelectionActions(orderedActionList, stage, false));
- dispatch(restoreAllSelectionByTypeActions(orderedActionList, stage, false));
- dispatch(restoreInspirationsWindow(compoundsAction));
-
- dispatch(setIsTrackingCompoundsRestoring(false));
-};
-
-const addType = {
- ligand: addLigand,
- protein: addHitProtein,
- complex: addComplex,
- surface: addSurface,
- quality: addQuality,
- vector: addVector,
- density: addDensity,
- densityCustom: addDensityCustomView
-};
-
-const addTypeCompound = {
- ligand: addDatasetLigand,
- protein: addDatasetHitProtein,
- complex: addDatasetComplex,
- surface: addDatasetSurface
-};
-
-const removeType = {
- ligand: removeLigand,
- protein: removeHitProtein,
- complex: removeComplex,
- surface: removeSurface,
- density: removeDensity,
- quality: removeQuality,
- vector: removeVector
-};
-
-const removeTypeCompound = {
- ligand: removeDatasetLigand,
- protein: removeDatasetHitProtein,
- complex: removeDatasetComplex,
- surface: removeDatasetSurface
-};
-
-const addNewType = (moleculesAction, actionType, type, stage, state, skipTracking = false) => async (
- dispatch,
- getState
-) => {
- let actions = moleculesAction.filter(action => action.type === actionType);
- if (actions) {
- for (const action of actions) {
- const freshState = getState();
- let data = getMolecule(action.object_name, freshState);
- if (data) {
- if (type === 'ligand') {
- await dispatch(addType[type](stage, data, colourList[data.id % colourList.length], true, true, skipTracking));
- } else if (type === 'protein') {
- await dispatch(addType[type](stage, data, colourList[data.id % colourList.length], true, skipTracking));
- } else if (type === 'vector') {
- await dispatch(addType[type](stage, data, true));
- } else if (type === 'density' || type === 'densityCustom') {
- if (!data.proteinData) {
- await dispatch(getProteinData(data)).then(i => {
- const proteinData = i;
- if (type === 'density') {
- data.proteinData = proteinData;
- data.proteinData.render_event = !!action.render_event;
- data.proteinData.render_diff = !!action.render_diff;
- data.proteinData.render_sigmaa = !!action.render_sigmaa;
- data.proteinData.render_quality = !!action.render_quality;
- }
- });
- if (type === 'density') {
- await dispatch(addType[type](stage, data, colourList[data.id % colourList.length], true, skipTracking));
- } else {
- await dispatch(addType[type](stage, data, colourList[data.id % colourList.length], true, skipTracking));
- }
- } else {
- if (type === 'density') {
- data.proteinData.render_event = !!action.render_event;
- data.proteinData.render_diff = !!action.render_diff;
- data.proteinData.render_sigmaa = !!action.render_sigmaa;
- data.proteinData.render_quality = !!action.render_quality;
- }
- if (type === 'density') {
- await dispatch(addType[type](stage, data, colourList[data.id % colourList.length], true, skipTracking));
- } else {
- await dispatch(addType[type](stage, data, colourList[data.id % colourList.length], true, skipTracking));
- }
- }
- } else if (type === 'quality') {
- await dispatch(removeType[type](stage, data, colourList[data.id % colourList.length], skipTracking));
- } else {
- await dispatch(addType[type](stage, data, colourList[data.id % colourList.length], skipTracking));
- }
- }
- }
- }
-};
-
-const addNewTypeOfAction = (action, type, stage, state, skipTracking = false) => dispatch => {
- if (action) {
- let data = getMolecule(action.object_name, state);
- if (data) {
- if (type === 'ligand') {
- dispatch(addType[type](stage, data, colourList[data.id % colourList.length], true, true, skipTracking));
- } else if (type === 'vector') {
- dispatch(addType[type](stage, data, true));
- } else if (type === 'density' || type === 'densityCustom') {
- dispatch(addType[type](stage, data, colourList[data.id % colourList.length], true, skipTracking));
- } else {
- dispatch(addType[type](stage, data, colourList[data.id % colourList.length], skipTracking));
- }
- }
- }
-};
-
-const addNewTypeCompound = (moleculesAction, actionType, type, stage, state, skipTracking = false) => dispatch => {
- let actions = moleculesAction.filter(action => action.type === actionType);
- if (actions) {
- actions.forEach(action => {
- let data = getCompound(action, state);
- if (data) {
- dispatch(
- addTypeCompound[type](stage, data, colourList[data.id % colourList.length], action.dataset_id, skipTracking)
- );
- }
- });
- }
-};
-
-const addNewTypeCompoundOfAction = (action, type, stage, state, skipTracking = false) => dispatch => {
- if (action) {
- let data = getCompound(action, state);
- if (data) {
- dispatch(
- addTypeCompound[type](stage, data, colourList[data.id % colourList.length], action.dataset_id, skipTracking)
- );
- }
- }
-};
-
-const getTarget = (targetName, state) => {
- let targetList = state.apiReducers.target_id_list;
- let target = targetList.find(target => target.title === targetName);
- return target;
-};
-
-const getTag = (tagId, state) => {
- const tagList = state.apiReducers.tagList;
- const tag = tagList.find(t => t.id === tagId);
- return tag;
-};
-
-export const getMolecule = (moleculeName, state) => {
- let moleculeList = state.apiReducers.all_mol_lists;
- let molecule = null;
-
- molecule = moleculeList.find(m => m.code === moleculeName);
-
- return molecule;
-};
-
-export const getCompound = (action, state) => {
- let moleculeList = state.datasetsReducers.moleculeLists;
- let molecule = null;
-
- let name = action.object_name;
- let datasetID = action.dataset_id;
-
- if (moleculeList) {
- let moleculeListOfDataset = moleculeList[datasetID];
- if (moleculeListOfDataset) {
- molecule = moleculeListOfDataset.find(m => m.name === name);
- }
- }
- return molecule;
-};
-
-export const getCompoundByName = (name, datasetID, state) => {
- let moleculeList = state.datasetsReducers.moleculeLists;
- let molecule = null;
-
- if (moleculeList) {
- let moleculeListOfDataset = moleculeList[datasetID];
- if (moleculeListOfDataset) {
- molecule = moleculeListOfDataset.find(m => m.name === name);
- }
- }
- return molecule;
-};
-
-export const getCompoundById = (cmpId, datasetID, state) => {
- let moleculeList = state.datasetsReducers.moleculeLists;
- let molecule = null;
-
- if (moleculeList) {
- let moleculeListOfDataset = moleculeList[datasetID];
- if (moleculeListOfDataset) {
- molecule = moleculeListOfDataset.find(m => m.id === cmpId);
- }
- }
- return molecule;
-};
-
-export const undoAction = (stages = []) => (dispatch, getState) => {
- dispatch(setIsUndoRedoAction(true));
- let action = dispatch(getUndoAction());
- if (action) {
- Promise.resolve(dispatch(handleUndoAction(action, stages))).then(() => {
- dispatch(setIsUndoRedoAction(false));
- });
- }
-};
-
-const getUndoAction = () => (dispatch, getState) => {
- const state = getState();
- const actionUndoList = state.undoableTrackingReducers.future;
-
- let action = { text: '' };
- let actions = actionUndoList && actionUndoList[0];
- if (actions) {
- let actionsLenght = actions.undo_redo_actions_list.length;
- actionsLenght = actionsLenght > 0 ? actionsLenght - 1 : actionsLenght;
- action = actions.undo_redo_actions_list[actionsLenght];
- }
-
- return action;
-};
-
-const getRedoAction = () => (dispatch, getState) => {
- const state = getState();
- const actions = state.undoableTrackingReducers.present;
-
- let action = { text: '' };
- if (actions) {
- let actionsLenght = actions.undo_redo_actions_list.length;
- actionsLenght = actionsLenght > 0 ? actionsLenght - 1 : actionsLenght;
- action = actions.undo_redo_actions_list[actionsLenght];
- }
-
- return action;
-};
-
-const getNextUndoAction = () => (dispatch, getState) => {
- const state = getState();
- const actionUndoList = state.undoableTrackingReducers.present;
-
- let action = { text: '' };
- let actions = actionUndoList && actionUndoList.undo_redo_actions_list;
- if (actions) {
- let actionsLenght = actions.length;
- actionsLenght = actionsLenght > 0 ? actionsLenght - 1 : actionsLenght;
- action = actions[actionsLenght];
- }
-
- return action;
-};
-
-const getNextRedoAction = () => (dispatch, getState) => {
- const state = getState();
- const actionUndoList = state.undoableTrackingReducers.future;
-
- let action = { text: '' };
- let actionss = actionUndoList && actionUndoList[0];
-
- let actions = actionss && actionss.undo_redo_actions_list;
- if (actions) {
- let actionsLenght = actions.length;
- actionsLenght = actionsLenght > 0 ? actionsLenght - 1 : actionsLenght;
- action = actions[actionsLenght];
- }
-
- return action;
-};
-
-export const redoAction = (stages = []) => (dispatch, getState) => {
- dispatch(setIsUndoRedoAction(true));
- let action = dispatch(getRedoAction());
- if (action) {
- Promise.resolve(dispatch(dispatch(handleRedoAction(action, stages)))).then(() => {
- dispatch(setIsUndoRedoAction(false));
- });
- }
-};
-
-const handleUndoAction = (action, stages) => (dispatch, getState) => {
- const state = getState();
-
- if (action) {
- const majorView = stages.find(view => view.id === VIEWS.MAJOR_VIEW);
- // const summaryView = stages.find(view => view.id === VIEWS.SUMMARY_VIEW);
- // const stageSummaryView = summaryView.stage;
- const majorViewStage = majorView.stage;
-
- const type = action.type;
- switch (type) {
- case actionType.ALL_HIDE:
- dispatch(handleAllHideAction(action, true, majorViewStage));
- break;
- case actionType.ALL_TURNED_ON:
- dispatch(handleAllAction(action, false, majorViewStage, state));
- break;
- case actionType.ALL_TURNED_OFF:
- dispatch(handleAllAction(action, true, majorViewStage, state));
- break;
- case actionType.SELECTED_TURNED_ON_BY_TYPE:
- dispatch(handleAllActionByType(action, false, majorViewStage));
- break;
- case actionType.ALL_TURNED_OFF_BY_TYPE:
- dispatch(handleAllActionByType(action, true, majorViewStage));
- break;
- case actionType.LIGAND_TURNED_ON:
- dispatch(handleMoleculeAction(action, 'ligand', false, majorViewStage, state));
- break;
- case actionType.SIDECHAINS_TURNED_ON:
- dispatch(handleMoleculeAction(action, 'protein', false, majorViewStage, state));
- break;
- case actionType.INTERACTIONS_TURNED_ON:
- dispatch(handleMoleculeAction(action, 'complex', false, majorViewStage, state));
- break;
- case actionType.SURFACE_TURNED_ON:
- dispatch(handleMoleculeAction(action, 'surface', false, majorViewStage, state));
- break;
- case actionType.QUALITY_TURNED_ON:
- dispatch(handleMoleculeAction(action, 'quality', false, majorViewStage, state));
- break;
- case actionType.DENSITY_TURNED_ON:
- dispatch(handleDensityMoleculeAction(action, 'density', false, majorViewStage, state));
- break;
- case actionType.DENSITY_TYPE_ON:
- dispatch(handleDensityMoleculeAction(action, 'density', false, majorViewStage, state));
- break;
- case actionType.DENSITY_CUSTOM_TURNED_ON:
- dispatch(handleDensityMoleculeAction(action, 'densityCustom', false, majorViewStage, state));
- break;
- case actionType.VECTORS_TURNED_ON:
- dispatch(handleMoleculeAction(action, 'vector', false, majorViewStage, state));
- break;
- case actionType.LIGAND_TURNED_OFF:
- dispatch(handleMoleculeAction(action, 'ligand', true, majorViewStage, state));
- break;
- case actionType.SIDECHAINS_TURNED_OFF:
- dispatch(handleMoleculeAction(action, 'protein', true, majorViewStage, state));
- break;
- case actionType.INTERACTIONS_TURNED_OFF:
- dispatch(handleMoleculeAction(action, 'complex', true, majorViewStage, state));
- break;
- case actionType.SURFACE_TURNED_OFF:
- dispatch(handleMoleculeAction(action, 'surface', true, majorViewStage, state));
- break;
- case actionType.QUALITY_TURNED_OFF:
- dispatch(handleMoleculeAction(action, 'quality', true, majorViewStage, state));
- break;
- case actionType.DENSITY_TURNED_OFF:
- dispatch(handleDensityMoleculeAction(action, 'density', true, majorViewStage, state));
- break;
- case actionType.DENSITY_TYPE_OFF:
- dispatch(handleDensityMoleculeAction(action, 'density', true, majorViewStage, state));
- break;
- case actionType.VECTORS_TURNED_OFF:
- dispatch(handleMoleculeAction(action, 'vector', true, majorViewStage, state));
- break;
- case actionType.ARROW_NAVIGATION:
- dispatch(handleArrowNavigationAction(action, false, majorViewStage));
- break;
- case actionType.POSE_WINDOW_ACTION:
- dispatch(handlePoseWindowAction(action, true));
- break;
- case actionType.INSPIRATION_WINDOW_ACTION:
- dispatch(handleInspirationsWindowAction(action, true));
- break;
- case actionType.VECTOR_SELECTED:
- dispatch(handleVectorAction(action, false));
- break;
- case actionType.VECTOR_DESELECTED:
- dispatch(handleVectorAction(action, true));
- break;
- case actionType.VECTOR_COUMPOUND_ADDED:
- dispatch(handleVectorCompoundAction(action, false, majorViewStage));
- break;
- case actionType.VECTOR_COUMPOUND_REMOVED:
- dispatch(handleVectorCompoundAction(action, true, majorViewStage));
- break;
- case actionType.CLASS_SELECTED:
- dispatch(handleClassSelectedAction(action, false));
- break;
- case actionType.CLASS_UPDATED:
- dispatch(handleClassUpdatedAction(action, false));
- break;
- case actionType.COLOR_FILTER_TURNED_ON:
- dispatch(handleColorFilterAction(action, false));
- break;
- case actionType.COLOR_FILTER_TURNED_OFF:
- dispatch(handleColorFilterAction(action, true));
- break;
- case actionType.TARGET_LOADED:
- dispatch(handleTargetAction(action, false));
- break;
- case actionType.SITE_TURNED_ON:
- dispatch(handleMoleculeGroupAction(action, false));
- break;
- case actionType.SITE_TURNED_OFF:
- dispatch(handleMoleculeGroupAction(action, true));
- break;
- case actionType.TAG_SELECTED:
- dispatch(handleTagAction(action, false));
- break;
- case actionType.TAG_UNSELECTED:
- dispatch(handleTagAction(action, true));
- break;
- case actionType.MOLECULE_ADDED_TO_SHOPPING_CART:
- dispatch(handleShoppingCartAction(action, false));
- break;
- case actionType.MOLECULE_REMOVED_FROM_SHOPPING_CART:
- dispatch(handleShoppingCartAction(action, true));
- break;
- case actionType.MOLECULE_ADDED_TO_SHOPPING_CART_ALL:
- dispatch(handleShoppingCartAllAction(action, false, majorViewStage));
- break;
- case actionType.MOLECULE_REMOVED_FROM_SHOPPING_CART_ALL:
- dispatch(handleShoppingCartAllAction(action, true, majorViewStage));
- break;
- case actionType.COMPOUND_SELECTED:
- dispatch(handleCompoundAction(action, false));
- break;
- case actionType.COMPOUND_DESELECTED:
- dispatch(handleCompoundAction(action, true));
- break;
- case actionType.COMPOUND_LOCKED:
- dispatch(handleCompoundLockAction(action, false));
- break;
- case actionType.COMPOUND_UNLOCKED:
- dispatch(handleCompoundLockAction(action, true));
- break;
- case actionType.COMPOUND_ADDED_TO_COLOR_GROUP:
- dispatch(handleCompoundColorAction(action, false));
- break;
- case actionType.COMPOUND_REMOVED_FROM_COLOR_GROUP:
- dispatch(handleCompoundColorAction(action, true));
- break;
- case actionType.ALL_COMPOUNDS_ADDED_TO_COLOR_GROUP:
- dispatch(handlePaintAllCompoundsAction(action, false));
- break;
- case actionType.ALL_COMPOUNDS_REMOVED_FROM_COLOR_GROUP:
- dispatch(handlePaintAllCompoundsAction(action, true));
- break;
- case actionType.MOLECULE_SELECTED:
- dispatch(handleSelectMoleculeAction(action, false));
- break;
- case actionType.MOLECULE_UNSELECTED:
- dispatch(handleSelectMoleculeAction(action, true));
- break;
- case actionType.ALL_MOLECULES_SELECTED:
- dispatch(handleSelectAllMolecules(action, false));
- break;
- case actionType.ALL_MOLECULES_UNSELECTED:
- dispatch(handleSelectAllMolecules(action, true));
- break;
- case actionType.ALL_VISIBLE_HITS_SELECTED:
- dispatch(handleSelectAllVisibleHits(action, false));
- break;
- case actionType.ALL_VISIBLE_HITS_UNSELECTED:
- dispatch(handleSelectAllVisibleHits(action, true));
- break;
- case actionType.TAB:
- dispatch(handleTabAction(action, false));
- break;
- case actionType.DATASET_INDEX:
- dispatch(handleTabAction(action, false));
- break;
- case actionType.DATASET_FILTER:
- dispatch(handleFilterAction(action, false));
- break;
- case actionType.DATASET_FILTER_SCORE:
- dispatch(handleFilterScoreAction(action, false));
- break;
- case actionType.DRAG_DROP_FINISHED:
- dispatch(handleDragDropFinished(action, false));
- break;
- case actionType.REPRESENTATION_VISIBILITY_UPDATED:
- dispatch(handleUpdateRepresentationVisibilityAction(action, false, majorView));
- break;
- case actionType.REPRESENTATION_VISIBILITY_ALL_UPDATED:
- dispatch(handleUpdateRepresentationVisibilityAllAction(action, false, majorView));
- break;
- case actionType.REPRESENTATION_UPDATED:
- dispatch(handleUpdateRepresentationAction(action, false, majorView));
- break;
- case actionType.REPRESENTATION_ADDED:
- dispatch(handleRepresentationAction(action, false, majorView));
- break;
- case actionType.REPRESENTATION_REMOVED:
- dispatch(handleRepresentationAction(action, true, majorView));
- break;
- case actionType.REPRESENTATION_CHANGED:
- dispatch(handleChangeRepresentationAction(action, false, majorView));
- break;
- case actionType.BACKGROUND_COLOR_CHANGED:
- dispatch(setNglBckGrndColor(action.oldSetting, majorViewStage));
- break;
- case actionType.CLIP_NEAR:
- dispatch(setNglClipNear(action.oldSetting, action.newSetting, majorViewStage));
- break;
- case actionType.CLIP_FAR:
- dispatch(setNglClipFar(action.oldSetting, action.newSetting, majorViewStage));
- break;
- case actionType.CLIP_DIST:
- dispatch(setNglClipDist(action.oldSetting, action.newSetting, majorViewStage));
- break;
- case actionType.FOG_NEAR:
- dispatch(setNglFogNear(action.oldSetting, action.newSetting, majorViewStage));
- break;
- case actionType.FOG_FAR:
- dispatch(setNglFogFar(action.oldSetting, action.newSetting, majorViewStage));
- break;
- case actionType.ISO_LEVEL_EVENT:
- dispatch(setIsoLevel(MAP_TYPE.event, action.oldSetting, action.newSetting, majorViewStage));
- break;
- case actionType.BOX_SIZE_EVENT:
- dispatch(setBoxSize(MAP_TYPE.event, action.oldSetting, action.newSetting, majorViewStage));
- break;
- case actionType.OPACITY_EVENT:
- dispatch(setOpacity(MAP_TYPE.event, action.oldSetting, action.newSetting, majorViewStage));
- break;
- case actionType.CONTOUR_EVENT:
- dispatch(setContour(MAP_TYPE.event, action.oldSetting, action.newSetting, majorViewStage));
- break;
- case actionType.COLOR_EVENT:
- dispatch(setElectronDesityMapColor(MAP_TYPE.event, action.oldSetting, action.newSetting, majorViewStage));
- break;
- case actionType.ISO_LEVEL_SIGMAA:
- dispatch(setIsoLevel(MAP_TYPE.sigmaa, action.oldSetting, action.newSetting, majorViewStage));
- break;
- case actionType.BOX_SIZE_SIGMAA:
- dispatch(setBoxSize(MAP_TYPE.sigmaa, action.oldSetting, action.newSetting, majorViewStage));
- break;
- case actionType.OPACITY_SIGMAA:
- dispatch(setOpacity(MAP_TYPE.sigmaa, action.oldSetting, action.newSetting, majorViewStage));
- break;
- case actionType.CONTOUR_SIGMAA:
- dispatch(setContour(MAP_TYPE.sigmaa, action.oldSetting, action.newSetting, majorViewStage));
- break;
- case actionType.COLOR_SIGMAA:
- dispatch(setElectronDesityMapColor(MAP_TYPE.sigmaa, action.oldSetting, action.newSetting, majorViewStage));
- break;
- case actionType.ISO_LEVEL_DIFF:
- dispatch(setIsoLevel(MAP_TYPE.diff, action.oldSetting, action.newSetting, majorViewStage));
- break;
- case actionType.BOX_SIZE_DIFF:
- dispatch(setBoxSize(MAP_TYPE.diff, action.oldSetting, action.newSetting, majorViewStage));
- break;
- case actionType.OPACITY_DIFF:
- dispatch(setOpacity(MAP_TYPE.diff, action.oldSetting, action.newSetting, majorViewStage));
- break;
- case actionType.CONTOUR_DIFF:
- dispatch(setContour(MAP_TYPE.diff, action.oldSetting, action.newSetting, majorViewStage));
- break;
- case actionType.COLOR_DIFF:
- dispatch(setElectronDesityMapColor(MAP_TYPE.diff, action.oldSetting, action.newSetting, majorViewStage));
- break;
- case actionType.WARNING_ICON:
- dispatch(setWarningIcon(action.oldSetting, action.newSetting));
- break;
- case actionType.TURN_SIDE:
- dispatch(handleTurnSideAction(action, false));
- break;
- case actionType.SELECTED_SELECT_ALL_BUTTON_FOR_DATASET:
- dispatch(handleSelectAllDatasetCompounds(action, false));
- break;
- case actionType.SELECT_ALL_DATASET_COMPOUNDS:
- dispatch(handleUnselectedAllCompounds(action));
- break;
- default:
- break;
- }
- }
-};
-
-const handleRedoAction = (action, stages) => (dispatch, getState) => {
- const state = getState();
-
- if (action) {
- const majorView = stages.find(view => view.id === VIEWS.MAJOR_VIEW);
- // const summaryView = stages.find(view => view.id === VIEWS.SUMMARY_VIEW);
- // const stageSummaryView = summaryView.stage;
- const majorViewStage = majorView.stage;
-
- const type = action.type;
- switch (type) {
- case actionType.ALL_HIDE:
- dispatch(handleAllHideAction(action, false, majorViewStage));
- break;
- case actionType.ALL_TURNED_ON:
- dispatch(handleAllAction(action, true, majorViewStage, state));
- break;
- case actionType.ALL_TURNED_OFF:
- dispatch(handleAllAction(action, false, majorViewStage, state));
- break;
- case actionType.SELECTED_TURNED_ON_BY_TYPE:
- dispatch(handleAllActionByType(action, true, majorViewStage));
- break;
- case actionType.ALL_TURNED_OFF_BY_TYPE:
- dispatch(handleAllActionByType(action, false, majorViewStage));
- break;
- case actionType.LIGAND_TURNED_ON:
- dispatch(handleMoleculeAction(action, 'ligand', true, majorViewStage, state));
- break;
- case actionType.SIDECHAINS_TURNED_ON:
- dispatch(handleMoleculeAction(action, 'protein', true, majorViewStage, state));
- break;
- case actionType.INTERACTIONS_TURNED_ON:
- dispatch(handleMoleculeAction(action, 'complex', true, majorViewStage, state));
- break;
- case actionType.SURFACE_TURNED_ON:
- dispatch(handleMoleculeAction(action, 'surface', true, majorViewStage, state));
- break;
- case actionType.POSE_WINDOW_ACTION:
- dispatch(handlePoseWindowAction(action, false));
- break;
- case actionType.INSPIRATION_WINDOW_ACTION:
- dispatch(handleInspirationsWindowAction(action, false));
- break;
- case actionType.QUALITY_TURNED_ON:
- dispatch(handleMoleculeAction(action, 'quality', true, majorViewStage, state));
- break;
- case actionType.DENSITY_TURNED_ON:
- dispatch(handleDensityMoleculeAction(action, 'density', true, majorViewStage, state));
- break;
- case actionType.DENSITY_TYPE_ON:
- dispatch(handleDensityMoleculeAction(action, 'density', true, majorViewStage, state));
- break;
- case actionType.DENSITY_CUSTOM_TURNED_ON:
- dispatch(handleDensityMoleculeAction(action, 'densityCustom', true, majorViewStage, state));
- break;
- case actionType.VECTORS_TURNED_ON:
- dispatch(handleMoleculeAction(action, 'vector', true, majorViewStage, state));
- break;
- case actionType.LIGAND_TURNED_OFF:
- dispatch(handleMoleculeAction(action, 'ligand', false, majorViewStage, state));
- break;
- case actionType.SIDECHAINS_TURNED_OFF:
- dispatch(handleMoleculeAction(action, 'protein', false, majorViewStage, state));
- break;
- case actionType.INTERACTIONS_TURNED_OFF:
- dispatch(handleMoleculeAction(action, 'complex', false, majorViewStage, state));
- break;
- case actionType.SURFACE_TURNED_OFF:
- dispatch(handleMoleculeAction(action, 'surface', false, majorViewStage, state));
- break;
- case actionType.QUALITY_TURNED_OFF:
- dispatch(handleMoleculeAction(action, 'quality', false, majorViewStage, state));
- break;
- case actionType.DENSITY_TURNED_OFF:
- dispatch(handleDensityMoleculeAction(action, 'density', false, majorViewStage, state));
- break;
- case actionType.DENSITY_TYPE_OFF:
- dispatch(handleDensityMoleculeAction(action, 'density', false, majorViewStage, state));
- break;
- case actionType.VECTORS_TURNED_OFF:
- dispatch(handleMoleculeAction(action, 'vector', false, majorViewStage, state));
- break;
- case actionType.ARROW_NAVIGATION:
- dispatch(handleArrowNavigationAction(action, true, majorViewStage));
- break;
- case actionType.VECTOR_SELECTED:
- dispatch(handleVectorAction(action, true));
- break;
- case actionType.VECTOR_DESELECTED:
- dispatch(handleVectorAction(action, false));
- break;
- case actionType.VECTOR_COUMPOUND_ADDED:
- dispatch(handleVectorCompoundAction(action, true, majorViewStage));
- break;
- case actionType.VECTOR_COUMPOUND_REMOVED:
- dispatch(handleVectorCompoundAction(action, false, majorViewStage));
- break;
- case actionType.CLASS_SELECTED:
- dispatch(handleClassSelectedAction(action, true));
- break;
- case actionType.CLASS_UPDATED:
- dispatch(handleClassUpdatedAction(action, true));
- break;
- case actionType.COLOR_FILTER_TURNED_ON:
- dispatch(handleColorFilterAction(action, true));
- break;
- case actionType.COLOR_FILTER_TURNED_OFF:
- dispatch(handleColorFilterAction(action, false));
- break;
- case actionType.TARGET_LOADED:
- dispatch(handleTargetAction(action, true));
- break;
- case actionType.SITE_TURNED_ON:
- dispatch(handleMoleculeGroupAction(action, true));
- break;
- case actionType.SITE_TURNED_OFF:
- dispatch(handleMoleculeGroupAction(action, false));
- break;
- case actionType.TAG_SELECTED:
- dispatch(handleTagAction(action, true));
- break;
- case actionType.TAG_UNSELECTED:
- dispatch(handleTagAction(action, false));
- break;
- case actionType.MOLECULE_ADDED_TO_SHOPPING_CART:
- dispatch(handleShoppingCartAction(action, true));
- break;
- case actionType.MOLECULE_REMOVED_FROM_SHOPPING_CART:
- dispatch(handleShoppingCartAction(action, false));
- break;
- case actionType.MOLECULE_ADDED_TO_SHOPPING_CART_ALL:
- dispatch(handleShoppingCartAllAction(action, true, majorViewStage));
- break;
- case actionType.MOLECULE_REMOVED_FROM_SHOPPING_CART_ALL:
- dispatch(handleShoppingCartAllAction(action, false, majorViewStage));
- break;
- case actionType.COMPOUND_SELECTED:
- dispatch(handleCompoundAction(action, true));
- break;
- case actionType.COMPOUND_DESELECTED:
- dispatch(handleCompoundAction(action, false));
- break;
- case actionType.COMPOUND_LOCKED:
- dispatch(handleCompoundLockAction(action, true));
- break;
- case actionType.COMPOUND_UNLOCKED:
- dispatch(handleCompoundLockAction(action, false));
- break;
- case actionType.COMPOUND_ADDED_TO_COLOR_GROUP:
- dispatch(handleCompoundColorAction(action, true));
- break;
- case actionType.COMPOUND_REMOVED_FROM_COLOR_GROUP:
- dispatch(handleCompoundColorAction(action, false));
- break;
- case actionType.ALL_COMPOUNDS_ADDED_TO_COLOR_GROUP:
- dispatch(handlePaintAllCompoundsAction(action, true));
- break;
- case actionType.ALL_COMPOUNDS_REMOVED_FROM_COLOR_GROUP:
- dispatch(handlePaintAllCompoundsAction(action, false));
- break;
- case actionType.MOLECULE_SELECTED:
- dispatch(handleSelectMoleculeAction(action, true));
- break;
- case actionType.MOLECULE_UNSELECTED:
- dispatch(handleSelectMoleculeAction(action, false));
- break;
- case actionType.ALL_MOLECULES_SELECTED:
- dispatch(handleSelectAllMolecules(action, true));
- break;
- case actionType.ALL_MOLECULES_UNSELECTED:
- dispatch(handleSelectAllMolecules(action, false));
- break;
- case actionType.ALL_VISIBLE_HITS_SELECTED:
- dispatch(handleSelectAllVisibleHits(action, true));
- break;
- case actionType.ALL_VISIBLE_HITS_UNSELECTED:
- dispatch(handleSelectAllVisibleHits(action, false));
- break;
- case actionType.TAB:
- dispatch(handleTabAction(action, true));
- break;
- case actionType.DATASET_INDEX:
- dispatch(handleTabAction(action, true));
- break;
- case actionType.DATASET_FILTER:
- dispatch(handleFilterAction(action, true));
- break;
- case actionType.DATASET_FILTER_SCORE:
- dispatch(handleFilterScoreAction(action, true));
- break;
- case actionType.DRAG_DROP_FINISHED:
- dispatch(handleDragDropFinished(action, true));
- break;
- case actionType.REPRESENTATION_VISIBILITY_UPDATED:
- dispatch(handleUpdateRepresentationVisibilityAction(action, true, majorView));
- break;
- case actionType.REPRESENTATION_VISIBILITY_ALL_UPDATED:
- dispatch(handleUpdateRepresentationVisibilityAllAction(action, true, majorView));
- break;
- case actionType.REPRESENTATION_UPDATED:
- dispatch(handleUpdateRepresentationAction(action, true, majorView));
- break;
- case actionType.REPRESENTATION_ADDED:
- dispatch(handleRepresentationAction(action, true, majorView));
- break;
- case actionType.REPRESENTATION_REMOVED:
- dispatch(handleRepresentationAction(action, false, majorView));
- break;
- case actionType.REPRESENTATION_CHANGED:
- dispatch(handleChangeRepresentationAction(action, true, majorView));
- break;
- case actionType.BACKGROUND_COLOR_CHANGED:
- dispatch(setNglBckGrndColor(action.newSetting, majorViewStage));
- break;
- case actionType.CLIP_NEAR:
- dispatch(setNglClipNear(action.newSetting, action.oldSetting, majorViewStage));
- break;
- case actionType.CLIP_FAR:
- dispatch(setNglClipFar(action.newSetting, action.oldSetting, majorViewStage));
- break;
- case actionType.CLIP_DIST:
- dispatch(setNglClipDist(action.newSetting, action.oldSetting, majorViewStage));
- break;
- case actionType.FOG_NEAR:
- dispatch(setNglFogNear(action.newSetting, action.oldSetting, majorViewStage));
- break;
- case actionType.FOG_FAR:
- dispatch(setNglFogFar(action.newSetting, action.oldSetting, majorViewStage));
- break;
- case actionType.ISO_LEVEL_EVENT:
- dispatch(setIsoLevel(MAP_TYPE.event, action.newSetting, action.oldSetting, majorViewStage));
- break;
- case actionType.BOX_SIZE_EVENT:
- dispatch(setBoxSize(MAP_TYPE.event, action.newSetting, action.oldSetting, majorViewStage));
- break;
- case actionType.OPACITY_EVENT:
- dispatch(setOpacity(MAP_TYPE.event, action.newSetting, action.oldSetting, majorViewStage));
- break;
- case actionType.CONTOUR_EVENT:
- dispatch(setContour(MAP_TYPE.event, action.newSetting, action.oldSetting, majorViewStage));
- break;
- case actionType.COLOR_EVENT:
- dispatch(setElectronDesityMapColor(MAP_TYPE.event, action.newSetting, action.oldSetting, majorViewStage));
- break;
- case actionType.ISO_LEVEL_SIGMAA:
- dispatch(setIsoLevel(MAP_TYPE.sigmaa, action.newSetting, action.oldSetting, majorViewStage));
- break;
- case actionType.BOX_SIZE_SIGMAA:
- dispatch(setBoxSize(MAP_TYPE.sigmaa, action.newSetting, action.oldSetting, majorViewStage));
- break;
- case actionType.OPACITY_SIGMAA:
- dispatch(setOpacity(MAP_TYPE.sigmaa, action.newSetting, action.oldSetting, majorViewStage));
- break;
- case actionType.CONTOUR_SIGMAA:
- dispatch(setContour(MAP_TYPE.sigmaa, action.newSetting, action.oldSetting, majorViewStage));
- break;
- case actionType.COLOR_SIGMAA:
- dispatch(setElectronDesityMapColor(MAP_TYPE.sigmaa, action.newSetting, action.oldSetting, majorViewStage));
- break;
- case actionType.ISO_LEVEL_DIFF:
- dispatch(setIsoLevel(MAP_TYPE.diff, action.newSetting, action.oldSetting, majorViewStage));
- break;
- case actionType.BOX_SIZE_DIFF:
- dispatch(setBoxSize(MAP_TYPE.diff, action.newSetting, action.oldSetting, majorViewStage));
- break;
- case actionType.OPACITY_DIFF:
- dispatch(setOpacity(MAP_TYPE.diff, action.newSetting, action.oldSetting, majorViewStage));
- break;
- case actionType.CONTOUR_DIFF:
- dispatch(setContour(MAP_TYPE.diff, action.newSetting, action.oldSetting, majorViewStage));
- break;
- case actionType.COLOR_DIFF:
- dispatch(setElectronDesityMapColor(MAP_TYPE.diff, action.newSetting, action.oldSetting, majorViewStage));
- break;
- case actionType.WARNING_ICON:
- dispatch(setWarningIcon(action.newSetting, action.oldSetting));
- break;
- case actionType.TURN_SIDE:
- dispatch(handleTurnSideAction(action, true));
- break;
- case actionType.SELECTED_SELECT_ALL_BUTTON_FOR_DATASET:
- dispatch(handleSelectAllDatasetCompounds(action, true));
- break;
- case actionType.SELECT_ALL_DATASET_COMPOUNDS:
- dispatch(handleSelectedAllCompounds(action));
- break;
- default:
- break;
- }
- }
-};
-
-const handleAllActionByType = (action, isAdd, stage) => (dispatch, getState) => {
- let actionItems = action.items;
- let type = action.control_type;
- if (action.object_type === actionObjectType.MOLECULE || action.object_type === actionObjectType.INSPIRATION) {
- if (isAdd) {
- dispatch(setSelectedAllByType(type, actionItems, action.object_type === actionObjectType.INSPIRATION));
-
- actionItems.forEach(data => {
- if (data) {
- if (type === 'ligand') {
- dispatch(addType[type](stage, data, colourList[data.id % colourList.length], true, true, true));
- } else if (type === 'vector') {
- dispatch(addType[type](stage, data, true));
- } else if (type === 'density' || type === 'densityCustom') {
- dispatch(addType[type](stage, data, colourList[data.id % colourList.length], false, true));
- } else {
- dispatch(addType[type](stage, data, colourList[data.id % colourList.length], true));
- }
- }
- });
- } else {
- dispatch(setDeselectedAllByType(type, actionItems, action.object_type === actionObjectType.INSPIRATION));
-
- actionItems.forEach(data => {
- if (data) {
- if (type === 'ligand' || type === 'vector') {
- dispatch(removeType[type](stage, data, true));
- } else {
- dispatch(removeType[type](stage, data, colourList[data.id % colourList.length], true));
- }
- }
- });
- }
- } else if (
- action.object_type === actionObjectType.COMPOUND ||
- action.object_type === actionObjectType.CROSS_REFERENCE
- ) {
- if (isAdd) {
- dispatch(
- setSelectedAllByTypeOfDataset(
- type,
- action.dataset_id,
- actionItems,
- action.object_type === actionObjectType.CROSS_REFERENCE
- )
- );
-
- actionItems.forEach(data => {
- if (data && data.molecule) {
- dispatch(
- addTypeCompound[type](
- stage,
- data.molecule,
- colourList[data.molecule.id % colourList.length],
- data.datasetID,
- true
- )
- );
- }
- });
- } else {
- dispatch(
- setDeselectedAllByTypeOfDataset(
- type,
- action.dataset_id,
- actionItems,
- action.object_type === actionObjectType.CROSS_REFERENCE
- )
- );
-
- actionItems.forEach(data => {
- if (data && data.molecule) {
- dispatch(
- removeTypeCompound[type](
- stage,
- data.molecule,
- colourList[data.molecule.id % colourList.length],
- data.datasetID,
- true
- )
- );
- }
- });
- }
- }
-};
-
-const handleAllHideAction = (action, isAdd, stage) => (dispatch, getState) => {
- let data = action.data;
- let ligandDataList = data.ligandList;
- let proteinDataList = data.proteinList;
- let complexDataList = data.complexList;
- let surfaceDataList = data.surfaceList;
- let vectorOnDataList = data.vectorOnList;
-
- dispatch(setHideAll(data, !isAdd));
-
- if (isAdd) {
- ligandDataList.forEach(data => {
- if (data) {
- dispatch(addType['ligand'](stage, data, colourList[data.id % colourList.length], true, true, true));
- }
- });
-
- proteinDataList.forEach(data => {
- if (data) {
- dispatch(addType['protein'](stage, data, colourList[data.id % colourList.length], true));
- }
- });
-
- complexDataList.forEach(data => {
- if (data) {
- dispatch(addType['complex'](stage, data, colourList[data.id % colourList.length], true));
- }
- });
-
- surfaceDataList.forEach(data => {
- if (data) {
- dispatch(addType['surface'](stage, data, colourList[data.id % colourList.length], true));
- }
- });
- vectorOnDataList.forEach(data => {
- if (data) {
- dispatch(addType['vector'](stage, data, true));
- }
- });
- } else {
- ligandDataList.forEach(data => {
- if (data) {
- dispatch(removeType['ligand'](stage, data, true));
- }
- });
-
- proteinDataList.forEach(data => {
- if (data) {
- dispatch(removeType['protein'](stage, data, colourList[data.id % colourList.length], true));
- }
- });
-
- complexDataList.forEach(data => {
- if (data) {
- dispatch(removeType['complex'](stage, data, colourList[data.id % colourList.length], true));
- }
- });
-
- surfaceDataList.forEach(data => {
- if (data) {
- dispatch(removeType['surface'](stage, data, colourList[data.id % colourList.length], true));
- }
- });
- vectorOnDataList.forEach(data => {
- if (data) {
- dispatch(removeType['vector'](stage, data, true));
- }
- });
- }
-};
-
-const handleAllAction = (action, isSelected, majorViewStage, state) => (dispatch, getState) => {
- let isSelection =
- action.object_type === actionObjectType.MOLECULE || action.object_type === actionObjectType.INSPIRATION;
-
- if (isSelected) {
- if (isSelection) {
- dispatch(setSelectedAll(action.item, true, true, true));
- } else {
- dispatch(setSelectedAllOfDataset(action.dataset_id, action.item, true, true, true));
- }
- } else {
- if (isSelection) {
- dispatch(setDeselectedAll(action.item, action.isLigand, action.isProtein, action.isComplex));
- } else {
- dispatch(
- setDeselectedAllOfDataset(action.dataset_id, action.item, action.isLigand, action.isProtein, action.isComplex)
- );
- }
- }
-
- if (action.isLigand) {
- dispatch(handleMoleculeAction(action, 'ligand', isSelected, majorViewStage, state, true));
- }
-
- if (action.isProtein) {
- dispatch(handleMoleculeAction(action, 'protein', isSelected, majorViewStage, state, true));
- }
-
- if (action.isComplex) {
- dispatch(handleMoleculeAction(action, 'complex', isSelected, majorViewStage, state, true));
- }
-};
-
-const handleVectorAction = (action, isSelected) => (dispatch, getState) => {
- if (action) {
- if (isSelected === false) {
- dispatch(selectVectorAndResetCompounds(undefined));
- } else {
- dispatch(selectVectorAndResetCompounds(action.object_name));
- }
- }
-};
-
-const handleVectorCompoundAction = (action, isSelected, majorViewStage) => (dispatch, getState) => {
- if (action) {
- let data = action.item;
- dispatch(handleShowVectorCompound({ isSelected, data, majorViewStage: majorViewStage }));
- }
-};
-
-const handleClassSelectedAction = (action, isAdd) => (dispatch, getState) => {
- if (action) {
- let value = isAdd ? action.value : action.oldValue;
- let oldValue = isAdd ? action.oldValue : action.value;
- dispatch(setCurrentCompoundClass(value, oldValue));
- }
-};
-
-const handleClassUpdatedAction = (action, isAdd) => (dispatch, getState) => {
- if (action) {
- let id = action.object_id;
- let newValue = isAdd ? action.newCompoundClasses : action.oldCompoundClasses;
- let oldValue = isAdd ? action.oldCompoundClasses : action.newCompoundClasses;
- let value = isAdd ? action.object_name : action.oldCompoundClasses[id];
- value = value !== undefined ? value : '';
- dispatch(setCompoundClasses(newValue, oldValue, value, id));
- }
-};
-
-const handleColorFilterAction = (action, isSelected) => (dispatch, getState) => {
- if (action) {
- const color = action.value;
- if (isSelected) {
- dispatch(appendColorToSelectedColorFilter(color));
- } else {
- dispatch(removeColorFromSelectedColorFilter(color));
- }
- }
-};
-
-const handleTargetAction = (action, isSelected, stages) => (dispatch, getState) => {
- const state = getState();
- if (action) {
- if (isSelected === false) {
- dispatch(setTargetOn(undefined));
- } else {
- let target = getTarget(action.object_name, state);
- if (target) {
- dispatch(setTargetOn(target.id));
- dispatch(shouldLoadProtein({ nglViewList: stages, currentSnapshotID: null, isLoadingCurrentSnapshot: false }));
- }
- }
- }
-};
-
-const handleTabAction = (action, isSelected) => (dispatch, getState) => {
- if (action) {
- let newValue = isSelected === true ? action.object_id : action.oldObjectId;
- let oldValue = isSelected === true ? action.oldObjectId : action.object_id;
- let name = isSelected === true ? action.object_name : action.oldObjectName;
- let oldName = isSelected === true ? action.oldObjectName : action.object_name;
-
- if (action.type === actionType.DATASET_INDEX) {
- dispatch(setSelectedDatasetIndex(oldValue, newValue, name, oldName));
- } else {
- dispatch(setSortDialogOpen(false));
- dispatch(setTabValue(oldValue, newValue, name, oldName));
- }
- }
-};
-
-const handleFilterAction = (action, isSelected) => (dispatch, getState) => {
- if (action) {
- const {
- datasetID,
- key,
- newProperties,
- oldProperties,
- newSettings,
- oldSettings,
- oldDragDropState,
- newDragDropState
- } = action;
- const newFilterProperties = isSelected ? newProperties : oldProperties;
- const newFilterSettings = isSelected ? newSettings : oldSettings;
- const newFilterDragDropState = isSelected ? newDragDropState : oldDragDropState;
- dispatch(setDatasetFilter(datasetID, newFilterProperties, newFilterSettings, key, newFilterDragDropState));
- dispatch(setFilterProperties(datasetID, newFilterProperties));
- dispatch(setFilterSettings(datasetID, newFilterSettings));
- dispatch(setDragDropState(datasetID, newFilterDragDropState));
- }
-};
-
-const handleFilterScoreAction = (action, isSelected) => (dispatch, getState) => {
- if (action) {
- let datasetID = action.dataset_id;
- let isChecked = isSelected === true ? action.isChecked : !action.isChecked;
- let scoreName = action.object_name;
- dispatch(selectScoreProperty({ isChecked, datasetID, scoreName }));
- }
-};
-
-const handleDragDropFinished = (action, isSelected) => dispatch => {
- if (action) {
- const { oldDragDropState, newDragDropState, datasetID } = action;
- dispatch(setDragDropState(datasetID, isSelected ? newDragDropState : oldDragDropState));
- }
-};
-
-const handleCompoundAction = (action, isSelected) => (dispatch, getState) => {
- const state = getState();
- if (action) {
- let data = getCompound(action, state);
- if (data) {
- if (isSelected === true) {
- dispatch(appendMoleculeToCompoundsOfDatasetToBuy(action.dataset_id, data.id, data.name));
- } else {
- dispatch(removeMoleculeFromCompoundsOfDatasetToBuy(action.dataset_id, data.id, data.name));
- }
- }
- }
-};
-
-const handleCompoundLockAction = (action, isLocked) => (dispatch, getState) => {
- const state = getState();
- if (action) {
- let data = getCompound(action, state);
- if (data) {
- if (isLocked) {
- dispatch(appendCompoundToSelectedCompoundsByDataset(action.dataset_id, data.id, data.name));
- } else {
- dispatch(removeCompoundFromSelectedCompoundsByDataset(action.dataset_id, data.id, data.name));
- }
- }
- }
-};
-
-const handleCompoundColorAction = (action, isAdded) => (dispatch, getState) => {
- const state = getState();
- if (action) {
- let data = getCompound(action, state);
- if (data) {
- if (isAdded) {
- dispatch(appendCompoundColorOfDataset(action.dataset_id, data.id, action.color_class, data.name));
- } else {
- dispatch(removeCompoundColorOfDataset(action.dataset_id, data.id, action.color_class, data.name));
- }
- }
- }
-};
-
-const handlePaintAllCompoundsAction = (action, arePainted) => (dispatch, getState) => {
- const state = getState();
- if (action?.items) {
- action.items.forEach(cmpId => {
- const cmp = getCompoundById(cmpId, action?.dataset_id, state);
- if (cmp) {
- if (arePainted) {
- dispatch(appendCompoundColorOfDataset(action?.dataset_id, cmpId, action?.color, cmp.name, true));
- } else {
- dispatch(removeCompoundColorOfDataset(action?.dataset_id, cmpId, action?.color, cmp.name, true));
- }
- }
- });
- }
-};
-
-const handleSelectMoleculeAction = (action, isSelected) => (dispatch, getState) => {
- if (action) {
- dispatch(handleSelectMoleculeByName(action.object_name));
- }
-};
-
-const handleSelectMoleculeByName = (molName, isSelected) => (dispatch, getState) => {
- const state = getState();
- if (molName) {
- let mol = getMolecule(molName, state);
- if (mol) {
- if (isSelected) {
- dispatch(appendToMolListToEdit(mol.id));
- } else {
- dispatch(removeFromMolListToEdit(mol.id));
- }
- }
- }
-};
-
-const handleSelectAllMolecules = (action, isSelected) => (dispatch, getState) => {
- if (action && action.items) {
- dispatch(selectAllHits(action.items, setNextXMolecules, !isSelected));
- }
-};
-
-const handleSelectAllVisibleHits = (action, isSelected) => (dispatch, getState) => {
- if (action && action.items) {
- dispatch(selectAllVisibleObservations(action.items, setNextXMolecules, !isSelected));
- }
-};
-
-const handleSelectAllDatasetCompounds = (action, isSelected) => (dispatch, getState) => {
- if (action.selectAllButton) {
- dispatch(setSelectAllButtonForDataset(isSelected));
- }
-};
-
-const handleSelectedAllCompounds = action => (dispatch, getState) => {
- if (action) {
- dispatch(setCompoundToSelectedCompoundsByDataset(action.dataset_id.datasetID, action.dataset_id.selectedCompounds));
- }
-};
-
-const handleUnselectedAllCompounds = action => (dispatch, getState) => {
- if (action) {
- dispatch(setCompoundToSelectedCompoundsByDataset(action.dataset_id.datasetID, []));
- }
-};
-
-const handleShoppingCartAction = (action, isAdd) => (dispatch, getState) => {
- if (action) {
- let data = action.item;
- if (data) {
- dispatch(handleBuyList({ isSelected: isAdd, data, skipTracking: false }));
- }
- }
-};
-
-const handleShoppingCartAllAction = (action, isAdd, majorViewStage) => (dispatch, getState) => {
- if (action) {
- dispatch(handleBuyListAll({ isSelected: isAdd, items: action.items, majorViewStage: majorViewStage }));
- }
-};
-
-const handleRepresentationAction = (action, isAdd, nglView) => (dispatch, getState) => {
- if (action) {
- if (isAdd === true) {
- dispatch(addRepresentation(action, action.object_id, action.representation, nglView));
- } else {
- dispatch(removeRepresentation(action, action.object_id, action.representation, nglView));
- }
- }
-};
-
-const handleTurnSideAction = (action, restore) => dispatch => {
- if (action) {
- const { side, open } = action;
- dispatch(turnSide(side, restore ? open : !open, true));
- }
-};
-
-const addRepresentation = (action, parentKey, representation, nglView, update, skipTracking = false) => (
- dispatch,
- getState
-) => {
- const oldRepresentation = representation;
- const newRepresentationType = oldRepresentation.type;
- const comp = nglView.stage.getComponentsByName(parentKey).first;
- const newRepresentation = assignRepresentationToComp(
- newRepresentationType,
- oldRepresentation.params,
- comp,
- oldRepresentation.lastKnownID
- );
- action.representation = newRepresentation;
- if (update === true) {
- action.newRepresentation = newRepresentation;
- } else {
- action.oldRepresentation = newRepresentation;
- }
- dispatch(addComponentRepresentation(parentKey, newRepresentation, skipTracking));
-};
-
-const removeRepresentation = (action, parentKey, representation, nglView, skipTracking = false) => (
- dispatch,
- getState
-) => {
- const comp = nglView.stage.getComponentsByName(parentKey).first;
- let foundRepresentation = undefined;
- comp.eachRepresentation(r => {
- if (
- r.uuid === representation.uuid ||
- r.uuid === representation.lastKnownID ||
- r.repr.type === representation.type
- ) {
- foundRepresentation = r;
- }
- });
-
- if (foundRepresentation) {
- comp.removeRepresentation(foundRepresentation);
-
- if (comp.reprList.length === 0) {
- dispatch(deleteObject(nglView, nglView.stage, true));
- } else {
- hideShapeRepresentations(foundRepresentation, nglView, parentKey);
- dispatch(removeComponentRepresentation(parentKey, foundRepresentation, skipTracking));
- }
- } else {
- console.log(`Not found representation:`, representation);
- }
-};
-
-const changeMolecularRepresentationForSnapshotRestoration = (action, nglView) => (dispatch, getState) => {
- // this is not needed probably
- const comp = nglView.stage.getComponentsByName(action.object_id).first;
-
- // add representation to NGL
- const newRepresentation = assignRepresentationToComp(
- action.newRepresentation.type,
- action.newRepresentation.params,
- comp,
- action.newRepresentation.lastKnownID
- );
-
- // remove previous representation from NGL
- dispatch(removeRepresentationForSnapshotRestoration(action.oldRepresentation, action.object_id, nglView));
-
- // add new representation to redux
- dispatch(addComponentRepresentation(action.object_id, newRepresentation, true));
-
- dispatch(changeComponentRepresentation(action.object_id, action.oldRepresentation, newRepresentation));
-};
-
-const removeRepresentationForSnapshotRestoration = (representation, parentKey, nglView) => (dispatch, getState) => {
- // find in redux
- const objectsInView = getState().nglReducers.objectsInView;
- // added representations have a new uuid so it is different than preserved lastKnownID in representation
- // so compare all possibilities to fetch possible match saved in redux
- let representationToRemove = undefined;
- for (const [objectId, object] of Object.entries(objectsInView)) {
- for (const r of object.representations) {
- if (
- r.uuid === representation.uuid ||
- r.uuid === representation.lastKnownID ||
- r.lastKnownID === representation.uuid ||
- r.lastKnownID === representation.lastKnownID
- ) {
- representationToRemove = r;
- break;
- }
- }
- }
- // find in nglView
- const comp = nglView.stage.getComponentsByName(parentKey).first;
- let foundRepresentation = undefined;
- comp.eachRepresentation(r => {
- if (
- r.uuid === representation.uuid ||
- r.uuid === representation.lastKnownID ||
- (representationToRemove &&
- (r.uuid === representationToRemove.uuid || r.uuid === representationToRemove.lastKnownID))
- ) {
- foundRepresentation = r;
- }
- });
- if (foundRepresentation) {
- // update in nglView
- comp.removeRepresentation(foundRepresentation);
- // update in redux
- const targetObject = objectsInView[parentKey];
- if (comp.reprList.length === 0) {
- // remove from nglReducer and selectionReducer
- dispatch(deleteObject(targetObject, nglView.stage, true));
- } else {
- hideShapeRepresentations(foundRepresentation, nglView, parentKey);
- if (representationToRemove) {
- // this could freeze the app if "wrong" representation is passed, what is wrong tho
- dispatch(removeComponentRepresentation(parentKey, representationToRemove, true));
- }
- }
- } else {
- console.log('Not found representation:', representation);
- }
-};
-
-const handleUpdateRepresentationVisibilityAction = (action, isAdd, nglView) => (dispatch, getState) => {
- if (action) {
- let parentKey = action.object_id;
- let representation = action.representation;
- let representationElement = null;
-
- const comp = nglView.stage.getComponentsByName(parentKey).first;
- comp.eachRepresentation(r => {
- if (r.uuid === representation.uuid || r.uuid === representation.lastKnownID) {
- representationElement = r;
- const newVisibility = isAdd ? action.value : !action.value;
- // update in redux
- representation.params.visible = newVisibility;
- dispatch(updateComponentRepresentation(parentKey, representation.uuid, representation, '', true));
- dispatch(
- updateComponentRepresentationVisibility(parentKey, representation.uuid, representation, newVisibility)
- );
- // update in nglView
- r.setVisibility(newVisibility);
- }
- });
-
- hideShapeRepresentations(representationElement, nglView, parentKey);
- }
-};
-
-const handleUpdateRepresentationVisibilityAllAction = (action, isAdd, nglView) => (dispatch, getState) => {
- if (action) {
- const state = getState();
- let parentKey = action.object_id;
- let objectsInView = state.nglReducers.objectsInView;
- let newVisibility = isAdd ? action.value : !action.value;
-
- const representations = (objectsInView[parentKey] && objectsInView[parentKey].representations) || [];
- const comp = nglView.stage.getComponentsByName(parentKey).first;
-
- if (representations) {
- representations.forEach((representation, index) => {
- let representationElement = null;
- comp.eachRepresentation(r => {
- if (r.uuid === representation.uuid || r.uuid === representation.lastKnownID) {
- representationElement = r;
- representation.params.visible = newVisibility;
- // update in nglView
- r.setVisibility(newVisibility);
- // update in redux
- dispatch(updateComponentRepresentation(parentKey, representation.uuid, representation, '', true));
- }
- });
- hideShapeRepresentations(representationElement, nglView, parentKey);
- });
-
- dispatch(updateComponentRepresentationVisibilityAll(parentKey, newVisibility));
- }
- }
-};
-
-const handleUpdateRepresentationAction = (action, isAdd, nglView) => (dispatch, getState) => {
- if (action) {
- dispatch(updateRepresentation(isAdd, action.change, action.object_id, action.representation, nglView));
- }
-};
-
-const updateRepresentation = (isAdd, change, parentKey, representation, nglView) => (dispatch, getState) => {
- const comp = nglView.stage.getComponentsByName(parentKey).first;
- const r = comp.reprList.find(rep => rep.uuid === representation.uuid || rep.uuid === representation.lastKnownID);
- if (r && change) {
- let key = change.key;
- let value = isAdd ? change.value : change.oldValue;
-
- r.setParameters({ [key]: value });
- representation.params[key] = value;
-
- dispatch(updateComponentRepresentation(parentKey, representation.uuid, representation));
- }
-};
-
-const handleChangeRepresentationAction = (action, isAdd, nglView) => (dispatch, getState) => {
- if (action) {
- let representation = action.newRepresentation;
- let type = action.oldRepresentation.type;
- dispatch(changeMolecularRepresentation(action, representation, type, action.object_id, nglView));
- }
-};
-
-const changeMolecularRepresentation = (action, representation, type, parentKey, nglView) => (dispatch, getState) => {
- const newRepresentationType = type;
-
- const oldRepresentation = JSON.parse(JSON.stringify(representation));
- const comp = nglView.stage.getComponentsByName(parentKey).first;
-
- // add representation to NGL
- const newRepresentation = assignRepresentationToComp(
- newRepresentationType,
- oldRepresentation.params,
- comp,
- oldRepresentation.lastKnownID
- );
-
- action.newRepresentation = newRepresentation;
- action.oldRepresentation = representation;
-
- // add new representation to redux
- dispatch(addComponentRepresentation(parentKey, newRepresentation, true));
-
- // remove previous representation from NGL
- dispatch(removeRepresentation(action, parentKey, representation, nglView, true));
-
- dispatch(changeComponentRepresentation(parentKey, oldRepresentation, newRepresentation));
-};
-
-const handleArrowNavigationAction = (action, isSelected, majorViewStage) => (dispatch, getState) => {
- if (action) {
- let isSelection =
- action.object_type === actionObjectType.MOLECULE || action.object_type === actionObjectType.INSPIRATION;
-
- if (isSelection === true) {
- dispatch(handleArrowNavigationActionOfMolecule(action, isSelected, majorViewStage));
- } else {
- dispatch(handleArrowNavigationActionOfCompound(action, isSelected, majorViewStage));
- }
- }
-};
-
-const handleArrowNavigationActionOfMolecule = (action, isSelected, majorViewStage) => (dispatch, getState) => {
- const state = getState();
- if (action) {
- let molecules = state.apiReducers.all_mol_lists;
- let item = isSelected === true ? action.item : action.newItem;
- let newItem = isSelected === true ? action.newItem : action.item;
- let isInspiration = newItem && newItem.isInspiration;
- let data = action.data;
-
- dispatch(removeSelectedMolTypes(majorViewStage, molecules, true, isInspiration));
- dispatch(moveSelectedMolSettings(majorViewStage, item, newItem, data, true));
- dispatch(setArrowUpDown(item, newItem, action.arrowType, data));
- }
-};
-
-const handleArrowNavigationActionOfCompound = (action, isSelected, majorViewStage) => (dispatch, getState) => {
- const state = getState();
- if (action) {
- const molecules = state.apiReducers.all_mol_lists;
- const allInspirations = state.datasetsReducers.allInspirations;
-
- let data = action.data;
- let item = isSelected === true ? action.item : action.newItem;
- let newItem = isSelected === true ? action.newItem : action.item;
- let datasetID = action.datasetID;
-
- const proteinListMolecule = data.proteinList;
- const complexListMolecule = data.complexList;
- const fragmentDisplayListMolecule = data.fragmentDisplayList;
- const surfaceListMolecule = data.surfaceList;
- const densityListMolecule = data.densityList;
- const densityListCustomMolecule = data.densityListCustom;
- const vectorOnListMolecule = data.vectorOnList;
- const qualityListMolecule = data.qualityList;
-
- dispatch(hideAllSelectedMolecules(majorViewStage, molecules, false, true));
- dispatch(removeSelectedDatasetMolecules(majorViewStage, true, newItem));
-
- const newDatasetID = (newItem.hasOwnProperty('datasetID') && newItem.datasetID) || datasetID;
- const moleculeTitlePrev = newItem && newItem.name;
-
- const inspirations = getInspirationsForMol(allInspirations, datasetID, newItem.id);
- dispatch(setInspirationMoleculeDataList(inspirations));
- dispatch(moveSelectedMoleculeSettings(majorViewStage, item, newItem, newDatasetID, datasetID, data, true));
-
- if (isSelected === true) {
- dispatch(
- moveMoleculeInspirationsSettings(
- item,
- newItem,
- majorViewStage,
- data.objectsInView,
- fragmentDisplayListMolecule,
- proteinListMolecule,
- complexListMolecule,
- surfaceListMolecule,
- densityListMolecule,
- densityListCustomMolecule,
- vectorOnListMolecule,
- qualityListMolecule,
- true
- )
- );
- } else {
- dispatch(
- moveSelectedInspirations(
- majorViewStage,
- data.objectsInView,
- fragmentDisplayListMolecule,
- proteinListMolecule,
- complexListMolecule,
- surfaceListMolecule,
- densityListMolecule,
- densityListCustomMolecule,
- vectorOnListMolecule,
- qualityListMolecule,
- true
- )
- );
- }
-
- dispatch(setCrossReferenceCompoundName(moleculeTitlePrev));
- dispatch(setArrowUpDownOfDataset(datasetID, item, newItem, action.arrowType, data));
- }
-};
-
-const handleMoleculeGroupAction = (action, isSelected, stageSummaryView, majorViewStage) => (dispatch, getState) => {
- const state = getState();
- if (action) {
- const tag = getTag(action.object_id, state);
- if (tag) {
- if (isSelected === true) {
- dispatch(addSelectedTag(tag));
- } else {
- dispatch(removeSelectedTag(tag));
- }
- }
- }
-};
-
-const handleTagAction = (action, isSelected) => (dispatch, getState) => {
- const state = getState();
- if (action) {
- const tag = getTag(action.object_id, state);
- if (tag) {
- if (isSelected === true) {
- dispatch(addSelectedTag(tag));
- } else {
- dispatch(removeSelectedTag(tag));
- }
- }
- }
-};
-
-const handlePoseWindowAction = (action, invert) => (dispatch, getState) => {
- if (action) {
- const openDialog = action.isOpen;
- if (openDialog) {
- if (invert && action.prevPoseId && action.prevObservations?.length > 0) {
- dispatch(setObservationsForLHSCmp(action.prevObservations));
- dispatch(setOpenObservationsDialog(true));
- dispatch(setPoseIdForObservationsDialog(action.prevPoseId));
- dispatch(setScrollFiredForLHS(false));
- } else if (invert) {
- dispatch(setObservationsForLHSCmp([]));
- dispatch(setOpenObservationsDialog(false));
- dispatch(setPoseIdForObservationsDialog(0));
- // dispatch(setScrollFiredForLHS(false));
- } else if (action.object_id && action.items?.length > 0) {
- dispatch(setObservationsForLHSCmp(action.items));
- dispatch(setOpenObservationsDialog(true));
- dispatch(setPoseIdForObservationsDialog(action.object_id));
- dispatch(setScrollFiredForLHS(false));
- } else {
- console.error(`${invert ? 'Undo' : 'Redo'} failed for action: ${JSON.stringify(action)}`);
- }
- } else {
- dispatch(setObservationsForLHSCmp([]));
- dispatch(setOpenObservationsDialog(false));
- dispatch(setPoseIdForObservationsDialog(0));
- }
- }
-};
-
-const handleInspirationsWindowAction = (action, invert) => (dispatch, getState) => {
- if (action) {
- const openDialog = action.isOpen;
- if (openDialog) {
- if (invert && action.prevCmpdId && action.prevInspirations?.length > 0) {
- dispatch(setInspirationMoleculeDataList(action.prevInspirations));
- dispatch(setIsOpenInspirationDialog(true));
- dispatch(setInspirationList(action.datasetID, [action.prevCmpdId]));
- dispatch(resetDatasetScrolledMap());
- dispatch(setSelectedDatasetScrolled(false));
- } else if (invert) {
- dispatch(setInspirationMoleculeDataList([]));
- dispatch(setIsOpenInspirationDialog(false));
- dispatch(setInspirationList(action.datasetID, 0));
- // dispatch(resetDatasetScrolledMap());
- } else if (action.object_id && action.items?.length > 0) {
- dispatch(setInspirationMoleculeDataList(action.items));
- dispatch(setIsOpenInspirationDialog(true));
- dispatch(setInspirationList(action.datasetID, [action.object_id]));
- dispatch(resetDatasetScrolledMap());
- dispatch(setSelectedDatasetScrolled(false));
- } else {
- console.error(`${invert ? 'Undo' : 'Redo'} failed for action: ${JSON.stringify(action)}`);
- }
- } else {
- dispatch(setInspirationMoleculeDataList([]));
- dispatch(setIsOpenInspirationDialog(false));
- dispatch(setInspirationList(action.datasetID, 0));
- }
- }
-};
-
-const handleDensityMoleculeAction = (action, type, isAdd, stage, state, skipTracking) => (dispatch, getState) => {
- if (action.object_type === actionObjectType.MOLECULE || action.object_type === actionObjectType.INSPIRATION) {
- if (isAdd) {
- dispatch(addNewTypeOfAction(action, type, stage, state, skipTracking));
- } else {
- if (type === 'densityCustom') {
- dispatch(removeNewType(action, 'density', stage, state, skipTracking));
- dispatch(addNewTypeOfAction(action, 'density', stage, state, skipTracking));
- } else {
- dispatch(removeNewType(action, type, stage, state, skipTracking));
- }
- }
- }
-};
-
-const handleMoleculeAction = (action, type, isAdd, stage, state, skipTracking) => (dispatch, getState) => {
- if (action.object_type === actionObjectType.MOLECULE || action.object_type === actionObjectType.INSPIRATION) {
- if (isAdd) {
- dispatch(addNewTypeOfAction(action, type, stage, state, skipTracking));
- } else {
- dispatch(removeNewType(action, type, stage, state, skipTracking));
- }
- } else if (
- action.object_type === actionObjectType.COMPOUND ||
- action.object_type === actionObjectType.CROSS_REFERENCE
- ) {
- if (isAdd) {
- dispatch(addNewTypeCompoundOfAction(action, type, stage, state, skipTracking));
- } else {
- dispatch(removeNewTypeCompound(action, type, stage, state, skipTracking));
- }
- }
-};
-
-const removeNewType = (action, type, stage, state, skipTracking) => dispatch => {
- if (action) {
- let data = getMolecule(action.object_name, state);
- if (data) {
- if (type === 'ligand' || type === 'vector') {
- dispatch(removeType[type](stage, data, skipTracking, false));
- } else {
- dispatch(removeType[type](stage, data, colourList[data.id % colourList.length], skipTracking));
- }
- }
- }
-};
-
-const removeNewTypeCompound = (action, type, stage, state, skipTracking) => dispatch => {
- if (action) {
- let data = getCompound(action, state);
- if (data) {
- dispatch(
- removeTypeCompound[type](stage, data, colourList[data.id % colourList.length], action.dataset_id, skipTracking)
- );
- }
- }
-};
-
-export const getCanUndo = () => (dispatch, getState) => {
- const state = getState();
- return state.undoableTrackingReducers.past.length > 0;
-};
-
-export const getCanRedo = () => (dispatch, getState) => {
- const state = getState();
- return state.undoableTrackingReducers.future.length > 0;
-};
-
-export const getUndoActionText = () => (dispatch, getState) => {
- let action = dispatch(getNextUndoAction());
- return action?.text ?? '';
-};
-
-export const getRedoActionText = () => (dispatch, getState) => {
- let action = dispatch(getNextRedoAction());
- return action?.text ?? '';
-};
-
-export const appendAndSendTrackingActions = trackAction => async (dispatch, getState) => {
- const state = getState();
- const isUndoRedoAction = state.trackingReducers.isUndoRedoAction;
- dispatch(setIsActionTracking(true));
- if (trackAction && trackAction !== null) {
- const actionList = state.trackingReducers.track_actions_list;
- const sendActionList = state.trackingReducers.send_actions_list;
- const mergedActionList = mergeActions(trackAction, [...actionList]);
- const mergedSendActionList = mergeActions(trackAction, [...sendActionList]);
- dispatch(setActionsList(mergedActionList.list));
- dispatch(setSendActionsList(mergedSendActionList.list));
- if (isUndoRedoAction === false) {
- const undoRedoActionList = state.trackingReducers.undo_redo_actions_list;
- const mergedUndoRedoActionList = mergeActions(trackAction, [...undoRedoActionList]);
- if (mergedActionList.merged) {
- dispatch(setUndoRedoActionList(mergedUndoRedoActionList.list));
- dispatch(UndoActionCreators.removeLastPast());
- } else {
- dispatch(setUndoRedoActionList(mergedUndoRedoActionList.list));
- }
- }
- }
- dispatch(setIsActionTracking(false));
- dispatch(checkSendTrackingActions());
-};
-
-export const mergeActions = (trackAction, list) => {
- let merged = false;
- if (needsToBeMerged(trackAction)) {
- let newList = [];
- if (list.length > 0) {
- const lastEntry = list[list.length - 1];
- if (isSameTypeOfAction(trackAction, lastEntry) && isActionWithinTimeLimit(lastEntry, trackAction)) {
- trackAction.oldSetting = lastEntry.oldSetting;
- trackAction.text = trackAction.getText();
- newList = [...list.slice(0, list.length - 1), trackAction];
- merged = true;
- } else {
- newList = [...list, trackAction];
- }
- } else {
- newList.push(trackAction);
- }
- return { merged: merged, list: newList };
- } else {
- return { merged: merged, list: [...list, trackAction] };
- }
- // return {merged: merged, list: [...list, trackAction]};
-};
-
-const needsToBeMerged = trackAction => {
- return trackAction.merge !== undefined ? trackAction.merge : false;
-};
-
-const isSameTypeOfAction = (firstAction, secondAction) => {
- return firstAction.type === secondAction.type;
-};
-
-const isActionWithinTimeLimit = (firstAction, secondAction) => {
- const diffInSeconds = Math.abs(firstAction.timestamp - secondAction.timestamp) / 1000;
- return diffInSeconds <= NUM_OF_SECONDS_TO_IGNORE_MERGE;
-};
-
-export const manageSendTrackingActions = (projectID, copy) => async (dispatch, getState) => {
- if (copy) {
- await dispatch(checkActionsProject(projectID));
- } else {
- await dispatch(checkSendTrackingActions(true));
- }
-};
-
-export const checkSendTrackingActions = (save = false) => async (dispatch, getState) => {
- const state = getState();
- const currentProject = state.projectReducers.currentProject;
- const sendActions = state.trackingReducers.send_actions_list;
- const length = sendActions.length;
-
- if (/*length >= CONSTANTS.COUNT_SEND_TRACK_ACTIONS || */ save) {
- await dispatch(sendTrackingActions(sendActions, currentProject, true));
- }
-};
-
-const sendTrackingActions = (sendActions, project, clear = false) => async (dispatch, getState) => {
- if (project) {
- const projectID = project && project.projectID;
-
- if (projectID && sendActions && sendActions.length > 0) {
- dispatch(setIsActionsSending(true));
-
- const dataToSend = {
- session_project: projectID,
- author: project.authorID,
- last_update_date: moment().format(),
- actions: JSON.stringify(sendActions)
- };
- return api({
- url: `${base_url}/api/session-actions/`,
- method: METHOD.POST,
- data: JSON.stringify(dataToSend)
- })
- .then(() => {
- if (clear === true) {
- dispatch(setSendActionsList([]));
- }
- })
- .catch(error => {
- throw new Error(error);
- })
- .finally(() => {
- dispatch(setIsActionsSending(false));
- });
- } else {
- return Promise.resolve();
- }
- } else {
- return Promise.resolve();
- }
-};
-
-export const setProjectTrackingActions = () => (dispatch, getState) => {
- const state = getState();
- const isProjectActionListLoaded = state.trackingReducers.isProjectActionListLoaded;
- if (!isProjectActionListLoaded) {
- const currentProject = state.projectReducers.currentProject;
- const projectID = currentProject && currentProject.projectID;
- dispatch(setProjectActionList([]));
- dispatch(getTrackingActions(projectID, true));
- }
-};
-
-const getTrackingActions = (projectID, withTreeSeparation) => (dispatch, getState) => {
- const state = getState();
- const currentProject = state.projectReducers.currentProject;
- const currentProjectID = currentProject && currentProject.projectID;
- const sendActions = state.trackingReducers.send_actions_list;
- const currentActionList = state.trackingReducers.current_actions_list;
- const trackActionsList = state.trackingReducers.track_actions_list;
-
- if (projectID) {
- dispatch(setIsActionsLoading(true));
- return api({
- url: `${base_url}/api/session-actions/?session_project=${projectID}`
- })
- .then(response => {
- let results = response.data.results;
- let listToSet = [];
- results.forEach(r => {
- let resultActions = JSON.parse(r.actions);
- let actions = resultActions.map(obj => ({ ...obj, actionId: r.id }));
- listToSet.push(...actions);
- });
-
- if (withTreeSeparation === true) {
- listToSet = dispatch(separateTrackkingActionBySnapshotTree(listToSet));
-
- let actionsWithoutSnapshot = listToSet.filter(action => action.type !== actionType.SNAPSHOT);
- let snapshotActions = listToSet.filter(action => action.type === actionType.SNAPSHOT);
- if (snapshotActions) {
- const key = 'object_id';
- const arrayUniqueByKey = [...new Map(snapshotActions.map(item => [item[key], item])).values()];
- actionsWithoutSnapshot.push(...arrayUniqueByKey);
- listToSet = actionsWithoutSnapshot;
- }
- }
-
- let projectActions = currentProjectID && currentProjectID != null ? [...listToSet, ...sendActions] : listToSet;
- dispatch(setProjectActionList(projectActions));
- dispatch(setProjectActionListLoaded(true));
- return Promise.resolve(projectActions);
- })
- .catch(error => {
- throw new Error(error);
- })
- .finally(() => {
- dispatch(setIsActionsLoading(false));
- });
- } else {
- // let projectActions = [...sendActions];
- // const projectActions = [];
- let projectActions = [...currentActionList, ...sendActions, ...trackActionsList];
- projectActions = uniqWith(projectActions, isEqual);
- dispatch(setProjectActionList(projectActions));
- return Promise.resolve(projectActions);
- }
-};
-
-const separateTrackkingActionBySnapshotTree = actionList => (dispatch, getState) => {
- const state = getState();
- const snapshotID = state.projectReducers.currentSnapshot && state.projectReducers.currentSnapshot.id;
- const currentSnapshotTree = state.projectReducers.currentSnapshotTree;
- const currentSnapshotList = state.projectReducers.currentSnapshotList;
-
- if (snapshotID && currentSnapshotTree != null) {
- let treeActionList = [];
- let snapshotIdList = [];
- snapshotIdList.push(currentSnapshotTree.id);
-
- if (currentSnapshotList != null) {
- for (const id in currentSnapshotList) {
- let snapshot = currentSnapshotList[id];
- let snapshotChildren = snapshot.children;
-
- if (
- (snapshotChildren && snapshotChildren !== null && snapshotChildren.includes(snapshotID)) ||
- snapshot.id === snapshotID
- ) {
- snapshotIdList.push(snapshot.id);
- }
- }
- }
-
- treeActionList = actionList.filter(
- a => snapshotIdList.includes(a.snapshotId) || a.snapshotId === null || a.snapshotId === undefined
- );
- return treeActionList;
- } else {
- return actionList;
- }
-};
-
-const checkActionsProject = projectID => async (dispatch, getState) => {
- const state = getState();
- const currentProject = state.projectReducers.currentProject;
- const currentProjectID = currentProject && currentProject.projectID;
-
- await dispatch(getTrackingActions(projectID));
- await dispatch(
- copyActionsToProject(currentProject, true, currentProjectID && currentProjectID != null ? true : false)
- );
-};
-
-const copyActionsToProject = (toProject, setActionList = true, clear = false) => async (dispatch, getState) => {
- const state = getState();
- const actionList = state.trackingReducers.project_actions_list;
-
- if (toProject) {
- let newActionsList = [];
-
- actionList.forEach(r => {
- newActionsList.push(Object.assign({ ...r }));
- });
-
- if (setActionList === true) {
- dispatch(setActionsList(newActionsList));
- }
- await dispatch(sendTrackingActions(newActionsList, toProject, clear));
- }
-};
-
-export const sendTrackingActionsByProjectId = (projectID, authorID, offline = false) => async (dispatch, getState) => {
- const state = getState();
- const currentProject = state.projectReducers.currentProject;
- const currentProjectID = currentProject && currentProject.projectID;
-
- const project = { projectID, authorID };
-
- await dispatch(getTrackingActions(offline ? null : currentProjectID));
- await dispatch(copyActionsToProject(project, false, currentProjectID && currentProjectID != null ? true : false));
-};
-
-export const sendInitTrackingActionByProjectId = target_on => (dispatch, getState) => {
- const state = getState();
- const snapshotID = state.projectReducers.currentSnapshot && state.projectReducers.currentSnapshot.id;
-
- let trackAction = dispatch(createInitAction(target_on));
- if (trackAction && trackAction != null) {
- let actions = [];
- actions.push(trackAction);
- dispatch(appendToSendActionList(trackAction));
- dispatch(checkSendTrackingActions(true));
- dispatch(saveTrackingActions(actions, snapshotID));
- }
-};
-
-export const updateTrackingActions = action => (dispatch, getState) => {
- const state = getState();
- const project = state.projectReducers.currentProject;
- const projectActions = state.trackingReducers.project_actions_list;
- const projectID = project && project.projectID;
- let actionID = action && action.actionId;
-
- if (projectID && actionID && projectActions) {
- let actions = projectActions.filter(a => a.actionId === actionID);
-
- if (actions && actions.length > 0) {
- const dataToSend = {
- session_action_id: actionID,
- session_project: projectID,
- author: project.authorID,
- last_update_date: moment().format(),
- actions: JSON.stringify(actions)
- };
- return api({
- url: `${base_url}/api/session-actions/${actionID}/`,
- method: METHOD.PUT,
- data: JSON.stringify(dataToSend)
- })
- .then(() => {})
- .catch(error => {
- throw new Error(error);
- })
- .finally(() => {});
- } else {
- return Promise.resolve();
- }
- } else {
- return Promise.resolve();
- }
-};
-
-function groupArrayOfObjects(list, key) {
- return list.reduce(function(rv, x) {
- (rv[x[key]] = rv[x[key]] || []).push(x);
- return rv;
- }, {});
-}
-
-export const setAndUpdateTrackingActions = (actionList, projectID) => (dispatch, getState) => {
- if (projectID) {
- const groupBy = groupArrayOfObjects(actionList, 'actionId');
-
- for (const group in groupBy) {
- let actionID = group;
- let actions = groupBy[group];
- if (actionID && actions && actions.length > 0) {
- const dataToSend = {
- session_action_id: actionID,
- session_project: projectID,
- last_update_date: moment().format(),
- actions: JSON.stringify(actions)
- };
- return api({
- url: `${base_url}/api/session-actions/${actionID}/`,
- method: METHOD.PUT,
- data: JSON.stringify(dataToSend)
- })
- .then(() => {})
- .catch(error => {
- throw new Error(error);
- })
- .finally(() => {});
- } else {
- return Promise.resolve();
- }
- }
- } else {
- return Promise.resolve();
- }
-};
diff --git a/js/reducers/tracking/dispatchActionsSwitchSnapshot.js b/js/reducers/tracking/dispatchActionsSwitchSnapshot.js
deleted file mode 100644
index 7f03d891d..000000000
--- a/js/reducers/tracking/dispatchActionsSwitchSnapshot.js
+++ /dev/null
@@ -1,623 +0,0 @@
-import { base_url, URLS } from '../../components/routes/constants';
-import { api } from '../../../js/utils/api';
-import { setCurrentSnapshot } from '../../components/projects/redux/actions';
-import {
- setCurrentActionsList,
- setIsActionsRestoring,
- setSkipOrientationChange,
- setIsSnapshotDirty,
- setSnapshotActionsDownloaded
-} from './actions';
-import { resetSelectionState, setScrollFiredForLHS } from '../selection/actions';
-import {
- resetDatasetsStateOnSnapshotChange,
- resetDatasetScrolledMap,
- setSelectedDatasetScrolled
-} from '../../components/datasets/redux/actions';
-import { resetViewerControlsState } from '../../components/preview/viewerControls/redux/actions';
-import { resetNglTrackingState } from '../nglTracking/dispatchActions';
-import { removeAllNglComponents } from '../ngl/actions';
-import {
- restoreStateBySavedActionList,
- restoreViewerControlActions,
- restoreSitesActions,
- restoreTagActions,
- restoreMoleculesActions,
- restoreRepresentationActions,
- restoreMoleculeSelectionActions,
- restoreTabActions,
- restoreCartActions,
- restoreSnapshotImageActions,
- restoreNglStateAction,
- restoreNglSettingsAction,
- restoreCompoundsActions,
- getMolecule,
- getCompound,
- restoreNglOrientationAnim
-} from './dispatchActions';
-import { VIEWS } from '../../../js/constants/constants';
-import { loadProteinOfRestoringActions } from '../../components/preview/redux/dispatchActions';
-import { actionType, snapshotSwitchManualActions, actionObjectType } from './constants';
-import { getMoleculeForId } from '../../components/preview/tags/redux/dispatchActions';
-import {
- addLigand,
- removeLigand,
- removeHitProtein,
- addHitProtein,
- removeSurface,
- addSurface,
- removeQuality,
- addQuality,
- removeComplex,
- addComplex,
- removeVector,
- addVector,
- removeDensity,
- addDensity,
- addDensityCustomView
-} from '../../components/preview/molecule/redux/dispatchActions';
-import { getRandomColor } from '../../components/preview/molecule/utils/color';
-import {
- addDatasetLigand,
- removeDatasetLigand,
- removeDatasetHitProtein,
- addDatasetHitProtein,
- removeDatasetSurface,
- addDatasetSurface,
- removeDatasetComplex,
- addDatasetComplex
-} from '../../components/datasets/redux/dispatchActions';
-import { getDifference } from './utils';
-import { setIsSnapshot, setSnapshotLoadingInProgress } from '../api/actions';
-import { isEqual, uniqWith } from 'lodash';
-
-/**
- * The goal of this method is to restore the state of the app based on the tracking
- * action. All of the dispatched actions were added by trial and error - in case you
- * need to alter, remove or add anything, you should properly test the changes.
- */
-export const restoreAfterSnapshotChange = (stages, projectId) => async (dispatch, getState) => {
- console.count(`restoreAfterSnapshotChange start`);
- const state = getState();
-
- const currentActionList = state.trackingReducers.current_actions_list;
- const filteredActionList = currentActionList.filter(action => !snapshotSwitchManualActions.includes(action.type));
- const orderedActionList = filteredActionList.sort((a, b) => a.timestamp - b.timestamp);
- const targetId = state.apiReducers.target_on;
-
- if (targetId && stages && stages.length > 0) {
- console.count(`BEFORE restoration orientation from snapshot`);
- await dispatch(restoreNglOrientationAnim(orderedActionList, stages));
- console.count(`AFTER restoration orientation from snapshot`);
-
- dispatch(setSkipOrientationChange(true));
- const majorView = stages.find(view => view.id === VIEWS.MAJOR_VIEW);
-
- dispatch(restoreViewerControlActions(orderedActionList));
-
- // await dispatch(loadProteinOfRestoringActions({ nglViewList: stages }));
-
- await dispatch(restoreSitesActions(orderedActionList));
- await dispatch(restoreTagActions(orderedActionList));
- await dispatch(restoreMoleculesActions(orderedActionList, majorView.stage));
-
- await dispatch(handleLigandsOfMols(currentActionList, majorView.stage));
- await dispatch(handleProteinsOfMols(currentActionList, majorView.stage));
- await dispatch(handleComplexesOfMols(currentActionList, majorView.stage));
- await dispatch(handleShowAllOfMols(currentActionList, majorView.stage));
- await dispatch(handleSurfacesOfMols(currentActionList, majorView.stage));
- await dispatch(handleQualityOfMols(currentActionList, majorView.stage));
- await dispatch(handleVectorsOfMols(currentActionList, majorView.stage));
- await dispatch(handleDensityOfMols(currentActionList, majorView.stage));
- // await dispatch(handleDensityTypeOfMols(currentActionList, majorView.stage));
- await dispatch(handleCustomDensityOfMols(currentActionList, majorView.stage));
-
- await dispatch(restoreRepresentationActions(orderedActionList, stages));
- await dispatch(restoreMoleculeSelectionActions(orderedActionList));
- await dispatch(restoreTabActions(orderedActionList));
- await dispatch(restoreCartActions(orderedActionList, majorView.stage));
- await dispatch(restoreSnapshotImageActions(projectId));
- // console.count(`BEFORE restoration orientation from snapshot`);
- // dispatch(restoreNglStateAction(orderedActionList, stages));
- // console.count(`AFTER restoration orientation from snapshot`);
- await dispatch(restoreNglSettingsAction(orderedActionList, majorView.stage));
- // dispatch(restoreCompoundsActions(orderedActionList, majorView.stage));
-
- await dispatch(handleLigandsOfCompounds(currentActionList, majorView.stage));
- await dispatch(handleProteinsOfCompounds(currentActionList, majorView.stage));
- await dispatch(handleComplexesOfCompounds(currentActionList, majorView.stage));
- await dispatch(handleSurfacesOfCompounds(currentActionList, majorView.stage));
- await dispatch(handleShowAllOfCompounds(currentActionList, majorView.stage));
- await dispatch(restoreCompoundsActions(orderedActionList, majorView.stage));
-
- dispatch(setSkipOrientationChange(false));
- // console.count(`BEFORE restoration orientation from snapshot`);
- // await dispatch(restoreNglStateAction(orderedActionList, stages, true));
- // console.count(`AFTER restoration orientation from snapshot`);
-
- dispatch(resetDatasetScrolledMap()); // Have a look at useScrollToSelected.js
- dispatch(setScrollFiredForLHS(false));
- dispatch(setSelectedDatasetScrolled(false));
- dispatch(setIsActionsRestoring(false, true));
-
- console.count(`restoreAfterSnapshotChange end`);
- }
-};
-
-/**
- * The goal of this method is to change the snapshot without reloading the page.
- * All of the dispatched actions were added by trial and error - in case you need
- * to alter, remove or add anything, you should properly test the changes.
- */
-export const changeSnapshot = (projectID, snapshotID, nglViewList, stage) => async (dispatch, getState) => {
- console.count(`Change snapshot - start`);
- dispatch(setSnapshotActionsDownloaded(false));
- dispatch(setSnapshotLoadingInProgress(true));
- dispatch(setIsSnapshot(true));
- // A hacky way of changing the URL without triggering react-router
- window.history.replaceState(null, null, `${URLS.projects}${projectID}/${snapshotID}`);
-
- // Load the needed data
- const snapshotResponse = await api({ url: `${base_url}/api/snapshots/${snapshotID}` });
- const actionsResponse = await api({
- url: `${base_url}/api/snapshot-actions/?snapshot=${snapshotID}`
- });
-
- dispatch(
- setCurrentSnapshot({
- id: snapshotResponse.data.id,
- type: snapshotResponse.data.type,
- title: snapshotResponse.data.title,
- author: snapshotResponse.data.author,
- description: snapshotResponse.data.description,
- created: snapshotResponse.data.created,
- children: snapshotResponse.data.children,
- parent: snapshotResponse.data.parent,
- data: snapshotResponse.data.data
- })
- );
-
- let results = actionsResponse.data.results;
- let listToSet = [];
- results.forEach(r => {
- let resultActions = JSON.parse(r.actions);
- listToSet.push(...resultActions);
- });
- let snapshotActions = [...listToSet];
- dispatch(setCurrentActionsList(snapshotActions));
-
- dispatch(resetSelectionState()); //here what is visible from the LHS is reset
- dispatch(resetDatasetsStateOnSnapshotChange()); //here what is visible from RHS is reset
- dispatch(resetViewerControlsState()); //LHS and RHS is/isn't visible
- dispatch(resetNglTrackingState()); //????
-
- // dispatch(removeAllNglComponents(stage)); //this removes everything from ngl view
-
- dispatch(restoreStateBySavedActionList());
- await dispatch(restoreAfterSnapshotChange(nglViewList, projectID));
-
- dispatch(setIsSnapshotDirty(false));
- dispatch(setSnapshotLoadingInProgress(false));
-
- console.count(`Change snapshot - end`);
-};
-
-//ALL_TURNED_ON is a mass action so it needs special treatment
-const handleShowAllOfMols = (actions, stage) => async (dispatch, getState) => {
- const state = getState();
- const molIds = dispatch(getMoleculeIdsFromActions(actions, actionType.ALL_TURNED_ON));
- const ligands = state.selectionReducers.fragmentDisplayList;
- const proteins = state.selectionReducers.proteinList;
- const complexes = state.selectionReducers.complexList;
-
- for (const molId of molIds) {
- const mol = dispatch(getMoleculeForId(molId.id));
- if (mol) {
- const action = actions.find(
- a =>
- a.type === actionType.ALL_TURNED_ON && a.object_id === molId.id && a.object_type === actionObjectType.MOLECULE
- );
- if (action.isLigand && !ligands.find(l => l === molId.id)) {
- await dispatch(addLigand(stage, mol, getRandomColor(mol), false, true, true));
- }
- if (action.isProtein && !proteins.find(p => p === molId.id)) {
- await dispatch(addHitProtein(stage, mol, getRandomColor(mol), true, true));
- }
- if (action.isComplex && !complexes.find(c => c === molId.id)) {
- await dispatch(addComplex(stage, mol, getRandomColor(mol), true));
- }
- }
- }
-};
-
-//ALL_TURNED_ON is a mass action so it needs special treatment
-const handleShowAllOfCompounds = (actions, stage) => async (dispatch, getState) => {
- const state = getState();
- const compounds = dispatch(getCompoundsIdsFromActions(actions, actionType.ALL_TURNED_ON));
- const ligands = state.datasetsReducers.ligandLists;
- const proteins = state.datasetsReducers.proteinLists;
- const complexes = state.datasetsReducers.complexLists;
-
- for (const [datasetId, cmpIds] of Object.entries(compounds)) {
- for (const cmpId of cmpIds) {
- const cmp = dispatch(getCompoundById(cmpId.id, datasetId));
- if (cmp) {
- const action = actions.find(
- a =>
- a.type === actionType.ALL_TURNED_ON &&
- a.object_id === cmpId.id &&
- a.object_type === actionObjectType.COMPOUND
- );
- if (action.isLigand && !ligands[datasetId]?.find(l => l === cmpId.id)) {
- await dispatch(addDatasetLigand(stage, cmp, getRandomColor(cmp), datasetId, true));
- }
- if (action.isProtein && !proteins[datasetId]?.find(p => p === cmpId.id)) {
- await dispatch(addDatasetHitProtein(stage, cmp, getRandomColor(cmp), datasetId, true));
- }
- if (action.isComplex && !complexes[datasetId]?.find(c => c === cmpId.id)) {
- await dispatch(addDatasetComplex(stage, cmp, getRandomColor(cmp), datasetId, true));
- }
- }
- }
- }
-};
-
-const handleLigandsOfMols = (actions, stage) => async (dispatch, getState) => {
- const state = getState();
- const instructions = dispatch(
- getRestoreInstructionsForMols(actions, actionType.LIGAND_TURNED_ON, state.selectionReducers.fragmentDisplayList)
- );
-
- instructions.toTurnOff.forEach(molId => {
- const mol = dispatch(getMoleculeForId(molId));
- if (mol) {
- dispatch(removeLigand(stage, mol, true));
- }
- });
-
- for (const molId of instructions.toTurnOn) {
- const mol = dispatch(getMoleculeForId(molId));
- if (mol) {
- await dispatch(addLigand(stage, mol, getRandomColor(mol), false, true, true));
- }
- }
-};
-
-const handleLigandsOfCompounds = (actions, stage) => async (dispatch, getState) => {
- const state = getState();
- const instructions = dispatch(
- getRestoreInstructionsForCompounds(actions, actionType.LIGAND_TURNED_ON, state.datasetsReducers.ligandLists)
- );
-
- for (const [datasetId, cmpIds] of Object.entries(instructions)) {
- cmpIds.toTurnOff.forEach(cmpId => {
- const cmp = dispatch(getCompoundById(cmpId, datasetId));
- if (cmp) {
- dispatch(removeDatasetLigand(stage, cmp, getRandomColor(cmp), datasetId, true));
- }
- });
- for (const cmpId of cmpIds.toTurnOn) {
- const cmp = dispatch(getCompoundById(cmpId, datasetId));
- if (cmp) {
- await dispatch(addDatasetLigand(stage, cmp, getRandomColor(cmp), datasetId, true));
- }
- }
- }
-};
-
-const handleProteinsOfMols = (actions, stage) => async (dispatch, getState) => {
- const state = getState();
- const instructions = dispatch(
- getRestoreInstructionsForMols(actions, actionType.SIDECHAINS_TURNED_ON, state.selectionReducers.proteinList)
- );
-
- instructions.toTurnOff.forEach(molId => {
- const mol = dispatch(getMoleculeForId(molId));
- if (mol) {
- dispatch(removeHitProtein(stage, mol, getRandomColor(mol), true));
- }
- });
- for (const molId of instructions.toTurnOn) {
- const mol = dispatch(getMoleculeForId(molId));
- if (mol) {
- await dispatch(addHitProtein(stage, mol, getRandomColor(mol), true, true));
- }
- }
-};
-
-const handleProteinsOfCompounds = (actions, stage) => async (dispatch, getState) => {
- const state = getState();
- const instructions = dispatch(
- getRestoreInstructionsForCompounds(actions, actionType.SIDECHAINS_TURNED_ON, state.datasetsReducers.proteinLists)
- );
-
- for (const [datasetId, cmpIds] of Object.entries(instructions)) {
- cmpIds.toTurnOff.forEach(cmpId => {
- const cmp = dispatch(getCompoundById(cmpId, datasetId));
- if (cmp) {
- dispatch(removeDatasetHitProtein(stage, cmp, getRandomColor(cmp), datasetId, true));
- }
- });
- for (const cmpId of cmpIds.toTurnOn) {
- const cmp = dispatch(getCompoundById(cmpId, datasetId));
- if (cmp) {
- await dispatch(addDatasetHitProtein(stage, cmp, getRandomColor(cmp), datasetId, true));
- }
- }
- }
-};
-
-const handleSurfacesOfMols = (actions, stage) => async (dispatch, getState) => {
- const state = getState();
- const instructions = dispatch(
- getRestoreInstructionsForMols(actions, actionType.SURFACE_TURNED_ON, state.selectionReducers.surfaceList)
- );
-
- instructions.toTurnOff.forEach(molId => {
- const mol = dispatch(getMoleculeForId(molId));
- if (mol) {
- dispatch(removeSurface(stage, mol, getRandomColor(mol), true));
- }
- });
-
- for (const molId of instructions.toTurnOn) {
- const mol = dispatch(getMoleculeForId(molId));
- if (mol) {
- await dispatch(addSurface(stage, mol, getRandomColor(mol), true));
- }
- }
-};
-
-const handleSurfacesOfCompounds = (actions, stage) => async (dispatch, getState) => {
- const state = getState();
- const instructions = dispatch(
- getRestoreInstructionsForCompounds(actions, actionType.SURFACE_TURNED_ON, state.datasetsReducers.surfaceLists)
- );
-
- for (const [datasetId, cmpIds] of Object.entries(instructions)) {
- cmpIds.toTurnOff.forEach(cmpId => {
- const cmp = dispatch(getCompoundById(cmpId, datasetId));
- if (cmp) {
- dispatch(removeDatasetSurface(stage, cmp, getRandomColor(cmp), datasetId, true));
- }
- });
- for (const cmpId of cmpIds.toTurnOn) {
- const cmp = dispatch(getCompoundById(cmpId, datasetId));
- if (cmp) {
- await dispatch(addDatasetSurface(stage, cmp, getRandomColor(cmp), datasetId));
- }
- }
- }
-};
-
-const handleQualityOfMols = (actions, stage) => async (dispatch, getState) => {
- const state = getState();
-
- //quality is turned on implicitly by turning on ligands so in this case we just need to turn off quality
- //for mols which are in the snapshot. Just make sure that ligands are turned on first (and that action is awaited)
- let molIds = dispatch(getMoleculeIdsFromActions(actions, actionType.QUALITY_TURNED_OFF));
- molIds.forEach(async molId => {
- const mol = dispatch(getMoleculeForId(molId.id));
- if (mol) {
- await dispatch(removeQuality(stage, mol, getRandomColor(mol), true));
- }
- });
-
- //now we need to get all the ligands that should be on and turn on quality for them if the quality
- //was off in current snapshot. This is because if ligand is on in both snapshots it's not rerendered
- // (which implicitly turns on quality) so we need to render it manually
- molIds = dispatch(getMoleculeIdsFromActions(actions, actionType.LIGAND_TURNED_ON));
- const currentlyOnQuality = state.selectionReducers.qualityList;
- for (const molId of molIds) {
- if (!currentlyOnQuality.find(q => q === molId.id)) {
- const mol = dispatch(getMoleculeForId(molId.id));
- if (mol) {
- await dispatch(addQuality(stage, mol, getRandomColor(mol), true));
- }
- }
- }
-};
-
-const handleComplexesOfMols = (actions, stage) => async (dispatch, getState) => {
- const state = getState();
- const instructions = dispatch(
- getRestoreInstructionsForMols(actions, actionType.INTERACTIONS_TURNED_ON, state.selectionReducers.complexList)
- );
-
- instructions.toTurnOff.forEach(molId => {
- const mol = dispatch(getMoleculeForId(molId));
- if (mol) {
- dispatch(removeComplex(stage, mol, getRandomColor(mol), true));
- }
- });
-
- for (const molId of instructions.toTurnOn) {
- const mol = dispatch(getMoleculeForId(molId));
- if (mol) {
- await dispatch(addComplex(stage, mol, getRandomColor(mol), true));
- }
- }
-};
-
-const handleComplexesOfCompounds = (actions, stage) => async (dispatch, getState) => {
- const state = getState();
- const instructions = dispatch(
- getRestoreInstructionsForCompounds(actions, actionType.INTERACTIONS_TURNED_ON, state.datasetsReducers.complexLists)
- );
-
- for (const [datasetId, cmpIds] of Object.entries(instructions)) {
- cmpIds.toTurnOff.forEach(cmpId => {
- const cmp = dispatch(getCompoundById(cmpId, datasetId));
- if (cmp) {
- dispatch(removeDatasetComplex(stage, cmp, getRandomColor(cmp), datasetId, true));
- }
- });
- for (const cmpId of cmpIds.toTurnOn) {
- const cmp = dispatch(getCompoundById(cmpId, datasetId));
- if (cmp) {
- await dispatch(addDatasetComplex(stage, cmp, getRandomColor(cmp), datasetId, true));
- }
- }
- }
-};
-
-const handleVectorsOfMols = (actions, stage) => async (dispatch, getState) => {
- const state = getState();
- const instructions = dispatch(
- getRestoreInstructionsForMols(actions, actionType.VECTORS_TURNED_ON, state.selectionReducers.fragmentDisplayList) //TODO ???????
- );
-
- instructions.toTurnOff.forEach(molId => {
- const mol = dispatch(getMoleculeForId(molId));
- if (mol) {
- dispatch(removeVector(stage, mol, true));
- }
- });
-
- for (const molId of instructions.toTurnOn) {
- const mol = dispatch(getMoleculeForId(molId));
- if (mol) {
- await dispatch(addVector(stage, mol, true));
- }
- }
-};
-
-const handleDensityOfMols = (actions, stage) => async (dispatch, getState) => {
- const state = getState();
- const instructions = dispatch(
- getRestoreInstructionsForMols(actions, actionType.DENSITY_TURNED_ON, state.selectionReducers.densityList)
- );
-
- instructions.toTurnOff.forEach(molId => {
- const mol = dispatch(getMoleculeForId(molId));
- if (mol) {
- dispatch(removeDensity(stage, mol, getRandomColor(mol), false, true));
- }
- });
- for (const molId of instructions.toTurnOn) {
- const mol = dispatch(getMoleculeForId(molId));
- if (mol) {
- await dispatch(addDensity(stage, mol, getRandomColor(mol), true, true));
- }
- }
-};
-
-const handleCustomDensityOfMols = (actions, stage) => async (dispatch, getState) => {
- const state = getState();
- const instructions = dispatch(
- getRestoreInstructionsForMols(
- actions,
- actionType.DENSITY_CUSTOM_TURNED_ON,
- state.selectionReducers.densityListCustom
- )
- );
-
- instructions.toTurnOff.forEach(molId => {
- const mol = dispatch(getMoleculeForId(molId));
- if (mol) {
- dispatch(removeDensity(stage, mol, getRandomColor(mol), false, true));
- }
- });
-
- for (const molId of instructions.toTurnOn) {
- const mol = dispatch(getMoleculeForId(molId));
- if (mol) {
- await dispatch(addDensityCustomView(stage, mol, getRandomColor(mol), true, true));
- }
- }
-};
-
-//this one is wrong. If testing shows that we need to handle this in this way then it will need fixing
-//it needs to get which maps are enabled from the action and also which is disabled so actually
-//the implementation will be more akin to handleShowAllOfMols
-const handleDensityTypeOfMols = (actions, stage) => async (dispatch, getState) => {};
-
-const getInstructions = (idObjects, visibleIds) => {
- const cmpIdsFromActions = idObjects.map(idObject => idObject.id);
- const molsToTurnOff = getDifference(visibleIds, cmpIdsFromActions);
- const molsToTurnOn = getDifference(cmpIdsFromActions, visibleIds);
-
- return { toTurnOn: molsToTurnOn, toTurnOff: molsToTurnOff };
-};
-
-const getRestoreInstructionsForMols = (actions, actionType, list) => (dispatch, getState) => {
- const molIds = dispatch(getMoleculeIdsFromActions(actions, actionType));
-
- return getInstructions(molIds, list);
-};
-
-const getRestoreInstructionsForCompounds = (actions, actionType, compoundsLists) => (dispatch, getState) => {
- const state = getState();
- const compounds = dispatch(getCompoundsIdsFromActions(actions, actionType));
- const allDatasets = state.datasetsReducers.datasets;
-
- const result = {};
- const datasetsVisited = {};
-
- Object.entries(compounds).map(([datasetId, cmpIds]) => {
- datasetsVisited[datasetId] = true;
- const list = compoundsLists[datasetId];
- const instructions = getInstructions(cmpIds, list);
- result[datasetId] = instructions;
- });
-
- //this is here because if someone selectes A button on the compound (RHS which turns on L, P and C)
- //whitout ever using button on other compounds from given dataset then we need to turn them off
- //this way because turn on and off instructions are not generated for the action and dataset combo which is not in the snapshot
- allDatasets.forEach(dataset => {
- if (!datasetsVisited.hasOwnProperty(dataset.id) || !datasetsVisited[dataset.id]) {
- const list = compoundsLists[dataset.id];
- const instructions = getInstructions([], list);
- result[dataset.id] = instructions;
- }
- });
-
- return result;
-};
-
-const getMoleculeIdsFromActions = (actions, actionType) => (dispatch, getState) => {
- const state = getState();
- let result = actions
- .filter(action => action.type === actionType && action.object_type === actionObjectType.MOLECULE)
- .map(action => {
- const mol = getMolecule(action.object_name, state);
- if (mol) {
- return { id: mol?.id, name: mol?.code };
- }
- });
- result = uniqWith(result, isEqual);
-
- return result;
-};
-
-const getCompoundsIdsFromActions = (actions, actionType) => (dispatch, getState) => {
- const state = getState();
-
- let cmpOjects = actions
- .filter(action => action.type === actionType && action.object_type === actionObjectType.COMPOUND)
- .map(action => {
- const cmp = getCompound(action, state);
- if (cmp) {
- return { datasetId: action.dataset_id, id: cmp?.id, name: cmp.name };
- }
- });
- const result = {};
- cmpOjects.forEach(cmp => {
- if (cmp) {
- let datasetCmps = [];
- if (result.hasOwnProperty(cmp.datasetId)) {
- datasetCmps = result[cmp.datasetId];
- }
- datasetCmps = [...datasetCmps, { id: cmp.id, name: cmp.name }];
- result[cmp.datasetId] = datasetCmps;
- }
- });
-
- return result;
-};
-
-export const getCompoundById = (id, datasetId) => (dispatch, getState) => {
- const state = getState();
- const datasetCmps = state.datasetsReducers.moleculeLists[datasetId];
- return datasetCmps?.find(cmp => cmp.id === id);
-};
diff --git a/js/reducers/tracking/trackingActions.js b/js/reducers/tracking/trackingActions.js
deleted file mode 100644
index 8415e4811..000000000
--- a/js/reducers/tracking/trackingActions.js
+++ /dev/null
@@ -1,2146 +0,0 @@
-import {
- actionType,
- actionObjectType,
- actionDescription,
- actionAnnotation,
- mapTypesStrings,
- viewerControlsSides
-} from './constants';
-import { constants as apiConstants } from '../api/constants';
-import { CONSTANTS as nglConstants } from '../ngl/constants';
-import { constants as previewCompoundConstants } from '../../components/preview/compounds/redux/constants';
-import { constants as selectionConstants } from '../selection/constants';
-import { constants as customDatasetConstants } from '../../components/datasets/redux/constants';
-import { constants as viewerControlsConstants } from '../../components/preview/viewerControls/redux/constants';
-import { DJANGO_CONTEXT } from '../../utils/djangoContext';
-import { BACKGROUND_COLOR } from '../../components/nglView/constants/index';
-import { getMoleculeForId } from '../../components/preview/tags/redux/dispatchActions';
-import { constants as moleculeConstants } from '../../components/preview/molecule/redux/constants';
-
-export const findTrackAction = (action, state) => (dispatch, getState) => {
- const username = DJANGO_CONTEXT['username'];
- const target_on_name = state.apiReducers.target_on_name;
- const isActionRestoring = state.trackingReducers.isActionRestoring;
-
- let trackAction = null;
- if (isActionRestoring === false && action.skipTracking !== true) {
- if (action.type === apiConstants.SET_TARGET_ON) {
- if (action.target_on) {
- let targetName = getTargetName(action.target_on, state);
- trackAction = {
- type: actionType.TARGET_LOADED,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: actionObjectType.TARGET,
- object_name: targetName,
- object_id: action.target_on,
- text: `${actionDescription.TARGET} ${targetName} ${actionDescription.LOADED}`
- };
- }
- } else if (action.type === selectionConstants.APPEND_SELECTED_TAG_LIST) {
- if (action.item) {
- trackAction = {
- type: actionType.TAG_SELECTED,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: actionObjectType.TAG,
- object_name: action.item.tag,
- object_id: action.item.id,
- text: `${actionDescription.TAG} ${action.item.tag} ${actionDescription.TURNED_ON}`
- };
- }
- } else if (action.type === selectionConstants.REMOVE_FROM_SELECTED_TAG_LIST) {
- if (action.item) {
- trackAction = {
- type: actionType.TAG_UNSELECTED,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: actionObjectType.TAG,
- object_name: action.item.tag,
- object_id: action.item.id,
- text: `${actionDescription.TAG} ${action.item.tag} ${actionDescription.TURNED_OFF}`
- };
- }
- } else if (action.type === selectionConstants.SET_OBSERVATION_DIALOG_ACTION) {
- if (action) {
- trackAction = {
- type: actionType.POSE_WINDOW_ACTION,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: actionObjectType.MOLECULE,
- object_name: action.poseId,
- object_id: action.poseId,
- items: action?.observations?.length > 0 ? [...action.observations] : [],
- isOpen: action.open,
- prevPoseId: action.prevPoseId,
- prevObservations: action.prevObservations,
- text: action.open ? `Pose window opened` : `Pose window closed`
- };
- }
- } else if (action.type === customDatasetConstants.SET_INSPIRATION_DIALOG_ACTION) {
- if (action) {
- trackAction = {
- type: actionType.INSPIRATION_WINDOW_ACTION,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: actionObjectType.COMPOUND,
- object_name: action.inspirationList,
- object_id: action.inspirationList,
- items: action?.inpsirations?.length > 0 ? [...action.inpsirations] : [],
- datasetID: action.datasetID,
- isOpen: action.open,
- prevCmpdId: action.prevInspirationList?.length > 0 ? action.prevInspirationList[0] : 0,
- prevInspirations: action.prevInspirations,
- isSelectedList: action.isSelectedList,
- text: action.open ? `Inspirations window opened` : `Inspirations window closed`
- };
- }
- } else if (action.type === apiConstants.SET_MOL_GROUP_ON) {
- if (action.mol_group_on) {
- let molGroupSelection = state.selectionReducers.mol_group_selection;
- let currentMolGroup = molGroupSelection && molGroupSelection.find(o => o === action.mol_group_on);
- if (!currentMolGroup) {
- let molGroupName = getMolGroupName(action.mol_group_on, state);
- trackAction = {
- type: actionType.SITE_TURNED_ON,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: actionObjectType.SITE,
- object_name: molGroupName,
- object_id: action.mol_group_on,
- text: `${actionDescription.SITE} ${molGroupName} ${actionDescription.TURNED_ON}`
- };
- }
- }
- } else if (action.type === apiConstants.SET_MOL_GROUP_OFF) {
- const { mol_group_off } = action;
- let molGroupName = getMolGroupName(mol_group_off, state);
- trackAction = {
- type: actionType.SITE_TURNED_OFF,
- timestamp: Date.now(),
- username: username,
- object_type: actionObjectType.SITE,
- object_name: molGroupName,
- object_id: mol_group_off,
- text: `${actionDescription.SITE} ${molGroupName} ${actionDescription.TURNED_OFF}`
- };
- } else if (action.type === selectionConstants.SET_OBJECT_SELECTION) {
- let objectId = action.payload && action.payload[0];
- if (objectId) {
- let molGroupName = getMolGroupName(objectId, state);
- trackAction = {
- type: actionType.SITE_TURNED_OFF,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: actionObjectType.SITE,
- object_name: molGroupName,
- object_id: objectId,
- text: `${actionDescription.SITE} ${molGroupName} ${actionDescription.TURNED_OFF}`
- };
- }
- } else if (action.type === selectionConstants.SET_HIDE_ALL) {
- if (action.data) {
- let objectType = actionObjectType.MOLECULE;
- let description = action.isHide === true ? `` : `${actionDescription.CANCELED}`;
-
- trackAction = {
- type: actionType.ALL_HIDE,
- annotation: actionAnnotation.CLEAR,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- data: action.data,
- text: `${actionDescription.ALL} ${actionDescription.HIDDEN} ${description}`
- };
- }
- } else if (action.type === selectionConstants.SET_SELECTED_ALL) {
- if (action.item) {
- let objectType = action.item.isInspiration === true ? actionObjectType.INSPIRATION : actionObjectType.MOLECULE;
- let objectName = action.item.name || getMoleculeName(action.item.id, state);
-
- trackAction = {
- type: actionType.ALL_TURNED_ON,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.item.id,
- isLigand: action.isLigand,
- isProtein: action.isProtein,
- isComplex: action.isComplex,
- item: action.item,
- text: `${actionDescription.ALL} ${actionDescription.TURNED_ON} ${objectType} ${getMoleculeTitle(
- objectName,
- target_on_name
- )}`
- };
- }
- } else if (action.type === selectionConstants.SET_DESELECTED_ALL) {
- if (action.item) {
- let objectType = action.item.isInspiration === true ? actionObjectType.INSPIRATION : actionObjectType.MOLECULE;
- let objectName = action.item.name || getMoleculeName(action.item.id, state);
-
- trackAction = {
- type: actionType.ALL_TURNED_OFF,
- annotation: actionAnnotation.CLEAR,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.item.id,
- isLigand: action.isLigand,
- isProtein: action.isProtein,
- isComplex: action.isComplex,
- item: action.item,
- text: `${actionDescription.ALL} ${actionDescription.TURNED_OFF} ${objectType} ${getMoleculeTitle(
- objectName,
- target_on_name
- )}`
- };
- }
- } else if (action.type === selectionConstants.SET_SELECTED_BY_TYPE) {
- if (action.payload) {
- let payload = action.payload;
- let objectType = payload.isInspiration === true ? actionObjectType.INSPIRATION : actionObjectType.MOLECULE;
- let paylodTypeDescription = getTypeDescriptionOfSelectedAllAction(payload.type);
-
- trackAction = {
- type: actionType.SELECTED_TURNED_ON_BY_TYPE,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- control_type: payload.type,
- items: payload.items,
- text: `${actionDescription.SELECTED_TYPE} ${paylodTypeDescription} ${actionDescription.TURNED_ON} ${objectType}`
- };
- }
- } else if (action.type === selectionConstants.SET_DESELECTED_ALL_BY_TYPE) {
- if (action.payload) {
- let payload = action.payload;
- let objectType = payload.isInspiration === true ? actionObjectType.INSPIRATION : actionObjectType.MOLECULE;
- let paylodTypeDescription = getTypeDescriptionOfSelectedAllAction(payload.type);
-
- trackAction = {
- type: actionType.ALL_TURNED_OFF_BY_TYPE,
- annotation: actionAnnotation.CLEAR,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- control_type: payload.type,
- items: payload.items,
- text: `${actionDescription.ALL} ${paylodTypeDescription} ${actionDescription.TURNED_OFF} ${objectType}`
- };
- }
- } else if (action.type === customDatasetConstants.APPEND_COLOR_TO_ALL_COMPOUNDS_OF_DATASET) {
- let objectType = actionObjectType.COMPOUND;
-
- trackAction = {
- type: actionType.ALL_COMPOUNDS_ADDED_TO_COLOR_GROUP,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- items: action.payload.cmpIds,
- color: action.payload.colorClass,
- dataset_id: action.payload.datasetID,
- text: `All compounds of dataset ${action.payload.datasetID} were colored with color ${action.payload.colorClass}`
- };
- } else if (action.type === customDatasetConstants.REMOVE_COLOR_FROM_ALL_COMPOUNDS_OF_DATASET) {
- let objectType = actionObjectType.COMPOUND;
-
- trackAction = {
- type: actionType.ALL_COMPOUNDS_REMOVED_FROM_COLOR_GROUP,
- annotation: actionAnnotation.CLEAR,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- items: action.payload.cmpIds,
- color: action.payload.colorClass,
- dataset_id: action.payload.datasetID,
- text: `All compounds of dataset ${action.payload.datasetID} were unpainted with color ${action.payload.colorClass}`
- };
- } else if (action.type === selectionConstants.SET_SELECT_ALL_MOLECULES) {
- if (action && action.items) {
- let objectType = actionObjectType.MOLECULE;
-
- trackAction = {
- type: actionType.ALL_MOLECULES_SELECTED,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- items: [...action.items],
- text: `All hits were selected`
- };
- }
- } else if (action.type === selectionConstants.SET_UNSELECT_ALL_MOLECULES) {
- if (action && action.items) {
- let objectType = actionObjectType.MOLECULE;
-
- trackAction = {
- type: actionType.ALL_MOLECULES_UNSELECTED,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- items: action.items,
- text: `All hits were unselected`
- };
- }
- } else if (action.type === selectionConstants.SET_SELECT_VISIBLE_POSES) {
- if (action && action.items) {
- let objectType = actionObjectType.MOLECULE;
-
- trackAction = {
- type: actionType.ALL_VISIBLE_HITS_SELECTED,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- items: [...action.items],
- text: `All visible hits were selected`
- };
- }
- } else if (action.type === selectionConstants.SET_UNSELECT_VISIBLE_POSES) {
- if (action && action.items) {
- let objectType = actionObjectType.MOLECULE;
-
- trackAction = {
- type: actionType.ALL_VISIBLE_HITS_UNSELECTED,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- items: [...action.items],
- text: `All visible hits were unselected`
- };
- }
- } else if (action.type === selectionConstants.APPEND_FRAGMENT_DISPLAY_LIST) {
- if (action.item) {
- let objectType = action.item.isInspiration === true ? actionObjectType.INSPIRATION : actionObjectType.MOLECULE;
- let objectName = action.item.name || getMoleculeName(action.item.id, state);
-
- trackAction = {
- type: actionType.LIGAND_TURNED_ON,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.item.id,
- text: `${actionDescription.LIGAND} ${actionDescription.TURNED_ON} ${objectType} ${getMoleculeTitle(
- objectName,
- target_on_name
- )}`
- };
- }
- } else if (action.type === selectionConstants.REMOVE_FROM_FRAGMENT_DISPLAY_LIST) {
- if (action.item) {
- let objectType = action.item.isInspiration === true ? actionObjectType.INSPIRATION : actionObjectType.MOLECULE;
- let objectName = action.item.name || getMoleculeName(action.item.id, state);
-
- trackAction = {
- type: actionType.LIGAND_TURNED_OFF,
- annotation: actionAnnotation.CLEAR,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.item.id,
- text: `${actionDescription.LIGAND} ${actionDescription.TURNED_OFF} ${objectType} ${getMoleculeTitle(
- objectName,
- target_on_name
- )}`
- };
- }
- } else if (action.type === selectionConstants.APPEND_PROTEIN_LIST) {
- if (action.item) {
- let objectType = action.item.isInspiration === true ? actionObjectType.INSPIRATION : actionObjectType.MOLECULE;
- let objectName = action.item.name || getMoleculeName(action.item.id, state);
-
- trackAction = {
- type: actionType.SIDECHAINS_TURNED_ON,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.item.id,
- text: `${actionDescription.SIDECHAIN} ${actionDescription.TURNED_ON} ${objectType} ${getMoleculeTitle(
- objectName,
- target_on_name
- )}`
- };
- }
- } else if (action.type === selectionConstants.REMOVE_FROM_PROTEIN_LIST) {
- if (action.item) {
- let objectType = action.item.isInspiration === true ? actionObjectType.INSPIRATION : actionObjectType.MOLECULE;
- let objectName = action.item.name || getMoleculeName(action.item.id, state);
-
- trackAction = {
- type: actionType.SIDECHAINS_TURNED_OFF,
- annotation: actionAnnotation.CLEAR,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.item.id,
- text: `${actionDescription.SIDECHAIN} ${actionDescription.TURNED_OFF} ${objectType} ${getMoleculeTitle(
- objectName,
- target_on_name
- )}`
- };
- }
- } else if (action.type === selectionConstants.APPEND_DENSITY_TYPE) {
- let objectType = action.item.isInspiration === true ? actionObjectType.INSPIRATION : actionObjectType.MOLECULE;
- let objectName = action.item.name || getMoleculeName(action.item.id, state);
-
- trackAction = {
- type: actionType.DENSITY_TYPE_ON,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.item.id,
- render_event: action.item.render_event,
- render_sigmaa: action.item.render_sigmaa,
- render_diff: action.item.render_diff,
- render_quality: action.item.render_quality,
- text: `${actionDescription.DENSITY} ${actionDescription.TURNED_ON} ${objectType} ${getMoleculeTitle(
- objectName,
- target_on_name
- )}`
- };
- } else if (action.type === selectionConstants.REMOVE_DENSITY_TYPE) {
- let objectType = action.item.isInspiration === true ? actionObjectType.INSPIRATION : actionObjectType.MOLECULE;
- let objectName = action.item.name || getMoleculeName(action.item.id, state);
-
- trackAction = {
- type: actionType.DENSITY_TYPE_OFF,
- annotation: actionAnnotation.CLEAR,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.item.id,
- text: `${actionDescription.DENSITY} ${actionDescription.TURNED_OFF} ${objectType} ${getMoleculeTitle(
- objectName,
- target_on_name
- )}`
- };
- } else if (action.type === selectionConstants.APPEND_DENSITY_LIST) {
- if (action.item) {
- let objectType = action.item.isInspiration === true ? actionObjectType.INSPIRATION : actionObjectType.MOLECULE;
- let objectName = action.item.name || getMoleculeName(action.item.id, state);
-
- trackAction = {
- type: actionType.DENSITY_TURNED_ON,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.item.id,
- text: `${actionDescription.DENSITY} ${actionDescription.TURNED_ON} ${objectType} ${getMoleculeTitle(
- objectName,
- target_on_name
- )}`
- };
- }
- } else if (action.type === selectionConstants.REMOVE_FROM_DENSITY_LIST) {
- if (action.item) {
- let objectType = action.item.isInspiration === true ? actionObjectType.INSPIRATION : actionObjectType.MOLECULE;
- let objectName = action.item.name || getMoleculeName(action.item.id, state);
-
- trackAction = {
- type: actionType.DENSITY_TURNED_OFF,
- annotation: actionAnnotation.CLEAR,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.item.id,
- text: `${actionDescription.DENSITY} ${actionDescription.TURNED_OFF} ${objectType} ${getMoleculeTitle(
- objectName,
- target_on_name
- )}`
- };
- }
- } else if (action.type === selectionConstants.APPEND_DENSITY_LIST_CUSTOM) {
- if (action.item) {
- let objectType = action.item.isInspiration === true ? actionObjectType.INSPIRATION : actionObjectType.MOLECULE;
- let objectName = action.item.name || getMoleculeName(action.item.id, state);
-
- trackAction = {
- type: actionType.DENSITY_CUSTOM_TURNED_ON,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.item.id,
- text: `${actionDescription.DENSITY} ${actionDescription.CUSTOM_VIEW} ${
- actionDescription.TURNED_ON
- } ${objectType} ${getMoleculeTitle(objectName, target_on_name)}`
- };
- }
- } else if (action.type === selectionConstants.REMOVE_FROM_DENSITY_LIST_CUSTOM) {
- if (action.item) {
- let objectType = action.item.isInspiration === true ? actionObjectType.INSPIRATION : actionObjectType.MOLECULE;
- let objectName = action.item.name || getMoleculeName(action.item.id, state);
-
- trackAction = {
- type: actionType.DENSITY_CUSTOM_TURNED_OFF,
- annotation: actionAnnotation.CLEAR,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.item.id,
- text: `${actionDescription.DENSITY} ${actionDescription.CUSTOM_VIEW} ${
- actionDescription.TURNED_OFF
- } ${objectType} ${getMoleculeTitle(objectName, target_on_name)}`
- };
- }
- } else if (action.type === selectionConstants.APPEND_COMPLEX_LIST) {
- if (action.item) {
- let objectType = action.item.isInspiration === true ? actionObjectType.INSPIRATION : actionObjectType.MOLECULE;
- let objectName = action.item.name || getMoleculeName(action.item.id, state);
-
- trackAction = {
- type: actionType.INTERACTIONS_TURNED_ON,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.item.id,
- text: `${actionDescription.INTERACTION} ${actionDescription.TURNED_ON} ${objectType} ${getMoleculeTitle(
- objectName,
- target_on_name
- )}`
- };
- }
- } else if (action.type === selectionConstants.REMOVE_FROM_COMPLEX_LIST) {
- if (action.item) {
- let objectType = action.item.isInspiration === true ? actionObjectType.INSPIRATION : actionObjectType.MOLECULE;
- let objectName = action.item.name || getMoleculeName(action.item.id, state);
-
- trackAction = {
- type: actionType.INTERACTIONS_TURNED_OFF,
- annotation: actionAnnotation.CLEAR,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.item.id,
- text: `${actionDescription.INTERACTION} ${actionDescription.TURNED_OFF} ${objectType} ${getMoleculeTitle(
- objectName,
- target_on_name
- )}`
- };
- }
- } else if (action.type === selectionConstants.APPEND_SURFACE_LIST) {
- if (action.item) {
- let objectType = action.item.isInspiration === true ? actionObjectType.INSPIRATION : actionObjectType.MOLECULE;
- let objectName = action.item.name || getMoleculeName(action.item.id, state);
-
- trackAction = {
- type: actionType.SURFACE_TURNED_ON,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.item.id,
- text: `${actionDescription.SURFACE} ${actionDescription.TURNED_ON} ${objectType} ${getMoleculeTitle(
- objectName,
- target_on_name
- )}`
- };
- }
- } else if (action.type === selectionConstants.REMOVE_FROM_SURFACE_LIST) {
- if (action.item) {
- let objectType = action.item.isInspiration === true ? actionObjectType.INSPIRATION : actionObjectType.MOLECULE;
- let objectName = action.item.name || getMoleculeName(action.item.id, state);
-
- trackAction = {
- type: actionType.SURFACE_TURNED_OFF,
- annotation: actionAnnotation.CLEAR,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.item.id,
- text: `${actionDescription.SURFACE} ${actionDescription.TURNED_OFF} ${objectType} ${getMoleculeTitle(
- objectName,
- target_on_name
- )}`
- };
- }
- } else if (action.type === selectionConstants.APPEND_QUALITY_LIST) {
- if (action.item) {
- let objectType = action.item.isInspiration === true ? actionObjectType.INSPIRATION : actionObjectType.MOLECULE;
- let objectName = action.item.name || getMoleculeName(action.item.id, state);
-
- trackAction = {
- type: actionType.QUALITY_TURNED_ON,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.item.id,
- text: `${actionDescription.QUALITY} ${actionDescription.TURNED_ON} ${objectType} ${getMoleculeTitle(
- objectName,
- target_on_name
- )}`
- };
- }
- } else if (action.type === selectionConstants.REMOVE_FROM_QUALITY_LIST) {
- if (action.item) {
- let objectType = action.item.isInspiration === true ? actionObjectType.INSPIRATION : actionObjectType.MOLECULE;
- let objectName = action.item.name || getMoleculeName(action.item.id, state);
-
- trackAction = {
- type: actionType.QUALITY_TURNED_OFF,
- annotation: actionAnnotation.CLEAR,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.item.id,
- text: `${actionDescription.QUALITY} ${actionDescription.TURNED_OFF} ${objectType} ${getMoleculeTitle(
- objectName,
- target_on_name
- )}`
- };
- }
- } else if (action.type === selectionConstants.APPEND_VECTOR_ON_LIST) {
- if (action.item) {
- let objectType = action.item.isInspiration === true ? actionObjectType.INSPIRATION : actionObjectType.MOLECULE;
- let objectName = action.item.name || getMoleculeName(action.item.id, state);
-
- trackAction = {
- type: actionType.VECTORS_TURNED_ON,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.item.id,
- text: `${actionDescription.VECTOR} ${actionDescription.TURNED_ON} ${objectType} ${getMoleculeTitle(
- objectName,
- target_on_name
- )}`
- };
- }
- } else if (action.type === selectionConstants.REMOVE_FROM_VECTOR_ON_LIST) {
- if (action.item) {
- let objectType = action.item.isInspiration === true ? actionObjectType.INSPIRATION : actionObjectType.MOLECULE;
- let objectName = action.item.name || getMoleculeName(action.item.id, state);
-
- trackAction = {
- type: actionType.VECTORS_TURNED_OFF,
- annotation: actionAnnotation.CLEAR,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.item.id,
- text: `${actionDescription.VECTOR} ${actionDescription.TURNED_OFF} ${objectType} ${getMoleculeTitle(
- objectName,
- target_on_name
- )}`
- };
- }
- } else if (action.type === selectionConstants.SET_ARROW_UP_DOWN) {
- let payload = action.payload;
- if (payload) {
- let item = payload.item;
- let newItem = payload.newItem;
- let objectType = item && item.isInspiration === true ? actionObjectType.INSPIRATION : actionObjectType.MOLECULE;
- let objectTypeDescription =
- item && item.isInspiration === true ? actionDescription.INSPIRATION : actionDescription.MOLECULE;
- let itemName = item?.name || getMoleculeName(item?.id, state);
- let newItemName = newItem?.name || getMoleculeName(newItem?.id, state);
-
- trackAction = {
- type: actionType.ARROW_NAVIGATION,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: itemName,
- object_id: item?.id,
- item: item,
- newItem: newItem,
- data: payload.data,
- arrowType: payload.arrowType,
- text: `${objectTypeDescription} ${actionDescription.MOVED} from: ${itemName} to ${newItemName}`
- };
- }
- } else if (action.type === selectionConstants.APPEND_TO_BUY_LIST) {
- if (action.item) {
- let objectType = actionObjectType.MOLECULE;
- let objectName = action.item && action.item.vector;
-
- trackAction = {
- type: actionType.MOLECULE_ADDED_TO_SHOPPING_CART,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: objectName,
- compoundId: action.index,
- item: action.item,
- text: `${actionDescription.VECTOR} ${objectName} ${actionDescription.ADDED} ${actionDescription.TO_SHOPPING_CART}`
- };
- }
- } else if (action.type === selectionConstants.REMOVE_FROM_TO_BUY_LIST) {
- if (action.item) {
- let objectType = actionObjectType.MOLECULE;
- let objectName = action.item && action.item.vector;
-
- trackAction = {
- type: actionType.MOLECULE_REMOVED_FROM_SHOPPING_CART,
- annotation: actionAnnotation.CLEAR,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: objectName,
- compoundId: action.index,
- item: action.item,
- text: `${actionDescription.VECTOR} ${objectName} ${actionDescription.REMOVED} ${actionDescription.FROM_SHOPPING_CART}`
- };
- }
- } else if (action.type === selectionConstants.APPEND_TO_BUY_LIST_ALL) {
- let items = action.items;
- let objectType = actionObjectType.COMPOUND;
-
- trackAction = {
- type: actionType.MOLECULE_ADDED_TO_SHOPPING_CART_ALL,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- items: items,
- text: `${actionDescription.ALL} ${actionDescription.ADDED} ${actionDescription.TO_SHOPPING_CART}`
- };
- } else if (action.type === selectionConstants.REMOVE_FROM_BUY_LIST_ALL) {
- let items = action.items;
- let objectType = actionObjectType.COMPOUND;
-
- trackAction = {
- type: actionType.MOLECULE_REMOVED_FROM_SHOPPING_CART_ALL,
- annotation: actionAnnotation.CLEAR,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- items: items,
- text: `${actionDescription.ALL} ${actionDescription.REMOVED} ${actionDescription.FROM_SHOPPING_CART}`
- };
- } else if (action.type === previewCompoundConstants.APPEND_SHOWED_COMPOUND_LIST) {
- let objectType = actionObjectType.COMPOUND;
- let objectName = action.item && action.item.vector;
- let objectId = action.item && action.item.smiles;
-
- trackAction = {
- type: actionType.VECTOR_COUMPOUND_ADDED,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: objectId,
- item: action.item,
- compoundId: action.payload,
- text: `${actionDescription.COMPOUND} ${objectName} ${actionDescription.ADDED}`
- };
- } else if (action.type === previewCompoundConstants.REMOVE_SHOWED_COMPOUND_LIST) {
- let objectType = actionObjectType.COMPOUND;
- let objectName = action.item && action.item.vector;
- let objectId = action.item && action.item.smiles;
-
- trackAction = {
- type: actionType.VECTOR_COUMPOUND_REMOVED,
- annotation: actionAnnotation.CLEAR,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: objectId,
- item: action.item,
- compoundId: action.payload,
- text: `${actionDescription.COMPOUND} ${objectName} ${actionDescription.REMOVED}`
- };
- } else if (action.type === selectionConstants.SET_CURRENT_VECTOR) {
- if (action.payload) {
- let objectType = actionObjectType.MOLECULE;
- let objectName = action.payload;
-
- trackAction = {
- type: actionType.VECTOR_SELECTED,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.payload,
- text: `${actionDescription.VECTOR} ${objectName} ${actionDescription.SELECTED}`
- };
- }
- } else if (action.type === customDatasetConstants.APPEND_COLOR_TO_SELECTED_COLOR_FILTERS) {
- if (action.payload) {
- let objectType = actionObjectType.COMPOUND;
-
- trackAction = {
- type: actionType.COLOR_FILTER_TURNED_ON,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: 'color_filter',
- object_id: 'color_filter',
- value: action.payload.colorClass,
- text: `${actionDescription.CLASS} filter turned on for color: ${action.payload.colorClass} `
- };
- }
- } else if (action.type === customDatasetConstants.REMOVE_COLOR_FROM_SELECTED_COLOR_FILTERS) {
- if (action.payload) {
- let objectType = actionObjectType.COMPOUND;
-
- trackAction = {
- type: actionType.COLOR_FILTER_TURNED_OFF,
- annotation: actionAnnotation.CLEAR,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: 'color_filter',
- object_id: 'color_filter',
- value: action.payload.colorClass,
- text: `${actionDescription.CLASS} filter turned off for color: ${action.payload.colorClass} `
- };
- }
- } else if (action.type === previewCompoundConstants.SET_CURRENT_COMPOUND_CLASS) {
- if (action.payload) {
- let objectType = actionObjectType.COMPOUND;
- let objectName = action.payload;
- let oldObjectName = action.oldCompoundClass;
-
- trackAction = {
- type: actionType.CLASS_SELECTED,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: objectName,
- oldValue: oldObjectName,
- value: objectName,
- text: `${actionDescription.CLASS} ${actionDescription.CHANGED} from value: ${oldObjectName} to value: ${objectName}`
- };
- }
- } else if (action.type === previewCompoundConstants.SET_COMPOUND_CLASSES) {
- if (action.payload) {
- let objectType = actionObjectType.COMPOUND;
-
- trackAction = {
- type: actionType.CLASS_UPDATED,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: action.value,
- object_id: action.id,
- newCompoundClasses: action.payload,
- oldCompoundClasses: action.oldCompoundClasses,
- text: `${actionDescription.CLASS} value ${actionDescription.UPDATED}: ${action.id}:${action.value}`
- };
- }
- } else if (action.type === customDatasetConstants.APPEND_COMPOUND_TO_SELECTED_COMPOUNDS_BY_DATASET) {
- if (action.payload) {
- let objectType = actionObjectType.COMPOUND;
- let objectName = action.payload.compoundTitle;
-
- trackAction = {
- type: actionType.COMPOUND_LOCKED,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.payload.compoundID,
- dataset_id: action.payload.datasetID,
- text: `${objectType} ${objectName} ${actionDescription.LOCKED} of dataset: ${action.payload.datasetID}`
- };
- }
- } else if (action.type === customDatasetConstants.REMOVE_COMPOUND_FROM_SELECTED_COMPOUNDS_BY_DATASET) {
- if (action.payload) {
- let objectType = actionObjectType.COMPOUND;
- let objectName = action.payload.compoundTitle;
-
- trackAction = {
- type: actionType.COMPOUND_UNLOCKED,
- annotation: actionAnnotation.CLEAR,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.payload.compoundID,
- dataset_id: action.payload.datasetID,
- text: `${objectType} ${objectName} ${actionDescription.UNLOCKED} of dataset: ${action.payload.datasetID}`
- };
- }
- } else if (action.type === customDatasetConstants.APPEND_COMPOUND_COLOR_OF_DATASET) {
- if (action.payload) {
- let objectType = actionObjectType.COMPOUND;
- let objectName = action.payload.compoundTitle;
-
- trackAction = {
- type: actionType.COMPOUND_ADDED_TO_COLOR_GROUP,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.payload.compoundID,
- dataset_id: action.payload.datasetID,
- color_class: action.payload.colorClass,
- text: `${objectType} ${objectName} ${actionDescription.ADDED_TO_COLOR_GROUP} ${action.payload.colorClass} of dataset: ${action.payload.datasetID}`
- };
- }
- } else if (action.type === customDatasetConstants.REMOVE_COMPOUND_COLOR_OF_DATASET) {
- if (action.payload) {
- let objectType = actionObjectType.COMPOUND;
- let objectName = action.payload.compoundTitle;
-
- trackAction = {
- type: actionType.COMPOUND_REMOVED_FROM_COLOR_GROUP,
- annotation: actionAnnotation.CLEAR,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.payload.compoundID,
- dataset_id: action.payload.datasetID,
- color_class: action.payload.colorClass,
- text: `${objectType} ${objectName} ${actionDescription.REMOVED_FROM_COLOR_GROUP} ${action.payload.colorClass} of dataset: ${action.payload.datasetID}`
- };
- }
- } else if (action.type === customDatasetConstants.APPEND_MOLECULE_TO_COMPOUNDS_TO_BUY_OF_DATASET) {
- if (action.payload) {
- let objectType = actionObjectType.COMPOUND;
- let objectName = action.payload.moleculeTitle;
-
- trackAction = {
- type: actionType.COMPOUND_SELECTED,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.payload.moleculeID,
- dataset_id: action.payload.datasetID,
- text: `${objectType} ${objectName} ${actionDescription.SELECTED} of dataset: ${action.payload.datasetID}`
- };
- }
- } else if (action.type === customDatasetConstants.REMOVE_MOLECULE_FROM_COMPOUNDS_TO_BUY_OF_DATASET) {
- if (action.payload) {
- let objectType = actionObjectType.COMPOUND;
- let objectName = action.payload.moleculeTitle;
-
- trackAction = {
- type: actionType.COMPOUND_DESELECTED,
- annotation: actionAnnotation.CLEAR,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.payload.moleculeID,
- dataset_id: action.payload.datasetID,
- text: `${objectType} ${objectName} ${actionDescription.DESELECTED} of dataset: ${action.payload.datasetID}`
- };
- }
- } else if (action.type === selectionConstants.APPEND_TO_MOL_LIST_TO_EDIT) {
- if (action.molId) {
- let objectType = actionObjectType.MOLECULE;
- let molId = action.molId;
- let mol = dispatch(getMoleculeForId(molId));
- let objectName = mol.code;
-
- trackAction = {
- type: actionType.MOLECULE_SELECTED,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: molId,
- text: `${objectType} ${objectName} ${actionDescription.SELECTED}`
- };
- }
- } else if (action.type === selectionConstants.REMOVE_FROM_MOL_LIST_TO_EDIT) {
- if (action.molId) {
- let objectType = actionObjectType.MOLECULE;
- let molId = action.molId;
- let mol = dispatch(getMoleculeForId(molId));
- let objectName = mol.code;
-
- trackAction = {
- type: actionType.MOLECULE_UNSELECTED,
- annotation: actionAnnotation.CLEAR,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: molId,
- text: `${objectType} ${objectName} ${actionDescription.DESELECTED}`
- };
- }
- } else if (action.type === customDatasetConstants.SET_SELECTED_ALL) {
- if (action.payload && action.payload.item) {
- let objectType =
- action.payload.item.isCrossReference === true ? actionObjectType.CROSS_REFERENCE : actionObjectType.COMPOUND;
- let objectName = action.payload.item.name;
-
- trackAction = {
- type: actionType.ALL_TURNED_ON,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.payload.item.id,
- dataset_id: action.payload.datasetID,
- isLigand: action.payload.isLigand,
- isProtein: action.payload.isProtein,
- isComplex: action.payload.isComplex,
- item: action.payload.item,
- text: `${actionDescription.ALL} ${actionDescription.TURNED_ON} ${objectType} ${objectName} of dataset: ${action.payload.datasetID}`
- };
- }
- } else if (action.type === customDatasetConstants.SET_DESELECTED_ALL) {
- if (action.payload && action.payload.item) {
- let objectType =
- action.payload.item.isCrossReference === true ? actionObjectType.CROSS_REFERENCE : actionObjectType.COMPOUND;
- let objectName = action.payload.item.name;
-
- trackAction = {
- type: actionType.ALL_TURNED_OFF,
- annotation: actionAnnotation.CLEAR,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.payload.item.id,
- dataset_id: action.payload.datasetID,
- isLigand: action.payload.isLigand,
- isProtein: action.payload.isProtein,
- isComplex: action.payload.isComplex,
- item: action.payload.item,
- text: `${actionDescription.ALL} ${actionDescription.TURNED_OFF} ${objectType} ${objectName} of dataset: ${action.payload.datasetID}`
- };
- }
- } else if (action.type === customDatasetConstants.SET_SELECTED_BY_TYPE) {
- if (action.payload) {
- let payload = action.payload;
- let objectType =
- payload.isCrossReference === true ? actionObjectType.CROSS_REFERENCE : actionObjectType.COMPOUND;
- let paylodTypeDescription = getTypeDescriptionOfSelectedAllAction(payload.type);
- let datasetDescription = payload.datasetID ? `of dataset: ${payload.datasetID}` : '';
-
- trackAction = {
- type: actionType.SELECTED_TURNED_ON_BY_TYPE,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- control_type: payload.type,
- items: payload.items,
- text: `${actionDescription.SELECTED_TYPE} ${paylodTypeDescription} ${actionDescription.TURNED_ON} ${objectType} ${datasetDescription}`
- };
- }
- } else if (action.type === customDatasetConstants.SET_DESELECTED_ALL_BY_TYPE) {
- if (action.payload) {
- let payload = action.payload;
- let objectType =
- payload.isCrossReference === true ? actionObjectType.CROSS_REFERENCE : actionObjectType.COMPOUND;
- let paylodTypeDescription = getTypeDescriptionOfSelectedAllAction(payload.type);
- let datasetDescription = payload.datasetID ? `of dataset: ${payload.datasetID}` : '';
-
- trackAction = {
- type: actionType.ALL_TURNED_OFF_BY_TYPE,
- annotation: actionAnnotation.CLEAR,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- control_type: payload.type,
- items: payload.items,
- text: `${actionDescription.ALL} ${paylodTypeDescription} ${actionDescription.TURNED_OFF} ${objectType} ${datasetDescription}`
- };
- }
- } else if (action.type === customDatasetConstants.APPEND_LIGAND_LIST) {
- if (action.payload && action.payload.item) {
- let objectType =
- action.payload.item.isCrossReference === true ? actionObjectType.CROSS_REFERENCE : actionObjectType.COMPOUND;
- let objectName = action.payload.item.name;
-
- trackAction = {
- type: actionType.LIGAND_TURNED_ON,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.payload.item.id,
- dataset_id: action.payload.datasetID,
- text: `${actionDescription.LIGAND} ${actionDescription.TURNED_ON} ${objectType} ${objectName} of dataset: ${action.payload.datasetID}`
- };
- }
- } else if (action.type === customDatasetConstants.REMOVE_FROM_LIGAND_LIST) {
- if (action.payload && action.payload.item) {
- let objectType =
- action.payload.item.isCrossReference === true ? actionObjectType.CROSS_REFERENCE : actionObjectType.COMPOUND;
- let objectName = action.payload.item.name;
-
- trackAction = {
- type: actionType.LIGAND_TURNED_OFF,
- annotation: actionAnnotation.CLEAR,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.payload.item.id,
- dataset_id: action.payload.datasetID,
- text: `${actionDescription.LIGAND} ${actionDescription.TURNED_OFF} ${objectType} ${objectName} of dataset: ${action.payload.datasetID}`
- };
- }
- } else if (action.type === customDatasetConstants.APPEND_PROTEIN_LIST) {
- if (action.payload && action.payload.item) {
- let objectType =
- action.payload.item.isCrossReference === true ? actionObjectType.CROSS_REFERENCE : actionObjectType.COMPOUND;
- let objectName = action.payload.item.name;
-
- trackAction = {
- type: actionType.SIDECHAINS_TURNED_ON,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.payload.item.id,
- dataset_id: action.payload.datasetID,
- text: `${actionDescription.SIDECHAIN} ${actionDescription.TURNED_ON} ${objectType} ${objectName} of dataset: ${action.payload.datasetID}`
- };
- }
- } else if (action.type === customDatasetConstants.REMOVE_FROM_PROTEIN_LIST) {
- if (action.payload && action.payload.item) {
- let objectType =
- action.payload.item.isCrossReference === true ? actionObjectType.CROSS_REFERENCE : actionObjectType.COMPOUND;
- let objectName = action.payload.item.name;
-
- trackAction = {
- type: actionType.SIDECHAINS_TURNED_OFF,
- annotation: actionAnnotation.CLEAR,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.payload.item.id,
- dataset_id: action.payload.datasetID,
- text: `${actionDescription.SIDECHAIN} ${actionDescription.TURNED_OFF} ${objectType} ${objectName} of dataset: ${action.payload.datasetID}`
- };
- }
- } else if (action.type === customDatasetConstants.APPEND_COMPLEX_LIST) {
- if (action.payload && action.payload.item) {
- let objectType =
- action.payload.item.isCrossReference === true ? actionObjectType.CROSS_REFERENCE : actionObjectType.COMPOUND;
- let objectName = action.payload.item.name;
-
- trackAction = {
- type: actionType.INTERACTIONS_TURNED_ON,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.payload.item.id,
- dataset_id: action.payload.datasetID,
- text: `${actionDescription.INTERACTION} ${actionDescription.TURNED_ON} ${objectType} ${objectName} of dataset: ${action.payload.datasetID}`
- };
- }
- } else if (action.type === customDatasetConstants.REMOVE_FROM_COMPLEX_LIST) {
- if (action.payload && action.payload.item) {
- let objectType =
- action.payload.item.isCrossReference === true ? actionObjectType.CROSS_REFERENCE : actionObjectType.COMPOUND;
- let objectName = action.payload.item.name;
-
- trackAction = {
- type: actionType.INTERACTIONS_TURNED_OFF,
- annotation: actionAnnotation.CLEAR,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.payload.item.id,
- dataset_id: action.payload.datasetID,
- text: `${actionDescription.INTERACTION} ${actionDescription.TURNED_OFF} ${objectType} ${objectName} of dataset: ${action.payload.datasetID}`
- };
- }
- } else if (action.type === customDatasetConstants.APPEND_SURFACE_LIST) {
- if (action.payload && action.payload.item) {
- let objectType =
- action.payload.item.isCrossReference === true ? actionObjectType.CROSS_REFERENCE : actionObjectType.COMPOUND;
- let objectName = action.payload.item.name;
-
- trackAction = {
- type: actionType.SURFACE_TURNED_ON,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.payload.item.id,
- dataset_id: action.payload.datasetID,
- text: `${actionDescription.SURFACE} ${actionDescription.TURNED_ON} ${objectType} ${objectName} of dataset: ${action.payload.datasetID}`
- };
- }
- } else if (action.type === customDatasetConstants.REMOVE_FROM_SURFACE_LIST) {
- if (action.payload && action.payload.item) {
- let objectType =
- action.payload.item.isCrossReference === true ? actionObjectType.CROSS_REFERENCE : actionObjectType.COMPOUND;
- let objectName = action.payload.item.name;
-
- trackAction = {
- type: actionType.SURFACE_TURNED_OFF,
- annotation: actionAnnotation.CLEAR,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: action.payload.item.id,
- dataset_id: action.payload.datasetID,
- text: `${actionDescription.SURFACE} ${actionDescription.TURNED_OFF} ${objectType} ${objectName} of dataset: ${action.payload.datasetID}`
- };
- }
- } else if (action.type === customDatasetConstants.SET_ARROW_UP_DOWN) {
- let payload = action.payload;
- if (payload) {
- const proteinList = state.selectionReducers.proteinList;
- const complexList = state.selectionReducers.complexList;
- const fragmentDisplayList = state.selectionReducers.fragmentDisplayList;
- const surfaceList = state.selectionReducers.surfaceList;
- const densityList = state.selectionReducers.densityList;
- const vectorOnList = state.selectionReducers.vectorOnList;
-
- let item = payload.item;
- let newItem = payload.newItem;
- let objectType =
- item && item.isCrossReference === true ? actionObjectType.CROSS_REFERENCE : actionObjectType.COMPOUND;
- let objectTypeDescription =
- item && item.isCrossReference === true ? actionDescription.CROSS_REFERENCE : actionDescription.COMPOUND;
- let itemId = item?.id;
- let itemName = item?.name;
- let newItemName = newItem?.name;
-
- let data = Object.assign(
- { proteinList, complexList, fragmentDisplayList, surfaceList, densityList, vectorOnList },
- payload.data
- );
-
- trackAction = {
- type: actionType.ARROW_NAVIGATION,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: itemName,
- object_id: itemId,
- datasetID: payload.datasetID,
- item: item,
- newItem: newItem,
- data: data,
- arrowType: payload.arrowType,
- text: `${objectTypeDescription} ${actionDescription.MOVED} from: ${itemName} to ${newItemName}`
- };
- }
- } else if (action.type === customDatasetConstants.SET_TAB_VALUE) {
- if (action.payload) {
- let objectType = actionObjectType.COMPOUND;
- let objectName = action.payload.name;
- let objectId = action.payload.value;
- let oldObjectId = action.payload.oldValue;
- let oldObjectName = action.payload.oldName;
-
- trackAction = {
- type: actionType.TAB,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: objectId,
- oldObjectId: oldObjectId,
- oldObjectName: oldObjectName,
- text: `${actionDescription.TAB} ${objectName} ${actionDescription.SELECTED}`
- };
- }
- } else if (action.type === customDatasetConstants.SET_SELECTED_DATASET_INDEX) {
- if (action.payload) {
- let objectType = actionObjectType.COMPOUND;
- let objectName = action.payload.name;
- let objectId = action.payload.value;
- let oldObjectId = action.payload.oldValue;
- let oldObjectName = action.payload.oldName;
-
- trackAction = {
- type: actionType.DATASET_INDEX,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: objectName,
- object_id: objectId,
- oldObjectId: oldObjectId,
- oldObjectName: oldObjectName,
- text: `${actionDescription.DATASET} ${objectName} ${actionDescription.SELECTED}`
- };
- }
- } else if (action.type === customDatasetConstants.SET_DATASET_FILTER) {
- if (action.payload) {
- const {
- filterPropertiesDatasetMap: filterProperties,
- filterDatasetMap: filterSettings,
- dragDropMap
- } = state.datasetsReducers;
- const { datasetID, key, properties, settings, dragDropState } = action.payload;
-
- const filterPropertiesOfDataset = (filterProperties[datasetID] = {});
- const filterSettingsOfDataset = (filterSettings[datasetID] = {});
-
- const objectType = actionObjectType.COMPOUND;
- const descriptionProperties = getFilterKeyChange(filterPropertiesOfDataset[key], properties[key]);
-
- trackAction = {
- type: actionType.DATASET_FILTER,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- oldProperties: filterPropertiesOfDataset,
- oldSettings: filterSettingsOfDataset,
- newProperties: properties,
- newSettings: settings,
- datasetID: datasetID,
- key: key,
- oldDragDropState: dragDropMap[datasetID],
- newDragDropState: dragDropState,
- text:
- key === 'clear'
- ? `Filter ${actionDescription.CHANGED} to default values of dataset: ${datasetID}`
- : `Filter parameter: ${key} ${actionDescription.CHANGED} ${descriptionProperties} of dataset: ${datasetID}`
- };
- }
- } else if (action.type === customDatasetConstants.DRAG_DROP_FINISHED) {
- const { datasetID, molecule, index } = action.payload;
- const {
- dragDropMap,
- dragDropStatus: { startingDragDropState, startingIndex }
- } = state.datasetsReducers;
-
- trackAction = {
- type: actionType.DRAG_DROP_FINISHED,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: actionObjectType.COMPOUND,
- oldDragDropState: startingDragDropState,
- newDragDropState: dragDropMap[datasetID],
- datasetID,
- text: `Position for molecule ${molecule.name} from dataset ${datasetID} changed from ${startingIndex +
- 1} to ${index + 1}`
- };
- } else if (action.type === customDatasetConstants.SET_FILTER_SHOWED_SCORE_PROPERTIES) {
- if (action.payload) {
- let objectType = actionObjectType.COMPOUND;
- let valueDescription = action.payload.isChecked === true ? actionDescription.VISIBLE : actionDescription.HIDDEN;
-
- trackAction = {
- type: actionType.DATASET_FILTER_SCORE,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: action.payload.scoreName,
- isChecked: action.payload.isChecked,
- oldScoreList: action.payload.oldScoreList,
- newScoreList: action.payload.scoreList,
- dataset_id: action.payload.datasetID,
- text: `Filter parameter: ${action.payload.scoreName} ${actionDescription.CHANGED} to ${valueDescription} of dataset: ${action.payload.datasetID}`
- };
- }
- } else if (action.type === customDatasetConstants.SET_SEARCH_STRING) {
- let searchString = action.payload.searchString;
- let objectType = actionType.SEARCH_STRING;
-
- trackAction = {
- type: actionType.SEARCH_STRING,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- dataset_id: action.payload.datasetID,
- searchString: searchString,
- text: `Searched string: ${searchString}`
- };
- } else if (action.type === moleculeConstants.SET_SEARCH_STRING_HIT_NAVIGATOR) {
- let searchStringHitNavigator = action.payload;
- let objectType = actionType.SET_SEARCH_STRING_HIT_NAVIGATOR;
-
- trackAction = {
- type: actionType.SEARCH_STRING_HIT_NAVIGATOR,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- // dataset_id: action.payload.datasetID,
- searchStringHitNavigator: searchStringHitNavigator,
- text: `Searched string in Hit navigator: ${searchStringHitNavigator}`
- };
- } else if (action.type === customDatasetConstants.SET_SELECT_ALL_BUTTON_FOR_DATASET) {
- let selectAllButton = action.payload;
- let objectType = actionType.SELECTED_SELECT_ALL_BUTTON_FOR_DATASET;
-
- trackAction = {
- type: actionType.SELECTED_SELECT_ALL_BUTTON_FOR_DATASET,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- dataset_id: action.payload,
- selectAllButton: selectAllButton,
- text: `Pressed button ${selectAllButton === true ? 'Select' : 'Unselect'} all`
- };
- } else if (action.type === customDatasetConstants.SET_COMPOUND_TO_SELECTED_COMPOUNDS_BY_DATASET) {
- if (action.payload) {
- let selectedAllDatasetCompounds = action.payload;
- let objectType = actionType.SELECT_ALL_DATASET_COMPOUNDS;
-
- trackAction = {
- type: actionType.SELECT_ALL_DATASET_COMPOUNDS,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- dataset_id: action.payload,
- selectedAllDatasetCompounds: selectedAllDatasetCompounds,
- text: `${selectedAllDatasetCompounds === true ? 'Selected' : 'Unselected'} all dataset compounds`
- };
- }
- } else if (action.type === selectionConstants.SET_TAG_DETAIL_VIEW) {
- let tagDetailView = action.payload;
- let objectType = actionType.TAG_DETAIL_VIEW;
- let setGridListView = action.payload === true ? actionDescription.GRID_VIEW : actionDescription.LIST_VIEW;
-
- trackAction = {
- type: actionType.TAG_DETAIL_VIEW,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- dataset_id: action.payload,
- tagDetailView: tagDetailView,
- text: `Selected ${setGridListView} for Tag Detail`
- };
- } else if (action.type === nglConstants.UPDATE_COMPONENT_REPRESENTATION_VISIBILITY) {
- let objectType = actionObjectType.REPRESENTATION;
- let value = action.newVisibility;
- let valueDescription = value === true ? actionDescription.VISIBLE : actionDescription.HIDDEN;
-
- trackAction = {
- type: actionType.REPRESENTATION_VISIBILITY_UPDATED,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: actionObjectType.REPRESENTATION,
- object_name: action.objectInViewID,
- object_id: action.objectInViewID,
- representation_id: action.representationID,
- representation: action.representation,
- value: value,
- text: `${objectType} '${action.representation?.type}' ${actionDescription.VISIBILITY} of ${action.objectInViewID} ${actionDescription.CHANGED} to: ${valueDescription}`
- };
- } else if (action.type === nglConstants.UPDATE_COMPONENT_REPRESENTATION_VISIBILITY_ALL) {
- let objectType = actionObjectType.REPRESENTATION;
- let value = action.newVisibility;
- let valueDescription = value === true ? actionDescription.VISIBLE : actionDescription.HIDDEN;
-
- trackAction = {
- type: actionType.REPRESENTATION_VISIBILITY_ALL_UPDATED,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: actionObjectType.REPRESENTATION,
- object_name: action.objectInViewID,
- object_id: action.objectInViewID,
- value: value,
- text: `${objectType} ${actionDescription.VISIBILITY} of ${action.objectInViewID} ${actionDescription.CHANGED} to: ${valueDescription}`
- };
- } else if (action.type === nglConstants.UPDATE_COMPONENT_REPRESENTATION) {
- let objectType = actionObjectType.REPRESENTATION;
- let key = action.change?.key;
- let oldValue = action.change?.oldValue;
- let newValue = action.change?.value;
- let valueDescription =
- key !== 'clipCenter'
- ? `from value: ${oldValue} to value: ${newValue}`
- : getClipCenterChange(oldValue, newValue);
-
- trackAction = {
- type: actionType.REPRESENTATION_UPDATED,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: actionObjectType.REPRESENTATION,
- object_name: action.objectInViewID,
- object_id: action.objectInViewID,
- representation_id: action.representationID,
- representation: action.newRepresentation,
- change: action.change,
- text: `${objectType} '${key}' of ${action.objectInViewID} ${actionDescription.UPDATED} ${valueDescription}`
- };
- } else if (action.type === nglConstants.ADD_COMPONENT_REPRESENTATION) {
- let objectType = actionObjectType.REPRESENTATION;
- let representationName = action.newRepresentation && action.newRepresentation.type;
-
- trackAction = {
- type: actionType.REPRESENTATION_ADDED,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: actionObjectType.REPRESENTATION,
- object_name: representationName,
- object_id: action.objectInViewID,
- representation: action.newRepresentation,
- text: `${objectType} '${representationName}' of ${action.objectInViewID} ${actionDescription.ADDED}`
- };
- } else if (action.type === nglConstants.REMOVE_COMPONENT_REPRESENTATION) {
- let objectType = actionObjectType.REPRESENTATION;
- let representationName = action.representation && action.representation.type;
-
- trackAction = {
- type: actionType.REPRESENTATION_REMOVED,
- annotation: actionAnnotation.CLEAR,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: representationName,
- object_id: action.objectInViewID,
- representation: action.representation,
- text: `${objectType} '${representationName}' of ${action.objectInViewID} ${actionDescription.REMOVED}`
- };
- } else if (action.type === nglConstants.CHANGE_COMPONENT_REPRESENTATION) {
- let objectType = actionObjectType.REPRESENTATION;
- let oldRepresentationName = action.oldRepresentation && action.oldRepresentation.type;
- let newRepresentationName = action.newRepresentation && action.newRepresentation.type;
-
- trackAction = {
- type: actionType.REPRESENTATION_CHANGED,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: objectType,
- object_name: action.objectInViewID,
- object_id: action.objectInViewID,
- oldRepresentation: action.oldRepresentation,
- newRepresentation: action.newRepresentation,
- text: `${objectType} of ${action.objectInViewID} ${actionDescription.CHANGED} from value: ${oldRepresentationName} to value: ${newRepresentationName}`
- };
- } else if (action.type === nglConstants.SET_BACKGROUND_COLOR) {
- let oldSetting = action.payload === BACKGROUND_COLOR.white ? BACKGROUND_COLOR.black : BACKGROUND_COLOR.white;
- let newSetting = action.payload;
-
- trackAction = {
- type: actionType.BACKGROUND_COLOR_CHANGED,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: 'NGL',
- object_name: 'NGL',
- oldSetting: oldSetting,
- newSetting: newSetting,
- text: `Color of NGL ${actionDescription.CHANGED} to value: ${newSetting}`
- };
- } else if (action.type === nglConstants.SET_CLIP_NEAR) {
- let oldSetting = action.payload.oldValue;
- let newSetting = action.payload.newValue;
-
- trackAction = {
- type: actionType.CLIP_NEAR,
- merge: true,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: 'NGL',
- object_name: 'NGL',
- oldSetting: oldSetting,
- newSetting: newSetting,
- getText: function() {
- return (
- 'Clip near of NGL ' +
- actionDescription.CHANGED +
- ' from value: ' +
- this.oldSetting +
- ' to value: ' +
- this.newSetting
- );
- },
- text: `Clip near of NGL ${actionDescription.CHANGED} to value: ${newSetting}`
- };
- } else if (action.type === nglConstants.SET_CLIP_FAR) {
- let oldSetting = action.payload.oldValue;
- let newSetting = action.payload.newValue;
-
- trackAction = {
- type: actionType.CLIP_FAR,
- merge: true,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: 'NGL',
- object_name: 'NGL',
- oldSetting: oldSetting,
- newSetting: newSetting,
- getText: function() {
- return (
- 'Clip far of NGL ' +
- actionDescription.CHANGED +
- ' from value: ' +
- this.oldSetting +
- ' to value: ' +
- this.newSetting
- );
- },
- text: `Clip far of NGL ${actionDescription.CHANGED} to value: ${newSetting}`
- };
- } else if (action.type === nglConstants.SET_CLIP_DIST) {
- let oldSetting = action.payload.oldValue;
- let newSetting = action.payload.newValue;
-
- trackAction = {
- type: actionType.CLIP_DIST,
- merge: true,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: 'NGL',
- object_name: 'NGL',
- oldSetting: oldSetting,
- newSetting: newSetting,
- getText: function() {
- return (
- 'Clip dist of NGL ' +
- actionDescription.CHANGED +
- ' from value: ' +
- this.oldSetting +
- ' to value: ' +
- this.newSetting
- );
- },
- text: `Clip dist of NGL ${actionDescription.CHANGED} to value: ${newSetting}`
- };
- } else if (action.type === nglConstants.SET_FOG_NEAR) {
- let oldSetting = action.payload.oldValue;
- let newSetting = action.payload.newValue;
-
- trackAction = {
- type: actionType.FOG_NEAR,
- merge: true,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: 'NGL',
- object_name: 'NGL',
- oldSetting: oldSetting,
- newSetting: newSetting,
- getText: function() {
- return (
- 'Fog near of NGL ' +
- actionDescription.CHANGED +
- ' from value: ' +
- this.oldSetting +
- ' to value: ' +
- this.newSetting
- );
- },
- text: `Fog near of NGL ${actionDescription.CHANGED} to value: ${newSetting}`
- };
- } else if (action.type === nglConstants.SET_FOG_FAR) {
- let oldSetting = action.payload.oldValue;
- let newSetting = action.payload.newValue;
-
- trackAction = {
- type: actionType.FOG_FAR,
- merge: true,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: 'NGL',
- object_name: 'NGL',
- oldSetting: oldSetting,
- newSetting: newSetting,
- getText: function() {
- return (
- 'Fog far of NGL ' +
- actionDescription.CHANGED +
- ' from value: ' +
- this.oldSetting +
- ' to value: ' +
- this.newSetting
- );
- },
- text: `Fog far of NGL ${actionDescription.CHANGED} to value: ${newSetting}`
- };
- } else if (
- action.type === nglConstants.SET_ISO_LEVEL_DENSITY ||
- action.type === nglConstants.SET_ISO_LEVEL_DENSITY_MAP_diff ||
- action.type === nglConstants.SET_ISO_LEVEL_DENSITY_MAP_sigmaa
- ) {
- let objectName = null;
- let actionTypeMap = null;
- if (action.type === nglConstants.SET_ISO_LEVEL_DENSITY) {
- objectName = mapTypesStrings.EVENT;
- actionTypeMap = actionType.ISO_LEVEL_EVENT;
- } else if (action.type === nglConstants.SET_ISO_LEVEL_DENSITY_MAP_diff) {
- objectName = mapTypesStrings.DIFF;
- actionTypeMap = actionType.ISO_LEVEL_DIFF;
- } else if (action.type === nglConstants.SET_ISO_LEVEL_DENSITY_MAP_sigmaa) {
- objectName = mapTypesStrings.SIGMAA;
- actionTypeMap = actionType.ISO_LEVEL_SIGMAA;
- }
-
- let oldSetting = action.payload.oldValue;
- let newSetting = action.payload.newValue;
-
- trackAction = {
- type: actionTypeMap,
- merge: true,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: 'NGL',
- object_name: objectName,
- oldSetting: oldSetting,
- newSetting: newSetting,
- getText: function() {
- return (
- 'ISO of ' +
- objectName +
- ' ' +
- actionDescription.CHANGED +
- ' from value: ' +
- this.oldSetting +
- ' to value: ' +
- this.newSetting
- );
- },
- text: `ISO of ${objectName} ${actionDescription.CHANGED} to value: ${newSetting}`
- };
- } else if (
- action.type === nglConstants.SET_BOX_SIZE_DENSITY ||
- action.type === nglConstants.SET_BOX_SIZE_DENSITY_MAP_diff ||
- action.type === nglConstants.SET_BOX_SIZE_DENSITY_MAP_sigmaa
- ) {
- let objectName = null;
- let actionTypeMap = null;
- if (action.type === nglConstants.SET_BOX_SIZE_DENSITY) {
- objectName = mapTypesStrings.EVENT;
- actionTypeMap = actionType.BOX_SIZE_EVENT;
- } else if (action.type === nglConstants.SET_BOX_SIZE_DENSITY_MAP_diff) {
- objectName = mapTypesStrings.DIFF;
- actionTypeMap = actionType.BOX_SIZE_DIFF;
- } else if (action.type === nglConstants.SET_BOX_SIZE_DENSITY_MAP_sigmaa) {
- objectName = mapTypesStrings.SIGMAA;
- actionTypeMap = actionType.BOX_SIZE_SIGMAA;
- }
-
- let oldSetting = action.payload.oldValue;
- let newSetting = action.payload.newValue;
-
- trackAction = {
- type: actionTypeMap,
- merge: true,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: 'NGL',
- object_name: objectName,
- oldSetting: oldSetting,
- newSetting: newSetting,
- getText: function() {
- return (
- 'Box size of ' +
- objectName +
- ' ' +
- actionDescription.CHANGED +
- ' from value: ' +
- this.oldSetting +
- ' to value: ' +
- this.newSetting
- );
- },
- text: `Boz size of ${objectName} ${actionDescription.CHANGED} to value: ${newSetting}`
- };
- } else if (
- action.type === nglConstants.SET_OPACITY_DENSITY ||
- action.type === nglConstants.SET_OPACITY_DENSITY_MAP_diff ||
- action.type === nglConstants.SET_OPACITY_DENSITY_MAP_sigmaa
- ) {
- let objectName = null;
- let actionTypeMap = null;
- if (action.type === nglConstants.SET_OPACITY_DENSITY) {
- objectName = mapTypesStrings.EVENT;
- actionTypeMap = actionType.OPACITY_EVENT;
- } else if (action.type === nglConstants.SET_OPACITY_DENSITY_MAP_diff) {
- objectName = mapTypesStrings.DIFF;
- actionTypeMap = actionType.OPACITY_DIFF;
- } else if (action.type === nglConstants.SET_OPACITY_DENSITY_MAP_sigmaa) {
- objectName = mapTypesStrings.SIGMAA;
- actionTypeMap = actionType.OPACITY_SIGMAA;
- }
-
- let oldSetting = action.payload.oldValue;
- let newSetting = action.payload.newValue;
-
- trackAction = {
- type: actionTypeMap,
- merge: true,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: 'NGL',
- object_name: objectName,
- oldSetting: oldSetting,
- newSetting: newSetting,
- getText: function() {
- return (
- 'Opacity of ' +
- objectName +
- ' ' +
- actionDescription.CHANGED +
- ' from value: ' +
- this.oldSetting +
- ' to value: ' +
- this.newSetting
- );
- },
- text: `Opacity of NGL ${actionDescription.CHANGED} to value: ${newSetting}`
- };
- } else if (
- action.type === nglConstants.SET_CONTOUR_DENSITY ||
- action.type === nglConstants.SET_CONTOUR_DENSITY_MAP_diff ||
- action.type === nglConstants.SET_CONTOUR_DENSITY_MAP_sigmaa
- ) {
- let objectName = null;
- let actionTypeMap = null;
- if (action.type === nglConstants.SET_CONTOUR_DENSITY) {
- objectName = mapTypesStrings.EVENT;
- actionTypeMap = actionType.CONTOUR_EVENT;
- } else if (action.type === nglConstants.SET_CONTOUR_DENSITY_MAP_diff) {
- objectName = mapTypesStrings.DIFF;
- actionTypeMap = actionType.CONTOUR_DIFF;
- } else if (action.type === nglConstants.SET_CONTOUR_DENSITY_MAP_sigmaa) {
- objectName = mapTypesStrings.SIGMAA;
- actionTypeMap = actionType.CONTOUR_SIGMAA;
- }
-
- let oldSetting = action.payload.oldValue;
- let newSetting = action.payload.newValue;
-
- let oldSettingDescription = getContourChangeDescription(oldSetting);
- let newSettingDescription = getContourChangeDescription(newSetting);
-
- trackAction = {
- type: actionTypeMap,
- merge: false,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: 'NGL',
- object_name: objectName,
- oldSetting: oldSetting,
- newSetting: newSetting,
- getText: function() {
- return (
- 'Surface/wireframe of ' +
- objectName +
- ' ' +
- actionDescription.CHANGED +
- ' from value: ' +
- oldSettingDescription +
- ' to value: ' +
- newSettingDescription
- );
- },
- text: `Surface/wireframe of ${objectName} ${actionDescription.CHANGED} to value: ${newSettingDescription}`
- };
- } else if (
- action.type === nglConstants.SET_ELECTRON_COLOR_DENSITY ||
- action.type === nglConstants.SET_ELECTRON_COLOR_DENSITY_MAP_sigmaa ||
- action.type === nglConstants.SET_ELECTRON_COLOR__DENSITY_MAP_diff
- ) {
- let objectName = null;
- let actionTypeMap = null;
- if (action.type === nglConstants.SET_ELECTRON_COLOR_DENSITY) {
- objectName = mapTypesStrings.EVENT;
- actionTypeMap = actionType.COLOR_EVENT;
- } else if (action.type === nglConstants.SET_ELECTRON_COLOR_DENSITY_MAP_sigmaa) {
- objectName = mapTypesStrings.DIFF;
- actionTypeMap = actionType.COLOR_SIGMAA;
- } else if (action.type === nglConstants.SET_ELECTRON_COLOR__DENSITY_MAP_diff) {
- objectName = mapTypesStrings.SIGMAA;
- actionTypeMap = actionType.COLOR_DIFF;
- }
-
- let oldSetting = action.payload.oldValue;
- let newSetting = action.payload.newValue;
-
- trackAction = {
- type: actionTypeMap,
- merge: false,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: 'NGL',
- object_name: objectName,
- oldSetting: oldSetting,
- newSetting: newSetting,
- getText: function() {
- return (
- 'Color of ' +
- objectName +
- ' ' +
- actionDescription.CHANGED +
- ' from color: ' +
- this.oldSetting +
- ' to color: ' +
- this.newSetting
- );
- },
- text: `Color of ${objectName} ${actionDescription.CHANGED} to value: ${newSetting}`
- };
- } else if (action.type === nglConstants.SET_WARNING_ICON) {
- let oldSetting = action.payload.oldValue;
- let newSetting = action.payload.newValue;
-
- trackAction = {
- type: actionType.WARNING_ICON,
- merge: true,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username: username,
- object_type: 'NGL',
- object_name: 'NGL',
- oldSetting: oldSetting,
- newSetting: newSetting,
- getText: function() {
- return (
- 'Warning icon showing ' + (newSetting === true ? actionDescription.TURNED_ON : actionDescription.TURNED_OFF)
- );
- },
- text: `Warning icon showing ${newSetting === true ? actionDescription.TURNED_ON : actionDescription.TURNED_OFF}`
- };
- } else if (action.type === viewerControlsConstants.TURN_SIDE) {
- if (action.payload) {
- const { side, open } = action.payload;
-
- const openDescription = open ? actionDescription.TURNED_ON : actionDescription.TURNED_OFF;
-
- trackAction = {
- type: actionType.TURN_SIDE,
- annotation: actionAnnotation.CHECK,
- timestamp: Date.now(),
- username,
- side,
- open,
- text: `${viewerControlsSides[side]} ${openDescription}`
- };
- }
- }
- }
- return trackAction;
-};
-
-const getMoleculeTitle = (objectName, targetName) => {
- let title = objectName.replace(new RegExp(`${targetName}-`, 'i'), '');
- return title;
-};
-
-const getMolGroupName = (molGroupId, state) => {
- let molGroupList = state.apiReducers.mol_group_list;
- let molGroup = molGroupList.find(group => group.id === molGroupId);
- let molGroupName = (molGroup && molGroup.description) || '';
- return molGroupName;
-};
-
-const getTargetName = (targetId, state) => {
- let targetList = state.apiReducers.target_id_list;
- let target = targetList.find(target => target.id === targetId);
- let targetName = (target && target.title) || '';
- return targetName;
-};
-
-const getMoleculeName = (moleculeId, state) => {
- const moleculeList = state.apiReducers.all_mol_lists;
- const molecule = moleculeList.find(molecule => molecule.id === moleculeId);
- return molecule?.code ?? '';
-};
-
-const getTypeDescriptionOfSelectedAllAction = type => {
- switch (type) {
- case 'ligand':
- return actionDescription.LIGANDS;
- case 'protein':
- return actionDescription.SIDECHAINS;
- case 'complex':
- return actionDescription.INTERACTIONS;
- default:
- return type;
- }
-};
-
-const getClipCenterChange = (oldValue, newValue) => {
- let description = '';
- if (oldValue && newValue) {
- if (oldValue.x !== newValue.x) {
- description += ' from value: x:' + oldValue.x + ' to value: x:' + newValue.x;
- }
- if (oldValue.y !== newValue.y) {
- description += ' from value: y:' + oldValue.y + ' to value: y:' + newValue.y;
- }
- if (oldValue.z !== newValue.z) {
- description += ' from value: z:' + oldValue.z + ' to value: z:' + newValue.z;
- }
- }
- return description;
-};
-
-const getFilterKeyChange = (oldValue, newValue) => {
- let description = '';
- if (oldValue && newValue) {
- if (oldValue.order !== newValue.order) {
- description +=
- ' from value: order: ' +
- getOrderDescription(oldValue.order) +
- ' to value: order: ' +
- getOrderDescription(newValue.order);
- return description;
- } else if (oldValue.newPrio !== newValue.newPrio) {
- description +=
- ' from value: priority: ' + (newValue.oldPrio + 1) + ' to value: priority: ' + (newValue.newPrio + 1);
- return description;
- } else {
- if (oldValue.isBoolean === true) {
- if (oldValue.minValue !== newValue.minValue) {
- return (
- ' from value: ' +
- getBooleanDescription(oldValue.minValue) +
- ' to value: ' +
- getBooleanDescription(newValue.minValue)
- );
- } else if (oldValue.maxValue !== newValue.maxValue) {
- return (
- ' from value: ' +
- getBooleanDescription(oldValue.maxValue) +
- ' to value: ' +
- getBooleanDescription(newValue.maxValue)
- );
- } else {
- return ' to value: ignore';
- }
- } else {
- if (oldValue.minValue !== newValue.minValue) {
- return ' from value: ' + oldValue.minValue + ' to value: ' + newValue.minValue;
- } else if (oldValue.maxValue !== newValue.maxValue) {
- return ' from value: max: ' + oldValue.maxValue + ' to value: max: ' + newValue.maxValue;
- }
- }
- }
- }
- return description;
-};
-
-const getOrderDescription = order => {
- let description = '';
- if (order === 1) {
- return 'up';
- }
-
- if (order === -1) {
- return 'down';
- }
-
- if (order === 0) {
- return 'ignore';
- }
- return description;
-};
-
-const getBooleanDescription = value => {
- let description = '';
- if (value === 1) {
- return 'false';
- }
-
- if (value === 50) {
- return 'ignore';
- }
-
- if (value === 100) {
- return 'true';
- }
- return description;
-};
-
-const getContourChangeDescription = value => {
- if (value === true) {
- return 'wireframe';
- } else if (value === false) {
- return 'surface';
- } else {
- return '';
- }
-};
-
-export const createInitAction = target_on => (dispatch, getState) => {
- const state = getState();
- const username = DJANGO_CONTEXT['username'];
-
- if (target_on) {
- let targetName = getTargetName(target_on, state);
- let trackAction = {
- type: actionType.TARGET_LOADED,
- timestamp: Date.now(),
- username: username,
- object_type: actionObjectType.TARGET,
- object_name: targetName,
- object_id: target_on,
- text: `${actionDescription.TARGET} ${targetName} ${actionDescription.LOADED}`
- };
-
- return trackAction;
- }
-};
diff --git a/js/reducers/tracking/trackingMiddleware.js b/js/reducers/tracking/trackingMiddleware.js
deleted file mode 100644
index 8508793dd..000000000
--- a/js/reducers/tracking/trackingMiddleware.js
+++ /dev/null
@@ -1,29 +0,0 @@
-import { appendAndSendTrackingActions } from './dispatchActions';
-import { constants } from './constants';
-import { findTrackAction } from './trackingActions';
-import { setIsSnapshotDirty } from './actions';
-
-const trackingMiddleware = ({ dispatch, getState }) => next => action => {
- //console.log(`Redux Log:`, action);
-
- if (action) {
- const state = getState();
- if (action && action.type && !action.type.includes(constants.APPEND_ACTIONS_LIST)) {
- let trackAction = dispatch(findTrackAction(action, state));
- if (trackAction && trackAction != null && Object.keys(trackAction).length > 0) {
- const isSnapshotDirty = state.trackingReducers.isSnapshotDirty;
- const snapshotLoadingInProgress = state.apiReducers.snapshotLoadingInProgress;
- if (!isSnapshotDirty && !snapshotLoadingInProgress) {
- dispatch(setIsSnapshotDirty(true));
- }
- dispatch(appendAndSendTrackingActions(trackAction));
- } else if (trackAction && trackAction != null && Object.keys(trackAction).length === 0) {
- console.error(`Track action is empty for action: ${JSON.stringify(action)}`);
- }
- }
-
- next(action);
- }
-};
-
-export default trackingMiddleware;
diff --git a/js/reducers/tracking/trackingReducers.js b/js/reducers/tracking/trackingReducers.js
deleted file mode 100644
index c7eebdd86..000000000
--- a/js/reducers/tracking/trackingReducers.js
+++ /dev/null
@@ -1,149 +0,0 @@
-import { constants } from './constants';
-import { undoable } from '../../undoredo/reducer';
-import { includeAction } from '../../undoredo/helpers';
-
-export const INITIAL_STATE = {
- track_actions_list: [],
- undo_redo_actions_list: [],
- current_actions_list: [],
- isTrackingMoleculesRestoring: false,
- isTrackingCompoundsRestoring: false,
- isUndoRedoAction: false,
- isActionsSending: false,
- isActionsLoading: false,
- isActionSaving: false,
- send_actions_list: [],
- project_actions_list: [],
- snapshotActionImageList: [],
- isActionRestoring: false,
- isActionRestored: false,
- isActionTracking: false,
- trackingImageSource: '',
- isProjectActionListLoaded: false,
- skipOrientationChange: false,
- isSnapshotDirty: false,
- areSnapshotActionsDownloaded: false
-};
-
-export function trackingReducers(state = INITIAL_STATE, action = {}) {
- switch (action.type) {
- case constants.SET_ACTIONS_LIST:
- return Object.assign({}, state, {
- track_actions_list: action.track_actions_list
- });
-
- case constants.SET_SNAPSHOT_ACTIONS_DOWNLOADED: {
- return {
- ...state,
- areSnapshotActionsDownloaded: action.isDownloaded
- };
- }
-
- case constants.APPEND_ACTIONS_LIST:
- return Object.assign({}, state, {
- track_actions_list: [...new Set([...state.track_actions_list, action.track_action])]
- });
-
- case constants.APPEND_UNDO_REDO_ACTIONS_LIST:
- return Object.assign({}, state, {
- undo_redo_actions_list: [...new Set([...state.undo_redo_actions_list, action.track_action])]
- });
-
- case constants.SET_UNDO_REDO_ACTIONS_LIST:
- return {
- ...state,
- undo_redo_actions_list: action.undo_redo_actions_list
- };
-
- case constants.SET_CURRENT_ACTIONS_LIST:
- return Object.assign({}, state, {
- current_actions_list: [...action.current_actions_list]
- });
-
- case constants.SET_IS_TRACKING_MOLECULES_RESTORING:
- return Object.assign({}, state, {
- isTrackingMoleculesRestoring: action.isTrackingMoleculesRestoring
- });
-
- case constants.SET_IS_TRACKING_COMPOUNDS_RESTORING:
- return Object.assign({}, state, {
- isTrackingCompoundsRestoring: action.isTrackingCompoundsRestoring
- });
-
- case constants.SET_IS_UNDO_REDO_ACTION:
- return Object.assign({}, state, {
- isUndoRedoAction: action.isUndoRedoAction
- });
-
- case constants.SET_IS_ACTIONS_SENDING:
- return Object.assign({}, state, {
- isActionsSending: action.isActionsSending
- });
-
- case constants.SET_IS_ACTIONS_LOADING:
- return Object.assign({}, state, {
- isActionsLoading: action.isActionsLoading
- });
-
- case constants.SET_SEND_ACTIONS_LIST:
- return Object.assign({}, state, {
- send_actions_list: [...action.send_actions_list]
- });
-
- case constants.APPEND_SEND_ACTIONS_LIST:
- return Object.assign({}, state, {
- send_actions_list: [...new Set([...state.send_actions_list, action.track_action])]
- });
-
- case constants.SET_PROJECT_ACTIONS_LIST:
- return Object.assign({}, state, {
- project_actions_list: action.project_actions_list
- });
-
- case constants.SET_SNAPSOT_IMAGE_ACTIONS_LIST:
- return Object.assign({}, state, {
- snapshotActionImageList: action.snapshotActionImageList
- });
-
- case constants.SET_IS_ACTIONS_SAVING:
- return Object.assign({}, state, {
- isActionSaving: action.isActionSaving
- });
-
- case constants.SET_IS_ACTIONS_RESTORING:
- return Object.assign({}, state, {
- isActionRestoring: action.isActionRestoring,
- isActionRestored: action.isActionRestored
- });
-
- case constants.SET_PROJECT_ACTIONS_LIST_LOADED:
- return { ...state, isProjectActionListLoaded: action.isLoaded };
-
- case constants.SET_IS_ACTION_TRACKING:
- return Object.assign({}, state, {
- isActionTracking: action.isActionTracking
- });
-
- case constants.SET_TRACKING_IMAGE_SOURCE:
- return Object.assign({}, state, {
- trackingImageSource: action.payload
- });
-
- case constants.SET_SKIP_ORIENTATION_CHANGE:
- return { ...state, skipOrientationChange: action.skipOrientationChange };
-
- case constants.SET_IS_SNAPSHOT_DIRTY:
- return { ...state, isSnapshotDirty: action.isSnapshotDirty };
-
- case constants.RESET_TRACKING_STATE:
- return INITIAL_STATE;
-
- default:
- return state;
- }
-}
-
-export const undoableTrackingReducers = undoable(trackingReducers, {
- limit: false,
- filter: includeAction(constants.SET_UNDO_REDO_ACTIONS_LIST)
-});
diff --git a/js/reducers/tracking/utils.js b/js/reducers/tracking/utils.js
deleted file mode 100644
index 71f70cbf3..000000000
--- a/js/reducers/tracking/utils.js
+++ /dev/null
@@ -1,26 +0,0 @@
-import { actionType } from './constants';
-
-export const getQualityOffActions = (orderedActionList, currentActionList) => (dispatch, getState) => {
- const state = getState();
- const ligandsOn = state.selectionReducers.fragmentDisplayList;
- const qualitiesOn = state.selectionReducers.qualityList;
-
- const qualitiesToTurnOff = getDifference(ligandsOn, qualitiesOn);
- const actionList = orderedActionList.filter(action => action.type === actionType.QUALITY_TURNED_OFF);
-
- qualitiesToTurnOff.forEach(molId => {
- const action = actionList.find(action => action.object_id === molId);
-
- if (action) {
- currentActionList.push({ ...action });
- }
- });
-};
-
-/**
- * The goal of this method is to compare two arrays of primitive values and return the difference.
- */
-export const getDifference = (array1, array2) => {
- const result = array1.filter(x => !array2.includes(x));
- return result;
-};
diff --git a/js/undoredo/actions.js b/js/undoredo/actions.js
deleted file mode 100644
index 33834025b..000000000
--- a/js/undoredo/actions.js
+++ /dev/null
@@ -1,33 +0,0 @@
-export const ActionTypes = {
- UNDO: '@@redux-undo/UNDO',
- REDO: '@@redux-undo/REDO',
- JUMP_TO_FUTURE: '@@redux-undo/JUMP_TO_FUTURE',
- JUMP_TO_PAST: '@@redux-undo/JUMP_TO_PAST',
- JUMP: '@@redux-undo/JUMP',
- CLEAR_HISTORY: '@@redux-undo/CLEAR_HISTORY',
- REMOVE_LAST_PAST: '@@redux-undo/REMOVE_LAST_PAST'
-}
-
-export const ActionCreators = {
- undo () {
- return { type: ActionTypes.UNDO }
- },
- redo () {
- return { type: ActionTypes.REDO }
- },
- jumpToFuture (index) {
- return { type: ActionTypes.JUMP_TO_FUTURE, index }
- },
- jumpToPast (index) {
- return { type: ActionTypes.JUMP_TO_PAST, index }
- },
- jump (index) {
- return { type: ActionTypes.JUMP, index }
- },
- clearHistory () {
- return { type: ActionTypes.CLEAR_HISTORY }
- },
- removeLastPast() {
- return {type: ActionTypes.REMOVE_LAST_PAST}
- }
-}
diff --git a/js/undoredo/debug.js b/js/undoredo/debug.js
deleted file mode 100644
index 739806dee..000000000
--- a/js/undoredo/debug.js
+++ /dev/null
@@ -1,90 +0,0 @@
-let __DEBUG__
-let displayBuffer
-
-const colors = {
- prevState: '#9E9E9E',
- action: '#03A9F4',
- nextState: '#4CAF50'
-}
-
-/* istanbul ignore next: debug messaging is not tested */
-function initBuffer () {
- displayBuffer = {
- header: [],
- prev: [],
- action: [],
- next: [],
- msgs: []
- }
-}
-
-/* istanbul ignore next: debug messaging is not tested */
-function printBuffer () {
- const { header, prev, next, action, msgs } = displayBuffer
- if (console.group) {
- console.groupCollapsed(...header)
- console.log(...prev)
- console.log(...action)
- console.log(...next)
- console.log(...msgs)
- console.groupEnd()
- } else {
- console.log(...header)
- console.log(...prev)
- console.log(...action)
- console.log(...next)
- console.log(...msgs)
- }
-}
-
-/* istanbul ignore next: debug messaging is not tested */
-function colorFormat (text, color, obj) {
- return [
- `%c${text}`,
- `color: ${color}; font-weight: bold`,
- obj
- ]
-}
-
-/* istanbul ignore next: debug messaging is not tested */
-function start (action, state) {
- initBuffer()
- if (__DEBUG__) {
- if (console.group) {
- displayBuffer.header = ['%credux-undo', 'font-style: italic', 'action', action.type]
- displayBuffer.action = colorFormat('action', colors.action, action)
- displayBuffer.prev = colorFormat('prev history', colors.prevState, state)
- } else {
- displayBuffer.header = ['redux-undo action', action.type]
- displayBuffer.action = ['action', action]
- displayBuffer.prev = ['prev history', state]
- }
- }
-}
-
-/* istanbul ignore next: debug messaging is not tested */
-function end (nextState) {
- if (__DEBUG__) {
- if (console.group) {
- displayBuffer.next = colorFormat('next history', colors.nextState, nextState)
- } else {
- displayBuffer.next = ['next history', nextState]
- }
- printBuffer()
- }
-}
-
-/* istanbul ignore next: debug messaging is not tested */
-function log (...args) {
- if (__DEBUG__) {
- displayBuffer.msgs = displayBuffer.msgs
- .concat([...args, '\n'])
- }
-}
-
-/* istanbul ignore next: debug messaging is not tested */
-function set (debug) {
- __DEBUG__ = debug
-}
-
-export { set, start, end, log }
diff --git a/js/undoredo/helpers.js b/js/undoredo/helpers.js
deleted file mode 100644
index a8a9532f3..000000000
--- a/js/undoredo/helpers.js
+++ /dev/null
@@ -1,57 +0,0 @@
-// parseActions helper: takes a string (or array)
-// and makes it an array if it isn't yet
-export function parseActions (rawActions, defaultValue = []) {
- if (Array.isArray(rawActions)) {
- return rawActions
- } else if (typeof rawActions === 'string') {
- return [rawActions]
- }
- return defaultValue
-}
-
-// isHistory helper: check for a valid history object
-export function isHistory (history) {
- return typeof history.present !== 'undefined' &&
- typeof history.future !== 'undefined' &&
- typeof history.past !== 'undefined' &&
- Array.isArray(history.future) &&
- Array.isArray(history.past)
-}
-
-// includeAction helper: whitelist actions to be added to the history
-export function includeAction (rawActions) {
- const actions = parseActions(rawActions)
- return (action) => actions.indexOf(action.type) >= 0
-}
-
-// excludeAction helper: blacklist actions from being added to the history
-export function excludeAction (rawActions) {
- const actions = parseActions(rawActions)
- return (action) => actions.indexOf(action.type) < 0
-}
-
-// combineFilters helper: combine multiple filters to one
-export function combineFilters (...filters) {
- return filters.reduce((prev, curr) =>
- (action, currentState, previousHistory) =>
- prev(action, currentState, previousHistory) &&
- curr(action, currentState, previousHistory)
- , () => true)
-}
-
-export function groupByActionTypes (rawActions) {
- const actions = parseActions(rawActions)
- return (action) => actions.indexOf(action.type) >= 0 ? action.type : null
-}
-
-export function newHistory (past, present, future, group = null) {
- return {
- past,
- present,
- future,
- group,
- _latestUnfiltered: present,
- index: past.length,
- limit: past.length + future.length + 1
- }
-}
diff --git a/js/undoredo/index.js b/js/undoredo/index.js
deleted file mode 100644
index a62f460ce..000000000
--- a/js/undoredo/index.js
+++ /dev/null
@@ -1,8 +0,0 @@
-export { ActionTypes, ActionCreators } from './actions'
-export {
- parseActions, isHistory,
- includeAction, excludeAction,
- combineFilters, groupByActionTypes, newHistory
-} from './helpers'
-
-export { default } from './reducer'
diff --git a/js/undoredo/reducer.js b/js/undoredo/reducer.js
deleted file mode 100644
index 8e1da2517..000000000
--- a/js/undoredo/reducer.js
+++ /dev/null
@@ -1,274 +0,0 @@
-import * as debug from './debug'
-import { ActionTypes } from './actions'
-import { parseActions, isHistory, newHistory } from './helpers'
-
-// createHistory
-function createHistory (state, ignoreInitialState) {
- // ignoreInitialState essentially prevents the user from undoing to the
- // beginning, in the case that the undoable reducer handles initialization
- // in a way that can't be redone simply
- const history = newHistory([], state, [])
- if (ignoreInitialState) {
- history._latestUnfiltered = null
- }
- return history
-}
-
-function removeLastPast(history) {
- const { past, present, future } = history;
-
- const newPast = [...past];
- newPast.pop();
-
- return newHistory(newPast, present, future)
-}
-
-// insert: insert `state` into history, which means adding the current state
-// into `past`, setting the new `state` as `present` and erasing
-// the `future`.
-function insert (history, state, limit, group) {
- const lengthWithoutFuture = history.past.length + 1
-
- debug.log('inserting', state)
- debug.log('new free: ', limit - lengthWithoutFuture)
-
- const { past, _latestUnfiltered } = history
- const isHistoryOverflow = limit && limit <= lengthWithoutFuture
-
- const pastSliced = past.slice(isHistoryOverflow ? 1 : 0)
- const newPast = _latestUnfiltered != null
- ? [
- ...pastSliced,
- _latestUnfiltered
- ] : pastSliced
-
- return newHistory(newPast, state, [], group)
-}
-
-// jumpToFuture: jump to requested index in future history
-function jumpToFuture (history, index) {
- if (index < 0 || index >= history.future.length) return history
-
- const { past, future, _latestUnfiltered } = history
-
- const newPast = [...past, _latestUnfiltered, ...future.slice(0, index)]
- const newPresent = future[index]
- const newFuture = future.slice(index + 1)
-
- return newHistory(newPast, newPresent, newFuture)
-}
-
-// jumpToPast: jump to requested index in past history
-function jumpToPast (history, index) {
- if (index < 0 || index >= history.past.length) return history
-
- const { past, future, _latestUnfiltered } = history
-
- const newPast = past.slice(0, index)
- const newFuture = [...past.slice(index + 1), _latestUnfiltered, ...future]
- const newPresent = past[index]
-
- return newHistory(newPast, newPresent, newFuture)
-}
-
-// jump: jump n steps in the past or forward
-function jump (history, n) {
- if (n > 0) return jumpToFuture(history, n - 1)
- if (n < 0) return jumpToPast(history, history.past.length + n)
- return history
-}
-
-// helper to dynamically match in the reducer's switch-case
-function actionTypeAmongClearHistoryType (actionType, clearHistoryType) {
- return clearHistoryType.indexOf(actionType) > -1 ? actionType : !actionType
-}
-
-// redux-undo higher order reducer
-export function undoable (reducer, rawConfig = {}) {
- debug.set(rawConfig.debug)
-
- const config = {
- limit: undefined,
- filter: () => true,
- groupBy: () => null,
- undoType: ActionTypes.UNDO,
- redoType: ActionTypes.REDO,
- jumpToPastType: ActionTypes.JUMP_TO_PAST,
- jumpToFutureType: ActionTypes.JUMP_TO_FUTURE,
- jumpType: ActionTypes.JUMP,
- removeLastPast: ActionTypes.REMOVE_LAST_PAST,
- neverSkipReducer: false,
- ignoreInitialState: false,
- syncFilter: false,
-
- ...rawConfig,
-
- initTypes: parseActions(rawConfig.initTypes, ['@@redux-undo/INIT']),
- clearHistoryType: parseActions(
- rawConfig.clearHistoryType,
- [ActionTypes.CLEAR_HISTORY]
- )
- }
-
- // Allows the user to call the reducer with redux-undo specific actions
- const skipReducer = config.neverSkipReducer
- ? (res, action, ...slices) => ({
- ...res,
- present: reducer(res.present, action, ...slices)
- })
- : (res) => res
-
- let initialState
- return (state = initialState, action = {}, ...slices) => {
- debug.start(action, state)
-
- let history = state
- if (!initialState) {
- debug.log('history is uninitialized')
-
- if (state === undefined) {
- const createHistoryAction = { type: '@@redux-undo/CREATE_HISTORY' }
- const start = reducer(state, createHistoryAction, ...slices)
-
- history = createHistory(
- start,
- config.ignoreInitialState
- )
-
- debug.log('do not set initialState on probe actions')
- debug.end(history)
- return history
- } else if (isHistory(state)) {
- history = initialState = config.ignoreInitialState
- ? state : newHistory(
- state.past,
- state.present,
- state.future
- )
- debug.log(
- 'initialHistory initialized: initialState is a history',
- initialState
- )
- } else {
- history = initialState = createHistory(
- state,
- config.ignoreInitialState
- )
- debug.log(
- 'initialHistory initialized: initialState is not a history',
- initialState
- )
- }
- }
-
- let res
- switch (action.type) {
- case undefined:
- return history
-
- case config.undoType:
- res = jump(history, -1)
- debug.log('perform undo')
- debug.end(res)
- return skipReducer(res, action, ...slices)
-
- case config.redoType:
- res = jump(history, 1)
- debug.log('perform redo')
- debug.end(res)
- return skipReducer(res, action, ...slices)
-
- case config.jumpToPastType:
- res = jumpToPast(history, action.index)
- debug.log(`perform jumpToPast to ${action.index}`)
- debug.end(res)
- return skipReducer(res, action, ...slices)
-
- case config.jumpToFutureType:
- res = jumpToFuture(history, action.index)
- debug.log(`perform jumpToFuture to ${action.index}`)
- debug.end(res)
- return skipReducer(res, action, ...slices)
-
- case config.jumpType:
- res = jump(history, action.index)
- debug.log(`perform jump to ${action.index}`)
- debug.end(res)
- return skipReducer(res, action, ...slices)
-
- case config.removeLastPast:
- res = removeLastPast(history);
- return skipReducer(res, action, ...slices);
-
- case actionTypeAmongClearHistoryType(action.type, config.clearHistoryType):
- res = createHistory(history.present, config.ignoreInitialState)
- debug.log('perform clearHistory')
- debug.end(res)
- return skipReducer(res, action, ...slices)
-
- default:
- res = reducer(
- history.present,
- action,
- ...slices
- )
-
- if (config.initTypes.some((actionType) => actionType === action.type)) {
- debug.log('reset history due to init action')
- debug.end(initialState)
- return initialState
- }
-
- if (history._latestUnfiltered === res) {
- // Don't handle this action. Do not call debug.end here,
- // because this action should not produce side effects to the console
- return history
- }
-
- /* eslint-disable-next-line no-case-declarations */
- const filtered = typeof config.filter === 'function' && !config.filter(
- action,
- res,
- history
- )
-
- if (filtered) {
- // if filtering an action, merely update the present
- const filteredState = newHistory(
- history.past,
- res,
- history.future,
- history.group
- )
- if (!config.syncFilter) {
- filteredState._latestUnfiltered = history._latestUnfiltered
- }
- debug.log('filter ignored action, not storing it in past')
- debug.end(filteredState)
- return filteredState
- }
-
- /* eslint-disable-next-line no-case-declarations */
- const group = config.groupBy(action, res, history)
- if (group != null && group === history.group) {
- // if grouping with the previous action, only update the present
- const groupedState = newHistory(
- history.past,
- res,
- history.future,
- history.group
- )
- debug.log('groupBy grouped the action with the previous action')
- debug.end(groupedState)
- return groupedState
- }
-
- // If the action wasn't filtered or grouped, insert normally
- history = insert(history, res, config.limit, group)
-
- debug.log('inserted new state into history')
- debug.end(history)
- return history
- }
- }
-}
diff --git a/js/utils/genericDispatchActions.js b/js/utils/genericDispatchActions.js
new file mode 100644
index 000000000..128ed0fd6
--- /dev/null
+++ b/js/utils/genericDispatchActions.js
@@ -0,0 +1,5 @@
+export const getCompoundById = (id, datasetId) => (dispatch, getState) => {
+ const state = getState();
+ const datasetCmps = state.datasetsReducers.moleculeLists[datasetId];
+ return datasetCmps?.find(cmp => cmp.id === id);
+};
diff --git a/js/utils/objectUtils.js b/js/utils/objectUtils.js
new file mode 100644
index 000000000..566b17a1f
--- /dev/null
+++ b/js/utils/objectUtils.js
@@ -0,0 +1,142 @@
+import { deepMerge } from './merge';
+
+export const setDeepValue = (obj, path, value) => {
+ const keys = path.split('.');
+ const lastKey = keys.pop();
+ const lastObj = keys.reduce((obj, key) => (obj[key] = obj[key] || {}), obj);
+ lastObj[lastKey] = value;
+};
+
+export const getDeepValue = (obj, path) => {
+ return path.split('.').reduce((obj, key) => obj[key], obj);
+};
+
+export const deepMergeOjects = (a, b) => {
+ return deepMerge(a, b);
+};
+
+//returns deep value but path is preserved in resulting object shape
+export const getDeepValueWithKeys = (obj, path) => {
+ const keys = path.split('.');
+ return keys.reduce((obj, key) => ({ [key]: obj[key] }), obj);
+};
+
+//but this is specific for snapshot so it's not quite universal - at least I think so
+export const deepMergeWithPriority = (a, b) => {
+ const merge = (a, b) => {
+ const keys = Object.keys(b);
+ keys.forEach(key => {
+ if (a[key] && typeof a[key] === 'object' && b[key] && typeof b[key] === 'object') {
+ if (Array.isArray(a[key]) && Array.isArray(b[key])) {
+ // a[key] = [...a[key], ...b[key]];
+ a[key] = [...b[key]];
+ } else {
+ // a[key] = deepMerge(a[key], b[key]);
+ if (Object.keys(b[key]).length === 0) {
+ a[key] = b[key];
+ } else {
+ a[key] = merge(a[key], b[key]);
+ }
+ }
+ } else {
+ a[key] = b[key];
+ }
+ });
+ return a;
+ };
+
+ return merge({ ...a }, b);
+};
+
+export const deepClone = obj => {
+ return JSON.parse(JSON.stringify(obj));
+};
+
+export const deepMergeWithPriorityAndBlackList = (a, b, blackList) => {
+ const isWholePathPresentIntoBlackList = (path, blackList) => {
+ let partOfBlackList = blackList;
+ for (let i = 0; i < path.length; i++) {
+ const pathToCheck = path[i];
+ if (partOfBlackList[pathToCheck]) {
+ partOfBlackList = partOfBlackList[pathToCheck];
+ if (i === path.length - 1 && Object.keys(partOfBlackList).length > 0) {
+ // console.log(`isWholePathPresentIntoBlackList - path: ${JSON.stringify(path)} - false - not entire path`);
+ return false;
+ }
+ } else {
+ // console.log(`isWholePathPresentIntoBlackList - path: ${JSON.stringify(path)} - false`);
+ return false;
+ }
+ }
+ // console.log(`isWholePathPresentIntoBlackList - path: ${JSON.stringify(path)} - true`);
+ return true;
+ };
+ const merge = (a, b, path) => {
+ const keys = Object.keys(b);
+
+ keys.forEach(key => {
+ const currentPath = [...path, key];
+ if (!isWholePathPresentIntoBlackList(currentPath, blackList)) {
+ if (a[key] && typeof a[key] === 'object' && b[key] && typeof b[key] === 'object') {
+ if (
+ Array.isArray(a[key]) &&
+ Array.isArray(b[key]) &&
+ !isWholePathPresentIntoBlackList(currentPath, blackList)
+ ) {
+ a[key] = [...b[key]];
+ } else {
+ if (Object.keys(b[key]).length === 0 && !isWholePathPresentIntoBlackList(currentPath, blackList)) {
+ a[key] = b[key];
+ } else {
+ a[key] = merge(a[key], b[key], currentPath);
+ }
+ }
+ } else {
+ if (!isWholePathPresentIntoBlackList(currentPath, blackList)) {
+ a[key] = b[key];
+ }
+ }
+ }
+ });
+
+ // currentPath.pop();
+ return a;
+ };
+
+ return merge({ ...a }, b, []);
+};
+
+export const deepEqual = (obj1, obj2, path = '') => {
+ if (obj1 === obj2) return true;
+
+ if (typeof obj1 !== 'object' || typeof obj2 !== 'object' || obj1 === null || obj2 === null) {
+ console.log(`deepEqual - Mismatch found at ${path || 'root'}: ${obj1} !== ${obj2}`);
+ return false;
+ }
+
+ if (Array.isArray(obj1) !== Array.isArray(obj2)) {
+ console.log(`deepEqual - Type mismatch at ${path || 'root'}: One is array, the other is not`);
+ return false;
+ }
+
+ const keys1 = Object.keys(obj1);
+ const keys2 = Object.keys(obj2);
+
+ if (keys1.length !== keys2.length) {
+ console.log(`deepEqual - Key length mismatch at ${path || 'root'}: ${keys1.length} !== ${keys2.length}`);
+ return false;
+ }
+
+ for (const key of keys1) {
+ const newPath = path ? `${path}.${key}` : key;
+ if (!keys2.includes(key)) {
+ console.log(`deepEqual - Key missing in second object at ${newPath}`);
+ return false;
+ }
+ if (!deepEqual(obj1[key], obj2[key], newPath)) {
+ return false;
+ }
+ }
+
+ return true;
+};