Agrupar por valores e condições

Para fazer qualquer tipo de "agrupamento" com consultas do MongoDB, você deseja usar a estrutura de agregação ou mapReduce. A estrutura de agregação é geralmente preferida, pois usa operadores codificados nativos em vez de tradução JavaScript e, portanto, normalmente é mais rápida.

As instruções de agregação só podem ser executadas no lado da API do servidor, o que faz sentido porque você não deseja fazer isso no cliente. Mas pode ser feito lá e disponibilizar os resultados para o cliente.

Com atribuição a esta resposta por fornecer os métodos para publicar os resultados:

Meteor.publish("cardLikesDislikes", function(args) {
    var sub = this;

    var db = MongoInternals.defaultRemoteCollectionDriver().mongo.db;

    var pipeline = [
        { "$group": {
            "_id": "$card_id",
            "likes": {
                "$sum": {
                    "$cond": [
                        { "$eq": [ "$vote", 1 ] },
                        1,
                        0
                    ]
                }
            },
            "dislikes": {
                "$sum": {
                    "$cond": [
                        { "$eq": [ "$vote", 2 ] },
                        1,
                        0
                    ]
                }
            },
            "total": {
                "$sum": {
                    "$cond": [
                        { "$eq": [ "$vote", 1 ] },
                        1,
                        -1
                    ]
                }
            }
        }},
        { "$sort": { "total": -1 } }
    ];

    db.collection("server_collection_name").aggregate(        
        pipeline,
        // Need to wrap the callback so it gets called in a Fiber.
        Meteor.bindEnvironment(
            function(err, result) {
                // Add each of the results to the subscription.
                _.each(result, function(e) {
                    // Generate a random disposable id for aggregated documents
                    sub.added("client_collection_name", Random.id(), {
                        card: e._id,                        
                        likes: e.likes,
                        dislikes: e.dislikes,
                        total: e.total
                    });
                });
                sub.ready();
            },
            function(error) {
                Meteor._debug( "Error doing aggregation: " + error);
            }
        )
    );

});

A declaração geral de agregação é apenas um $group operação na chave única de "card_id". Para obter os "curtidas" e "não curtidas", você usa uma "expressão condicional" que é $cond .

Este é um operador "ternário" que considera um teste lógico no valor de "voto", e onde ele corresponde ao tipo esperado e então um 1 positivo é retornado, caso contrário é 0 .

Esses valores são então enviados para o acumulador que é $sum para adicioná-los e produzir as contagens totais para cada "card_id" por "curtir" ou "não gostar".

Para o "total", a forma mais eficiente é atribuir um valor "positivo" para "curtir" e um valor negativo para "não gostar" ao mesmo tempo em que faz o agrupamento. Há um $add operador, mas neste caso seu uso exigiria outro estágio de pipeline. Então, nós apenas fazemos isso em um único estágio.

No final há um $sort em ordem "descendente" para que a maior contagem de votos positivos fique no topo. Isso é opcional e você pode querer usar a classificação dinâmica do lado do cliente. Mas é um bom começo para um padrão que remove a sobrecarga de ter que fazer isso.

Então isso é fazer uma agregação condicional e trabalhar com os resultados.

Lista de testes

Isso é o que eu testei com o projeto meteoro recém-criado, sem addins e apenas um único modelo e arquivo javascript

comandos do console

meteor create cardtest
cd cardtest
meteor remove autopublish

Criei a coleção "cartões" no banco de dados com os documentos postados na pergunta. E então editei os arquivos padrão com o conteúdo abaixo:

cardtest.js

Cards = new Meteor.Collection("cardStore");

if (Meteor.isClient) {

  Meteor.subscribe("cards");

  Template.body.helpers({
    cards: function() {
      return Cards.find({});
    }
  });

}

if (Meteor.isServer) {

  Meteor.publish("cards",function(args) {
    var sub = this;

    var db = MongoInternals.defaultRemoteCollectionDriver().mongo.db;

    var pipeline = [
      { "$group": {
        "_id": "$card_id",
        "likes": { "$sum": { "$cond": [{ "$eq": [ "$vote", 1 ] },1,0] } },
        "dislikes": { "$sum": { "$cond": [{ "$eq": [ "$vote", 2 ] },1,0] } },
        "total": { "$sum": { "$cond": [{ "$eq": [ "$vote", 1 ] },1,-1] } }
      }},
      { "$sort": { "total": -1, "_id": 1 } }

    ];

    db.collection("cards").aggregate(
      pipeline,
      Meteor.bindEnvironment(
        function(err,result) {
          _.each(result,function(e) {
            e.card_id = e._id;
            delete e._id;

            sub.added("cardStore",Random.id(), e);
          });
          sub.ready();
        },
        function(error) {
          Meteor._debug( "error running: " + error);
        }
      )
    );

  });
}

cardtest.html

<head>
  <title>cardtest</title>
</head>

<body>
  <h1>Card aggregation</h1>

  <table border="1">
    <tr>
      <th>Card_id</th>
      <th>Likes</th>
      <th>Dislikes</th>
      <th>Total</th>
    </tr>
    {{#each cards}}
      {{> card }}
    {{/each}}
  </table>

</body>

<template name="card">
  <tr>
    <td>{{card_id}}</td>
    <td>{{likes}}</td>
    <td>{{dislikes}}</td>
    <td>{{total}}</td>
  </tr>
</template>

Conteúdo da coleção agregada final:

[
   {
     "_id":"Z9cg2p2vQExmCRLoM",
     "likes":3,
     "dislikes":1,
     "total":2,
     "card_id":1
   },
   {
     "_id":"KQWCS8pHHYEbiwzBA",
      "likes":2,
      "dislikes":0,
      "total":2,
      "card_id":2
   },
   {
      "_id":"KbGnfh3Lqcmjow3WN",
      "likes":1,
      "dislikes":0,
      "total":1,
      "card_id":3
   }
]