在node.js和mongoose中添加好友路由的正確方法？

Question

我打算創建一條路線，讓用戶可以將其他用戶添加爲他/她的朋友，以便他們可以在他們成爲朋友後互相聊天。

所以基本上，一旦用戶A已經發送到用戶B的請求，用戶B將獲得有關請求現場通知通過socket.io

現在的問題是，我不能拿出自己的解決方案關於如何實現上述場景，從我知道，我應該創建兩條路線GET和POST

我用貓鼬進行數據庫查詢，插入，更新和刪除

這裏是我的代碼

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

用戶模式代碼 - 不是真的知道這一個要麼

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

我不和你們完全誠實的，在POST路線，我對如何編寫邏輯沒有再用想法，因爲我現在很困惑，用戶B如何獲得實時請求通知？我應該爲此創建另一條路線嗎？

這是我的問題，當涉及到構建稍微複雜的應用程序時，我無法想出如何執行某個功能的好邏輯，即使它看起來很容易。我一直在這個問題上停留了近4個小時，瀏覽和閱讀網絡，但我相信SO是唯一能找到關於如何做某事的線索的地方。

謝謝。

Answer 1

你可以做的是爲每個facebookName（如果唯一的）創建套接字。

在客戶端：

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

服務器與facebookName每個插槽節省：

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

現在，當用戶在該請求發送聊天請求到該用戶

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

你'試圖分兩步進行處理，所以至少需要兩個來自第二個請求的呼叫請求者，另一個是決定是否允許請求者提出請求。您可以使用布爾值來處理第一個函數的回調，如果這是一個新的請求，用戶可以在客戶端彈出一個提示。

貓鼬的一個很好的目的是擴展的架構，你可以做，所以我在這裏增加了兩個功能：一個是從請求者請求被請求方的友誼，而另一個被請求的決定

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

所以，有兩件事情發生：

• 沒有經過測試
• 它不是幹
• 它是有限的而無需額外的友誼綱要

通過友誼綱要，您可以定義拒絕級別（例如， 「不在這個時間」等），您可以更好地清除細節並細化控制友情變化的行爲。在上面，你可以看到一旦你被拒絕，這是非常宿命的，因爲它決定了你永遠不會成爲朋友！所以爲了獲得更多這種類型的行爲，我肯定會使用友情模式，並將其靜態和方法刷新出去，應該是用戶。