How to use

uniq

function

in

CollectionChain

_.chain(order)
    .flatten()
    .uniq()
    .sort()
    .map(key => ({
      key,
      done: false,
      deps: order.filter(([a, b]) => b === key)
        .map(d => d[0])
    }))
    .keyBy('key')
    .value()

Promise.all(semesters.map(function (semester) {
      return self.__getSemesterExams__(semester);
    }
  )).then(function (examsArray) {
    return _.chain(examsArray).flatten().uniq(function (exam) {
      return exam.course.id;
    }).value();
  }, function (err) {
    return self.__getAllExamsOffline__();
  })

//
 // ---- ACL
 //

 _trimActions(actions) {
  return _.chain(actions)
   .map(_.lowerCase)
   .map(act => ACTION_ALIASES[act] || act)
   .filter(act => _.includes(ALLOWED_ACTIONS, act))
   .uniq()
   .value();
 }

/**
  * Check if roleAction matches routeAction
  *
  * @private
  *
  * @param roleAction Action of the current role loop
  * @param routeAction Action required by the route
  *
  * @return {boolean}
  */
 _matchActions (roleAction, routeAction) {
  const actionsKeys = chain(keys(routeAction)).concat(keys(roleAction)).uniq().value()

  for (const key of actionsKeys) {
   const roleActionValue = roleAction[key]
   const routeActionValue = routeAction[key] || '*'

   if (roleActionValue !== '*') {
    if (Array.isArray(roleActionValue)) {
     if (roleActionValue.indexOf(routeActionValue) === -1) return false
    } else if (roleActionValue !== routeActionValue) return false
   }
  }

  return true
 }

_.chain(events)
    .map('guard')
    .filter()
    .uniq()
    .map(id => ({
      id,
      asleep: false,
      minutesAsleep: 0,
      byMinute: _.range(60)
        .map(() => 0)
    }))
    .keyBy('id')
    .value()

Promise.all(semesters.map(function (semester) {
      return self.__getSemesterCourses__(semester);
    }
  )).then(function (coursesArray) {
    return _.chain(coursesArray).flatten().uniq(function (course) {
      return course.id;
    }).value();
  }, function (err) {
    return self.__getAllCoursesOffline__();
  })

_.chain(order)
    .flatten()
    .uniq()
    .sort()
    .map(key => ({
      key,
      worker: -1,
      seconds: minTime + key.charCodeAt(0) - 64,
      deps: order.filter(([a, b]) => b === key)
        .map(d => d[0])
    }))
    .keyBy('key')
    .value()

_.chain(events)
    .map('guard')
    .filter()
    .uniq()
    .map(id => ({
      id,
      asleep: false,
      minutesAsleep: 0,
      byMinute: _.range(60)
        .map(() => 0)
    }))
    .keyBy('id')
    .value()