Richtiger Weg, um eine Friend Route in node.js und mongoose hinzuzufügen?

Question

Ich plane, eine Route zu erstellen, wo ein Benutzer einen anderen Benutzer als seinen/ihren Freund hinzufügen kann, so dass sie miteinander chatten können, sobald sie Freunde sind.

Also im Grunde einmal Benutzer A eine Anfrage an Benutzer B gesendet hat, wird Benutzer B eine Live-Benachrichtigung über die Anforderung über socket.io

Das Problem ist im Moment bekommen, dass ich nicht mit meiner eigenen Lösung einfiel auf, wie das obige Szenario zu implementieren, von dem, was ich weiß, ich sollte zwei Routen GET und POST

für Datenbankabfrage, einfügen, aktualisieren Mungo erstellen und löschen

Hier ist mein Code ich verwende

// 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"}); 
    }); 
}); 

Benutzer Schema Code - Nicht wirklich sicher über diesen entweder

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); 

ich mit euch nicht ganz ehrlich bin, in der POST Route, ich habe keine freaking Idee auf, wie die Logik schreiben , weil ich gerade jetzt wirklich verwirrt bin, wie der Benutzer B die Live-Anfrage erhalten wird? Soll ich dafür eine andere Route erstellen?

Dies ist mein Problem, wenn es darum geht, ein wenig komplexe Anwendungen zu erstellen, ich konnte einfach nicht eine gute Logik auf, wie man eine bestimmte Funktion, obwohl es ziemlich einfach aussieht. Ich stecke seit fast 4 Stunden in diesem Problem fest, stöbere und lese das Netz, aber ich glaube, dass SO der einzige Ort ist, an dem ich einen Hinweis finde, wie ich etwas tun kann.

Vielen Dank.

Answer 1

Was Sie tun können, ist Socket für jeden facebookName (wenn einzigartig) zu erstellen.

Auf Client-Seite:

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

Server speichert jede Buchse mit facebookName:

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

Nun, wenn der Benutzer an den Benutzer in dieser Anfrage Chatanfrage sendet

// 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

Sie versuchen, einen zweistufigen Prozess zu bekommen, so dass Sie mindestens zwei Anrufe benötigen, wo einer eine Anfrage von th ist Der andere ist die Entscheidung, ob diese Anfrage vom Anfragenden zugelassen wird oder nicht. Sie können Ihren Rückruf für die erste Funktion mit einem booleschen Wert ausführen. Bei einer neuen Anforderung kann der Benutzer mit einem Popup auf dem Client aufgefordert werden.

Ein guter Zweck Mungo ist die Erweiterungen des Schemas, die Sie machen können, so ich hier um zwei Funktionen: eine aus dem Anforderer requestee Freundschaft anfordert, und die andere die Entscheidung des 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); 

So ein paar Dinge passiert:

• wurde nicht geprüft ist es nicht DRY
• es ohne zusätzliche begrenzt ist Freundschaftsschema

Mit einem Freundschaftsschema können Sie Abstoßungsniveaus definieren (z. "Nicht zu dieser Zeit", etc.), können Sie besser Details und granulare Kontrolle für das sich ändernde Verhalten von Freundschaften ausspülen. In dem oben genannten können Sie sehen, dass es, sobald Sie abgelehnt werden, ziemlich fatalistisch ist, dass es zu keiner Zeit bestimmt ist, dass Sie Freunde werden sollten! Um mehr von dieser Art von Verhalten zu bekommen, würde ich definitiv mit einem Freundschaftsschema gehen, dessen Statik und Methoden ausgelöscht werden.