@outliant/sunrise-utils 1.0.0

package/helpers/taskFilter/criticalPathFilter.js

@@ -0,0 +1,144 @@
+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: {
+      should: [
+        {
+          bool: {
+            must_not: [
+              {
+                exists: {
+                  field: 'critical_path'
+                }
+              }
+            ]
+          }
+        },
+        {
+          bool: {
+            must_not: [
+              {
+                exists: {
+                  field: 'critical_path.stage_id'
+                }
+              }
+            ]
+          }
+        },
+        {
+          term: {
+            'critical_path.stage_id': {
+              value: ''
+            }
+          }
+        }
+      ]
+    }
+  };
+};
+
+module.exports.isNotEmpty = () => {
+  return {
+    bool: {
+      must: [
+        {
+          exists: {
+            field: 'critical_path'
+          }
+        },
+        {
+          exists: {
+            field: 'critical_path.stage_id'
+          }
+        }
+      ],
+      must_not: [
+        {
+          term: {
+            'critical_path.stage_id': {
+              value: ''
+            }
+          }
+        }
+      ]
+    }
+  };
+};
+
+module.exports.isEqual = (filter) => {
+  return {
+    bool: {
+      must: [
+        {
+          exists: {
+            field: 'critical_path.stage_id'
+          }
+        },
+        {
+          term: {
+            'critical_path.stage_id': {
+              value: filter.value
+            }
+          }
+        }
+      ]
+    }
+  };
+};
+
+module.exports.isAnyOf = (filter) => {
+  let value = filter.value;
+
+  if (typeof value === 'string') {
+    value = value.split(';');
+  }
+
+  return {
+    bool: {
+      must: [
+        {
+          exists: {
+            field: 'critical_path.stage_id'
+          }
+        },
+        {
+          terms: {
+            'critical_path.stage_id': value
+          }
+        }
+      ]
+    }
+  };
+};
+
+module.exports.isNotEqual = (filter) => {
+  return {
+    bool: {
+      must_not: [
+        {
+          term: {
+            'critical_path.stage_id': {
+              value: filter.value
+            }
+          }
+        }
+      ]
+    }
+  };
+};

package/helpers/taskFilter/index.js

@@ -0,0 +1,228 @@
+const buildStatusFilter = require('./statusFilter');
+const buildOwnerFilter = require('./ownerFilter');
+const buildPathAgeFilter = require('./pathAgeFilter');
+const buildRegionFilter = require('./regionFilter');
+const buildTaskFieldFilter = require('./taskFieldFilter');
+const buildCriticalPathFilter = require('./criticalPathFilter');
+const buildOnHoldFilter = require('./onHoldFilter');
+const buildProjectFieldFilter = require('../projectFilter/projectFieldFilter');
+
+module.exports.taskStatusOptions = [
+  {
+    label: 'Blocked',
+    value: 'new'
+  },
+  {
+    label: 'Pending',
+    value: 'pending'
+  },
+  {
+    label: 'Completed',
+    value: 'completed'
+  },
+  {
+    label: 'Cancelled',
+    value: 'on_hold'
+  },
+  {
+    label: 'Overdue',
+    value: 'overdue'
+  }
+];
+
+module.exports.defaultCustomColumns = [
+  {
+    name: 'Owner',
+    value: 'owner',
+    type: 'owner',
+    field_type: 'select',
+    options: []
+  },
+  {
+    name: 'Age',
+    value: 'ready_at',
+    type: 'ready_at',
+    field_type: 'date'
+  },
+  {
+    name: 'Project ID',
+    value: 'project_id',
+    type: 'project_id',
+    field_type: 'text'
+  },
+  {
+    name: 'Status',
+    value: 'status',
+    type: 'status',
+    field_type: 'select',
+    options: []
+  },
+  {
+    name: 'Region',
+    value: 'region',
+    type: 'region',
+    field_type: 'checkbox',
+    options: []
+  },
+  {
+    name: 'Description',
+    value: 'notes',
+    type: 'notes',
+    field_type: 'textarea'
+  },
+  {
+    name: 'Cancelled',
+    value: 'on_hold',
+    type: 'on_hold',
+    field_type: 'select',
+    options: [
+      {
+        label: 'Yes',
+        value: 'Yes'
+      },
+      {
+        label: 'No',
+        value: 'No'
+      }
+    ]
+  },
+  {
+    name: 'Last Comment',
+    value: 'last_comment',
+    type: 'last_comment',
+    field_type: 'textarea'
+  },
+  {
+    name: 'Last Comment Date',
+    value: 'last_comment_date',
+    type: 'last_comment_date',
+    field_type: 'date'
+  },
+  {
+    name: 'Due Date',
+    value: 'due_date',
+    type: 'due_date',
+    field_type: 'date'
+  },
+  {
+    name: 'Completed By',
+    value: 'completed_by',
+    type: 'completed_by',
+    field_type: 'select',
+    options: []
+  },
+  {
+    name: 'Completed At',
+    value: 'completed_at',
+    type: 'completed_at',
+    field_type: 'date'
+  },
+  {
+    name: 'Created',
+    value: 'created_at',
+    type: 'created_at',
+    field_type: 'date'
+  },
+  {
+    name: 'Updated',
+    value: 'updated_at',
+    type: 'updated_at',
+    field_type: 'date'
+  },
+  {
+    name: 'Critical Path Stage',
+    value: 'critical_path_stage',
+    type: 'critical_path_stage',
+    field_type: 'select',
+    options: []
+  },
+  {
+    name: 'Was Marked Incomplete',
+    value: 'was_marked_incomplete',
+    type: 'was_marked_incomplete',
+    field_type: 'select',
+    options: [
+      {
+        label: 'Yes',
+        value: 'Yes'
+      },
+      {
+        label: 'No',
+        value: 'No'
+      }
+    ]
+  },
+  {
+    name: 'Marked Incomplete At',
+    value: 'marked_incomplete_at',
+    type: 'marked_incomplete_at',
+    field_type: 'date'
+  }
+];
+
+module.exports.defaultTaskFilter = {
+  bool: {
+    should: [
+      {
+        term: {
+          on_hold: false
+        }
+      },
+      {
+        bool: {
+          must_not: {
+            exists: {
+              field: 'on_hold'
+            }
+          }
+        }
+      }
+    ]
+  }
+};
+
+module.exports.buildTaskPipelineFilter = (filter) => {
+  switch (filter.type) {
+    case 'status':
+      return buildStatusFilter(filter);
+    case 'owner':
+      return buildOwnerFilter(filter);
+    case 'region':
+      return buildRegionFilter(filter);
+    case 'critical_path_stage':
+      return buildCriticalPathFilter(filter);
+    case 'on_hold':
+      return buildOnHoldFilter(filter);
+    // Always expected as is_equal condition
+    case 'path_age':
+      return buildPathAgeFilter(filter);
+    // Always expected as is_equal condition with array of task template ids
+    case 'task_templates':
+      let value = filter.value;
+
+      if (typeof value === 'string') {
+        value = value.split(';');
+      }
+
+      return {
+        bool: {
+          should: value.map((x) => {
+            return {
+              term: {
+                task_template_id: {
+                  value: x
+                }
+              }
+            };
+          })
+        }
+      };
+    case 'dealinformation':
+    case 'contactinformation':
+    case 'ticketinformation':
+      return buildProjectFieldFilter(filter);
+    default:
+      // Task Fields
+      return buildTaskFieldFilter(filter);
+  }
+};

package/helpers/taskFilter/onHoldFilter.js

@@ -0,0 +1,101 @@
+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); // if is any, means all tasks that have value
+    default:
+      return null;
+  }
+};
+
+module.exports.isEmpty = () => {
+  return {
+    bool: {
+      must_not: [
+        {
+          exists: {
+            field: 'on_hold'
+          }
+        }
+      ]
+    }
+  };
+};
+
+module.exports.isNotEmpty = () => {
+  return {
+    bool: {
+      must: [
+        {
+          exists: {
+            field: 'on_hold'
+          }
+        }
+      ]
+    }
+  };
+};
+
+module.exports.isEqual = (filter) => {
+  return {
+    bool: {
+      must: [
+        {
+          term: {
+            on_hold: {
+              value: filter.value === 'Yes'
+            }
+          }
+        }
+      ]
+    }
+  };
+};
+
+module.exports.isNotEqual = (filter) => {
+  return {
+    bool: {
+      must_not: [
+        {
+          term: {
+            on_hold: {
+              value: filter.value === 'Yes'
+            }
+          }
+        }
+      ]
+    }
+  };
+};
+
+module.exports.isAnyOf = (filter) => {
+  let value = filter.value;
+
+  if (typeof value === 'string') {
+    value = value.split(';');
+  }
+
+  const should = [];
+  value.forEach((x) => {
+    should.push({
+      term: {
+        on_hold: {
+          value: x === 'Yes'
+        }
+      }
+    });
+  });
+
+  return {
+    bool: {
+      should
+    }
+  };
+};

package/helpers/taskFilter/ownerFilter.js

@@ -0,0 +1,148 @@
+const { validate: isUuid } = require('uuid');
+
+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: {
+      should: [
+        {
+          bool: {
+            must: [
+              {
+                term: {
+                  user_id: ''
+                }
+              },
+              {
+                term: {
+                  team_id: ''
+                }
+              }
+            ]
+          }
+        },
+        {
+          bool: {
+            must_not: [
+              {
+                exists: {
+                  field: 'user_id'
+                }
+              },
+              {
+                exists: {
+                  field: 'team_id'
+                }
+              }
+            ]
+          }
+        }
+      ]
+    }
+  };
+};
+
+module.exports.isNotEmpty = (filter) => {
+  const isEmptyFilter = module.exports.isEmpty(filter);
+
+  return {
+    bool: {
+      must_not: isEmptyFilter
+    }
+  };
+};
+
+module.exports.isEqual = (filter) => {
+  const must = [];
+
+  // If uuid, treat as user id
+  if (isUuid(filter.value)) {
+    must.push({
+      term: {
+        user_id: {
+          value: filter.value
+        }
+      }
+    });
+  } else {
+    must.push({
+      term: {
+        team_id: {
+          value: filter.value
+        }
+      }
+    });
+  }
+
+  return {
+    bool: {
+      must
+    }
+  };
+};
+
+module.exports.isAnyOf = (filter) => {
+  let value = filter.value;
+
+  if (typeof value === 'string') {
+    value = value.split(';');
+  }
+
+  const should = [];
+  value.forEach((x) => {
+    // If uuid, treat as user id
+    if (isUuid(x)) {
+      should.push({
+        term: {
+          user_id: {
+            value: x
+          }
+        }
+      });
+    } else {
+      should.push({
+        term: {
+          team_id: {
+            value: x
+          }
+        }
+      });
+    }
+  });
+
+  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/pathAgeFilter.js

@@ -0,0 +1,18 @@
+module.exports = (filter) => {
+  switch (filter.condition) {
+    case 'is_equal':
+      return module.exports.isEqual(filter);
+    default:
+      return null;
+  }
+};
+
+module.exports.isEqual = (filter) => {
+  return {
+    term: {
+      'critical_path.color_id': {
+        value: filter.value
+      }
+    }
+  };
+};

package/helpers/taskFilter/regionFilter.js

@@ -0,0 +1,82 @@
+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);
+    default:
+      return null;
+  }
+};
+
+module.exports.isEmpty = () => {
+  return {
+    bool: {
+      must_not: [
+        {
+          exists: {
+            field: 'region_id'
+          }
+        }
+      ]
+    }
+  };
+};
+
+module.exports.isNotEmpty = () => {
+  return {
+    bool: {
+      must: [
+        {
+          exists: {
+            field: 'region_id'
+          }
+        }
+      ]
+    }
+  };
+};
+
+module.exports.isEqual = (filter) => {
+  let value = filter.value;
+
+  if (typeof value === 'string') {
+    value = value.split(';');
+  }
+
+  return {
+    bool: {
+      should: value.map((value) => {
+        if (String(value).toLowerCase() === 'is_empty') {
+          return module.exports.isEmpty();
+        }
+
+        return {
+          term: {
+            region_id: {
+              value
+            }
+          }
+        };
+      })
+    }
+  };
+};
+
+module.exports.isNotEqual = (filter) => {
+  const equalFilter = module.exports.isEqual(filter);
+
+  if (equalFilter) {
+    return {
+      bool: {
+        must_not: equalFilter
+      }
+    };
+  }
+
+  return null;
+};