TypeScript lodash.omitBy函数代码示例

      [`${resource}Modified`]: async function restoreModified(message: any,
        ctx: any, config: any, eventName: string): Promise<any> {
        that.decodeBufferField(message, resource);
        await db.update(`${resource}s`, { id: message.id }, _.omitBy(message, _.isNil));

        return {};
      },

export function payments(state: PaymentsState = initialState, {type, payload}: Action): PaymentsState {
  switch (type) {

    case PatientActions.REMOVE_SUCCESS: {
      const data = _.omitBy(state.data, p => p.patient_id == payload) as PaymentData;
      const ids = _.values(data).map(data => data['id']);
      return { ...state, ids, data };
    }

    case PaymentsActions.EDIT_SUCCESS: {
      return { ...state, data: { ...state.data, [payload.id]: payload } };
    }

    case PaymentsActions.CREATE_SUCCESS: {
      const data = { ...state.data, [payload.id]: payload };
      const ids = [payload.id, ...state.ids];
      return { selected: payload.id, status: true, ids , data };
    }

    case PaymentsActions.REMOVE_SUCCESS: {
      const ids = state.ids.filter(ids => ids !== payload.id);
      const data = _.omit(state.data, payload.id) as PaymentData;
      return { ...state, ids, data };
    }

    case PaymentsActions.INIT_SUCCESS: {
      const ids = payload.map(data => data.id);
      const data = _.mapKeys(payload, 'id') as PaymentData;

      return { ...state, status: false, ids, data };
    }

    default: return state;
  }
};

export function findExamClashes(modules: Module[], semester: Semester): ExamClashes {
  const groupedModules = groupBy(modules, (module) =>
    get(getModuleSemesterData(module, semester), 'examDate'),
  );
  delete groupedModules.undefined; // Remove modules without exams
  return omitBy(groupedModules, (mods) => mods.length === 1); // Remove non-clashing mods
}

  buildSaveObject() {
    const obj = _.omitBy(this, (val, key) => {
      return _.startsWith(key, '$')
        || _.isNotWritable(this, key);
    });

    return obj;
  }

  onSubmit(params) {
    this.passwordConfirmation.updateValueAndValidity({});
    this.passwordConfirmation.markAsTouched();
    if (!this.myForm.valid) return;

    this.userService.updateMe(omitBy(params, isEmpty))
      .subscribe(() => {
        toastr.success('Successfully updated.');
      }, this.handleError);
  }

 static getSpecialStatString(item) {
   const newItem = _.omitBy(item, (val, key) => {
     return _.includes(baseIgnores, key) || _.includes(key, 'Percent') || _.includes(key, 'item') || !_.isNumber(val) || key === 'vector' || _.includes(key, 'Req');
   });
   return _(newItem)
     .keys()
     .filter(key => newItem[key] !== 0)
     .map(key => `${key}(${newItem[key]})`)
     .join(' ');
 }

 updateCommunity(community: noosfero.Community) {
     const headers = {
         'Content-Type': 'application/json'
     };
     const attributesToUpdate: any = {
         community: Object.assign({}, _.omitBy(_.pick(community, ['name', 'closed']), _.isNull))
     };
     const restRequest = this.getElement(community.id).customOperation("patch", null, null, headers, attributesToUpdate);
     return restRequest.toPromise().then(this.getHandleSuccessFunction());
 }

export function getFilterUrl(ownProps: OwnProps, part: RawQuery) {
  const basePathName = ownProps.organization
    ? `/organizations/${ownProps.organization.key}/projects`
    : '/projects';
  const pathname = basePathName + (ownProps.isFavorite ? '/favorite' : '');
  const query: RawQuery = omitBy({ ...ownProps.query, ...part }, isNil);
  each(query, (value, key) => {
    if (Array.isArray(value)) {
      query[key] = value.join(',');
    }
  });
  return { pathname, query };
}

export function getStandaloneMainSections(sysInfoData: T.SysInfoBase): T.SysInfoValueObject {
  return {
    ...getSystemData(sysInfoData),
    ...(omitBy(
      sysInfoData,
      (value, key) =>
        value == null ||
        [PLUGINS_FIELD, SETTINGS_FIELD, STATS_FIELD, SYSTEM_FIELD].includes(key) ||
        key.startsWith(CE_FIELD_PREFIX) ||
        key.startsWith(SEARCH_PREFIX) ||
        key.startsWith(WEB_PREFIX)
    ) as T.SysInfoValueObject)
  };
}

export function getStandaloneMainSections(sysInfoData: SysInfo): SysValueObject {
  return {
    ...getSystemData(sysInfoData),
    ...(omitBy(
      sysInfoData,
      (value, key) =>
        value == null ||
        [PLUGINS_FIELD, SETTINGS_FIELD, 'Statistics', 'System'].includes(key) ||
        key.startsWith('Compute Engine') ||
        key.startsWith('Search') ||
        key.startsWith('Web')
    ) as SysValueObject)
  };
}