Derby Auth

server.coffee

http = require("http")
path = require("path")
express = require("express")
gzippo = require("gzippo")
derby = require("derby")
app = require("../app")
everyauth = require("everyauth")
serverError = require("./serverError")
crypto = require 'crypto'
Mongostore = require("connect-mongo")(express)


ONE_YEAR = 1000 * 60 * 60 * 24 * 365
zero = 0
root = path.dirname(path.dirname(__dirname))
publicPath = path.join root, "public"


expressApp = express()
module.exports = server = http.createServer expressApp

everyauth.debug = yes
everyauth.facebook
  .appId("APPID")
  .appSecret("APP SECRET")
  .handleAuthCallbackError((req, res) ->
    console.log req
  )
  .findOrCreateUser((session, accessToken, accessTokExtra, fbUserMetadata) ->
    promise = @.Promise().fulfill fbUserMetadata
  )
  .redirectPath("/")

everyauth.everymodule.findUserById (req, userId, callback)->
  if req.session.auth and req.session.auth.facebook 
    user = req.session.auth.facebook.user
  callback null, user

derby.use("racer-db-mongo")
.use(derby.logPlugin)

store = derby.createStore({
  listen: server, 
 
  db: {
       type: "Mongo"
       host: "localhost" 
       port: 27017
       database: "derby"
      }
    })

store.accessControl = yes

# Everyauth 
everyauthMiddleware = (req, res, next)->
  model = req.getModel()
  if req.user?
    fb = req.user
    session = model.session
    model.set "_fb", fb
    model.subscribe "users.#{fb.id}", (err, user)->
      if err 
        throw err
      user.setNull "email", fb.email
      user.setNull "communicationEmail", fb.email
      #user.setNull "emailhash", crypto.createHash('md5').update(fb.email or "").digest "hex"
      user.setNull "name", fb.name
      user.setNull "location", fb.location
      model.ref "_user", user
      session.userid = fb.id
      console.log model.session
      next()
  else
    console.log "Not logged in"
    next()



##### Express Route #####


expressApp
  .use(express.favicon())
  # Gzip static files and serve from memory
  .use(gzippo.staticGzip publicPath, maxAge: zero)
  # Gzip dynamically rendered content
  .use(express.compress())

  # Uncomment to add form data parsing support
  .use(express.bodyParser({keepExtension: yes, uploadDir: "./public/uploads"}))
  .use(express.methodOverride())

  # Uncomment and supply secret to add Derby session handling
  # Derby session middleware creates req.session and socket.io sessions
  .use(express.cookieParser())
  #.use(express.session({secret: "secret"}))
  .use(store.sessionMiddleware
     secret: process.env.SESSION_SECRET || 'YOUR SECRET HERE'
     cookie: {maxAge: ONE_YEAR}
     store: new Mongostore(url: "mongodb://@localhost:27017/session")
   )
  #.use(everyauthMiddleware)
  # Adds req.getModel method
  .use(store.modelMiddleware())
  # Middelware can be inserted after the modelMiddleware and before
  # the app router to pass server accessible data to a model
  # Creates an express middleware from the app's routes
  .use(everyauth.middleware())
  .use(everyauthMiddleware)
  .use(app.router())
  .use(expressApp.router)
  .use(serverError root)
  
model = store.createModel()


#Solr search express route
expressApp.get "/search", (req, res, next)->
  solr = require "solr-client"
  client = solr.createClient()
  model = store.createModel()
  query = client.createQuery().q(req.query.q)
  client.search query, (err, result)->
    model.set "_topProjects", result.response.docs if result?
    model.set "_user", req.user
    app.render res, model, "explore"

#404
expressApp.all "*", (req) ->
  throw "404: " + req.url



require("./queryMotifs")(store)
require "./solr_listener"