gistfile1.txt

const conversionValueKey: string = 'http://my.lobsterink.com/xapi/extension/conversion-value'
const verbFirstOccurenceKey: string = 'http://my.lobsterink.com/xapi/extension/verb-first-occurence'

export class UserWithConversionValue {
  conversionValue: number
  userSubject: string
}

export class UserWithConversions {
  conversions: Statement[]
  userSubject: string
}

export class User { // Stored in db
  dismissedRecommendations: Statement[]
  verbsOcurred: string[]
}

let eventMappings: EventMapping[] // DI

// Public functions
getActivityLog(userSubjects: string[], startDate: Date): Statement[] {
  let usersWithConversions: UserWithConversions = userSubjects.map((userSubject: string) => {
    return getConversionsForUser(userSubject, startDate)
  }, [])
  
  return getActivityLog(usersWithConversions)
}

getLeaderboard(userSubjects: string[], startDate: Date, endDate: Date): UserWithConversionValue[] {
  return userSubjects.map((userSubject: string) => {
    let conversions: Statement = getConversionsForUser(userSubject, startDate, endDate)
    let conversionValue: number = conversions.reduce((conversionValue: number, statement: Statement) => {
      return conversionValue + statement.extensions[conversionValueKey]
    }, 0)
    
    return { conversionValue: conversionValue, userSubject: userSubject }
  }).sort((userA: UserWithConversionValue, userB: UserWithConversionValue) => {
    return userA.conversionValue > userB.conversionValue
  })
}

// Private functions
private calculateSignature(statement: Statement): string { // Most recommendations don't have an object
  return md5Hash(statement.actor.id + statement.verb.id + (statement.object.id || ''))
}

private getActivityLog(usersWithConversions: UserWithConversions[]): Statement[] {
  return usersWithConversions.reduce((statements: Statement[], userWithConversions: UserWithConversions) => {
    return statements.concat(userWithConversions.conversions)
  }, [])
}

private getConversionsForUser(userSubject: string, startDate?: Date, endDate?: Date): Statement[] {
  return eventMappings.filter((eventMapping: eventMapping) => {
      return return eventMapping.conversionValues.engagement > 0 
    }).map((eventMapping: eventMapping) => {
      let statement: Statement = executeQuery(eventMapping.dbQuery, userSubject, startDate, endDate)
      
      statement.extensions[conversionValueKey] = statement.extensions[verbFirstOccurenceKey] ? 
        eventMapping.conversionValues.first : eventMapping.conversionValues.subsequent
      
      return statement
  })
}

private executeQuery(query: string, userSubject: string, startDate: Date, endDate: Date) // returns a Statement[]