@gudhub/core 1.0.37

package/GUDHUB/Utils/merge_chunks/merge_chunks.js

@@ -0,0 +1,30 @@
+export function mergeChunks(chunks) {
+  const result = {};
+
+  chunks.forEach((chunk) => {
+    chunk.items_list.forEach((item) => {
+      const dstItem = result[item.item_id];
+      if (dstItem) {
+        return item.fields.forEach((srcField) => {
+          let isFieldNonExist = true;
+          dstItem.fields = dstItem.fields.map((dstField) => {
+            if (Number(dstField.field_id) === Number(srcField.field_id)) {
+              isFieldNonExist = false;
+              if (dstField.field_value != srcField.field_value) {
+                return {
+                  ...srcField,
+                  history: srcField.history.concat(dstField.history),
+                };
+              }
+              return dstField;
+            }
+            return dstField;
+          });
+          if (isFieldNonExist) dstItem.fields.push(srcField);
+        });
+      }
+      return (result[item.item_id] = item);
+    });
+  });
+  return Object.values(result);
+}

package/GUDHUB/Utils/merge_compare_items/merge_compare_items.js

@@ -0,0 +1,316 @@
+//********************************************//
+//******************* ITEMS ******************//
+//********************************************//
+
+        /*
+        |============================================== POPULATE WITH ITEM REFFERENCE ==========================================================|
+        |=====  populateWithItemRef (sorceItemsRef, srcFieldIdToCompare, destinationItems, destFieldIdToCompare, destFieldForRef, app_id)  =====|
+        |=======================================================================================================================================|
+        | We update destination Items  with item_ref of  sorce Items. Connectiontion between sorceItemsRef & srcFieldIdToCompare we are checking with 
+        | help of srcFieldIdToCompare & destFieldIdToCompare. After connection is detected we save the item_ref into destFieldForRef.
+        |
+        |   Arguments:
+        |    - sorceItemsRef - items those are will be used as referense for item_ref
+        |    - destinationItems - items those are will be used to save item_ref to sorceItemsRef 
+        |    - srcFieldIdToCompare - we use value from this field to find the similar items in source and destimation items array
+        |    - destFieldIdToCompare - we use value from this field to find the similar items in source and destimation items array
+        |    - destFieldForRef - field where value of item_ref
+        |    - app_id - we use aplication id to generate value for item_ref
+        |
+        |   Return:
+        |   [{},{}...] - returns arey of updated items
+        |   
+        |=====================================================================================================================================|
+        */
+
+        //********************** POPULATE WITH ITEM REFFERENCE ************************/
+        export function populateWithItemRef(sorceItemsRef, srcFieldIdToCompare, destinationItems, destFieldIdToCompare, destFieldForRef, app_id){
+            let resultedItems = [];
+
+            const theSameIdValueFn = function(srcComprItem, dstComprItem){
+                let fieldForRef = getFieldById(dstComprItem, destFieldForRef);
+
+                if(fieldForRef){
+                    fieldForRef.field_value = app_id + "." + srcComprItem.item_id;
+                    resultedItems.push(dstComprItem);
+                }
+            }
+
+            destinationItems.forEach(dstItem => {
+                sorceItemsRef.forEach(srcItem => {
+                    compareTwoItemsByFieldId(srcItem, dstItem, srcFieldIdToCompare, destFieldIdToCompare, theSameIdValueFn);
+                })
+            });
+
+            return resultedItems;
+        }
+
+
+
+        /*
+        |====================================== MERGE ITEM ==================================|
+        |==============      mergeItems (sorceItems, destinationItems)           ============|
+        |====================================================================================|
+        | We replace all fields with values in destinationItems by values from sorceItems.
+        | If destinationItems doesn't have fields that sorceItems then we create them in destinationItems
+        |
+        |   NOTE: items from chanks hase a history properti in a field   
+        |
+        |   Arguments:
+        |    - sorceItems - array of items that will be used to update items from destinationItems items array
+        |    - destinationItems - array of items that is gong to be updated
+        |
+        |   Return:
+        |   [{},{}...] - returns arey of updated items
+        |   
+        |==================================================================================|
+        */
+
+        //********************** MERGE ITEMS ************************/
+        export function mergeItems(sorceItems, destinationItems, mergeByFieldId){
+            let src = JSON.parse(JSON.stringify(sorceItems));
+            let dst = JSON.parse(JSON.stringify(destinationItems));
+            let result = [];
+            
+            //-- The Source and in the Destination has the same item ids but different field values
+            const differentSrcItemFn = function(srcItem, dstItem){
+                result.push( mergeTwoItems(srcItem, dstItem));
+            }
+
+            //-- The Source and in the Destination has the same item ids and field values
+            const theSameSrcItemFn = function(srcItem){
+                result.push(srcItem);
+            }
+
+            //-- Items thoase exist in the Source but they are not exist in the Destination list 
+            const newSrcItemFn = function(srcItem){
+                result.push(srcItem);
+            }
+
+            //-- Items thoase exist in the Destination list but they are not exist in the Source list
+            const uniqDestItemFn = function(dstItem){
+                result.push(dstItem);
+            }
+
+            //---------  Compearing Src & Dst Items by item_id  ---------//
+            if(mergeByFieldId){
+                compareItemsByFieldId(src, dst, mergeByFieldId, differentSrcItemFn, theSameSrcItemFn, newSrcItemFn)
+            }else compareItemsByItemId(src, dst, differentSrcItemFn, theSameSrcItemFn, newSrcItemFn, uniqDestItemFn)
+
+
+            //--------- Final Report ---------//
+            return result;
+        }
+
+
+
+        /*
+        |==================================== COMPARE ITEM ==================================================|
+        |===========      compareItems (sorceItems, destinationItems, fieldToCompare)           =============|
+        |====================================================================================================|
+        | We compare fields of sorceItems with fields of destinationItems. It means that if sorceItems 
+        | have the same fields with the same values as destinationItems thay will be described as 'same_items'
+        | even if destinationItems have additional fields those sorceItems doesn't have
+        |
+        | There to ways how it works:
+        |   1 compering items by item_id (if fieldToCompare is undefined)
+        |   2 compering items by value of specific field_id (if fieldToCompare is defined)
+        |
+        |   Arguments:
+        |    - sorceItems - array of items that is going to be used as a sorce for comperison
+        |    - destinationItems - array of items that is gong to be compared with sorceItems
+        |    - fieldToCompare - field that we use to compare sorce items with destination items, if this is not specified then we compare items by item_id
+        |
+        |   Return:
+        |    {
+        |        is_items_diff: false,
+        |        new_src_items:[],
+        |        diff_src_items:[],
+        |        same_items:[]
+        |    }
+        |
+        |==================================================================================|
+        */
+
+        //********************** COMPARE ITEMS ************************/
+        export function compareItems(sorceItems, destinationItems, fieldToCompare){
+            const src = JSON.parse(JSON.stringify(sorceItems));
+            const dst = JSON.parse(JSON.stringify(destinationItems));
+            let result = {
+                is_items_diff: false,
+                new_src_items:[],
+                diff_src_items:[],
+                same_items:[]
+            };
+
+            const differentSrcItemFn = function(item){
+                result.diff_src_items.push(item);
+            }
+
+            const theSameSrcItemFn = function(item){
+                result.same_items.push(item);
+            }
+
+            const newSrcItemFn = function(item){
+                result.new_src_items.push(item);
+            }
+
+            
+            //---------  Compearing Src & Dst Items by item_id  ---------//
+            if(fieldToCompare){
+                compareItemsByFieldId(src, dst, fieldToCompare, differentSrcItemFn, theSameSrcItemFn, newSrcItemFn)
+            }else compareItemsByItemId(src, dst, differentSrcItemFn, theSameSrcItemFn, newSrcItemFn)
+
+
+            //--------- Final Report ---------//
+            result.is_items_diff = result.new_src_items.length > 0 || result.diff_src_items.length > 0;       
+            return result;
+        }
+
+
+
+
+        function mergeTwoItems (src, dst){
+            src.fields.forEach(srcField =>{
+                let destField = getFieldById(dst, srcField.field_id);
+
+                if(destField){
+                    destField.field_value = srcField.field_value;
+                    
+                    // if we work with chanked items then we merge history 
+                    if(srcField.history && destField.history){
+                        destField.history = srcField.history.concat(destField.history);
+                    }
+                        
+                }else{//-- if we didn't find field with item then we add it
+                    dst.fields.push(srcField);
+                }
+            })
+
+            return dst;
+        }
+        
+
+
+        function compareItemsByFieldId(src, dst, fieldToCompare, differentSrcItemFn, theSameSrcItemFn, newSrcItemFn){
+            src.forEach(srcItem =>{
+                let notFoundDestItemforSrc = true;
+                let srcVal = getFieldById(srcItem, fieldToCompare).field_value;
+
+                dst.forEach(dstItem =>{
+                    let dstVal = getFieldById(dstItem, fieldToCompare).field_value;
+                    if (srcVal == dstVal){
+                        notFoundDestItemforSrc = false;
+                        compareTwoItems(srcItem, dstItem, differentSrcItemFn, theSameSrcItemFn);
+                    }
+                });
+
+                //-- If there no destination item with the same item_id then it means that item is new
+                if(notFoundDestItemforSrc){
+                    newSrcItemFn(srcItem);
+                }
+            });
+        }
+
+
+
+        function compareItemsByItemId(src, dst, differentSrcItemFn, theSameSrcItemFn, newSrcItemFn, uniqDestItemFn){
+            let dstItemsMap = new ItemsMapper(dst);
+
+            src.forEach(srcItem => {
+                let destIndex = dstItemsMap.pullItemIndex(srcItem.item_id);
+
+                if(destIndex != undefined){
+                    compareTwoItems(srcItem, dst[destIndex], differentSrcItemFn, theSameSrcItemFn);
+                }else{
+                    newSrcItemFn(srcItem);
+                };
+            });
+            
+            //-- In case if we have destination items which are new then we 
+            if(uniqDestItemFn)
+                for (const [key, value] of Object.entries(dstItemsMap.itemsMap)) {
+                    uniqDestItemFn(dst[value]);
+                }
+        }
+
+
+
+        function compareTwoItems (src, dst, differentSrcItemFn, theSameSrcItemFn ){
+            let sameItem = true;
+
+            for(let i=0; i<src.fields.length; i++){
+                let destField = getFieldById(dst, src.fields[i].field_id);
+
+                if(destField){
+                    //-- if value of some field of the item is different then item is different too
+                    if(destField.field_value != src.fields[i].field_value){
+                        sameItem = sameItem && false;
+                    }
+                }else{//-- if we didn't find field with item then item is different
+                    sameItem = sameItem && false;
+                }
+            }
+            
+            //-- Sending Compearing Result
+            if (sameItem){
+                theSameSrcItemFn(src, dst);
+            }else differentSrcItemFn(src, dst);
+        }
+
+
+
+        function compareTwoItemsByFieldId (srcItem, dstItem, srcFieldId, dstFieldId, theSameSrcItemFn ){
+            let srcFieldVal = getFieldById(srcItem, srcFieldId).field_value;
+            let dstFieldIdVal = getFieldById(dstItem, dstFieldId).field_value;
+
+            if(srcFieldVal == dstFieldIdVal){
+                theSameSrcItemFn(srcItem, dstItem);
+            }
+        }
+
+        
+
+
+        
+
+        function getFieldById (item, field_id){
+            let result = null;
+
+            for(let i=0; i<item.fields.length; i++){
+                if (field_id == item.fields[i].field_id){
+                  result = item.fields[i];
+                }
+            };
+
+            return result;
+        }
+
+
+        class ItemsMapper {
+            constructor(items) {
+                this._itemsMap = {};
+                
+                items.forEach((item,key) => {
+                    this._itemsMap[item.item_id] = key;
+                });
+
+            }
+
+            pullItemIndex(item_id){
+                let index = this._itemsMap[item_id];
+                delete this._itemsMap[item_id];
+                return index;
+            }
+
+            getItemIndex(item_id) {
+              return this._itemsMap[item_id];
+            }
+
+            get itemsMap() {
+                return this._itemsMap;
+            }
+          }
+          
+    
+