3b3717d307
* Folds=>groups * Show groups on user profile * Allow group creation from /create * Refactoring to groups * Convert folds to groups * Add new add to group notification * Fix user profile tab bug * Add groups nav and tab for my groups * Remove bad profile pages * remove comments * Add group list dropdown to sidebar * remove unused * group cards ui * Messages=>Comments, v2, groupDetails * Discussion time * Cleaning up some code * Remove follow count * Fix pool scoring for cpmm * Fix imports * Simplify rules, add GroupUser collection * Fix group cards * Refactor * Refactor * Small fixes * Remove string * Add api error detail handling * Clear name field * Componentize * Spacing * Undo userpage memo * Member groups are already in my tab * Remove active contracts reference for now * Remove unused * Refactoring * Allow adding old questions to a group * Rename * Wording * Throw standard v2 APIError * Hide input for non-members, add about under title * Multiple names to & # more * Move comments firestore rules to appropriate subpaths * Group membership, pool=>volume * Cleanup, useEvent * Raise state to parent * Eliminate unused * Cleaning up * Clean code * Revert tags input deletion * Cleaning code * Stylling * Limit members to display * Array cleanup * Add categories back in * Private=>closed * Unused vars
100 lines
3.0 KiB
TypeScript
100 lines
3.0 KiB
TypeScript
import { groupBy, mapValues, maxBy, sortBy } from 'lodash'
|
|
import { Contract } from 'web/lib/firebase/contracts'
|
|
import { Comment } from 'web/lib/firebase/comments'
|
|
import { Bet } from 'common/bet'
|
|
|
|
const MAX_ACTIVE_CONTRACTS = 75
|
|
|
|
// This does NOT include comment times, since those aren't part of the contract atm.
|
|
// TODO: Maybe store last activity time directly in the contract?
|
|
// Pros: simplifies this code; cons: harder to tweak "activity" definition later
|
|
function lastActivityTime(contract: Contract) {
|
|
return Math.max(contract.resolutionTime || 0, contract.createdTime)
|
|
}
|
|
|
|
// Types of activity to surface:
|
|
// - Comment on a market
|
|
// - New market created
|
|
// - Market resolved
|
|
// - Bet on market
|
|
export function findActiveContracts(
|
|
allContracts: Contract[],
|
|
recentComments: Comment[],
|
|
recentBets: Bet[],
|
|
seenContracts: { [contractId: string]: number }
|
|
) {
|
|
const idToActivityTime = new Map<string, number>()
|
|
function record(contractId: string, time: number) {
|
|
// Only record if the time is newer
|
|
const oldTime = idToActivityTime.get(contractId)
|
|
idToActivityTime.set(contractId, Math.max(oldTime ?? 0, time))
|
|
}
|
|
|
|
const contractsById = new Map(allContracts.map((c) => [c.id, c]))
|
|
|
|
// Record contract activity.
|
|
for (const contract of allContracts) {
|
|
record(contract.id, lastActivityTime(contract))
|
|
}
|
|
|
|
// Add every contract that had a recent comment, too
|
|
for (const comment of recentComments) {
|
|
if (comment.contractId) {
|
|
const contract = contractsById.get(comment.contractId)
|
|
if (contract) record(contract.id, comment.createdTime)
|
|
}
|
|
}
|
|
|
|
// Add contracts by last bet time.
|
|
const contractBets = groupBy(recentBets, (bet) => bet.contractId)
|
|
const contractMostRecentBet = mapValues(
|
|
contractBets,
|
|
(bets) => maxBy(bets, (bet) => bet.createdTime) as Bet
|
|
)
|
|
for (const bet of Object.values(contractMostRecentBet)) {
|
|
const contract = contractsById.get(bet.contractId)
|
|
if (contract) record(contract.id, bet.createdTime)
|
|
}
|
|
|
|
let activeContracts = allContracts.filter(
|
|
(contract) =>
|
|
contract.visibility === 'public' &&
|
|
!contract.isResolved &&
|
|
(contract.closeTime ?? Infinity) > Date.now()
|
|
)
|
|
activeContracts = sortBy(
|
|
activeContracts,
|
|
(c) => -(idToActivityTime.get(c.id) ?? 0)
|
|
)
|
|
|
|
const contractComments = groupBy(
|
|
recentComments,
|
|
(comment) => comment.contractId
|
|
)
|
|
const contractMostRecentComment = mapValues(
|
|
contractComments,
|
|
(comments) => maxBy(comments, (c) => c.createdTime) as Comment
|
|
)
|
|
|
|
const prioritizedContracts = sortBy(activeContracts, (c) => {
|
|
const seenTime = seenContracts[c.id]
|
|
if (!seenTime) {
|
|
return 0
|
|
}
|
|
|
|
const lastCommentTime = contractMostRecentComment[c.id]?.createdTime
|
|
if (lastCommentTime && lastCommentTime > seenTime) {
|
|
return 1
|
|
}
|
|
|
|
const lastBetTime = contractMostRecentBet[c.id]?.createdTime
|
|
if (lastBetTime && lastBetTime > seenTime) {
|
|
return 2
|
|
}
|
|
|
|
return seenTime
|
|
})
|
|
|
|
return prioritizedContracts.slice(0, MAX_ACTIVE_CONTRACTS)
|
|
}
|