github.com/replicatedhq/ship@v0.55.0/web/init/src/services/ConfigService.js (about)

     1  // @TODO: Refactor this so its not using so much lodash
     2  // the "without" module throws if we import every lodash util piecemeal
     3  import _, { get, isEmpty, some, has } from "lodash";
     4  
     5  export const ConfigService = {
     6    getItems(groups) {
     7      return _(groups)
     8        .map((group) => {
     9          return _(get(group, "items", []))
    10            .map((item) => {
    11              if (!isEmpty(item)) {
    12                if (item.type === "select_many") {
    13                  return _(get(item, "items", []))
    14                    .map((childItem) => {
    15                      if (!isEmpty(childItem)) {
    16                        return childItem;
    17                      }
    18                    })
    19                    .value();
    20                }
    21                return item;
    22              }
    23            })
    24            .value();
    25        })
    26        .flattenDeep()
    27        .without(null)
    28        .value();
    29    },
    30  
    31    getItem(groups, itemName) {
    32      let item = null;
    33      some(ConfigService.getItems(groups), (otherItem) => {
    34        if (otherItem.name === itemName) {
    35          item = otherItem;
    36          return true;
    37        }
    38      });
    39      return item;
    40    },
    41  
    42    evaluateWhen(groups, when) {
    43      const expanded = ConfigService.expandWhen(when);
    44      if (!expanded.key) {
    45        return true;
    46      }
    47      const theItem = ConfigService.getItem(groups, expanded.key);
    48      if (!theItem) {
    49        return true;
    50      }
    51      // recursively evaluate whens
    52      if (theItem.when && !ConfigService.evaluateWhen(groups, theItem.when)) {
    53        return false;
    54      }
    55      let value = get(theItem, "value");
    56      value = isEmpty(value) ? theItem.default : value;
    57      return (value === expanded.value) !== expanded.negate;
    58    },
    59  
    60    filterGroups(groups, filters) {
    61      return _(groups)
    62        .map((group) => {
    63          if (!ConfigService.evaluateFilters(get(group, "filters"), filters)) {
    64            return null;
    65          }
    66          group.items = _(get(group, "items", []))
    67            .map((item) => {
    68              if (!ConfigService.evaluateFilters(get(item, "filters"), filters)) {
    69                return null;
    70              }
    71              return item;
    72            })
    73            .without(null)
    74            .value();
    75          return group;
    76        })
    77        .without(null)
    78        .value();
    79    },
    80  
    81    evaluateFilters(assertions, filters) {
    82      return !some(assertions, (when) => {
    83        const expanded = ConfigService.expandWhen(when);
    84        if (has(filters, expanded.key)) {
    85          const values = expanded.value.split(",");
    86          return !(expanded.negate !== some(values, (value) => {
    87            return filters[expanded.key] === value;
    88          }));
    89        }
    90        return false;
    91      });
    92    },
    93  
    94    expandWhen(when) {
    95      let expanded = {
    96        key: "",
    97        value: "",
    98        negate: false,
    99      };
   100      if (!when || typeof when !== "string") {
   101        return expanded;
   102      }
   103      const parts = when.split("=");
   104      if (parts.length < 2) {
   105        return expanded;
   106      }
   107      expanded.key = parts.shift();
   108      expanded.value = parts.join("=");
   109      if (expanded.key.substr(expanded.key.length - 1) === "!") {
   110        expanded.key = expanded.key.substr(0, expanded.key.length - 1);
   111        expanded.negate = true;
   112      }
   113      return expanded;
   114    },
   115  
   116    isVisible(groups, obj) {
   117      return !obj.hidden && obj.when !== "false" && ConfigService.isEnabled(groups, obj);
   118    },
   119  
   120    isEnabled(groups, obj) {
   121      const when = get(obj, "when");
   122      return when ? ConfigService.evaluateWhen(groups, when) : true;
   123    },
   124  };