refactor(realtime): updateNote

Signed-off-by: BoHong Li <[email protected]>

Author: a60814billy

lib/realtime.js

@@ -111,65 +111,96 @@ function disconnectSocketOnNote (note) {
 }
 
 function updateNote (note, callback) {
-  models.Note.findOne({
+  _updateNoteAsync(note).then(_note => {
+    callback(null, _note)
+  }).catch((err) => {
+    logger.error(err)
+    return callback(err, null)
+  })
+}
+
+function findNoteByIdAsync (id) {
+  return models.Note.findOne({
     where: {
-      id: note.id
+      id: id
     }
-  }).then(function (_note) {
-    if (!_note) return callback(null, null)
-    // update user note history
-    var tempUsers = Object.assign({}, note.tempUsers)
-    note.tempUsers = {}
-    Object.keys(tempUsers).forEach(function (key) {
-      updateHistory(key, note, tempUsers[key])
-    })
-    if (note.lastchangeuser) {
-      if (_note.lastchangeuserId !== note.lastchangeuser) {
-        models.User.findOne({
-          where: {
-            id: note.lastchangeuser
-          }
-        }).then(function (user) {
-          if (!user) return callback(null, null)
-          note.lastchangeuserprofile = models.User.getProfile(user)
-          return finishUpdateNote(note, _note, callback)
-        }).catch(function (err) {
-          logger.error(err)
-          return callback(err, null)
-        })
-      } else {
-        return finishUpdateNote(note, _note, callback)
-      }
-    } else {
-      note.lastchangeuserprofile = null
-      return finishUpdateNote(note, _note, callback)
+  })
+}
+
+function updateHistoryForEveryUserCollaborateNote (note) {
+  // update history to every user in this note
+  const tempUsers = Object.assign({}, note.tempUsers)
+  note.tempUsers = {}
+  // update history should async function, but in there return values is not matter
+  Object.keys(tempUsers).forEach(function (key) {
+    exports.updateHistory(key, note, tempUsers[key])
+  })
+}
+
+async function getUserProfileByIdAsync (id) {
+  const user = await models.User.findOne({
+    where: {
+      id: id
     }
-  }).catch(function (err) {
-    logger.error(err)
-    return callback(err, null)
   })
+  if (!user) return null
+  return models.User.getProfile(user)
+}
+
+class UserNotFoundException extends Error {
+  constructor () {
+    super('user not found')
+    this.name = this.constructor.name
+    Error.captureStackTrace(this, this.constructor)
+  }
 }
 
-function finishUpdateNote (note, _note, callback) {
-  if (!note || !note.server) return callback(null, null)
-  var body = note.server.document
-  var title = note.title = models.Note.parseNoteTitle(body)
-  var values = {
+async function getLastChangeUserProfileAsync (currentLastChangeUserId, lastChangeUserIdInDatabase, lastChangeUserProfileInDatabase) {
+  if (!currentLastChangeUserId) return null
+  if (currentLastChangeUserId === lastChangeUserIdInDatabase) return lastChangeUserProfileInDatabase
+  const profile = await getUserProfileByIdAsync(currentLastChangeUserId)
+  if (!profile) {
+    throw new UserNotFoundException()
+  }
+  return profile
+}
+
+function buildNoteUpdateData (note) {
+  const body = note.server.document
+  const title = note.title = models.Note.parseNoteTitle(body)
+  return {
     title: title,
     content: body,
     authorship: note.authorship,
     lastchangeuserId: note.lastchangeuser,
     lastchangeAt: Date.now()
   }
-  _note.update(values).then(function (_note) {
-    saveRevisionJob.setSaverSleep(false)
-    return callback(null, _note)
-  }).catch(function (err) {
-    logger.error(err)
-    return callback(err, null)
-  })
 }
 
+async function _updateNoteAsync (note) {
+  let noteModel = await findNoteByIdAsync(note.id)
+  if (!noteModel) return null
+
+  updateHistoryForEveryUserCollaborateNote(note)
+
+  try {
+    note.lastchangeuserprofile = await getLastChangeUserProfileAsync(
+      note.lastchangeuser,
+      noteModel.lastchangeuserId,
+      noteModel.lastchangeuserprofile
+    )
+  } catch (err) {
+    if (err instanceof UserNotFoundException) {
+      return null
+    }
+    throw err
+  }
+
+  if (!note || !note.server) return null
+  noteModel = await noteModel.update(buildNoteUpdateData(note))
+  saveRevisionJob.setSaverSleep(false)
+  return noteModel
+}
 
 function getStatus (callback) {
   models.Note.count().then(function (notecount) {
@@ -776,7 +807,6 @@ exports = module.exports = realtime
 exports.extractNoteIdFromSocket = extractNoteIdFromSocket
 exports.parseNoteIdFromSocket = parseNoteIdFromSocket
 exports.updateNote = updateNote
-exports.finishUpdateNote = finishUpdateNote
 exports.failConnection = failConnection
 exports.isDuplicatedInSocketQueue = isDuplicatedInSocketQueue
 exports.updateUserData = updateUserData
@@ -794,6 +824,7 @@ exports.disconnectSocketOnNote = disconnectSocketOnNote
 exports.queueForDisconnect = queueForDisconnect
 exports.terminate = terminate
 exports.getUserPool = getUserPool
+exports.updateHistory = updateHistory
 exports.disconnectProcessQueue = disconnectProcessQueue
 exports.notes = notes
 exports.users = users

test/realtime/realtime.test.js

@@ -37,76 +37,6 @@ function removeModuleFromRequireCache (modulePath) {
 }
 
 describe('realtime', function () {
-  describe('updateNote', function () {
-    let realtime, fakeNote
-    beforeEach(() => {
-      mock('../../lib/logger', {
-        error: () => {
-        }
-      })
-      mock('../../lib/history', {})
-      mock('../../lib/models', {
-        Note: {
-          findOne: async function () {
-            return fakeNote
-          }
-        }
-      })
-      mock('../../lib/config', {})
-    })
-
-    afterEach(() => {
-      mock.stopAll()
-    })
-
-    it('should return null when note not found', function (done) {
-      fakeNote = null
-      realtime = require('../../lib/realtime')
-
-      sinon.stub(realtime, 'finishUpdateNote').callsFake(function (a, b, callback) {
-        callback(null, b)
-      })
-
-      const fakeCallback = sinon.fake()
-      realtime.updateNote({ id: '123' }, fakeCallback)
-      setTimeout(() => {
-        assert.ok(fakeCallback.called)
-        assert.deepStrictEqual(fakeCallback.getCall(0).args, [null, null])
-        sinon.restore()
-        done()
-      }, 50)
-    })
-  })
-
-  describe('finishUpdateNote', function () {
-    let realtime
-    beforeEach(() => {
-      mock('../../lib/logger', {})
-      mock('../../lib/history', {})
-      mock('../../lib/models', {
-        Note: {
-          parseNoteTitle: (data) => (data)
-        }
-      })
-      mock('../../lib/config', {})
-      realtime = require('../../lib/realtime')
-    })
-
-    afterEach(() => {
-      removeModuleFromRequireCache('../../lib/realtime')
-      mock.stopAll()
-    })
-
-    it('return null when note is null', () => {
-      const fakeCallback = sinon.fake()
-
-      realtime.finishUpdateNote(null, {}, fakeCallback)
-
-      assert.ok(fakeCallback.calledOnce)
-      assert.deepStrictEqual(fakeCallback.lastCall.args, [null, null])
-    })
-  })
-
   describe('connection', function () {
     let realtime
     beforeEach(() => {