Move tags in another table

2 files changed, 158 insertions, 36 deletions

diff --git a/server/controllers/api/remote.js b/server/controllers/api/remote.js
index a6753a2b0..c7a5658e8 100644
--- a/server/controllers/api/remote.js
+++ b/server/controllers/api/remote.js
@@ -50,28 +50,35 @@ function remoteVideos (req, res, next) {
   return res.type('json').status(204).end()
 }
 
-function addRemoteVideo (videoToCreateData, fromHost, callback) {
+function addRemoteVideo (videoToCreateData, fromHost, finalCallback) {
   logger.debug('Adding remote video "%s".', videoToCreateData.name)
 
   waterfall([
 
-    function findOrCreatePod (callback) {
+    function startTransaction (callback) {
+      db.sequelize.transaction().asCallback(function (err, t) {
+        return callback(err, t)
+      })
+    },
+
+    function findOrCreatePod (t, callback) {
       const query = {
         where: {
           host: fromHost
         },
         defaults: {
           host: fromHost
-        }
+        },
+        transaction: t
       }
 
       db.Pod.findOrCreate(query).asCallback(function (err, result) {
         // [ instance, wasCreated ]
-        return callback(err, result[0])
+        return callback(err, t, result[0])
       })
     },
 
-    function findOrCreateAuthor (pod, callback) {
+    function findOrCreateAuthor (t, pod, callback) {
       const username = videoToCreateData.author
 
       const query = {
@@ -82,16 +89,45 @@ function addRemoteVideo (videoToCreateData, fromHost, callback) {
         defaults: {
           name: username,
           podId: pod.id
-        }
+        },
+        transaction: t
       }
 
       db.Author.findOrCreate(query).asCallback(function (err, result) {
         // [ instance, wasCreated ]
-        return callback(err, result[0])
+        return callback(err, t, result[0])
       })
     },
 
-    function createVideoObject (author, callback) {
+    function findOrCreateTags (t, author, callback) {
+      const tags = videoToCreateData.tags
+      const tagInstances = []
+
+      each(tags, function (tag, callbackEach) {
+        const query = {
+          where: {
+            name: tag
+          },
+          defaults: {
+            name: tag
+          },
+          transaction: t
+        }
+
+        db.Tag.findOrCreate(query).asCallback(function (err, res) {
+          if (err) return callbackEach(err)
+
+          // res = [ tag, isCreated ]
+          const tag = res[0]
+          tagInstances.push(tag)
+          return callbackEach()
+        })
+      }, function (err) {
+        return callback(err, t, author, tagInstances)
+      })
+    },
+
+    function createVideoObject (t, author, tagInstances, callback) {
       const videoData = {
         name: videoToCreateData.name,
         remoteId: videoToCreateData.remoteId,
@@ -99,31 +135,58 @@ function addRemoteVideo (videoToCreateData, fromHost, callback) {
         infoHash: videoToCreateData.infoHash,
         description: videoToCreateData.description,
         authorId: author.id,
-        duration: videoToCreateData.duration,
-        tags: videoToCreateData.tags
+        duration: videoToCreateData.duration
       }
 
       const video = db.Video.build(videoData)
 
-      return callback(null, video)
+      return callback(null, t, tagInstances, video)
     },
 
-    function generateThumbnail (video, callback) {
+    function generateThumbnail (t, tagInstances, video, callback) {
       db.Video.generateThumbnailFromBase64(video, videoToCreateData.thumbnailBase64, function (err) {
         if (err) {
           logger.error('Cannot generate thumbnail from base 64 data.', { error: err })
           return callback(err)
         }
 
-        video.save().asCallback(callback)
+        return callback(err, t, tagInstances, video)
       })
     },
 
-    function insertIntoDB (video, callback) {
-      video.save().asCallback(callback)
+    function insertVideoIntoDB (t, tagInstances, video, callback) {
+      const options = {
+        transaction: t
+      }
+
+      video.save(options).asCallback(function (err, videoCreated) {
+        return callback(err, t, tagInstances, videoCreated)
+      })
+    },
+
+    function associateTagsToVideo (t, tagInstances, video, callback) {
+      const options = { transaction: t }
+
+      video.setTags(tagInstances, options).asCallback(function (err) {
+        return callback(err, t)
+      })
     }
 
-  ], callback)
+  ], function (err, t) {
+    if (err) {
+      logger.error('Cannot insert the remote video.')
+
+      // Abort transaction?
+      if (t) t.rollback()
+
+      return finalCallback(err)
+    }
+
+    // Commit transaction
+    t.commit()
+
+    return finalCallback()
+  })
 }
 
 function removeRemoteVideo (videoToRemoveData, fromHost, callback) {
diff --git a/server/controllers/api/videos.js b/server/controllers/api/videos.js
index a61f2b2c9..992f03db0 100644
--- a/server/controllers/api/videos.js
+++ b/server/controllers/api/videos.js
@@ -1,5 +1,6 @@
 'use strict'
 
+const each = require('async/each')
 const express = require('express')
 const fs = require('fs')
 const multer = require('multer')
@@ -87,7 +88,13 @@ function addVideo (req, res, next) {
 
   waterfall([
 
-    function findOrCreateAuthor (callback) {
+    function startTransaction (callback) {
+      db.sequelize.transaction().asCallback(function (err, t) {
+        return callback(err, t)
+      })
+    },
+
+    function findOrCreateAuthor (t, callback) {
       const username = res.locals.oauth.token.user.username
 
       const query = {
@@ -98,75 +105,125 @@ function addVideo (req, res, next) {
         defaults: {
           name: username,
           podId: null // null because it is OUR pod
-        }
+        },
+        transaction: t
       }
 
       db.Author.findOrCreate(query).asCallback(function (err, result) {
         // [ instance, wasCreated ]
-        return callback(err, result[0])
+        return callback(err, t, result[0])
+      })
+    },
+
+    function findOrCreateTags (t, author, callback) {
+      const tags = videoInfos.tags
+      const tagInstances = []
+
+      each(tags, function (tag, callbackEach) {
+        const query = {
+          where: {
+            name: tag
+          },
+          defaults: {
+            name: tag
+          },
+          transaction: t
+        }
+
+        db.Tag.findOrCreate(query).asCallback(function (err, res) {
+          if (err) return callbackEach(err)
+
+          // res = [ tag, isCreated ]
+          const tag = res[0]
+          tagInstances.push(tag)
+          return callbackEach()
+        })
+      }, function (err) {
+        return callback(err, t, author, tagInstances)
       })
     },
 
-    function createVideoObject (author, callback) {
+    function createVideoObject (t, author, tagInstances, callback) {
       const videoData = {
         name: videoInfos.name,
         remoteId: null,
         extname: path.extname(videoFile.filename),
         description: videoInfos.description,
         duration: videoFile.duration,
-        tags: videoInfos.tags,
         authorId: author.id
       }
 
       const video = db.Video.build(videoData)
 
-      return callback(null, author, video)
+      return callback(null, t, author, tagInstances, video)
     },
 
      // Set the videoname the same as the id
-    function renameVideoFile (author, video, callback) {
+    function renameVideoFile (t, author, tagInstances, video, callback) {
       const videoDir = constants.CONFIG.STORAGE.VIDEOS_DIR
       const source = path.join(videoDir, videoFile.filename)
       const destination = path.join(videoDir, video.getVideoFilename())
 
       fs.rename(source, destination, function (err) {
-        return callback(err, author, video)
+        return callback(err, t, author, tagInstances, video)
       })
     },
 
-    function insertIntoDB (author, video, callback) {
-      video.save().asCallback(function (err, videoCreated) {
+    function insertVideoIntoDB (t, author, tagInstances, video, callback) {
+      const options = { transaction: t }
+
+      // Add tags association
+      video.save(options).asCallback(function (err, videoCreated) {
+        if (err) return callback(err)
+
         // Do not forget to add Author informations to the created video
         videoCreated.Author = author
 
-        return callback(err, videoCreated)
+        return callback(err, t, tagInstances, videoCreated)
       })
     },
 
-    function sendToFriends (video, callback) {
+    function associateTagsToVideo (t, tagInstances, video, callback) {
+      const options = { transaction: t }
+
+      video.setTags(tagInstances, options).asCallback(function (err) {
+        video.Tags = tagInstances
+
+        return callback(err, t, video)
+      })
+    },
+
+    function sendToFriends (t, video, callback) {
       video.toRemoteJSON(function (err, remoteVideo) {
         if (err) return callback(err)
 
         // Now we'll add the video's meta data to our friends
         friends.addVideoToFriends(remoteVideo)
 
-        return callback(null)
+        return callback(null, t)
       })
     }
 
-  ], function andFinally (err) {
+  ], function andFinally (err, t) {
     if (err) {
       logger.error('Cannot insert the video.')
+
+      // Abort transaction?
+      if (t) t.rollback()
+
       return next(err)
     }
 
+    // Commit transaction
+    t.commit()
+
     // TODO : include Location of the new video -> 201
     return res.type('json').status(204).end()
   })
 }
 
 function getVideo (req, res, next) {
-  db.Video.loadAndPopulateAuthorAndPod(req.params.id, function (err, video) {
+  db.Video.loadAndPopulateAuthorAndPodAndTags(req.params.id, function (err, video) {
     if (err) return next(err)
 
     if (!video) {
@@ -222,12 +279,14 @@ function removeVideo (req, res, next) {
 }
 
 function searchVideos (req, res, next) {
-  db.Video.searchAndPopulateAuthorAndPod(req.params.value, req.query.field, req.query.start, req.query.count, req.query.sort,
-  function (err, videosList, videosTotal) {
-    if (err) return next(err)
+  db.Video.searchAndPopulateAuthorAndPodAndTags(
+    req.params.value, req.query.field, req.query.start, req.query.count, req.query.sort,
+    function (err, videosList, videosTotal) {
+      if (err) return next(err)
 
-    res.json(getFormatedVideos(videosList, videosTotal))
-  })
+      res.json(getFormatedVideos(videosList, videosTotal))
+    }
+  )
 }
 
 // ---------------------------------------------------------------------------