Modo corretto per aggiungere un percorso amico in node.js e mangusta?

Question

Sto progettando di creare un percorso in cui un utente possa aggiungere un altro utente come suo amico, in modo che possano chattare tra loro una volta che sono amici.

Quindi, in pratica, una volta l'utente A ha inviato una richiesta all'utente B, l'utente B otterrà una notifica dal vivo circa la richiesta via socket.io

Il problema ora è che, non ho potuto venire con la mia soluzione su come implementare lo scenario di cui sopra, da quello che so, dovrei creare due percorsi GET e POST

sto usando mangusta per query di database, inserire, aggiornare e cancellare

Ecco il mio codice

012.

// GET route for getting the user's information -- Simple route 

router.get('/users/:facebook_name', function(req, res) { 
    User.findOne(facebook_name, function(err, user) { 
    if (!user) { 
     res.json({message: "Couldn't find a user by that name"}); 
     return; 
    } 
    res.json(user); 
    }); 
}); 

// POST route for adding a friend 
router.post('/friendships/create/:facebook_name', ensureAuthenticated, function(req, res) { 
    // What should i put in this route to make the adding a friend feature works? 
    User.findOneAndUpdate(facebook_name, function(err, user) { 
    if (user) { 
     res.json({message: "You already send a friend request to that person"}); 
     return; 
    } 
    // Send a live notification to the other user 
    socket.emit('sending request', {message: "added you as a friend"}); 
    }); 
}); 

codice schema utente - Non proprio sicuro di questo uno o

var mongoose = require('mongoose'); 
var Schema = mongoose.Schema; 

var UserSchema = new Schema({ 

    friends: [{ type: Schema.Types.ObjectId, ref: 'User'}], 
    facebook: { 
    id: String, 
    token: String, 
    // email: String, 
    displayName: String, 
    photo: String 
    } 
}); 

// Should I even create this schema? 
var FriendsRequest = new Schema({ 

    madeBy: [{ type: Schema.Types.ObjectId, ref: 'User'}], 


}) 

module.exports = mongoose.model('User', UserSchema); 
module.exports = mongoose.model('FriendsRequest', FriendsRequest); 

Io non sono del tutto onesto con voi, nel percorso POST, non ho idea di che eccita su come scrivere la logica , perché in questo momento sono davvero confuso, in che modo l'utente B riceverà la notifica della richiesta live? Dovrei creare un altro percorso per questo?

Questo è il mio problema quando si tratta di creare applicazioni leggermente complesse, non ho potuto trovare una buona logica su come eseguire una determinata funzione anche se sembra piuttosto semplice. Sono rimasto bloccato in questo problema per quasi 4 ore, navigando e leggendo la rete, ma credo che SO sia l'unico posto in cui trovo un indizio su come fare qualcosa.

Grazie.

Answer 1

Quello che puoi fare è creare un socket per ogni FacebookName (se univoco).

Sul lato client:

socket.on('connection', function (data) { 
    socket.emit('setFacebookName', facebookName); }); 
} 

server salva ogni presa con facebookName:

socket.on('setFacebookName', function (facebookName) { 
    users[facebookName]=socket; 
}); 

Ora, quando l'utente invia richiesta di chat a tale utente in questa richiesta

// POST route for adding a friend 
router.post('/friendships/create/:facebook_name', ensureAuthenticated, function(req, res) { 
    // What should i put in this route to make the adding a friend feature works? 
    User.findOneAndUpdate(facebook_name, function(err, user) { 
    if (user) { 
     res.json({message: "You already send a friend request to that person"}); 
     return; 
    } 
    // Send a live notification to the other user 
    sendLiveNotification(facebook_name); 
    }); 
}); 

function sendLiveNotification(facebookName){ 
    socket.on('send notification', function (facebookName) { 
    users[facebookName].emit('sending request', "has sent friend request"); 
    }); 
} 

Answer 2

È Stai cercando di ottenere un processo in due passaggi, quindi avrai bisogno di almeno due chiamate in cui una è una richiesta di th e requester, e l'altra è la decisione se consentire o meno tale richiesta al richiedente. È possibile gestire la richiamata per la prima funzione utilizzando un booleano dove, se si tratta di una nuova richiesta, all'utente potrebbe essere richiesto un popup sul client.

Un buon proposito di Mongoose sono le estensioni allo schema che si può fare, ecco sto aggiungendo due funzioni: uno dal richiedente che richiede l'amicizia di REQUESTEE, e l'altro la decisione del REQUESTEE

var mongoose = require('mongoose'); 
var Schema = mongoose.Schema; 

var UserSchema = new Schema({ 

    friendsAccepted: [{ type: Schema.Types.ObjectId, ref: 'User'}], 
    friendsRequested: [{ type: Schema.Types.ObjectId, ref: 'User'}], 
    friendsPending: [{ type: Schema.Types.ObjectId, ref: 'User'}], 
    friendsRejected: [{ type: Schema.Types.ObjectId, ref: 'User'}], 
    facebook: { 
    id: String, 
    token: String, 
    // email: String, 
    displayName: String, 
    photo: String 
    } 
}); 



UserSchema.statics.requesterInitiatedRequestForFriendship = function(requesterID, requesteeID, cb) { 
    mongoose.model('UserSchema').findOne({_id: requesterID}).exec(function(err, requester) { 
     if (err) return cb(err); 
     mongoose.model('UserSchema').findOne({_id: requesteeID}).exec(function(err, requestee) { 
      if (err) return cb(err); 
      if (requestee.friendsAccepted(requesterID) === -1 && 
       requestee.friendsRequested(requesterID) === -1 && 
       requestee.friendsPending(requesterID) === -1 && 
       requestee.friendsRejected(requesterID) === -1) { 
       requestee.friendsPending.push(requesterID); 
       requester.friendsRequested.push(requesterID); 
       requestee.save(); 
       requester.save(); 
       cb(null, true); 
      } else { 
       cb(null, false); 
      }; 
     }); 
    }); 
}; 

UserSchema.statics.requesteeDecidedOnFriendship = function(requesterID, requesteeID, allowed, cb) { 
    mongoose.model('UserSchema').findOne({_id: requesterID}).exec(function(err, requester) { 
     if (err) return cb(err); 
     mongoose.model('UserSchema').findOne({_id: requesteeID}).exec(function(err, requestee) { 
      if (err) return cb(err); 
      if ((requestee.friendsAccepted(requesterID) === -1 && 
       requestee.friendsRequested(requesterID) === -1 && 
       requestee.friendsPending(requesterID) > -1 && 
       requestee.friendsRejected(requesterID) === -1) && 
       requester.friendsRequested(requesteeID) > -1) { 
       requestee.friendsPending.forEach(function(uid, idx) { 
        if (uid === requesterID) { 
         requestee.friendsPending.splice(idx, 1); 
         return; 
        }; 
       }); 
       requester.friendsRequested.forEach(function(uid, idx) { 
        if (uid === requesteeID) { 
         requester.friendsRequested.splice(idx, 1); 
         return; 
        }; 
       }); 
       if (allowed) { 
        requestee.friendsAccepted.push(requesterID); 
        requester.friendsAccepted.push(requesteeID); 
       } else { 
        requestee.friendsRejected.push(requesterID); 
        requester.friendsRejected.push(requesteeID); 
       } 
       requestee.save(); 
       requester.save(); 
      }; 
      cb(null); 
     }); 
    }); 
} 


module.exports = mongoose.model('User', UserSchema); 

Quindi un paio di cose che accadono:

• non è stato testato
• non è SECCO
• è limitata senza un ulteriore Schema di amicizia

Con uno schema di amicizia, è possibile definire i livelli di rifiuto (ad es. "non in questo momento", ecc.), puoi chiarire meglio i dettagli e controllare in modo granulare il comportamento mutevole delle amicizie. In quanto sopra, puoi vedere che una volta che sei stato respinto, è piuttosto fatalistico in quanto è determinato in nessun momento che diventerai amico! Quindi, per ottenere più di quel tipo di comportamento, andrei sicuramente con uno schema di amicizia con la sua statica e i metodi svuotati, come dovrebbero essere gli utenti.