walma/whiteboard.coffee at master · opinsys/walma · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
fs = require "fs"
gm = require "gm"
express = require "express"
_  = require 'underscore'
_.mixin require 'underscore.string'
async = require "async"

app = express.createServer()
io = require('socket.io').listen app
io.set "log level", 0

{Drawing} = require "./lib/drawmodel"
{Client} = require "./lib/client"

generateUniqueName = require "./lib/namegenerator"
urlshortener = require "./lib/urlshortener"


conf = require "./configure"

conf.setUp app, io


# Simple in-process room manager. This needs work when we have to scale out one
# process
_rooms = {}
roomManager =
  get: (name, cb) ->
    room = _rooms[name]

    if not room
      room = _rooms[name] = new Drawing name
      room.on "empty", ->
        console.log "Empty room #{ room.toString() }. Removing reference."
        roomManager.delete name


    room.fetch (err, doc) ->
      return cb err if err
      cb null, room

  delete: (name) ->
    if room = _rooms[name]
      room.removeAllListeners()
      delete _rooms[name]


app.get "/", (req, res) ->
  projector = "false"
  if req.query["projector"]?
    projector = "true"

  res.render "index.jade",
    layout: false,
    locals: { projector: projector }

  # res.send '''
  # <h1>Whiteboard</h1>
  # <p>Room:</p>
  # <form action="/" method="post" accept-charset="utf-8">
  # <p><input type="text" name="roomName" /></p>
  # <p><input type="submit" value="Go"></p>
  # <p><input type="submit" name="generate" value="Generate new"></p>
  # </form>
  # '''

app.post "/", (req, res) ->

  if req.body.generate
    generateUniqueName "main"
      , (prefix, num) ->
        urlshortener.encode num
      , (err, roomName) ->
        throw err if err
        res.setHeader "Location", "/" + roomName
        res.send 302
  else
    res.setHeader "Location", "/" + req.body.roomName
    res.send 302

app.get "/delete", (req, res) ->
  Drawing.deleteExpiredRooms (err, count) ->
    if err
      console.log "Failed to delete", err
      res.send "Failed to delete", 500
    else
      res.send "deleted #{ count }", 200


app.get "/bootstrap", (req, res) ->
  res.render "bootstrap.jade"

withRoom = (fn) -> (req, res) ->
  roomManager.get req.params.room, (err, room) ->
    if err
      console.log "failed to open room #{ req.params.room }"
      req.send "Error opening room", 500
    else
      fn.call this, req, res, room


app.get "/:room/bg", withRoom (req, res, room) ->
  res.contentType "image/png"
  room.getImage "background", (err, data) ->
    if err
      console.log "Could not find backgrond for #{ room.name }", err
      res.send "not found", 404
    else
      res.send data

app.get "/:room/published.png", withRoom (req, res, room) ->
  res.contentType "image/png"
  room.getImage "publishedImage", (err, data) ->
    if err
      console.log "Could not find published image for #{ room.name }", err
      res.send "not found", 404
    else
      res.send data


app.get "/multipart", (req, res) ->
  res.send """
    <!doctype html>
    <head>
      <meta http-equiv="content-type" content="text/html; charset=utf-8" />

      <title>POST</title>
    </head>
    <body>
      <form action="/api/create_multipart" method="post" enctype="multipart/form-data" accept-charset="utf-8">
       <input name=image type=file />
       <input type=submit value="Send image" />
      </form>
    </body>
  """

app.post "/api/create_multipart", (req, res) ->
  if req.body.cameraId
    cameraId = req.body.cameraId
  else
    if req.body.remotekey
      cameraId = req.body.remotekey
      console.log "Warning: client use old parameter name:", cameraId

  generateUniqueName "screenshot"
    , (prefix, num) ->
      "#{ prefix }-#{ num }"
    , (err, roomName) ->
      return res.send err.message if err
      room = new Drawing roomName
      room.fetch ->
        widths = []
        heights = []

        # Find clients minium resolutions
        if cameraId
          for client in desktopSockets.clients(cameraId)
            client.get "resolution", (err, resolution) ->
              if resolution
                widths.push resolution.width
                heights.push resolution.height

        minWidth = Math.min.apply null, widths
        minHeight = Math.min.apply null, heights

        gm(req.files.image.path)
        .resize(minWidth, minHeight)
        .autoOrient()
        .write req.files.image.path, ->

          fs.readFile req.files.image.path, (err, imageData) ->
            throw err if err
            room.saveImage "background", imageData, (err) ->

              fs.unlink req.files.image.path, (err) ->
                if err
                  console.info "Failed to remove", req.files.image, err

              return res.send err.message if err

              if cameraId
                console.log "Send open-browser message: ", cameraId
                desktopSockets.in(cameraId).emit("open-browser", { url: "/#{ roomName }" })
              res.json url: "/#{ roomName }"

app.post "/api/create", (req, res) ->
  generateUniqueName "screenshot"
    , (prefix, num) ->
      "#{ prefix }-#{ num }"
    , (err, roomName) ->
      throw err if err
      room = new Drawing roomName
      room.fetch ->
        room.saveImage "background", new Buffer(req.body.image, "base64"), (err) ->
          throw err if err
          res.json url: "/#{ roomName }"


# Epic dataURL parser. Returns base64 encoded PNG
parseDataURL = (dataURL) ->
  base64data = dataURL.split(",")[1]
  new Buffer(base64data, "base64")


imageToBuffer = (req, cb) ->

  if req.files.image
    fs.readFile req.files.image.path, (err, data) ->
      return cb err if err
      fs.unlink req.files.image.path, (err) ->
        return cb err if err
        cb null, data
  else
    base64data = parseDataURL req.body.image
    cb null, new Buffer(base64data, "base64")

app.post "/:room/image", withRoom (req, res, room) ->

  imageResponse = (err) ->
    if err
      console.log msg = "Failed to save image", err
      res.send msg, 500
    else
      console.log "image saved ok"
      res.send "ok"

  imageToBuffer req, (err, data) ->
    return imageResponse err if err

    if req.body.type is "background"
      room.saveImage "background", data, imageResponse
    else if req.body.type is "cache"
      room.setCache req.body.drawCount, data, imageResponse
    else
      imageResponse "Unknown image type #{ req.body.type }"


app.get "/:room", (req, res) ->
  res.render "paint.jade"


app.get "/:room/bitmap/:pos", (req, res) ->
  res.header('Content-Type', 'image/png')

  room = new Drawing req.params.room
  room.getCache req.params.pos, (err, data) ->
    if err
      res.send 404
    else
      res.send data


desktopSockets = io.of "/remote-start"
desktopSockets.on "connection", (socket) ->
  socket.on "join-desktop", (opts) ->
    if opts && opts.cameraId
      console.log "Joining: ", opts
      socket.join opts.cameraId
  socket.on "leave-desktop", (opts) ->
    if opts && opts.cameraId
      console.log "Leaving: ", opts
      socket.leave opts.cameraId
  socket.on 'set resolution', (resolution) ->
    socket.set 'resolution', resolution, ->


sockets = io.of "/drawer"
sockets.on "connection", (socket) ->


  socket.on "join", (opts) ->
    roomName = opts.room
    roomManager.get opts.room, (err, room) ->
      if err
        console.log "ERROR: could not open room #{ opts.room }", err
        return

      client = new Client
        socket: socket
        model: room
        userAgent: opts.userAgent
        id: opts.id

      console.log "added client to #{ room.toString() }"


      client.join()