R.filter(role => {
   // 判断返回的是否是 ids
   if (user.roles && _.isObjectLike(user.roles[0])) {
     return R.contains(role.id)(R.values(R.pluck('id', user.roles)));
   }
   return R.contains(role.id)(user.roles);
 }),

getIdOrNullFor = type => compose(
  ifElse(isNil, always(null), compose(
    ifElse(
      contains(type),
      compose<string, string[], string, number, Record<string, number>>(
        objOf(`${type}_id`), Number, last, split('-'),
      ),
      always(null),
    ),
  )),
);

export const craftMinion = (props: CraftMinionProps): Minion => ({
  abilities: [],
  attacksPerformed: 0,
  // TODO: refactor
  exhausted: !!props.abilities && props.abilities.length > 0
    ? !R.contains(Ability.Charge, props.abilities)
    : true,
  destroyed: false,
  health: props.maxHealth,
  ...props,
  id: newId(),
  type: CardType.Minion,
});

    route.query = function(context) {
      // console.log(context);
      context.query = queryParser(context.query || {});
      context.method = route.method;

      if (route.method === 'get') {
        context.query.limit = context.query.limit || options.defaultLimit;
        if (context.query.limit > options.maxItems) {
          context.query.limit = options.maxItems;
        }
      }

      let query = queryGenerator(context);

      let base;

      if (context.query.scope) {
        base = sequelize.models[state.model].scope(context.query.scope);
      }
      else {
        base = sequelize.models[state.model];
      }

      let f = base[methodMap[state.type][route.method]];

      let fParams = [query];

      if (R.contains(route.method, ['put', 'post', 'update'])) {
        fParams.unshift(context.payload);
      }

      return f.apply(base, fParams).then((response) => {
        if (route.method === 'put') {
          let updated = response[1];
          if (state.type === 'row') {
            return updated.length === 0 ? null : updated[0];
          }
          else {
            return updated;
          }
        }
        if (route.method === 'delete') {
          return {id: context.identifiers[state.identifier]};
        }
        else {
          return response;
        }
      });
    };

  private getExplanationVideos(letter: string) {
    if (contains(letter, ['a', 'e', 'n'])) {
      return [
        this.createExercise(ExerciseTypes.InfoScreen, {
          type: 'TutorialVideo',
          video: `explanation_find_letter_${letter}_w_letter`
        }),
        this.createExercise(ExerciseTypes.InfoScreen, {
          type: 'TutorialVideo',
          video: `explanation_find_letter_${letter}_wo_letter`
        })
      ];
    }

    return [];
  }

  private getExplanationVideos(letter: string) {
    if (contains(letter, ['h', 'i', 'r'])) {
      return [
        this.createExercise(ExerciseTypes.InfoScreen, {
          type: 'TutorialVideo',
          video: `explanation_has_phoneme_${letter}_w_phoneme`
        }),
        this.createExercise(ExerciseTypes.InfoScreen, {
          type: 'TutorialVideo',
          video: `explanation_has_phoneme_${letter}_wo_phoneme`
        })
      ];
    }

    return [];
  }

  private createOptionsForSyllable(syllable: string) {
    // find correct replacements (doubled vowels, diphtongs or knownVowels)
    const replacementSet = this.createCorrectReplacementSet(syllable);
    if (!replacementSet) {
      return undefined;
    }

    // create a syllable option for each element in the replacement set
    const result = map(
      replacement =>
        syllable.replace(
          new RegExp(`(${join('|', replacementSet)})`, 'g'),
          replacement
        ),
      replacementSet
    );

    return contains(syllable, result) ? result : [...result, syllable];
  }

 (ability: Ability, entity: Card): boolean =>
   R.contains(ability, entity.abilities)

 function isItemCompleted(item: ITodoItem): boolean {
     return R.contains("completed", item.states);
 }

const containsText = curryN(2, (textToSearch, list) => contains(list, textToSearch))