@konfuzio/document-validation-ui 0.1.14 → 0.1.16-dev.0

package/src/store/document.js

@@ -1,8 +1,15 @@
 import myImports from "../api";
-import { sleep } from "../utils/utils";
+import { MULTI_ANN_TABLE_FEATURE } from "../constants";
+import {
+  sleep,
+  getURLQueryParam,
+  navigateToNewDocumentURL,
+  getURLPath,
+} from "../utils/utils";
 
 const HTTP = myImports.HTTP;
 const documentPollDuration = 1000;
+export const table_reference_api = "api.v3.dvui.table";
 
 const state = {
   loading: true,
@@ -10,7 +17,7 @@ const state = {
   annotationSets: null,
   annotations: null,
   labels: [],
-  documentId: null,
+  documentId: process.env.VUE_APP_DOCUMENT_ID,
   sidebarAnnotationSelected: null,
   documentAnnotationSelected: null,
   selectedDocument: null,
@@ -21,14 +28,13 @@ const state = {
   showActionError: false,
   errorMessage: null,
   showDocumentError: false,
-  rejectedMissingAnnotations: null,
+  annotationsMarkedAsMissing: null,
   errorMessageWidth: null,
   hoveredAnnotationSet: null,
-  finishedReview: false,
   newAcceptedAnnotations: null,
-  selectedEntities: null,
   serverError: false,
-  categorizeModalIsActive: false,
+  splittingSuggestions: null,
+  enableGroupingFeature: true,
 };
 
 const getters = {
@@ -158,6 +164,83 @@ const getters = {
     return state.annotationSets.find((annSet) => annSet.id === annotationSetId);
   },
 
+  /* Get annotation sets created in table */
+  annotationSetsInTable: (state) => () => {
+    const annotationSetsList = {};
+    if (MULTI_ANN_TABLE_FEATURE) {
+      state.annotationSets.forEach((annotationSet) => {
+        let addAnnotationSet = false;
+        if (annotationSet.labels) {
+          annotationSet.labels.forEach((label) => {
+            if (
+              label.annotations &&
+              label.annotations.find(
+                (annotation) =>
+                  annotation.origin && annotation.origin === table_reference_api
+              )
+            ) {
+              addAnnotationSet = true;
+              return;
+            }
+          });
+        }
+        if (addAnnotationSet) {
+          // group by label set
+          if (annotationSetsList[`${annotationSet.label_set.id}`]) {
+            annotationSetsList[`${annotationSet.label_set.id}`].push(
+              annotationSet
+            );
+          } else {
+            annotationSetsList[`${annotationSet.label_set.id}`] = [
+              annotationSet,
+            ];
+          }
+        }
+      });
+    }
+    return annotationSetsList;
+  },
+
+  /* Get annotation sets without tables */
+  annotationSetsToShowInList: (state) => () => {
+    const annotationSetsList = [];
+    state.annotationSets.forEach((annotationSet) => {
+      let addAnnotationSet = true;
+      if (annotationSet.labels) {
+        annotationSet.labels.forEach((label) => {
+          if (
+            MULTI_ANN_TABLE_FEATURE &&
+            label.annotations &&
+            label.annotations.find(
+              (annotation) =>
+                annotation.origin && annotation.origin === table_reference_api
+            )
+          ) {
+            addAnnotationSet = false;
+            return;
+          }
+        });
+      }
+      if (addAnnotationSet) {
+        annotationSetsList.push(annotationSet);
+      }
+    });
+    return annotationSetsList;
+  },
+
+  /* Get annotations inside a list of annotation sets */
+  annotationsInAnnotationsSets: (state) => (annotationsSets) => {
+    const annotations = [];
+    annotationsSets.forEach((annotationSet) => {
+      annotationSet.labels.forEach((label) => {
+        label.annotations.forEach((annotation) => {
+          annotations.push(annotation);
+        });
+      });
+    });
+    return annotations;
+  },
+
   /* Process annotations and extract labels and sets */
   processAnnotationSets: (state, getters) => (annotationSets) => {
     // group annotations for sidebar
@@ -165,14 +248,11 @@ const getters = {
     const labels = [];
     const processedAnnotationSets = annotationSets.map((annotationSet) => {
       const annotationSetLabels = annotationSet.labels.map((label) => {
-        // filter label
-        const filteredLabel = getters.annotationsInLabelFiltered(label);
-
         // add annotations to the document array
-        annotations.push(...filteredLabel.annotations);
-        labels.push(filteredLabel);
+        annotations.push(...label.annotations);
+        labels.push(label);
         // add labels to the labels array
-        return filteredLabel;
+        return label;
       });
       annotationSet.labels = annotationSetLabels;
       return annotationSet;
@@ -185,6 +265,18 @@ const getters = {
     };
   },
 
+  /* Checks if there are annotations correct in the document */
+  documentHasCorrectAnnotations: (state) => () => {
+    if (
+      !state.annotations ||
+      (state.annotations &&
+        state.annotations.filter((ann) => ann.is_correct).length > 0)
+    ) {
+      return true;
+    }
+    return false;
+  },
+
   /* Returns the number of accepted annotations in a label */
   numberOfAcceptedAnnotationsInLabel: (_) => (label) => {
     const annotations = label.annotations.filter((annotation) => {
@@ -217,6 +309,7 @@ const getters = {
       });
       return found ? `${value + 1}` : "";
     }
+    return "";
   },
 
   /**
@@ -297,14 +390,32 @@ const getters = {
     return pendingEmpty.length;
   },
 
+  annotationIsNotFound: (state) => (annotationSet, label) => {
+    // Check if the combined label and label set have been marked as missing
+    // or if the document is in public mode
+    if (state.missingAnnotations.length === 0) {
+      return false;
+    } else {
+      const found = state.missingAnnotations.filter(
+        (el) =>
+          el.label === label.id &&
+          el.annotation_set === annotationSet.id &&
+          el.label_set === annotationSet.label_set.id
+      );
+      return found.length !== 0;
+    }
+  },
+
   // Check if document is ready to be finished
-  isDocumentReviewFinished: (state) => () => {
+  isDocumentReadyToFinishReview: (state) => {
     // check if all annotations have been revised
     let notRevised;
 
     const emptyAnnotations = [];
 
-    if (state.annotationSets) {
+    if (state.labels.length === 0) return false;
+
+    if (state.annotationSets && state.annotationSets.length > 0) {
       state.annotationSets.forEach((annSet) => {
         annSet.labels.map((label) => {
           // return only labels with empty annotations
@@ -324,7 +435,7 @@ const getters = {
 
     // if all annotations have been revised
     // and if there are no empty annotations or
-    // all empty annotations were rejected,
+    // all empty annotations were marked as missing,
     // we can finish the review
     if (
       !emptyAnnotations ||
@@ -335,10 +446,13 @@ const getters = {
     ) {
       return true;
     }
-
     return false;
   },
 
+  isDocumentReviewed: (state) => {
+    return state.selectedDocument.is_reviewed;
+  },
+
   /**
    * Get number of annotations pending review per annotation set
    */
@@ -359,12 +473,12 @@ const getters = {
           annotationsWithPendingReview.push(annotation);
         });
       }
-    });
 
-    // Check if we have grouped annotations by same label
-    if (state.enableGroupingFeature && label.annotations.length < 2) {
-      return annotationsWithPendingReview.length - label.annotations.length;
-    }
+      // Check if we have grouped annotations by same label
+      if (state.enableGroupingFeature && label.annotations.length < 2) {
+        return annotationsWithPendingReview.length - label.annotations.length;
+      }
+    });
 
     return annotationsWithPendingReview.length;
   },
@@ -397,23 +511,18 @@ const getters = {
     );
   },
 
-  documentHasCorrectAnnotations: (state) => () => {
-    return (
-      state.annotations &&
-      state.annotations.filter((ann) => ann.is_correct).length > 0
-    );
+  /**
+   * If automatic splitting is enabled for the project
+   */
+  waitingForSplittingConfirmation: () => (document) => {
+    return document && document.status_data === 41;
   },
 
   /**
-   * Joins all strings in a multi-entity Annotation array
-   * to look like a single string
+   * Show the Smart Split switch or not
    */
-  getTextFromEntities: (state) => () => {
-    return state.selectedEntities
-      .map((entity) => {
-        return entity.content;
-      })
-      .join(" ");
+  documentHasProposedSplit: () => (document) => {
+    return document.proposed_split && document.proposed_split.length > 0;
   },
 
   /**
@@ -430,7 +539,7 @@ const getters = {
   /**
    * Check status of annotation
    */
-  notFound: () => (annotation) => {
+  notExtracted: () => (annotation) => {
     if (annotation) {
       return !annotation.span;
     } else {
@@ -559,8 +668,8 @@ const actions = {
   setDocumentError: ({ commit }, value) => {
     commit("SET_DOCUMENT_ERROR", value);
   },
-  setRejectedMissingAnnotations: ({ commit }, annotations) => {
-    commit("SET_REJECTED_MISSING_ANNOTATIONS", annotations);
+  setAnnotationsMarkedAsMissing: ({ commit }, annotations) => {
+    commit("SET_ANNOTATIONS_MARKED_AS_MISSING", annotations);
   },
   setErrorMessageWidth: ({ commit }, width) => {
     commit("SET_ERROR_MESSAGE_WIDTH", width);
@@ -571,11 +680,8 @@ const actions = {
   setNewAcceptedAnnotations: ({ commit }, annotations) => {
     commit("SET_NEW_ACCEPTED_ANNOTATIONS", annotations);
   },
-  setSelectedEntities: ({ commit }, entities) => {
-    commit("SET_SELECTED_ENTITIES", entities);
-  },
-  setCategorizeModalIsActive: ({ commit }, value) => {
-    commit("SET_CATEGORIZE_MODAL_IS_ACTIVE", value);
+  setSplittingSuggestions: ({ commit }, value) => {
+    commit("SET_SPLITTING_SUGGESTIONS", value);
   },
 
   /**
@@ -605,14 +711,14 @@ const actions = {
 
           // load first page
           if (response.data.pages.length > 0) {
-            await dispatch("fetchDocumentPage", initialPage);
+            dispatch("fetchDocumentPage", initialPage);
           }
+
           // set information on the store
           commit("SET_ANNOTATION_SETS", annotationSets);
           commit("SET_ANNOTATIONS", annotations);
           commit("SET_LABELS", labels);
           commit("SET_SELECTED_DOCUMENT", response.data);
-          commit("SET_FINISHED_REVIEW", getters.isDocumentReviewFinished());
 
           if (rootState.project.projectId) {
             projectId = rootState.project.projectId;
@@ -623,6 +729,10 @@ const actions = {
             });
           }
 
+          if (getters.documentHasProposedSplit(response.data)) {
+            commit("SET_SPLITTING_SUGGESTIONS", response.data.proposed_split);
+          }
+
           categoryId = response.data.category;
           // TODO: add this validation to a method
           isRecalculatingAnnotations = response.data.labeling_available !== 1;
@@ -634,23 +744,41 @@ const actions = {
       });
 
     if (!state.publicView) {
+      await dispatch("fetchMissingAnnotations");
+
       await dispatch("project/fetchCurrentUser", null, {
         root: true,
       });
 
-      await dispatch("fetchMissingAnnotations");
+      // Check if we first open the document dashboard or the edit mode
+      if (
+        !state.selectedDocument.category ||
+        (!state.selectedDocument.category_is_revised &&
+          !getters.documentHasCorrectAnnotations() &&
+          state.missingAnnotations.length === 0)
+      ) {
+        dispatch("edit/enableEditMode", null, {
+          root: true,
+        });
+        dispatch("edit/setRenameAndCategorize", true, { root: true });
+      }
 
       if (projectId) {
         await dispatch("category/fetchCategories", projectId, {
           root: true,
         });
+
+        // get list of documents not reviewed
+        await dispatch("project/fetchDocumentList", "is_reviewed=false", {
+          root: true,
+        });
       }
-      if (categoryId) {
+      if (categoryId && rootState.category.createAvailableListOfDocuments) {
         await dispatch(
           "category/createAvailableDocumentsList",
           {
             categoryId,
-            user: rootState.project.currentUser,
+            user: rootState.project.currentUser.username,
             poll: pollDocumentList,
           },
           {
@@ -686,7 +814,7 @@ const actions = {
       id: annotation.id,
       span,
       page: span.page_index + 1,
-      labelName: label.name,
+      labelName: label ? label.name : "",
     };
     commit("SET_DOCUMENT_ANNOTATION_SELECTED", value);
   },
@@ -704,8 +832,7 @@ const actions = {
       HTTP.post(`/annotations/`, annotation)
         .then(async (response) => {
           if (response.status === 201) {
-            dispatch("fetchMissingAnnotations");
-            commit("SET_FINISHED_REVIEW", getters.isDocumentReviewFinished());
+            await dispatch("fetchMissingAnnotations");
 
             if (!getters.annotationSetExists(response.data.annotation_set)) {
               const documentData = await dispatch("fetchDocumentData");
@@ -719,6 +846,7 @@ const actions = {
             } else {
               commit("ADD_ANNOTATION", response.data);
             }
+
             resolve(response);
           }
         })
@@ -729,16 +857,19 @@ const actions = {
     });
   },
 
-  updateAnnotation: ({ commit, getters }, { updatedValues, annotationId }) => {
+  updateAnnotation: (
+    { commit, getters, dispatch },
+    { updatedValues, annotationId }
+  ) => {
     commit("SET_NEW_ACCEPTED_ANNOTATIONS", [annotationId]);
 
     return new Promise((resolve, reject) => {
       HTTP.patch(`/annotations/${annotationId}/`, updatedValues)
-        .then((response) => {
+        .then(async (response) => {
           if (response.status === 200) {
             commit("UPDATE_ANNOTATION", response.data);
-            commit("SET_FINISHED_REVIEW", getters.isDocumentReviewFinished());
             commit("SET_NEW_ACCEPTED_ANNOTATIONS", null);
+
             resolve(true);
           }
         })
@@ -749,13 +880,13 @@ const actions = {
     });
   },
 
-  deleteAnnotation: ({ commit, getters }, { annotationId }) => {
+  deleteAnnotation: ({ commit, getters, dispatch }, { annotationId }) => {
     return new Promise((resolve, reject) => {
       HTTP.delete(`/annotations/${annotationId}/`)
-        .then((response) => {
+        .then(async (response) => {
           if (response.status === 204) {
             commit("DELETE_ANNOTATION", annotationId);
-            commit("SET_FINISHED_REVIEW", getters.isDocumentReviewFinished());
+
             resolve(true);
           }
         })
@@ -777,7 +908,6 @@ const actions = {
               commit("UPDATE_FILE_NAME", response.data.data_file_name);
             } else {
               commit("SET_SELECTED_DOCUMENT", response.data);
-              commit("SET_FINISHED_REVIEW", getters.isDocumentReviewFinished());
 
               dispatch("pollDocumentEndpoint");
             }
@@ -786,32 +916,50 @@ const actions = {
           }
         })
         .catch((error) => {
-          reject(error.response);
           console.log(error);
+          // check if review error
+          if (
+            error.response &&
+            error.response.request &&
+            error.response.request.response
+          ) {
+            const is_reviewed = JSON.parse(error.request.response).is_reviewed;
+            if (is_reviewed && is_reviewed.length > 0) {
+              const errorData = {
+                data: [...is_reviewed],
+              };
+              reject(errorData);
+              return;
+            }
+          }
+          reject(error.response);
         });
     });
   },
 
   fetchMissingAnnotations: ({ commit, state, getters }) => {
-    return HTTP.get(
-      `/missing-annotations/?document=${state.documentId}&limit=100`
-    )
-      .then((response) => {
-        commit("SET_MISSING_ANNOTATIONS", response.data.results);
-        commit("SET_FINISHED_REVIEW", getters.isDocumentReviewFinished());
-      })
-      .catch((error) => {
-        console.log(error);
-      });
+    return new Promise((resolve, reject) => {
+      return HTTP.get(
+        `/missing-annotations/?document=${state.documentId}&limit=100`
+      )
+        .then((response) => {
+          commit("SET_MISSING_ANNOTATIONS", response.data.results);
+          resolve(true);
+        })
+        .catch((error) => {
+          reject(error.response);
+          console.log(error);
+        });
+    });
   },
 
-  addMissingAnnotations: ({ commit, dispatch }, missingAnnotations) => {
+  addMissingAnnotations: ({ commit, getters }, missingAnnotations) => {
     return new Promise((resolve, reject) => {
-      return HTTP.post(`/missing-annotations/`, missingAnnotations)
-        .then((response) => {
+      HTTP.post(`/missing-annotations/`, missingAnnotations)
+        .then(async (response) => {
           if (response.status === 201) {
-            commit("SET_REJECTED_MISSING_ANNOTATIONS", null);
-            dispatch("fetchMissingAnnotations");
+            commit("SET_ANNOTATIONS_MARKED_AS_MISSING", null);
+            commit("ADD_MISSING_ANNOTATIONS", response.data);
           }
 
           resolve(response);
@@ -823,17 +971,17 @@ const actions = {
     });
   },
 
-  deleteMissingAnnotation: ({ commit, getters, dispatch }, id) => {
-    return new Promise((resolve) => {
+  deleteMissingAnnotation: ({ commit, getters }, id) => {
+    return new Promise((resolve, reject) => {
       return HTTP.delete(`/missing-annotations/${id}/`)
         .then((response) => {
           if (response.status === 204) {
-            dispatch("fetchMissingAnnotations");
+            commit("DELETE_MISSING_ANNOTATION", id);
             resolve(true);
           }
         })
         .catch((error) => {
-          resolve(error.response);
+          reject(error.response);
           console.log(error);
         });
     });
@@ -869,8 +1017,11 @@ const actions = {
         `documents/${state.documentId}/?fields=status_data,labeling_available`
       )
         .then((response) => {
-          if (getters.isDocumentReadyToBeReviewed(response.data)) {
-            // ready
+          if (
+            getters.isDocumentReadyToBeReviewed(response.data) ||
+            getters.waitingForSplittingConfirmation(response.data)
+          ) {
+            // ready or has splitting suggestions
             return resolve(true);
           } else if (getters.documentHadErrorDuringExtraction(response.data)) {
             // error
@@ -881,6 +1032,7 @@ const actions = {
           }
         })
         .catch((error) => {
+          reject(error.response);
           console.log(error);
         });
     });
@@ -924,14 +1076,8 @@ const actions = {
     { commit, dispatch },
     { error, serverErrorMessage, defaultErrorMessage }
   ) => {
-    let errorAsString;
-
-    if (error && error.status) {
-      errorAsString = error.status.toString();
-    }
-
     // check type of error
-    if (error && error.status === 500) {
+    if (error && error.status >= 500 && error.status < 600) {
       dispatch("setErrorMessage", serverErrorMessage);
       commit("SET_SERVER_ERROR", true);
     } else if (error.data && error.data.length > 0) {
@@ -950,12 +1096,26 @@ const actions = {
   },
 
   contactSupport: ({ rootState }, error) => {
-    const url = "https://konfuzio.com/en/support/";
-    const params = `project=${rootState.project.projectId}&email=${rootState.project.currentUser}&issue=${error}`;
+    const url = "https://konfuzio.com/support/";
+    const params = `project=${rootState.project.projectId}&email=${rootState.project.currentUser.username}&issue=${error}`;
     const fullUrl = `${url}?${params}`;
 
     window.open(fullUrl, "_blank");
   },
+
+  changeCurrentDocument: ({ commit, state, dispatch }, newDocumentId) => {
+    // reset splitting suggestions
+    if (state.splittingSuggestions) {
+      commit("SET_SPLITTING_SUGGESTIONS", null);
+    }
+
+    if (getURLQueryParam("document") || getURLPath("d")) {
+      navigateToNewDocumentURL(state.selectedDocument.id, newDocumentId);
+    } else {
+      commit("SET_DOC_ID", newDocumentId);
+      dispatch("fetchDocument");
+    }
+  },
 };
 
 const mutations = {
@@ -994,7 +1154,7 @@ const mutations = {
       (existingAnnotation) => existingAnnotation.id === annotation.id
     );
     if (indexOfAnnotationInAnnotations > -1) {
-      state.annotations[indexOfAnnotationInAnnotations] = annotation;
+      state.annotations.splice(indexOfAnnotationInAnnotations, 1, annotation);
     }
     let updatedAnnotation = false;
     state.annotationSets.forEach((annotationSet) => {
@@ -1006,11 +1166,21 @@ const mutations = {
           (existingAnnotation) => existingAnnotation.id === annotation.id
         );
         if (indexOfAnnotationAnnotationSets > -1) {
-          label.annotations.splice(
-            indexOfAnnotationAnnotationSets,
-            1,
-            annotation
-          );
+          // checks if an annotation label was changed and add it to the new label
+          if (annotation.label && annotation.label.id !== label.id) {
+            label.annotations.splice(indexOfAnnotationAnnotationSets, 1);
+
+            const labelToAdd = annotationSet.labels.find(
+              (labelToAdd) => labelToAdd.id === annotation.label.id
+            );
+            labelToAdd.annotations.push(annotation);
+          } else {
+            label.annotations.splice(
+              indexOfAnnotationAnnotationSets,
+              1,
+              annotation
+            );
+          }
           updatedAnnotation = true;
           return;
         }
@@ -1056,9 +1226,6 @@ const mutations = {
   SET_EDIT_ANNOTATION: (state, editAnnotation) => {
     state.editAnnotation = editAnnotation;
   },
-  SET_FINISHED_REVIEW: (state, finishedReview) => {
-    state.finishedReview = finishedReview;
-  },
   RESET_EDIT_ANNOTATION: (state) => {
     state.editAnnotation = null;
   },
@@ -1086,13 +1253,12 @@ const mutations = {
     }
   },
   SET_SELECTED_DOCUMENT: (state, document) => {
-    if (document.is_reviewed === true) {
-      state.publicView = true;
-    }
     state.selectedDocument = document;
 
     // this is to handle cache when a document is edited or changed
-    state.selectedDocument.downloaded_at = Date.now();
+    if (state.selectedDocument) {
+      state.selectedDocument.downloaded_at = Date.now();
+    }
   },
   SET_RECALCULATING_ANNOTATIONS: (state, recalculatingAnnotations) => {
     state.recalculatingAnnotations = recalculatingAnnotations;
@@ -1100,7 +1266,39 @@ const mutations = {
   SET_MISSING_ANNOTATIONS: (state, missingAnnotations) => {
     state.missingAnnotations = missingAnnotations;
   },
+  ADD_MISSING_ANNOTATIONS: (state, annotations) => {
+    if (annotations && annotations.length > 0) {
+      annotations.map((annotation) => {
+        // check if already in missingAnnotations
+        const found = state.missingAnnotations.find(
+          (missingAnnotation) => missingAnnotation.id === annotation.id
+        );
 
+        if (found) {
+          const indexOfAnnotation = state.missingAnnotations.findIndex(
+            (missingAnnotation) => missingAnnotation.id === annotation.id
+          );
+
+          if (indexOfAnnotation > -1) {
+            state.missingAnnotations.splice(indexOfAnnotation, 1, annotation);
+          }
+        } else {
+          state.missingAnnotations.push(annotation);
+        }
+      });
+    } else {
+      state.missingAnnotations.push(annotations);
+    }
+  },
+  DELETE_MISSING_ANNOTATION: (state, id) => {
+    const indexOfAnnotationToDelete = state.missingAnnotations.findIndex(
+      (annotation) => annotation.id === id
+    );
+
+    if (indexOfAnnotationToDelete > -1) {
+      state.missingAnnotations.splice(indexOfAnnotationToDelete, 1);
+    }
+  },
   SET_SHOW_ACTION_ERROR: (state, value) => {
     state.showActionError = value;
   },
@@ -1110,8 +1308,8 @@ const mutations = {
   SET_DOCUMENT_ERROR: (state, value) => {
     state.showDocumentError = value;
   },
-  SET_REJECTED_MISSING_ANNOTATIONS: (state, annotations) => {
-    state.rejectedMissingAnnotations = annotations;
+  SET_ANNOTATIONS_MARKED_AS_MISSING: (state, annotations) => {
+    state.annotationsMarkedAsMissing = annotations;
   },
   SET_ERROR_MESSAGE_WIDTH: (state, width) => {
     state.errorMessageWidth = width;
@@ -1131,18 +1329,16 @@ const mutations = {
   SET_NEW_ACCEPTED_ANNOTATIONS: (state, annotations) => {
     state.newAcceptedAnnotations = annotations;
   },
-  SET_SELECTED_ENTITIES: (state, entities) => {
-    state.selectedEntities = entities;
-  },
   SET_SERVER_ERROR: (state, value) => {
     state.serverError = value;
   },
-  SET_CATEGORIZE_MODAL_IS_ACTIVE: (state, value) => {
-    state.categorizeModalIsActive = value;
-  },
+
   UPDATE_FILE_NAME: (state, value) => {
     state.selectedDocument.data_file_name = value;
   },
+  SET_SPLITTING_SUGGESTIONS: (state, array) => {
+    state.splittingSuggestions = array;
+  },
 };
 
 export default {