@outliant/sunrise-utils 1.0.0

package/helpers/taskFilter/statusFilter.js

@@ -0,0 +1,177 @@
+module.exports = (filter) => {
+  switch (filter.condition) {
+    case 'is_empty':
+      return module.exports.isEmpty();
+    case 'is_not_empty':
+      return module.exports.isNotEmpty();
+    case 'is_equal':
+      return module.exports.isEqual(filter);
+    case 'not_equal':
+      return module.exports.isNotEqual(filter);
+    case 'is_any_of':
+      return module.exports.isAnyOf(filter);
+    default:
+      return null;
+  }
+};
+
+module.exports.isEmpty = () => {
+  return {
+    bool: {
+      must_not: [
+        {
+          exists: {
+            field: 'is_complete'
+          }
+        },
+        {
+          exists: {
+            field: 'is_ready'
+          }
+        },
+        {
+          exists: {
+            field: 'on_hold'
+          }
+        }
+      ]
+    }
+  };
+};
+
+module.exports.isNotEmpty = () => {
+  const isEmptyFilter = module.exports.isEmpty();
+
+  return {
+    bool: {
+      must_not: isEmptyFilter
+    }
+  };
+};
+
+module.exports.isEqual = (filter) => {
+  switch (filter.value) {
+    case 'new':
+      return {
+        bool: {
+          must: [
+            {
+              term: {
+                is_ready: false
+              }
+            },
+            {
+              term: {
+                is_complete: false
+              }
+            }
+          ]
+        }
+      };
+    case 'pending':
+      return {
+        bool: {
+          must: [
+            {
+              term: {
+                is_ready: true
+              }
+            },
+            {
+              term: {
+                is_complete: false
+              }
+            }
+          ]
+        }
+      };
+    case 'completed':
+      return {
+        bool: {
+          must: [
+            {
+              term: {
+                is_complete: true
+              }
+            }
+          ]
+        }
+      };
+    case 'on_hold':
+      return {
+        bool: {
+          must: [
+            {
+              term: {
+                on_hold: true
+              }
+            }
+          ]
+        }
+      };
+    case 'overdue':
+      return {
+        bool: {
+          must: [
+            {
+              term: {
+                is_complete: false
+              }
+            },
+            {
+              exists: {
+                field: 'due_date'
+              }
+            },
+            {
+              range: {
+                due_date: {
+                  lte: Date.now()
+                }
+              }
+            }
+          ]
+        }
+      };
+    default:
+      return null;
+  }
+};
+
+module.exports.isAnyOf = (filter) => {
+  let value = filter.value;
+
+  if (typeof value === 'string') {
+    value = value.split(';');
+  }
+
+  const should = [];
+  value.forEach((x) => {
+    const condition = module.exports.isEqual({
+      value: x
+    });
+
+    if (condition) {
+      should.push(condition);
+    }
+  });
+  return {
+    bool: {
+      should
+    }
+  };
+};
+
+module.exports.isNotEqual = (filter) => {
+  const equalFilter = module.exports.isEqual(filter);
+
+  if (equalFilter) {
+    return {
+      bool: {
+        must_not: equalFilter
+      }
+    };
+  }
+
+  return null;
+};

package/helpers/taskFilter/taskFieldFilter.js

@@ -0,0 +1,309 @@
+const moment = require('moment');
+
+module.exports = (filter) => {
+  switch (filter.condition) {
+    case 'is_empty':
+      return module.exports.isEmpty(filter);
+    case 'is_any_of':
+      return module.exports.isAnyOf(filter);
+    case 'is_not_empty':
+      return module.exports.isNotEmpty(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(';');
+  }
+
+  return {
+    terms: {
+      [filter.type]: value
+    }
+  };
+};
+
+module.exports.isEmpty = (filter) => {
+  if (filter.field_type === 'text' || filter.field_type === 'textarea') {
+    return {
+      bool: {
+        should: [
+          {
+            bool: {
+              must_not: [
+                {
+                  exists: {
+                    field: filter.type
+                  }
+                }
+              ]
+            }
+          },
+          {
+            bool: {
+              must_not: [
+                {
+                  wildcard: {
+                    [filter.type]: {
+                      value: '?*'
+                    }
+                  }
+                }
+              ]
+            }
+          },
+          {
+            term: {
+              [filter.type]: {
+                value: ''
+              }
+            }
+          }
+        ]
+      }
+    };
+  }
+  return {
+    bool: {
+      should: [
+        {
+          bool: {
+            must_not: [
+              {
+                exists: {
+                  field: filter.type
+                }
+              }
+            ]
+          }
+        }
+      ]
+    }
+  };
+};
+
+module.exports.isNotEmpty = (filter) => {
+  if (filter.field_type === 'text' || filter.field_type === 'textarea') {
+    return {
+      bool: {
+        must: [
+          {
+            exists: {
+              field: filter.type
+            }
+          },
+          {
+            wildcard: {
+              [filter.type]: {
+                value: '?*'
+              }
+            }
+          },
+          {
+            bool: {
+              must_not: [
+                {
+                  term: {
+                    [filter.type]: {
+                      value: ''
+                    }
+                  }
+                }
+              ]
+            }
+          }
+        ]
+      }
+    };
+  }
+
+  return {
+    bool: {
+      must: [
+        {
+          exists: {
+            field: filter.type
+          }
+        }
+      ]
+    }
+  };
+};
+
+module.exports.isEqual = (filter) => {
+  if (filter.field_type === 'date') {
+    const startOfDay = moment(filter.value).startOf('day').valueOf();
+    const endOfDay = moment(filter.value).endOf('day').valueOf();
+
+    return {
+      range: {
+        [filter.type]: {
+          gte: startOfDay,
+          lte: endOfDay
+        }
+      }
+    };
+  } else if (filter.field_type === 'textarea') {
+    return {
+      query_string: {
+        fields: [filter.type],
+        query: `*${filter.value}*`
+      }
+    };
+  }
+
+  return {
+    bool: {
+      must: [
+        {
+          term: {
+            [filter.type]: {
+              value:
+                filter.field_type === 'number'
+                  ? parseInt(filter.value)
+                  : filter.value
+            }
+          }
+        }
+      ]
+    }
+  };
+};
+
+module.exports.isBefore = (filter) => {
+  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 {
+    range: {
+      [filter.type]: {
+        lt: param
+      }
+    }
+  };
+};
+
+module.exports.isAfter = (filter) => {
+  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 {
+    range: {
+      [filter.type]: {
+        gt: param
+      }
+    }
+  };
+};
+
+module.exports.isBeforeIncludeParam = (filter) => {
+  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 {
+    range: {
+      [filter.type]: {
+        lte: param
+      }
+    }
+  };
+};
+
+module.exports.isAfterIncludeParam = (filter) => {
+  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 {
+    range: {
+      [filter.type]: {
+        gte: param
+      }
+    }
+  };
+};
+
+module.exports.isBetween = (filter) => {
+  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 {
+    range: {
+      [filter.type]: {
+        gte: firstParam,
+        lte: secondParam
+      }
+    }
+  };
+};
+
+module.exports.isNotEqual = (filter) => {
+  const equalFilter = module.exports.isEqual(filter);
+
+  if (equalFilter) {
+    return {
+      bool: {
+        must_not: equalFilter
+      }
+    };
+  }
+
+  return null;
+};