@izara_project/izara-shared-search-and-sort 1.0.1 → 1.0.2

package/src/SearchSortSharedLib.js

@@ -0,0 +1,264 @@
+/*
+Copyright (C) 2025 Sven Mason <http://izara.io>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+"use strict";
+
+//* searchResultMain record
+import { objectHash as hash } from '@izara_project/izara-shared-core';  //const hash = require('@izara_project/izara-shared-core').objectHash;
+import { isEmpty as isEmpty } from 'lodash';
+import filtersSharedLib from './FiltersSharedLib'; //const filtersSharedLib = require('./FiltersSharedLib');
+import dataFieldsSharedLib from './DataFieldsSharedLib';
+import searchResultShared from '@izara_project/izara-core-library-search-result';
+
+
+function createSearchRequest(
+  _izContext,
+  objType,
+  initialLogicalElementId,
+  logicalElements,
+  requiredDataFields,
+  complexFilterCombinations,
+  perParentCombinations,
+  requiredDataLinkStepObjects,
+  requiredDataLinkSteps,
+  values
+) {
+  _izContext.logger.debug('createSearchResult: ', {
+    objType,
+    initialLogicalElementId,
+    logicalElements,
+    requiredDataFields,
+    complexFilterCombinations,
+    perParentCombinations,
+    requiredDataLinkStepObjects,
+    requiredDataLinkSteps,
+    values
+  });
+
+  let filterElements = {};
+  let status = 'valid'
+  let errorsObject = {};
+  let errorsFound = [];
+
+  //* create complexFilter normalize to send backend
+  let [
+    complexFilterRequest,
+    complexFilterStatus,
+    complexErrorsObject,
+    complexErrorsFound
+  ] = filtersSharedLib.createFiltersRequest(
+    _izContext,
+    objType,
+    initialLogicalElementId,
+    logicalElements,
+    values,
+    []
+  );
+  _izContext.logger.debug('return createComplexFilter: ', {
+    complexFilterRequest,
+    complexFilterStatus,
+    complexErrorsObject,
+    complexErrorsFound
+  });
+
+  if (complexErrorsFound.length > 0) {
+    errorsFound = errorsFound.concat(complexErrorsFound);
+    Object.assign(errorsObject, complexErrorsObject);
+  }
+
+  let requiredData = dataFieldsSharedLib.createRequiredData(
+    _izContext,
+    objType,
+    requiredDataFields,
+    complexFilterCombinations,
+    perParentCombinations,
+    requiredDataLinkStepObjects,
+    requiredDataLinkSteps,
+    values,
+  );
+  _izContext.logger.debug('return create requiredData: ', requiredData);
+
+  if (requiredData.status === 'invalid' || requiredData.errorsFound.length > 0) {
+    Object.assign(errorsObject, requiredData.errorsObject)
+    errorsFound.push('requiredData cannot create');
+    errorsFound = errorsFound.concat(requiredData.errorsFound);
+  }
+
+  if (errorsFound.length > 0) {
+    return [null, 'invalid', errorsObject, errorsFound]
+  }
+
+  filterElements = complexFilterRequest.filterElements;
+
+  if (!isEmpty(requiredData.perParentCombinations)) {
+    for (const filterObject of Object.values(requiredData.perParentCombinations)) {
+      Object.assign(filterElements, filterObject.filterElements);
+    }
+  }
+
+  if (!isEmpty(requiredData.complexFilterCombinations)) {
+    for (const filterObject of Object.values(requiredData.complexFilterCombinations)) {
+      Object.assign(filterElements, filterObject.filterElements);
+    }
+  }
+
+  if (!isEmpty(requiredData.filterElements)) {
+    Object.assign(filterElements, requiredData.filterElements);
+  }
+
+  _izContext.logger.debug("--------------------------- start create searchResult request -------------------------------", {
+    complexFilterRequest,
+    requiredData,
+    filterElements
+  });
+
+  let searchResultRequest = {
+    objType: objType,
+    searchResultId: complexFilterRequest.filterMainId,
+    searchDetailId: requiredData.requiredDataHash,
+    requiredDataObjects: requiredData.requiredDataObjects,
+    searchParams: {
+      filterObjectId: complexFilterRequest.filterMainId
+    },
+    filterElements: filterElements,
+    linkPathObjects: requiredData.linkPathObjects,
+    linkPathSteps: requiredData.linkPathSteps
+  };
+  _izContext.logger.debug("searchResultRequest: ", searchResultRequest);
+
+  return [searchResultRequest, status, errorsObject, errorsFound]
+
+}
+
+function createSortRequest(
+  _izContext,
+  objType,
+  initialLogicalElementId,
+  logicalElements,
+  requiredDataFields,
+  complexFilterCombinations,
+  perParentCombinations,
+  requiredDataLinkStepObjects,
+  requiredDataLinkSteps,
+  sortFields,
+  values
+) {
+  _izContext.logger.debug('createSortResult: ', {
+    objType,
+    initialLogicalElementId,
+    logicalElements,
+    requiredDataFields,
+    complexFilterCombinations,
+    perParentCombinations,
+    requiredDataLinkStepObjects,
+    requiredDataLinkSteps,
+    sortFields,
+    values
+  });
+
+  let sortFieldMain = []
+
+  //* set sortField
+  for (const sortField of sortFields) {
+    // {
+    //   requiredDataLinkStepObjectId: "userTag_LinkStepObjectC",
+    //   dataType: "number"
+    // },
+
+    let requiredDataLinkStepObjectId = sortField.requiredDataLinkStepObjectId;
+
+    let requiredDataLinkObject = requiredDataLinkStepObjects[requiredDataLinkStepObjectId];
+    _izContext.logger.debug('requiredDataLinkObject', requiredDataLinkObject);
+
+    let requiredDataLinkStepsSortField = requiredDataLinkObject.linkSteps;
+    _izContext.logger.debug('requiredDataLinkStepsSortField', requiredDataLinkStepsSortField);
+
+    let lastRequiredDataLinkStepId = requiredDataLinkStepsSortField[requiredDataLinkStepsSortField.length - 1];
+    _izContext.logger.debug('lastRequiredDataLinkStepId', lastRequiredDataLinkStepId);
+
+    let linkStep = requiredDataLinkSteps[lastRequiredDataLinkStepId];
+    _izContext.logger.debug('linkStep', linkStep);
+
+    sortFieldMain.push({
+      fieldName: linkStep.fieldName,
+      dataType: sortField.dataType
+    });
+
+  }
+  _izContext.logger.debug("sortFieldMain: ", sortFieldMain)
+
+  let [searchResultRequest, status, errorsObject, errorsFound] = createSearchRequest(
+    _izContext,
+    objType,
+    initialLogicalElementId,
+    logicalElements,
+    requiredDataFields,
+    complexFilterCombinations,
+    perParentCombinations,
+    requiredDataLinkStepObjects,
+    requiredDataLinkSteps,
+    values
+  );
+  _izContext.logger.debug('SearchResultRequest: ', {
+    searchResultRequest,
+    status,
+    errorsObject,
+    errorsFound
+  });
+
+  if (errorsFound.length > 0) {
+    return [null, 'invalid', errorsObject, errorsFound]
+  }
+
+  let searchResultId = searchResultRequest.searchResultId;
+  let searchDetailId = searchResultRequest.searchDetailId;
+  _izContext.logger.debug('searchResultMain: ', {
+    searchResultId,
+    searchDetailId
+  });
+
+  let sortResultId = searchResultShared.createSortResultId(
+    _izContext,
+    searchResultId,
+    searchDetailId,
+    sortFieldMain
+  );
+  _izContext.logger.debug('sortResultId: ', sortResultId)
+
+  let sortRequest = {
+    objType: objType,
+    searchResultId: searchResultRequest.searchResultId,
+    searchDetailId: searchResultRequest.searchDetailId,
+    requiredDataObjects: searchResultRequest.requiredDataObjects,
+    searchParams: searchResultRequest.searchParams,
+    filterElements: searchResultRequest.filterElements,
+    linkPathObjects: searchResultRequest.linkPathObjects,
+    linkPathSteps: searchResultRequest.linkPathSteps,
+    sortFields: sortFieldMain
+  };
+  _izContext.logger.debug('sortRequest: ', sortRequest);
+
+  return [sortRequest, status, errorsObject, errorsFound]
+
+}
+
+
+export default {
+  //* create request to backend to sort and search
+  createSearchRequest,
+  createSortRequest
+}