10 files changed, 82 insertions, 88 deletions

diff --git a/server/models/request/abstract-request-interface.ts b/server/models/request/abstract-request-interface.ts
new file mode 100644
index 000000000..a384f4d27
--- /dev/null
+++ b/server/models/request/abstract-request-interface.ts
@@ -0,0 +1,12 @@
+import * as Promise from 'bluebird'
+
+export interface AbstractRequestClass <T> {
+  countTotalRequests: () => Promise<number>
+  listWithLimitAndRandom: (limitPods: number, limitRequestsPerPod: number) => Promise<T>
+  removeWithEmptyTo: () => Promise<number>
+  removeAll: () => Promise<void>
+}
+
+export interface AbstractRequestToPodClass {
+  removeByRequestIdsAndPod: (ids: number[], podId: number) => Promise<number>
+}
diff --git a/server/models/request/index.ts b/server/models/request/index.ts
index 824c140f5..3dd6aedc2 100644
--- a/server/models/request/index.ts
+++ b/server/models/request/index.ts
@@ -1,3 +1,4 @@
+export * from './abstract-request-interface'
 export * from './request-interface'
 export * from './request-to-pod-interface'
 export * from './request-video-event-interface'
diff --git a/server/models/request/request-interface.ts b/server/models/request/request-interface.ts
index 483850633..7b0ee4df9 100644
--- a/server/models/request/request-interface.ts
+++ b/server/models/request/request-interface.ts
@@ -1,5 +1,7 @@
 import * as Sequelize from 'sequelize'
+import * as Promise from 'bluebird'
 
+import { AbstractRequestClass } from './abstract-request-interface'
 import { PodInstance, PodAttributes } from '../pod'
 import { RequestEndpoint } from '../../../shared/models/request-scheduler.model'
 
@@ -11,20 +13,16 @@ export type RequestsGrouped = {
 }
 
 export namespace RequestMethods {
-  export type CountTotalRequestsCallback = (err: Error, total: number) => void
-  export type CountTotalRequests = (callback: CountTotalRequestsCallback) => void
+  export type CountTotalRequests = () => Promise<number>
 
-  export type ListWithLimitAndRandomCallback = (err: Error, requestsGrouped?: RequestsGrouped) => void
-  export type ListWithLimitAndRandom = (limitPods, limitRequestsPerPod, callback: ListWithLimitAndRandomCallback) => void
+  export type ListWithLimitAndRandom = (limitPods: number, limitRequestsPerPod: number) => Promise<RequestsGrouped>
 
-  export type RemoveWithEmptyToCallback = (err: Error) => void
-  export type RemoveWithEmptyTo = (callback: RemoveWithEmptyToCallback) => void
+  export type RemoveWithEmptyTo = () => Promise<number>
 
-  export type RemoveAllCallback = (err: Error) => void
-  export type RemoveAll = (callback: RemoveAllCallback) => void
+  export type RemoveAll = () => Promise<void>
 }
 
-export interface RequestClass {
+export interface RequestClass extends AbstractRequestClass<RequestsGrouped> {
   countTotalRequests: RequestMethods.CountTotalRequests
   listWithLimitAndRandom: RequestMethods.ListWithLimitAndRandom
   removeWithEmptyTo: RequestMethods.RemoveWithEmptyTo
diff --git a/server/models/request/request-to-pod-interface.ts b/server/models/request/request-to-pod-interface.ts
index 6d75ca6e5..7ca99f4d4 100644
--- a/server/models/request/request-to-pod-interface.ts
+++ b/server/models/request/request-to-pod-interface.ts
@@ -1,11 +1,13 @@
 import * as Sequelize from 'sequelize'
+import * as Promise from 'bluebird'
+
+import { AbstractRequestToPodClass } from './abstract-request-interface'
 
 export namespace RequestToPodMethods {
-  export type RemoveByRequestIdsAndPodCallback = (err: Error) => void
-  export type RemoveByRequestIdsAndPod = (requestsIds: number[], podId: number, callback?: RemoveByRequestIdsAndPodCallback) => void
+  export type RemoveByRequestIdsAndPod = (requestsIds: number[], podId: number) => Promise<number>
 }
 
-export interface RequestToPodClass {
+export interface RequestToPodClass extends AbstractRequestToPodClass {
   removeByRequestIdsAndPod: RequestToPodMethods.RemoveByRequestIdsAndPod
 }
 
diff --git a/server/models/request/request-to-pod.ts b/server/models/request/request-to-pod.ts
index 67331be1d..6678ed290 100644
--- a/server/models/request/request-to-pod.ts
+++ b/server/models/request/request-to-pod.ts
@@ -2,7 +2,6 @@ import * as Sequelize from 'sequelize'
 
 import { addMethodsToModel } from '../utils'
 import {
-  RequestToPodClass,
   RequestToPodInstance,
   RequestToPodAttributes,
 
@@ -38,9 +37,7 @@ export default function (sequelize: Sequelize.Sequelize, DataTypes: Sequelize.Da
 
 // ---------------------------------------------------------------------------
 
-removeByRequestIdsAndPod = function (requestsIds: number[], podId: number, callback?: RequestToPodMethods.RemoveByRequestIdsAndPodCallback) {
-  if (!callback) callback = function () { /* empty */ }
-
+removeByRequestIdsAndPod = function (requestsIds: number[], podId: number) {
   const query = {
     where: {
       requestId: {
@@ -50,5 +47,5 @@ removeByRequestIdsAndPod = function (requestsIds: number[], podId: number, callb
     }
   }
 
-  RequestToPod.destroy(query).asCallback(callback)
+  return RequestToPod.destroy(query)
 }
diff --git a/server/models/request/request-video-event-interface.ts b/server/models/request/request-video-event-interface.ts
index 3ed03339a..a5032e1b1 100644
--- a/server/models/request/request-video-event-interface.ts
+++ b/server/models/request/request-video-event-interface.ts
@@ -1,5 +1,7 @@
 import * as Sequelize from 'sequelize'
+import * as Promise from 'bluebird'
 
+import { AbstractRequestClass, AbstractRequestToPodClass } from './abstract-request-interface'
 import { VideoInstance } from '../video'
 import { PodInstance } from '../pod'
 
@@ -16,20 +18,16 @@ export type RequestsVideoEventGrouped = {
 }
 
 export namespace RequestVideoEventMethods {
-  export type CountTotalRequestsCallback = (err: Error, total: number) => void
-  export type CountTotalRequests = (callback: CountTotalRequestsCallback) => void
+  export type CountTotalRequests = () => Promise<number>
 
-  export type ListWithLimitAndRandomCallback = (err: Error, requestsGrouped?: RequestsVideoEventGrouped) => void
-  export type ListWithLimitAndRandom = (limitPods: number, limitRequestsPerPod: number, callback: ListWithLimitAndRandomCallback) => void
+  export type ListWithLimitAndRandom = (limitPods: number, limitRequestsPerPod: number) => Promise<RequestsVideoEventGrouped>
 
-  export type RemoveByRequestIdsAndPodCallback = () => void
-  export type RemoveByRequestIdsAndPod = (ids: number[], podId: number, callback: RemoveByRequestIdsAndPodCallback) => void
+  export type RemoveByRequestIdsAndPod = (ids: number[], podId: number) => Promise<number>
 
-  export type RemoveAllCallback = () => void
-  export type RemoveAll = (callback: RemoveAllCallback) => void
+  export type RemoveAll = () => Promise<void>
 }
 
-export interface RequestVideoEventClass {
+export interface RequestVideoEventClass extends AbstractRequestClass<RequestsVideoEventGrouped>, AbstractRequestToPodClass {
   countTotalRequests: RequestVideoEventMethods.CountTotalRequests
   listWithLimitAndRandom: RequestVideoEventMethods.ListWithLimitAndRandom
   removeByRequestIdsAndPod: RequestVideoEventMethods.RemoveByRequestIdsAndPod
@@ -41,10 +39,12 @@ export interface RequestVideoEventAttributes {
   count: number
 }
 
-export interface RequestVideoEventInstance extends RequestVideoEventClass, RequestVideoEventAttributes, Sequelize.Instance<RequestVideoEventAttributes> {
+export interface RequestVideoEventInstance
+  extends RequestVideoEventClass, RequestVideoEventAttributes, Sequelize.Instance<RequestVideoEventAttributes> {
   id: number
 
   Video: VideoInstance
 }
 
-export interface RequestVideoEventModel extends RequestVideoEventClass, Sequelize.Model<RequestVideoEventInstance, RequestVideoEventAttributes> {}
+export interface RequestVideoEventModel
+  extends RequestVideoEventClass, Sequelize.Model<RequestVideoEventInstance, RequestVideoEventAttributes> {}
diff --git a/server/models/request/request-video-event.ts b/server/models/request/request-video-event.ts
index f552ef50b..90ea15702 100644
--- a/server/models/request/request-video-event.ts
+++ b/server/models/request/request-video-event.ts
@@ -10,7 +10,6 @@ import { REQUEST_VIDEO_EVENT_TYPES } from '../../initializers'
 import { isVideoEventCountValid } from '../../helpers'
 import { addMethodsToModel } from '../utils'
 import {
-  RequestVideoEventClass,
   RequestVideoEventInstance,
   RequestVideoEventAttributes,
 
@@ -77,23 +76,21 @@ function associate (models) {
   })
 }
 
-countTotalRequests = function (callback: RequestVideoEventMethods.CountTotalRequestsCallback) {
+countTotalRequests = function () {
   const query = {}
-  return RequestVideoEvent.count(query).asCallback(callback)
+  return RequestVideoEvent.count(query)
 }
 
-listWithLimitAndRandom = function (limitPods: number, limitRequestsPerPod: number, callback: RequestVideoEventMethods.ListWithLimitAndRandomCallback) {
+listWithLimitAndRandom = function (limitPods: number, limitRequestsPerPod: number) {
   const Pod = db.Pod
 
   // We make a join between videos and authors to find the podId of our video event requests
   const podJoins = 'INNER JOIN "Videos" ON "Videos"."authorId" = "Authors"."id" ' +
                    'INNER JOIN "RequestVideoEvents" ON "RequestVideoEvents"."videoId" = "Videos"."id"'
 
-  Pod.listRandomPodIdsWithRequest(limitPods, 'Authors', podJoins, function (err, podIds) {
-    if (err) return callback(err)
-
+  return Pod.listRandomPodIdsWithRequest(limitPods, 'Authors', podJoins).then(podIds => {
     // We don't have friends that have requests
-    if (podIds.length === 0) return callback(null, [])
+    if (podIds.length === 0) return []
 
     const query = {
       order: [
@@ -121,16 +118,14 @@ listWithLimitAndRandom = function (limitPods: number, limitRequestsPerPod: numbe
       ]
     }
 
-    RequestVideoEvent.findAll(query).asCallback(function (err, requests) {
-      if (err) return callback(err)
-
+    return RequestVideoEvent.findAll(query).then(requests => {
       const requestsGrouped = groupAndTruncateRequests(requests, limitRequestsPerPod)
-      return callback(err, requestsGrouped)
+      return requestsGrouped
     })
   })
 }
 
-removeByRequestIdsAndPod = function (ids: number[], podId: number, callback: RequestVideoEventMethods.RemoveByRequestIdsAndPodCallback) {
+removeByRequestIdsAndPod = function (ids: number[], podId: number) {
   const query = {
     where: {
       id: {
@@ -152,12 +147,12 @@ removeByRequestIdsAndPod = function (ids: number[], podId: number, callback: Req
     ]
   }
 
-  RequestVideoEvent.destroy(query).asCallback(callback)
+  return RequestVideoEvent.destroy(query)
 }
 
-removeAll = function (callback: RequestVideoEventMethods.RemoveAllCallback) {
+removeAll = function () {
   // Delete all requests
-  RequestVideoEvent.truncate({ cascade: true }).asCallback(callback)
+  return RequestVideoEvent.truncate({ cascade: true })
 }
 
 // ---------------------------------------------------------------------------
diff --git a/server/models/request/request-video-qadu-interface.ts b/server/models/request/request-video-qadu-interface.ts
index 805771cda..9a172a4d4 100644
--- a/server/models/request/request-video-qadu-interface.ts
+++ b/server/models/request/request-video-qadu-interface.ts
@@ -1,5 +1,7 @@
 import * as Sequelize from 'sequelize'
+import * as Promise from 'bluebird'
 
+import { AbstractRequestClass, AbstractRequestToPodClass } from './abstract-request-interface'
 import { VideoInstance } from '../video'
 import { PodInstance } from '../pod'
 
@@ -14,20 +16,16 @@ export type RequestsVideoQaduGrouped = {
 }
 
 export namespace RequestVideoQaduMethods {
-  export type CountTotalRequestsCallback = (err: Error, total: number) => void
-  export type CountTotalRequests = (callback: CountTotalRequestsCallback) => void
+  export type CountTotalRequests = () => Promise<number>
 
-  export type ListWithLimitAndRandomCallback = (err: Error, requestsGrouped?: RequestsVideoQaduGrouped) => void
-  export type ListWithLimitAndRandom = (limitPods: number, limitRequestsPerPod: number, callback: ListWithLimitAndRandomCallback) => void
+  export type ListWithLimitAndRandom = (limitPods: number, limitRequestsPerPod: number) => Promise<RequestsVideoQaduGrouped>
 
-  export type RemoveByRequestIdsAndPodCallback = () => void
-  export type RemoveByRequestIdsAndPod = (ids: number[], podId: number, callback: RemoveByRequestIdsAndPodCallback) => void
+  export type RemoveByRequestIdsAndPod = (ids: number[], podId: number) => Promise<number>
 
-  export type RemoveAllCallback = () => void
-  export type RemoveAll = (callback: RemoveAllCallback) => void
+  export type RemoveAll = () => Promise<void>
 }
 
-export interface RequestVideoQaduClass {
+export interface RequestVideoQaduClass extends AbstractRequestClass<RequestsVideoQaduGrouped>, AbstractRequestToPodClass {
   countTotalRequests: RequestVideoQaduMethods.CountTotalRequests
   listWithLimitAndRandom: RequestVideoQaduMethods.ListWithLimitAndRandom
   removeByRequestIdsAndPod: RequestVideoQaduMethods.RemoveByRequestIdsAndPod
@@ -38,11 +36,13 @@ export interface RequestVideoQaduAttributes {
   type: RequestVideoQaduType
 }
 
-export interface RequestVideoQaduInstance extends RequestVideoQaduClass, RequestVideoQaduAttributes, Sequelize.Instance<RequestVideoQaduAttributes> {
+export interface RequestVideoQaduInstance
+  extends RequestVideoQaduClass, RequestVideoQaduAttributes, Sequelize.Instance<RequestVideoQaduAttributes> {
   id: number
 
   Pod: PodInstance
   Video: VideoInstance
 }
 
-export interface RequestVideoQaduModel extends RequestVideoQaduClass, Sequelize.Model<RequestVideoQaduInstance, RequestVideoQaduAttributes> {}
+export interface RequestVideoQaduModel
+  extends RequestVideoQaduClass, Sequelize.Model<RequestVideoQaduInstance, RequestVideoQaduAttributes> {}
diff --git a/server/models/request/request-video-qadu.ts b/server/models/request/request-video-qadu.ts
index da62239f5..74e28f129 100644
--- a/server/models/request/request-video-qadu.ts
+++ b/server/models/request/request-video-qadu.ts
@@ -16,7 +16,6 @@ import { database as db } from '../../initializers/database'
 import { REQUEST_VIDEO_QADU_TYPES } from '../../initializers'
 import { addMethodsToModel } from '../utils'
 import {
-  RequestVideoQaduClass,
   RequestVideoQaduInstance,
   RequestVideoQaduAttributes,
 
@@ -83,20 +82,18 @@ function associate (models) {
   })
 }
 
-countTotalRequests = function (callback: RequestVideoQaduMethods.CountTotalRequestsCallback) {
+countTotalRequests = function () {
   const query = {}
-  return RequestVideoQadu.count(query).asCallback(callback)
+  return RequestVideoQadu.count(query)
 }
 
-listWithLimitAndRandom = function (limitPods: number, limitRequestsPerPod: number, callback: RequestVideoQaduMethods.ListWithLimitAndRandomCallback) {
+listWithLimitAndRandom = function (limitPods: number, limitRequestsPerPod: number) {
   const Pod = db.Pod
   const tableJoin = ''
 
-  Pod.listRandomPodIdsWithRequest(limitPods, 'RequestVideoQadus', tableJoin, function (err, podIds) {
-    if (err) return callback(err)
-
+  return Pod.listRandomPodIdsWithRequest(limitPods, 'RequestVideoQadus', tableJoin).then(podIds => {
     // We don't have friends that have requests
-    if (podIds.length === 0) return callback(null, [])
+    if (podIds.length === 0) return []
 
     const query = {
       include: [
@@ -114,16 +111,14 @@ listWithLimitAndRandom = function (limitPods: number, limitRequestsPerPod: numbe
       ]
     }
 
-    RequestVideoQadu.findAll(query).asCallback(function (err, requests) {
-      if (err) return callback(err)
-
+    return RequestVideoQadu.findAll(query).then(requests => {
       const requestsGrouped = groupAndTruncateRequests(requests, limitRequestsPerPod)
-      return callback(err, requestsGrouped)
+      return requestsGrouped
     })
   })
 }
 
-removeByRequestIdsAndPod = function (ids: number[], podId: number, callback: RequestVideoQaduMethods.RemoveByRequestIdsAndPodCallback) {
+removeByRequestIdsAndPod = function (ids: number[], podId: number) {
   const query = {
     where: {
       id: {
@@ -133,12 +128,12 @@ removeByRequestIdsAndPod = function (ids: number[], podId: number, callback: Req
     }
   }
 
-  RequestVideoQadu.destroy(query).asCallback(callback)
+  return RequestVideoQadu.destroy(query)
 }
 
-removeAll = function (callback: RequestVideoQaduMethods.RemoveAllCallback) {
+removeAll = function () {
   // Delete all requests
-  RequestVideoQadu.truncate({ cascade: true }).asCallback(callback)
+  return RequestVideoQadu.truncate({ cascade: true })
 }
 
 // ---------------------------------------------------------------------------
diff --git a/server/models/request/request.ts b/server/models/request/request.ts
index 66e7da845..c3ce2cd4e 100644
--- a/server/models/request/request.ts
+++ b/server/models/request/request.ts
@@ -5,7 +5,6 @@ import { database as db } from '../../initializers/database'
 import { REQUEST_ENDPOINTS } from '../../initializers'
 import { addMethodsToModel } from '../utils'
 import {
-  RequestClass,
   RequestInstance,
   RequestAttributes,
 
@@ -60,25 +59,23 @@ function associate (models) {
   })
 }
 
-countTotalRequests = function (callback: RequestMethods.CountTotalRequestsCallback) {
+countTotalRequests = function () {
   // We need to include Pod because there are no cascade delete when a pod is removed
   // So we could count requests that do not have existing pod anymore
   const query = {
     include: [ Request['sequelize'].models.Pod ]
   }
 
-  return Request.count(query).asCallback(callback)
+  return Request.count(query)
 }
 
-listWithLimitAndRandom = function (limitPods: number, limitRequestsPerPod: number, callback: RequestMethods.ListWithLimitAndRandomCallback) {
+listWithLimitAndRandom = function (limitPods: number, limitRequestsPerPod: number) {
   const Pod = db.Pod
   const tableJoin = ''
 
-  Pod.listRandomPodIdsWithRequest(limitPods, 'RequestToPods', '', function (err, podIds) {
-    if (err) return callback(err)
-
+  return Pod.listRandomPodIdsWithRequest(limitPods, 'RequestToPods', tableJoin).then(podIds => {
     // We don't have friends that have requests
-    if (podIds.length === 0) return callback(null, [])
+    if (podIds.length === 0) return []
 
     // The first x requests of these pods
     // It is very important to sort by id ASC to keep the requests order!
@@ -98,23 +95,20 @@ listWithLimitAndRandom = function (limitPods: number, limitRequestsPerPod: numbe
       ]
     }
 
-    Request.findAll(query).asCallback(function (err, requests) {
-      if (err) return callback(err)
+    return Request.findAll(query).then(requests => {
 
       const requestsGrouped = groupAndTruncateRequests(requests, limitRequestsPerPod)
-      return callback(err, requestsGrouped)
+      return requestsGrouped
     })
   })
 }
 
-removeAll = function (callback: RequestMethods.RemoveAllCallback) {
+removeAll = function () {
   // Delete all requests
-  Request.truncate({ cascade: true }).asCallback(callback)
+  return Request.truncate({ cascade: true })
 }
 
-removeWithEmptyTo = function (callback?: RequestMethods.RemoveWithEmptyToCallback) {
-  if (!callback) callback = function () { /* empty */ }
-
+removeWithEmptyTo = function () {
   const query = {
     where: {
       id: {
@@ -125,7 +119,7 @@ removeWithEmptyTo = function (callback?: RequestMethods.RemoveWithEmptyToCallbac
     }
   }
 
-  Request.destroy(query).asCallback(callback)
+  return Request.destroy(query)
 }
 
 // ---------------------------------------------------------------------------