Właściwy sposób dodania trasy znajomego w pliku node.js i mangusta?

Question

Mam zamiar utworzyć trasę, w której użytkownik może dodać innego użytkownika jako swojego znajomego, aby mogli rozmawiać ze sobą, gdy tylko będą przyjaciółmi.

Więc w zasadzie raz Użytkownik A wysłał prośbę do użytkownika B, Użytkownik B dostanie żywo powiadomienie o żądaniu przez socket.io

Problem teraz jest to, że nie mogłem wymyślić własnego rozwiązania na sposób realizacji powyższego scenariusza, z tego co wiem, należy utworzyć dwie trasy GET i POST

Używam mongoose dla zapytania do bazy danych, wstawiania, aktualizacji i usuwania

Oto mój kod

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

kod Schema użytkownik - Nie bardzo pewni tego jednego albo

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

Nie jestem do końca szczery z wami, w trasie POST, nie mam pojęcia, w jaki sposób niecodzienna napisać logikę , bo tak naprawdę teraz mylę się, w jaki sposób użytkownik B otrzyma powiadomienie na żywo? Czy powinienem stworzyć dla niego inną trasę?

To jest mój problem, jeśli chodzi o tworzenie nieco skomplikowanych aplikacji, po prostu nie mogłem wymyślić dobrej logiki, jak wykonać określoną funkcję, mimo że wygląda całkiem łatwo. Utknąłem w tym problemie przez prawie 4 godziny, przeglądając i czytając sieć, ale wierzę, że to jedyne miejsce, w którym mogę znaleźć wskazówkę, jak coś zrobić.

Dziękuję.

Answer 1

Co można zrobić, to utworzyć gniazdo dla każdego elementu facebookName (jeśli jest unikatowy).

po stronie klienta:

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

Serwer zapisuje każde gniazdo z facebookName:

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

Teraz, gdy użytkownik wysyła żądanie czat dla tego użytkownika w tym żądaniu

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

Ty "Próbujesz uzyskać dwuetapowy proces, więc będziesz potrzebował co najmniej dwóch połączeń, w których jeden jest żądaniem od e requester, a druga to decyzja, czy zezwolić na żądanie od requestee. Możesz obsłużyć wywołanie zwrotne dla pierwszej funkcji wykorzystującej wartość logiczną, w przypadku, gdy jest to nowe żądanie, które użytkownik może zostać poproszony o wyskakujące okienko na kliencie.

Dobrym celem Mangusta jest rozszerzenia do schematu, które można zrobić, więc tutaj Dodaję dwie funkcje: jeden od żądającego zainteresowanie przyjaźń REQUESTEE, a drugi decyzję 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); 

więc kilka rzeczy dzieje:

• nie został przetestowany
• to nie DRY
• jest ograniczona bez dodatkowego Schemat przyjaźni

Schemat przyjaźni umożliwia zdefiniowanie poziomów odrzucenia (np. "nie w tym czasie", itp.), możesz bardziej szczegółowo przepuścić szczegóły i szczegółową kontrolę nad zmieniającym się zachowaniem przyjaźni. Z powyższego widać, że po odrzuceniu jest to dość fatalistyczne, ponieważ jest ustalone, że nigdy nie zostaniecie przyjaciółmi! Aby uzyskać więcej tego typu zachowań, zdecydowanie skorzystam ze schematu przyjaźni z jego statystyką i metodami wypuszczonymi, tak jak powinni być użytkownicy.