import { destroy, getEnv, getParent, getRoot, types } from "mobx-state-tree";
|
|
import { errorBuilder } from "../../core/DataValidator/ConfigValidator";
|
import { DataValidator, ValidationError, VALIDATORS } from "../../core/DataValidator";
|
import { guidGenerator } from "../../core/Helpers";
|
import Registry from "../../core/Registry";
|
import Tree from "../../core/Tree";
|
import Types from "../../core/Types";
|
import { StoreExtender } from "../../mixins/SharedChoiceStore/extender";
|
import { ViewModel } from "../../tags/visual";
|
import Utils from "../../utils";
|
import { FF_DEV_3034, FF_DEV_3391, FF_SIMPLE_INIT, isFF } from "../../utils/feature-flags";
|
import { emailFromCreatedBy } from "../../utils/utilities";
|
import { Annotation } from "./Annotation";
|
import { HistoryItem } from "./HistoryItem";
|
|
const SelectedItem = types.union(Annotation, HistoryItem);
|
|
const localStorageKeys = {
|
viewingAll: "annotation-store-viewing-all",
|
};
|
|
const AnnotationStoreModel = types
|
.model("AnnotationStore", {
|
selected: types.maybeNull(types.reference(SelectedItem)),
|
selectedHistory: types.maybeNull(types.safeReference(SelectedItem)),
|
|
root: Types.allModelsTypes(),
|
names: types.map(types.reference(Types.allModelsTypes())),
|
toNames: types.map(types.array(types.reference(Types.allModelsTypes()))),
|
|
annotations: types.array(Annotation),
|
predictions: types.array(Annotation),
|
history: types.array(HistoryItem),
|
|
viewingAllAnnotations: types.optional(
|
types.boolean,
|
// Initialize from localStorage, defaulting to false if not set
|
() => {
|
return window.localStorage.getItem(localStorageKeys.viewingAll) === "true";
|
},
|
),
|
|
validation: types.maybeNull(types.array(ValidationError)),
|
})
|
.volatile(() => ({
|
initialized: false,
|
}))
|
.views((self) => ({
|
get store() {
|
return getRoot(self);
|
},
|
|
get viewingAll() {
|
// Even if we have View All flag stored as true, but we are in environment without it
|
// or if we are not ready yet — don't go into View All mode, it will be broken.
|
if (!self.initialized) return false;
|
if (!self.store.hasInterface("annotations:view-all")) return false;
|
return self.viewingAllAnnotations;
|
},
|
}))
|
.actions((self) => {
|
function toggleViewingAll() {
|
self.viewingAllAnnotations = !self.viewingAllAnnotations;
|
// Persist the state to localStorage
|
window.localStorage.setItem(localStorageKeys.viewingAll, String(self.viewingAllAnnotations));
|
|
if (self.viewingAllAnnotations) {
|
if (self.selected) {
|
// const comments = self.store.commentStore;
|
|
// @todo `currentComment` is an object and saving them was not a part of original fix
|
// @todo so I leave it for next fix coming soon
|
// if (comments.currentComment) {
|
// // comment will save draft automatically
|
// comments.commentFormSubmit();
|
// } else
|
if (self.selected.type === "annotation") {
|
// save draft if there are changes waiting to be saved — it's handled inside
|
self.selected.saveDraftImmediately();
|
}
|
|
self.selected.unselectAll();
|
self.selected.selected = false;
|
}
|
|
// When FF_SIMPLE_INIT is enabled, we need to ensure all tags have their results set from the annotations.
|
// This process is normally done via selecting explicitly all annotations but, when the flag is enabled, it is
|
// skipped in AppStore::initializeStore to enforcing better performance.
|
// The byproduct of this performance improvement is that we do not update the objects with their corresponding
|
// results and, when entering the ViewAll mode, we can only see the results updated for the previously selected
|
// annotation but not the rest of them.
|
// This fix aims to mimic the behaviour of selectAnnotation when it comes to updating the objects only without
|
// actually executing the full process of selecting the annotation.
|
if (isFF(FF_SIMPLE_INIT)) {
|
[...self.predictions, ...self.annotations].forEach((a) => {
|
// Skip the current annotation as it's already handled
|
if (a === self.selected) return;
|
|
// Set results for each annotation without selecting it
|
a.updateObjects();
|
});
|
}
|
|
self.annotations.forEach((a) => {
|
a.editable = false;
|
});
|
} else {
|
selectAnnotation(self.annotations.at(isFF(FF_SIMPLE_INIT) ? -1 : 0).id, { fromViewAll: true });
|
}
|
}
|
|
// @todo that's just an alias, rewrite it everywhere
|
function toggleViewingAllAnnotations() {
|
toggleViewingAll();
|
}
|
|
function unselectViewingAll() {
|
self.viewingAllAnnotations = false;
|
// Persist the state to localStorage
|
window.localStorage.setItem(localStorageKeys.viewingAll, String(self.viewingAllAnnotations));
|
}
|
|
function _unselectAll() {
|
if (self.selected) {
|
self.selected.unselectAll();
|
self.selected.selected = false;
|
}
|
}
|
|
// used only in old version of View All — Grid.jsx
|
function _selectItem(item) {
|
self._unselectAll();
|
item.editable = false;
|
item.selected = true;
|
self.selected = item;
|
item.updateObjects();
|
}
|
|
// Select annotation or prediction
|
function selectItem(id, list, resetHistory = true) {
|
// might be better to protect this change with FF_SIMPLE_INIT
|
// unselectViewingAll();
|
|
self._unselectAll();
|
|
// sad hack with pk while sdk are not using pk everywhere
|
const c = list.find((c) => c.id === id || c.pk === String(id)) || list[0];
|
|
if (!c) return null;
|
c.selected = true;
|
|
if (resetHistory) {
|
self.selectedHistory = null;
|
self.history = [];
|
}
|
|
self.selected = c;
|
|
c.updateObjects();
|
if (c.type === "annotation") c.setInitialValues();
|
|
return c;
|
}
|
|
/**
|
* Select annotation
|
* @param {*} id
|
*/
|
function selectAnnotation(id, options = {}) {
|
// `selectAnnotation()` is used a lot during init, usually for all annotations.
|
// It should only exit View All mode when it's explicitly requested.
|
// All other calls are just setting things up and should not affect View All mode.
|
if (options.exitViewAll) {
|
unselectViewingAll();
|
}
|
|
if (!self.annotations.length) return null;
|
|
const { selected } = self;
|
const c = selectItem(id, self.annotations, !options.retainHistory);
|
|
c.editable = true;
|
c.setupHotKeys();
|
|
getEnv(self).events.invoke("selectAnnotation", c, selected, options ?? {});
|
if (c.pk) getParent(self).addAnnotationToTaskHistory(c.pk);
|
return c;
|
}
|
|
function selectPrediction(id, options = {}) {
|
// The same logic as in `selectAnnotation()`
|
if (options.exitViewAll) {
|
unselectViewingAll();
|
}
|
|
return selectItem(id, self.predictions);
|
}
|
|
function clearDeletedParents(annotation) {
|
if (!annotation?.pk) return;
|
self.annotations.forEach((anno) => {
|
if (anno.parent_annotation && +anno.parent_annotation === +annotation.pk) {
|
anno.parent_annotation = null;
|
}
|
});
|
}
|
|
function deleteAnnotation(annotation) {
|
getEnv(self).events.invoke("deleteAnnotation", self.store, annotation);
|
|
/**
|
* MST destroy annotation
|
*/
|
destroy(annotation);
|
|
/**
|
* Clear any other parent_annotations connected to this annotation
|
*/
|
self.clearDeletedParents(annotation);
|
|
self.selected = null;
|
/**
|
* Select other annotation
|
*/
|
if (self.annotations.length > 0) {
|
self.selectAnnotation(self.annotations[0].id);
|
}
|
}
|
|
function showError(err) {
|
if (err) self.addErrors([errorBuilder.generalError(err)]);
|
// we have to return at least empty View to display interface
|
return (self.root = ViewModel.create({ id: "error" }));
|
}
|
|
function upsertToName(node) {
|
const val = self.toNames.get(node.toname);
|
|
if (val) {
|
val.push(node.name);
|
} else {
|
self.addToName(node);
|
}
|
}
|
|
function addToName(node) {
|
self.toNames.set(node.toname, [node.name]);
|
}
|
|
function addName(node) {
|
self.names.put(node);
|
}
|
|
function initRoot(config) {
|
if (self.root) return;
|
|
if (!config) {
|
return (self.root = ViewModel.create({ id: "empty" }));
|
}
|
|
// convert config to mst model
|
let rootModel;
|
|
try {
|
rootModel = Tree.treeToModel(config, self.store);
|
} catch (e) {
|
console.error(e);
|
return showError(e);
|
}
|
const modelClass = Registry.getModelByTag(rootModel.type);
|
// hacky way to get all the available object tag names
|
const objectTypes = Registry.objectTypes().map((type) => type.name.replace("Model", "").toLowerCase());
|
const objects = [];
|
|
self.validate(VALIDATORS.CONFIG, rootModel);
|
|
try {
|
self.root = modelClass.create(rootModel);
|
} catch (e) {
|
console.error(e);
|
return showError(e);
|
}
|
|
if (isFF(FF_DEV_3391)) {
|
// initialize toName bindings [DOCS] name & toName are used to
|
// connect different components to each other
|
const { names, toNames } = Tree.extractNames(self.root);
|
|
names.forEach((tag) => self.names.put(tag));
|
toNames.forEach((tags, name) => self.toNames.set(name, tags));
|
|
Tree.traverseTree(self.root, (node) => {
|
if (self.store.task && node.updateValue) node.updateValue(self.store);
|
});
|
|
self.initialized = true;
|
|
return self.root;
|
}
|
|
// initialize toName bindings [DOCS] name & toName are used to
|
// connect different components to each other
|
Tree.traverseTree(self.root, (node) => {
|
if (node?.name) {
|
self.addName(node);
|
if (objectTypes.includes(node.type)) objects.push(node.name);
|
}
|
|
const isControlTag = node.name && !objectTypes.includes(node.type);
|
|
// auto-infer missed toName if there is only one object tag in the config
|
if (isControlTag && !node.toname && objects.length === 1) {
|
node.toname = objects[0];
|
}
|
|
if (node && node.toname) {
|
self.upsertToName(node);
|
}
|
|
if (self.store.task && node.updateValue) node.updateValue(self.store);
|
});
|
|
self.initialized = true;
|
|
return self.root;
|
}
|
|
function findNonInteractivePredictionResults() {
|
return self.predictions.reduce((results, prediction) => {
|
return [
|
...results,
|
...prediction._initialAnnotationObj
|
.filter((result) => result.interactive_mode === false)
|
.map((r) => ({ ...r })),
|
];
|
}, []);
|
}
|
|
function createItem(options) {
|
const { user, config } = self.store;
|
|
if (!self.root) initRoot(config);
|
|
let pk = options.pk || options.id;
|
|
if (options.type === "annotation" && pk && isNaN(pk)) {
|
/* something happened where our annotation pk was replaced with the id */
|
pk = self.annotations?.[self.annotations.length - 1]?.storedValue?.pk;
|
}
|
|
//
|
const node = {
|
userGenerate: false,
|
createdDate: Utils.UDate.currentISODate(),
|
|
...options,
|
|
// id is internal so always new to prevent collisions
|
id: guidGenerator(5),
|
// pk and id may be missing, so undefined | string
|
pk: pk && String(pk),
|
root: options.root ?? self.root,
|
};
|
|
if (user && !("createdBy" in node)) node.createdBy = user.displayName;
|
if (options.user) node.user = options.user;
|
|
return node;
|
}
|
|
function addPrediction(options = {}) {
|
options.editable = false;
|
options.type = "prediction";
|
|
const item = createItem(options);
|
|
if (isFF(FF_SIMPLE_INIT)) {
|
self.predictions.push(item);
|
|
return self.predictions.at(-1);
|
}
|
|
self.predictions.unshift(item);
|
|
const record = self.predictions[0];
|
|
return record;
|
}
|
|
function addAnnotation(options = {}) {
|
options.type = "annotation";
|
|
const item = createItem(options);
|
|
if (item.userGenerate) {
|
let actual_user;
|
|
if (isFF(FF_DEV_3034)) {
|
// drafts can be created by other user, but we don't have much info
|
// so parse "id", get email and find user by it
|
const email = emailFromCreatedBy(item.createdBy);
|
const user = email && self.store.users.find((user) => user.email === email);
|
|
if (user) actual_user = user.id;
|
}
|
item.completed_by = actual_user ?? getRoot(self).user?.id ?? undefined;
|
}
|
|
if (isFF(FF_SIMPLE_INIT)) {
|
self.annotations.push(item);
|
} else {
|
self.annotations.unshift(item);
|
}
|
|
const record = self.annotations.at(isFF(FF_SIMPLE_INIT) ? -1 : 0);
|
|
record.addVersions({
|
result: options.result,
|
draft: options.draft,
|
});
|
|
return record;
|
}
|
|
function createAnnotation(options = { userGenerate: true }) {
|
const result = findNonInteractivePredictionResults();
|
const c = self.addAnnotation({ ...options, result });
|
|
if (result && result.length) {
|
const ids = {};
|
|
// Area id is <uniq-id>#<annotation-id> to be uniq across all tree
|
result.forEach((r) => {
|
if ("id" in r) {
|
const id = r.id.replace(/#.*$/, `#${c.id}`);
|
|
ids[r.id] = id;
|
r.id = id;
|
}
|
});
|
|
result.forEach((r) => {
|
if (r.parent_id) {
|
if (ids[r.parent_id]) r.parent_id = ids[r.parent_id];
|
// impossible case but to not break the app better to reset it
|
else r.parent_id = null;
|
}
|
});
|
|
selectAnnotation(c.id);
|
c.deserializeAnnotation(result);
|
// reinit will trigger `updateObjects()` so we omit it here
|
c.reinitHistory();
|
} else {
|
c.setDefaultValues();
|
}
|
return c;
|
}
|
|
function addHistory(options = {}) {
|
options.type = "history";
|
|
if (isFF(FF_DEV_3391)) {
|
options.root = self.selected.root;
|
}
|
|
const item = createItem(options);
|
|
self.history.push(item);
|
|
const record = self.history[self.history.length - 1];
|
|
return record;
|
}
|
|
function clearHistory() {
|
self.history.forEach((item) => destroy(item));
|
self.history.length = 0;
|
}
|
|
function selectHistory(item) {
|
self.selectedHistory = item;
|
setTimeout(() => {
|
// update classifications after render
|
const updatedItem = item ?? self.selected;
|
|
Array.from(updatedItem.names.values())
|
.filter((t) => t.isClassificationTag)
|
.forEach((t) => t.updateFromResult([]));
|
|
updatedItem?.results
|
.filter((r) => r.area.classification)
|
.forEach((r) => r.from_name.updateFromResult?.(r.mainValue));
|
});
|
|
getEnv(self).events.invoke("selectHistory", self.store, self.selected, self.selectedHistory);
|
}
|
|
function addAnnotationFromPrediction(entity) {
|
// immutable work, because we'll change ids soon
|
const s = entity._initialAnnotationObj.map((r) => ({ ...r }));
|
const c = self.addAnnotation({ userGenerate: true, result: s });
|
|
const ids = {};
|
|
// Area id is <uniq-id>#<annotation-id> to be uniq across all tree
|
s.forEach((r) => {
|
if ("id" in r) {
|
const id = r.id.replace(/#.*$/, `#${c.id}`);
|
|
ids[r.id] = id;
|
r.id = id;
|
}
|
});
|
|
s.forEach((r) => {
|
if (r.parent_id) {
|
if (ids[r.parent_id]) r.parent_id = ids[r.parent_id];
|
// impossible case but to not break the app better to reset it
|
else r.parent_id = null;
|
}
|
});
|
|
selectAnnotation(c.id);
|
c.deserializeAnnotation(s);
|
// reinit will trigger `updateObjects()` so we omit it here
|
c.reinitHistory();
|
|
// parent link for the new annotations
|
if (entity.pk) {
|
if (entity.type === "prediction") {
|
c.parent_prediction = Number.parseInt(entity.pk);
|
} else if (entity.type === "annotation") {
|
c.parent_annotation = Number.parseInt(entity.pk);
|
}
|
}
|
|
return c;
|
}
|
|
/** ERRORS HANDLING */
|
const handleErrors = (errors) => {
|
self.addErrors(errors);
|
};
|
|
const addErrors = (errors) => {
|
const ids = [];
|
|
const newErrors = [...(self.validation ?? []), ...errors].reduce((res, error) => {
|
const id = error.identifier;
|
|
if (ids.indexOf(id) < 0) {
|
ids.push(id);
|
res.push(error);
|
}
|
|
return res;
|
}, []);
|
|
self.validation = newErrors;
|
};
|
|
const afterCreate = () => {
|
self._validator = new DataValidator();
|
self._validator.addErrorCallback(handleErrors);
|
};
|
|
const beforeDestroy = () => {
|
self._validator.removeErrorCallback(handleErrors);
|
};
|
|
const validate = (validatorName, data) => {
|
return self._validator.validate(validatorName, data);
|
};
|
|
const resetAnnotations = () => {
|
self.selected = null;
|
self.selectedHistory = null;
|
self.annotations = [];
|
self.predictions = [];
|
self.history = [];
|
};
|
|
return {
|
afterCreate,
|
beforeDestroy,
|
|
toggleViewingAllAnnotations,
|
|
initRoot,
|
addToName,
|
addName,
|
upsertToName,
|
|
addPrediction,
|
addAnnotation,
|
createAnnotation,
|
addAnnotationFromPrediction,
|
addHistory,
|
clearHistory,
|
selectHistory,
|
|
addErrors,
|
validate,
|
|
selectAnnotation,
|
selectPrediction,
|
|
_selectItem,
|
_unselectAll,
|
|
deleteAnnotation,
|
clearDeletedParents,
|
resetAnnotations,
|
};
|
});
|
|
export default types.compose("AnnotationStore", AnnotationStoreModel, StoreExtender);
|
