[r/boards] initialize ranking

[salmad3]

Context:

A simple ranking system is essential for the initial version of r/boards. This system will apply to posts (threads and comments) within boards to allow users to vote on content to determine its visibility and importance. The ranking mechanism should integrate with the existing Permissions interface and focus on core functionality for the MVP.

Acceptance Criteria:

• [ ] The boards realm homepage includes a README controlled by the AdminDAO (without automatic listing of new or top) boards.

  Like other implementations, administration can use an interim solution (e.g., manual). The listing is also manual to start.

• [ ] Includes a Vote struct to represent user votes:

  Example

  ```go type Vote struct { UserID Address Direction int // 1 for upvote, -1 for downvote Timestamp time.Time TokensDonated uint64 // Only for public boards } ```

• [ ] A Votes field in the Post struct stores vote information:

  Example

  ```go type Post struct { // ... existing fields Votes []Vote }

• [ ] Leverages a simple CalculateScore function:

  • For private boards: Total upvotes minus downvotes
  • For public boards: Total tokens donated for upvotes minus total tokens donated for downvotes

• [ ] Provides a VoteOn method for Post that:

  • Checks if the user has permission to vote using bp.HasPermission()
  • Adds or updates the user's vote
  • Recalculates the score
    
    Example

  func (p *Post) VoteOn(bp *BoardsRealm, user User, direction int, tokensDonated uint64) error {
      if !bp.HasPermission(user, "vote", []interface{}{p.ID}) {
          return errors.New("user does not have permission to vote on this post")
      }
  
      var vote *Vote
      for i, v := range p.Votes {
          if v.UserID == user.Address {
              vote = &p.Votes[i]
              break
          }
      }
      if vote == nil {
          vote = &Vote{
              UserID:    user.Address,
              Timestamp: time.Now(),
          }
          p.Votes = append(p.Votes, *vote)
      }
  
      vote.Direction = direction
      vote.TokensDonated += tokensDonated
  
      p.recalculateScore()
  
      return nil
  }
  
  func (p *Post) recalculateScore() {
      var score int64
      for _, vote := range p.Votes {
          if vote.Direction > 0 {
              score += int64(vote.TokensDonated)
          } else {
              score -= int64(vote.TokensDonated)
          }
      }
      p.Score = score
  }

• [ ] Implements different voting mechanisms for private and public boards:

  • Private boards: Each member can vote only once per post
  • Public boards: Users can vote multiple times by donating GNOT (minimum 0.01 GNOT)

• [ ] For public boards, a mechanism is available to lock donated tokens in the board's treasury

• [ ] Includes a GetTopPosts function that returns a sorted list of posts based on calculated scores

• [ ] Unit tests to verify the basic ranking system's behavior

• [ ] Implements a simple API endpoint to retrieve top posts for a given board

Notes:

• Hacker News is a good reference for this.
• Time decay factor for post scores is not included in this initial implementation to reduce complexity
• Advanced features like complex scoring mechanisms, custom ranking (such as via moderation groups or other methods) or a ranking algorithm are postponed for future versions
• Search functionality will be implemented off-chain for the MVP

[jefft0]

Hello @salmad3 . You mention Hacker News as a reference. There is usually a consensus view on what is accurate technical discussion. But for a general message board, I don't think there should be a "one size fits all" single ranking system. It would be better to have separate moderation groups with their own perspective, and a user can choose which moderation group to subscribe to.

[salmad3]

Thanks @jefft0. That’s a good point. This idea was also brought up at some point, but we were thinking to start with a simpler method.