export const getStatus = (application) => {
	if (R.isNil(application.firstReviewer) || R.isNil(application.secondReviewer)) {
		return application.status
	}

	if (application.firstReviewerStatus === STATUS_APPROVED && application.secondReviewerStatus === STATUS_APPROVED) {
		return STATUS_APPROVED;
	}

	return STATUS_REJECTED;
}

 return configs.map((config: NodeBalancerConfigFields) => {
   return filter(
     /* remove the (key: value) pairs that we set to undefined */
     el => el !== undefined,
     {
       check_path: config.check_path || undefined,
       protocol:
         /*
          * If the provided protocol is "https" and the cert and key are set
          * to "<REDACTED", don't try to set the protocol, it has already
          * been set to "https".
          */
         config.protocol === 'https' &&
         config.ssl_cert === '<REDACTED>' &&
         config.ssl_key === '<REDACTED>'
           ? undefined
           : config.protocol || undefined,
       algorithm: config.algorithm || undefined,
       stickiness: config.stickiness || undefined,
       check: config.check || undefined,
       check_interval: !isNil(config.check_interval)
         ? +config.check_interval
         : undefined,
       check_timeout: !isNil(config.check_timeout)
         ? +config.check_timeout
         : undefined,
       check_attempts: !isNil(config.check_attempts)
         ? +config.check_attempts
         : undefined,
       port: config.port ? +config.port : undefined,
       check_body: config.check_body || undefined,
       check_passive: config.check_passive /* will be boolean or undefined */,
       cipher_suite: config.cipher_suite || undefined,
       ssl_cert:
         config.ssl_cert === '<REDACTED>'
           ? undefined
           : config.ssl_cert || undefined,
       ssl_key:
         config.ssl_key === '<REDACTED>'
           ? undefined
           : config.ssl_key || undefined,
       nodes: config.nodes.map(nodeForRequest),
       id: undefined,
       nodebalancer_id: undefined,
       nodes_status: undefined,
       ssl_fingerprint: undefined,
       ssl_commonname: undefined
     }
   ) as any;
 }) as NodeBalancerConfigFields[];

export const hiddenComponentDecorator = ({
  modelName,
  fields,
}: {
  modelName: string;
  fields: Fields;
}): { modelName; fields: Fields & WithHidden } => {
  const TAG = '[hiddenComponentDecorator]';
  logger.log(TAG, { fields });

  let wrappedFields = R.omit([castModelKey('createdAt'), castModelKey('updatedAt')])(fields);
  if (R.has('id', wrappedFields)) {
    const hidden = R.isNil(wrappedFields.id.value);
    wrappedFields = R.mergeDeepRight(wrappedFields, { id: { options: { hidden } } });
  }

  const positions = R.filter(R.pathEq(['options', 'type'], 'SortPosition'))(wrappedFields);
  if (!R.isEmpty(positions)) {
    const hiddenPositions = R.map(position => ({
      ...position,
      options: { hidden: true },
    }))(positions);

    wrappedFields = R.mergeDeepRight(wrappedFields, { ...hiddenPositions });
  }
  logger.log(TAG, 'wrappedFields', { wrappedFields }, diff(fields, wrappedFields));
  return { modelName, fields: wrappedFields };
};

export const result = (error: string, data: any): never | any => {
    if (isNil(data)) {
        throw new Error(error);
    }

    return data;
};

    return function(...args: any[]) {
        for (let fun of funcs) {
            let ret = fun(...args);
            if (!isNil(ret)) return ret;
        }

        return undefined;
    };

  function modelReducer(acc, key) {

    if (!R.isNil(model.tableAttributes[key].references)) {
      acc.push(model.tableAttributes[key].references.model);
      // references.model here is the name of the table
    }

    return acc;
  }

const createTypeRecord = (value?: string): null | DiskRecord | VolumeRecord => {
  if (isNil(value) || value === 'none') {
    return null;
  }

  // Given: volume-123
  const [type, id] = split('-', value); // -> [volume, 123]

  const key = `${type}_id`; // -> `volume_id`
  const idAsNumber = Number(id); // -> 123

  return objOf(key, idAsNumber); // -> { volume_id: 123 }
};

  const linearMatch = target => {
    const value = path(modifierPath, target)

    if (is(Boolean, value)) {
      return value
    }

    if (isNil(value)) {
      return false
    }

    return !isEmpty(value)
  }

 fields.forEach(field => {
   if (!toFilter) {
     if (R.is(Object, field)) {
       const key = R.head(R.keys(field));
       const value = R.values(field);
       if (key === 'eq') {
         toFilter = (obj[value] === query);
       }
     } else {
       if (!R.isNil(obj[field])) {
         toFilter = obj[field].toString()
           .toLowerCase().indexOf(query) > -1
       }
     }
   }
 });

const findRouteConfig = (config: any, pathParts: string[]) => {
    const getBasePath = getBasePathFilter(pathParts);

    if (
        !pathParts.length ||
        R.isNil(config.paths) ||
        (pathParts.length === 1 && getBasePath(config))
    ) {
        return config;
    }

    const newConfig = getBasePath(config.paths);
    const newPathParts = [pathParts.slice(0, 2).join('/')].concat(pathParts.slice(2));

    return findRouteConfig(newConfig, newPathParts);
};

			.filter(res => !R.isNil(res))

export const isNilOrEmpty = (v: any) => isNil(v) || isEmpty(v);

const isNotEmpty = compose(not, (v: any) => isEmpty(v) || isNil(v));

const isCreateSocketValid = (createSocket: (path: string) => WebSocket) => !isNil(createSocket)

 Object.keys(raw).filter((key) => {
   return !R.isNil(model.options.scopes[key]);
 })

		.combineLatest(employees$.filter(res => !R.isNil(res)))

 const concat = R.reduce((a, b) => {
   if (R.isEmpty(b) || R.isNil(b)) { return a }
   return a + '\n' + b
 }, '');

    ].reduce((acc, validator: swaggerTypeConfig) => {
        if (R.isNil(validator)) return acc;

        const [name, value] = validator;
        return value === true ? acc[name]() : acc[name](value);
    }, joi);

 (v: any) => isEmpty(v) || isNil(v)

		.combineLatest(receipts$.filter(res => !R.isNil(res)))