@outliant/sunrise-utils 1.0.0

package/helpers/projectFilter/projectFieldFilter.js

@@ -0,0 +1,587 @@
+const moment = require('moment');
+const { escapeElasticQuery } = require('../es');
+
+module.exports = (filter) => {
+  switch (filter.condition) {
+    case 'is_empty':
+      return module.exports.isEmpty(filter);
+    case 'is_not_empty':
+      return module.exports.isNotEmpty(filter);
+    case 'is_any_of':
+      return module.exports.isAnyOf(filter);
+    case 'is_equal':
+      return module.exports.isEqual(filter);
+    case 'not_equal':
+      return module.exports.isNotEqual(filter);
+    case 'before':
+    case 'less_than':
+      return module.exports.isBefore(filter);
+    case 'after':
+    case 'greater_than':
+      return module.exports.isAfter(filter);
+    case 'less_than_or_equal':
+      return module.exports.isBeforeIncludeParam(filter);
+    case 'greater_than_or_equal':
+      return module.exports.isAfterIncludeParam(filter);
+    case 'between':
+      return module.exports.isBetween(filter);
+    default:
+      return null;
+  }
+};
+
+module.exports.isAnyOf = (filter) => {
+  let value = filter.value;
+
+  if (typeof value === 'string') {
+    value = value.split(';');
+  }
+
+  if (filter.field_id) {
+    return {
+      nested: {
+        path: 'fields',
+        query: {
+          bool: {
+            must: [
+              {
+                term: {
+                  'fields.id': {
+                    value: filter.field_id
+                  }
+                }
+              },
+              {
+                terms: {
+                  'fields.text': value
+                }
+              }
+            ]
+          }
+        }
+      }
+    };
+  }
+
+  return {
+    terms: {
+      [filter.type]: value
+    }
+  };
+};
+
+module.exports.isEmpty = (filter) => {
+  if (!!filter.field_id) {
+    return {
+      bool: {
+        should: [
+          {
+            bool: {
+              must: [
+                {
+                  nested: {
+                    path: 'fields',
+                    query: {
+                      bool: {
+                        must: [
+                          {
+                            term: {
+                              'fields.id': {
+                                value: filter.field_id
+                              }
+                            }
+                          },
+                          {
+                            term: {
+                              'fields.text': {
+                                value: ''
+                              }
+                            }
+                          }
+                        ]
+                      }
+                    }
+                  }
+                }
+              ]
+            }
+          },
+          {
+            bool: {
+              must_not: [
+                {
+                  nested: {
+                    path: 'fields',
+                    query: {
+                      bool: {
+                        must: [
+                          {
+                            term: {
+                              'fields.id': {
+                                value: filter.field_id
+                              }
+                            }
+                          }
+                        ]
+                      }
+                    }
+                  }
+                }
+              ]
+            }
+          }
+        ]
+      }
+    };
+  }
+
+  return null;
+};
+
+module.exports.isNotEmpty = (filter) => {
+  if (!!filter.field_id) {
+    return {
+      bool: {
+        must: [
+          {
+            nested: {
+              path: 'fields',
+              query: {
+                bool: {
+                  must: [
+                    {
+                      term: {
+                        'fields.id': {
+                          value: filter.field_id
+                        }
+                      }
+                    },
+                    {
+                      exists: {
+                        field: 'fields.text'
+                      }
+                    },
+                    {
+                      bool: {
+                        must_not: [
+                          {
+                            term: {
+                              'fields.text': {
+                                value: ''
+                              }
+                            }
+                          }
+                        ]
+                      }
+                    }
+                  ]
+                }
+              }
+            }
+          }
+        ]
+      }
+    };
+  }
+
+  return null;
+};
+
+module.exports.isEqual = (filter) => {
+  if (!!filter.field_id) {
+    let mappingValue = {
+      term: {
+        'fields.text': {
+          value: filter.value
+        }
+      }
+    };
+
+    if (filter.field_type === 'date') {
+      const startOfDay = moment(filter.value).startOf('day').valueOf();
+      const endOfDay = moment(filter.value).endOf('day').valueOf();
+
+      mappingValue = {
+        range: {
+          'fields.number': {
+            gte: startOfDay,
+            lte: endOfDay
+          }
+        }
+      };
+    } else if (filter.field_type === 'number') {
+      mappingValue = {
+        term: {
+          'fields.number': {
+            value: parseInt(filter.value)
+          }
+        }
+      };
+    } else if (filter.field_type === 'textarea') {
+      mappingValue = {
+        query_string: {
+          fields: ['fields.text'],
+          query: `*${escapeElasticQuery(filter.value.trim())}*`
+        }
+      };
+    } else if (filter.field_type === 'checkbox') {
+      let value = filter.value;
+
+      if (typeof value === 'string') {
+        value = value.split(';');
+      }
+
+      mappingValue = {
+        bool: {
+          should: value.map((x) => {
+            return {
+              match: {
+                'fields.text.analyzed': {
+                  query: x,
+                  operator: 'and'
+                }
+              }
+            };
+          })
+        }
+      };
+    }
+
+    return {
+      bool: {
+        must: [
+          {
+            nested: {
+              path: 'fields',
+              query: {
+                bool: {
+                  must: [
+                    {
+                      term: {
+                        'fields.id': {
+                          value: filter.field_id
+                        }
+                      }
+                    },
+                    mappingValue
+                  ]
+                }
+              }
+            }
+          }
+        ]
+      }
+    };
+  }
+
+  return null;
+};
+
+module.exports.isBefore = (filter) => {
+  if (!!filter.field_id) {
+    let param;
+    if (filter.field_type === 'date') {
+      param = moment(filter.value).startOf('day').valueOf();
+    } else if (filter.field_type === 'number') {
+      param = parseInt(filter.value);
+    } else {
+      return null;
+    }
+
+    return {
+      bool: {
+        must: [
+          {
+            nested: {
+              path: 'fields',
+              query: {
+                bool: {
+                  must: [
+                    {
+                      term: {
+                        'fields.id': {
+                          value: filter.field_id
+                        }
+                      }
+                    },
+                    {
+                      range: {
+                        'fields.number': {
+                          lt: param
+                        }
+                      }
+                    }
+                  ]
+                }
+              }
+            }
+          }
+        ]
+      }
+    };
+  }
+
+  return null;
+};
+
+module.exports.isAfter = (filter) => {
+  if (!!filter.field_id) {
+    let param;
+    if (filter.field_type === 'date') {
+      param = moment(filter.value).endOf('day').valueOf();
+    } else if (filter.field_type === 'number') {
+      param = parseInt(filter.value);
+    } else {
+      return null;
+    }
+
+    return {
+      bool: {
+        must: [
+          {
+            nested: {
+              path: 'fields',
+              query: {
+                bool: {
+                  must: [
+                    {
+                      term: {
+                        'fields.id': {
+                          value: filter.field_id
+                        }
+                      }
+                    },
+                    {
+                      range: {
+                        'fields.number': {
+                          gt: param
+                        }
+                      }
+                    }
+                  ]
+                }
+              }
+            }
+          }
+        ]
+      }
+    };
+  }
+
+  return null;
+};
+
+module.exports.isBeforeIncludeParam = (filter) => {
+  if (!!filter.field_id) {
+    let param;
+    if (filter.field_type === 'date') {
+      param = moment(filter.value).endOf('day').valueOf();
+    } else if (filter.field_type === 'number') {
+      param = parseInt(filter.value);
+    } else {
+      return null;
+    }
+
+    return {
+      bool: {
+        must: [
+          {
+            nested: {
+              path: 'fields',
+              query: {
+                bool: {
+                  must: [
+                    {
+                      term: {
+                        'fields.id': {
+                          value: filter.field_id
+                        }
+                      }
+                    },
+                    {
+                      range: {
+                        'fields.number': {
+                          lte: param
+                        }
+                      }
+                    }
+                  ]
+                }
+              }
+            }
+          }
+        ]
+      }
+    };
+  }
+
+  return null;
+};
+
+module.exports.isAfterIncludeParam = (filter) => {
+  if (!!filter.field_id) {
+    let param;
+    if (filter.field_type === 'date') {
+      param = moment(filter.value).startOf('day').valueOf();
+    } else if (filter.field_type === 'number') {
+      param = parseInt(filter.value);
+    } else {
+      return null;
+    }
+
+    return {
+      bool: {
+        must: [
+          {
+            nested: {
+              path: 'fields',
+              query: {
+                bool: {
+                  must: [
+                    {
+                      term: {
+                        'fields.id': {
+                          value: filter.field_id
+                        }
+                      }
+                    },
+                    {
+                      range: {
+                        'fields.number': {
+                          gte: param
+                        }
+                      }
+                    }
+                  ]
+                }
+              }
+            }
+          }
+        ]
+      }
+    };
+  }
+
+  return null;
+};
+
+module.exports.isBetween = (filter) => {
+  if (!!filter.field_id) {
+    let firstParam;
+    let secondParam;
+
+    if (filter.field_type === 'date') {
+      firstParam = moment(filter.value).startOf('day').valueOf();
+      secondParam = moment(filter.second_value).endOf('day').valueOf();
+    } else if (filter.field_type === 'number') {
+      firstParam = parseInt(filter.value);
+      secondParam = parseInt(filter.second_value);
+    } else {
+      return null;
+    }
+
+    return {
+      bool: {
+        must: [
+          {
+            nested: {
+              path: 'fields',
+              query: {
+                bool: {
+                  must: [
+                    {
+                      term: {
+                        'fields.id': {
+                          value: filter.field_id
+                        }
+                      }
+                    },
+                    {
+                      range: {
+                        'fields.number': {
+                          gte: firstParam,
+                          lte: secondParam
+                        }
+                      }
+                    }
+                  ]
+                }
+              }
+            }
+          }
+        ]
+      }
+    };
+  }
+
+  return null;
+};
+
+module.exports.isNotEqual = (filter) => {
+  if (!!filter.field_id) {
+    let mappingValue = {
+      term: {
+        'fields.text': {
+          value: filter.value
+        }
+      }
+    };
+
+    if (filter.field_type === 'date') {
+      const startOfDay = moment(filter.value).startOf('day').valueOf();
+      const endOfDay = moment(filter.value).endOf('day').valueOf();
+
+      mappingValue = {
+        range: {
+          'fields.number': {
+            gte: startOfDay,
+            lte: endOfDay
+          }
+        }
+      };
+    } else if (filter.field_type === 'number') {
+      mappingValue = {
+        term: {
+          'fields.number': {
+            value: parseInt(filter.value)
+          }
+        }
+      };
+    }
+
+    return {
+      bool: {
+        must: [
+          {
+            nested: {
+              path: 'fields',
+              query: {
+                bool: {
+                  must: [
+                    {
+                      term: {
+                        'fields.id': {
+                          value: filter.field_id
+                        }
+                      }
+                    }
+                  ]
+                }
+              }
+            }
+          }
+        ],
+        must_not: [
+          {
+            nested: {
+              path: 'fields',
+              query: mappingValue
+            }
+          }
+        ]
+      }
+    };
+  }
+
+  return null;
+};

package/helpers/searchFilter.js

@@ -0,0 +1,86 @@
+const { validate: isUuid } = require('uuid');
+const { escapeElasticQuery } = require('./es');
+
+module.exports = (query = {}, searchFields = []) => {
+  const search = query.search;
+  let searchString = search.trim();
+
+  const parsedQuery = escapeElasticQuery(searchString);
+  /* eslint-disable  no-useless-escape */
+  const isQueryQuoteWrapped = /^\"(.*)\"$/.test(searchString);
+
+  if (isQueryQuoteWrapped) {
+    searchString = searchString.replace(/"/g, '');
+  }
+
+  const should = [];
+  const projectFields = searchFields.filter((x) => isUuid(x));
+  const localFields = searchFields.filter((x) => x !== '_id' && !isUuid(x));
+
+  if (searchFields.includes('_id')) {
+    should.push({
+      term: {
+        _id: {
+          value: searchString
+        }
+      }
+    });
+  }
+
+  if (localFields.length > 0) {
+    if (isQueryQuoteWrapped) {
+      should.push({
+        multi_match: {
+          query: searchString,
+          fields: localFields,
+          operator: 'and'
+        }
+      });
+    } else {
+      should.push({
+        query_string: {
+          fields: localFields,
+          query: `${parsedQuery} OR *${parsedQuery.toLowerCase()}* OR *${parsedQuery.toUpperCase()}*`
+        }
+      });
+    }
+  }
+
+  if (projectFields.length > 0) {
+    for (let i = 0; i < projectFields.length; i++) {
+      should.push({
+        function_score: {
+          query: {
+            nested: {
+              path: 'fields',
+              query: {
+                bool: {
+                  must: [
+                    {
+                      term: {
+                        'fields.id': {
+                          value: projectFields[i]
+                        }
+                      }
+                    },
+                    {
+                      match: {
+                        'fields.text.analyzed': {
+                          query: searchString,
+                          operator: isQueryQuoteWrapped ? 'and' : 'or'
+                        }
+                      }
+                    }
+                  ]
+                }
+              }
+            }
+          },
+          min_score: 15
+        }
+      });
+    }
+  }
+
+  return should;
+};