gistfile1.txt

## isBlockedBy
###
 {
 username: 'this is the user we want to know is blocked',
 blocker: 'the user we want to know is blocked'
 token
}
###
userRouter.post '/isBlockedBy', jsonAuth, (req, res) ->
  userQuery = User.findOne({ username: req.body.blocker }).select("_id blocked").populate("blocked")
  userQuery.exec((err, foundUser) ->
    if err
      res.status(400).json({ wtf:'in the removeFromSet Request you effed up', message: err.message})
    else
      isUserBlocked = foundUser.blocked.some((blockedUser) ->
        blockedUser.username == req.body.username
      )
      res.status(200).json({ msg: isUserBlocked })
  )

## has Blocked
###
 {
 username: 'this is the blocker',
 blocked: 'the user we want to know is blocked or not'
 token
}
###
userRouter.post '/hasBlocked', jsonAuth, (req, res) ->
  userQuery = User.findOne({ username: req.body.username }).select("_id blocked").populate("blocked")
  userQuery.exec((err, foundUser) ->
    if err
      res.status(400).json({ wtf:'in the removeFromSet Request you effed up', message: err.message})
    else
      isUserBlocked = foundUser.blocked.some((blockedUser) ->
        blockedUser.username == req.body.blocked
      )
      res.status(200).json({ msg: isUserBlocked })
  )

## Remove From Set
###
{
 username,
 setToUpdate
 token
 idToRemove: The MongoID Of the user
}
###
userRouter.post '/removeFromSet', jsonAuth, (req, res) ->
  userQuery = User.findOne({ username: req.body.username }).select("_id #{req.body.setToUpdate}")
  userQuery.exec((err, foundUser) ->
    if err
      res.status(400).json({ wtf:'in the removeFromSet Request you effed up', message: err.message})
    else
      foundUser[req.body.setToUpdate].pull({ _id: req.body.idToRemove })
      foundUser.save().then((savedUser) ->
        res.status(200).json savedUser
      ).catch((e) ->
        res.status(400).json({ wtf:'in the removeFromSet Request you effed up', message: e.message})
      )
  )

## unfollow
###
{
 username,
 token
 idToRemove: The MongoID Of the user
}
###
userRouter.post '/unfollow', jsonAuth, (req, res) ->
  userQuery = User.findOne({ username: req.body.username }).select("_id follows")
  otherUserQuery = User.findOne({ _id: req.body.idToRemove }).select("_id followers")
  userQuery.exec((err, foundUser) ->
    if err
      res.status(400).json({ wtf:'in the unfollow Request you effed up', message: err.message})
    else
      otherUserQuery.exec((err, jiltedLover) ->
        if err
          res.status(400).json({ wtf:'in the unfollow Request you effed up', message: err.message})
        else
          foundUser.follows.pull({ _id: req.body.idToRemove })
          jiltedLover.followers.pull({ _id: foundUser._id })
          foundUser.save().then((savedUser) ->
            jiltedLover.save().then((savedLover) ->
              res.status(200).json savedUser
            ).catch((e) ->
              res.status(400).json({ wtf:'in the unfollow Request you effed up', message: e.message})
            )
          ).catch((e) ->
            res.status(400).json({ wtf:'in the unfollow Request you effed up', message: e.message})
          )
      )
  )

## Add To Set
###
{
 username,
 setToUpdate
 token
 idToAdd: The MongoID Of the user
}
###

userRouter.post '/addToSet', jsonAuth, (req, res) ->
  userQuery = User.findOne({ username: req.body.username }).select("_id #{req.body.setToUpdate}")
  userQuery.exec((err, foundUser) ->
    if err
      res.status(400).json({ wtf:'in the addToSet Request you effed up', message: err.message})
    else
      foundUser[req.body.setToUpdate].addToSet({ _id: req.body.idToAdd })
      foundUser.save().then((savedUser) ->
        res.status(200).json savedUser
      ).catch((e) ->
        res.status(400).json({ wtf:'in the addToSet Request you effed up', message: e.message})
      )
  )


## Block User
###
{
 username
 token
}
###

userRouter.post '/blockUser/:userToBlock', jsonAuth, (req, res) ->
  userQuery = User.findOne({ username: req.body.username }) # Find the user by req.body.username
  userToBlockQuery = User.findOne({ username: req.params.userToBlock }) # Find the Blocked User

  userQuery.exec((err, foundUser) ->
    if err
      res.status(400).json({ wtf:'in the blockedUser Request you effed up', message: err.message})
    else
      userToBlockQuery.exec((err, blockedUser) ->
        unless err
          foundUser.blocked.addToSet({ _id: blockedUser._id }) # add blocked user to main users blocked list
          blockedUser.blockedBy.addToSet({ _id: foundUser._id }) # add main user to blocked users blocked by list
          # followers
          foundUser.followers.pull({ _id: blockedUser._id })
          blockedUser.followers.pull({ _id: foundUser._id })
          # connections
          foundUser.connections.pull({ _id: blockedUser._id })
          blockedUser.connections.pull({ _id: foundUser._id })
          # pendingConnections
          foundUser.pendingConnections.pull({ _id: blockedUser._id })
          blockedUser.pendingConnections.pull({ _id: foundUser._id })
          # follows
          foundUser.follows.pull({ _id: blockedUser._id })
          blockedUser.follows.pull({ _id: foundUser._id })
          # requestedConnections
          foundUser.requestedConnections.pull({ _id: blockedUser._id })
          blockedUser.requestedConnections.pull({ _id: foundUser._id })
          # save users
          blockedUser.save().then((savedDoc) ->
            foundUser.save().then((savedUser) ->
              res.status(200).json savedUser
            ).catch((e) ->
              res.status(401).json({ wtf:'in the blockedUser Request you effed up', message: e.message})
            )
          ).catch((e) ->
            res.status(401).json({ wtf:'in the blockeUser Request you effed up', message: e.message})
          )
        else
          res.status(403).json({ wtf:'in the blockedUser Request you effed up', message: err.message})
      )

  )

## unBlock User
###
{
 username
 token
}
###

userRouter.post '/unblockUser/:userToUnBlock', jsonAuth, (req, res) ->
  userQuery = User.findOne({ username: req.body.username }) # Find the user by req.body.username
  userToUnBlockQuery = User.findOne({ username: req.params.userToUnBlock }) # Find the Blocked User

  userQuery.exec((err, foundUser) ->
    if err
      res.status(400).json({ wtf:'in the unBlockedUser Request you effed up', message: err.message})
    else
      userToUnBlockQuery.exec((err, unBlockedUser) ->
        unless err
          foundUser.blocked.pull({ _id: unBlockedUser._id }) # add blocked user to main users blocked list
          unBlockedUser.blockedBy.pull({ _id: foundUser._id }) # add main user to blocked users blocked by list
          # save users
          unBlockedUser.save().then((savedDoc) ->
            foundUser.save().then((savedUser) ->
              res.status(200).json savedUser
            ).catch((e) ->
              res.status(401).json({ wtf:'in the unBlockedUser Request you effed up', message: e.message})
            )
          ).catch((e) ->
            res.status(401).json({ wtf:'in the unBlockUser Request you effed up', message: e.message})
          )
        else
          res.status(403).json({ wtf:'in the unBlockedUser Request you effed up', message: err.message})
      )
  )