ramda#values JavaScript Examples

recordNotesSelector = createSelector(
  [activeCollectionSelector, (_, ownProps) => ownProps],
  (collection, ownProps) => {
    const { resourceId } = ownProps;
    if (!collection.records[resourceId]?.notes) {
      return [];
    }
    const sortDesc = ({ dateCreated: d1 }, { dateCreated: d2 }) => (d1 > d2 ? -1 : 1);
    return values(collection.records[resourceId].notes).sort(sortDesc);
  },
)

collectionsCounterSelector = (state) => {
  const collections = Object.values(state.collections);
  const customCount = collections.filter(({ preBuilt }) => preBuilt === false).length;
  const preBuiltCount = collections.filter(({ preBuilt }) => preBuilt === true).length;
  return {
    customCount,
    preBuiltCount,
  };
}

patientSelector = createSelector(
  [resourcesSelector],
  (resources) => values(resources).find((r) => r.type === 'Patient'),
)

providersSelector = createSelector(
  [resourcesSelector],
  (resources) => values(resources).filter((r) => r.type === 'Organization'),
)

allValidRecordsSortedByDateSelector = createSelector(
  [resourcesSelector],
  (resources) => values(resources)
    .filter(({ type }) => PLURAL_RESOURCE_TYPES[type])
    .filter((r) => r.timelineDate) // must have timelineDate
    .map(pickTimelineFields)
    .sort(sortByDate),
)

collectionNotesSelector = createSelector(
  [activeCollectionSelector],
  (collection) => {
    const sortDesc = ({ dateCreated: d1 }, { dateCreated: d2 }) => (d1 > d2 ? -1 : 1);
    return values(collection.notes).sort(sortDesc);
  },
)

collectionsLabelsSelector = createSelector(
  [collectionsSelector],
  (collections) => values(collections)
    .reduce((acc, { label }) => { acc.push(label.toLowerCase()); return acc; }, []),
)

/**
 * Sends staking payouts for recent eras using the given sender account.
 *
 * @param {DockAPI} dock
 * @param {ErasInfo} erasInfo
 * @param {*} initiator - account to send tx from
 * @param {number} batchSize
 * @returns {Promise<boolean>} - `true` if some unpaid eras were found, `false` otherwise
 */
async function sendStakingPayouts(dock, erasInfo, initiator, batchSize) {
  const validators = pipe(
    values,
    pluck("validators"),
    chain(keys),
    (values) => new Set(values)
  )(erasInfo.pointsByEra);

  if (!validators.size) {
    console.log("- Validator set is empty.");
    return false;
  }

  console.log("- Retrieving validator eras...");
  const erasToBePaid = await lastValueFrom(
    from(validators).pipe(
      getUnclaimedStashesEras(dock.api, erasInfo),
      toArray()
    )
  );

  const rewards = pipe(buildValidatorRewards, toPairs)(erasInfo, erasToBePaid);

  if (isEmpty(rewards)) {
    console.log("- No unpaid validator rewards found for recent eras.");
    return false;
  }

  console.log("- Payouts need to be made:");

  for (const [stashId, eras] of rewards) {
    const total = eras.reduce(
      (total, { reward }) => (total != null ? total.add(reward) : reward),
      null
    );

    console.log(` * To \`${stashId}\`: ${formatDock(total)}`);
  }

  const logResult = ({ result, tx }) => {
    // Ther's a much better way to check this...
    const isBatch = tx.method.args?.[0]?.[0] instanceof Map;

    let msg = " * ";
    if (isBatch) msg += `Batch transaction`;
    else msg += `Transaction`;

    if (FinalizeTx) {
      msg += ` finalized at block \`${result.status.asFinalized}\`: `;
    } else {
      msg += ` included at block \`${result.status.asInBlock}\`: `;
    }

    const payoutsSummary = (isBatch ? tx.method.args[0] : [tx.method])
      .map((payout) => payout.get("args"))
      .map(
        ({ validator_stash, era }) =>
          `\`${validator_stash}\` rewarded for era ${era}`
      )
      .join(isBatch ? ",\n    " : ",");

    msg += isBatch ? `[\n    ${payoutsSummary}\n ]` : payoutsSummary;

    console.log(msg);
  };

  const payoutTxs$ = from(rewards).pipe(
    concatMap(([stashId, eras]) => from(eras.map(assoc("stashId", stashId)))),
    mapRx(({ stashId, era }) =>
      dock.api.tx.staking.payoutStakers(stashId, era)
    ),
    batchExtrinsics(dock.api, batchSize),
    signAndSendExtrinsics(dock, initiator),
    tap(logResult)
  );

  await new Promise((resolve, reject) =>
    payoutTxs$.subscribe({
      error: reject,
      complete: resolve,
    })
  );

  return true;
}