Move old backend code to old_src folder

Signed-off-by: David Mehren <git@herrmehren.de>

old_src/lib/web/imageRouter/azure.ts

@@ -0,0 +1,38 @@
+import azure from 'azure-storage'
+import path from 'path'
+
+import { config } from '../../config'
+import { logger } from '../../logger'
+import { UploadProvider } from './index'
+
+const AzureUploadProvider: UploadProvider = {
+  uploadImage: (imagePath, callback) => {
+    if (!callback || typeof callback !== 'function') {
+      logger.error('Callback has to be a function')
+      return
+    }
+
+    if (!imagePath) {
+      callback(new Error('Image path is missing or wrong'), undefined)
+      return
+    }
+
+    const azureBlobService = azure.createBlobService(config.azure.connectionString)
+
+    azureBlobService.createContainerIfNotExists(config.azure.container, { publicAccessLevel: 'blob' }, function (err, _, __) {
+      if (err) {
+        callback(new Error(err.message), undefined)
+      } else {
+        azureBlobService.createBlockBlobFromLocalFile(config.azure.container, path.basename(imagePath), imagePath, function (err, result, _) {
+          if (err) {
+            callback(new Error(err.message), undefined)
+          } else {
+            callback(undefined, azureBlobService.getUrl(config.azure.container, result.name))
+          }
+        })
+      }
+    })
+  }
+}
+
+export { AzureUploadProvider }

old_src/lib/web/imageRouter/filesystem.ts

@@ -0,0 +1,24 @@
+import path from 'path'
+import { URL } from 'url'
+
+import { config } from '../../config'
+import { logger } from '../../logger'
+import { UploadProvider } from './index'
+
+const FilesystemUploadProvider: UploadProvider = {
+  uploadImage: (imagePath, callback) => {
+    if (!callback || typeof callback !== 'function') {
+      logger.error('Callback has to be a function')
+      return
+    }
+
+    if (!imagePath) {
+      callback(new Error('Image path is missing or wrong'), undefined)
+      return
+    }
+
+    callback(undefined, (new URL(path.basename(imagePath), config.serverURL + '/uploads/')).href)
+  }
+}
+
+export { FilesystemUploadProvider }

old_src/lib/web/imageRouter/imgur.ts

@@ -0,0 +1,30 @@
+import imgur from 'old_src/lib/web/imageRouter/imgur'
+
+import { config } from '../../config'
+import { logger } from '../../logger'
+import { UploadProvider } from './index'
+
+const ImgurUploadProvider: UploadProvider = {
+  uploadImage: (imagePath, callback) => {
+    if (!callback || typeof callback !== 'function') {
+      logger.error('Callback has to be a function')
+      return
+    }
+
+    if (!imagePath) {
+      callback(new Error('Image path is missing or wrong'), undefined)
+      return
+    }
+
+    imgur.setClientId(config.imgur.clientID)
+    imgur.uploadFile(imagePath)
+      .then(function (json) {
+        logger.debug(`SERVER uploadimage success: ${JSON.stringify(json)}`)
+        callback(undefined, json.data.link.replace(/^http:\/\//i, 'https://'))
+      }).catch(function (err) {
+        callback(new Error(err), undefined)
+      })
+  }
+}
+
+export { ImgurUploadProvider }

old_src/lib/web/imageRouter/index.ts

@@ -0,0 +1,75 @@
+import { Router } from 'express'
+import formidable from 'formidable'
+
+import { config } from '../../config'
+import { logger } from '../../logger'
+import { errors } from '../../errors'
+import { AzureUploadProvider } from './azure'
+import { FilesystemUploadProvider } from './filesystem'
+import { ImgurUploadProvider } from './imgur'
+import { LutimUploadProvider } from './lutim'
+import { MinioUploadProvider } from './minio'
+import { S3UploadProvider } from './s3'
+
+interface UploadProvider {
+  uploadImage: (imagePath: string, callback: (err?: Error, url?: string) => void) => void;
+}
+
+const ImageRouter = Router()
+
+// upload image
+ImageRouter.post('/uploadimage', function (req, res) {
+  const form = new formidable.IncomingForm()
+
+  form.keepExtensions = true
+
+  if (config.imageUploadType === 'filesystem') {
+    form.uploadDir = config.uploadsPath
+  }
+
+  form.parse(req, function (err, fields, files) {
+    if (err || !files.image || !files.image.path) {
+      logger.error(`formidable error: ${err}`)
+      errors.errorForbidden(res)
+    } else {
+      logger.debug(`SERVER received uploadimage: ${JSON.stringify(files.image)}`)
+
+      let uploadProvider: UploadProvider
+      switch (config.imageUploadType) {
+        case 'azure':
+          uploadProvider = AzureUploadProvider
+          break
+        case 'filesystem':
+        default:
+          uploadProvider = FilesystemUploadProvider
+          break
+        case 'imgur':
+          uploadProvider = ImgurUploadProvider
+          break
+        case 'lutim':
+          uploadProvider = LutimUploadProvider
+          break
+        case 'minio':
+          uploadProvider = MinioUploadProvider
+          break
+        case 's3':
+          uploadProvider = S3UploadProvider
+          break
+      }
+
+      logger.debug(`imageRouter: Uploading ${files.image.path} using ${config.imageUploadType}`)
+      uploadProvider.uploadImage(files.image.path, function (err, url) {
+        if (err !== undefined) {
+          logger.error(err)
+          return res.status(500).end('upload image error')
+        }
+        logger.debug(`SERVER sending ${url} to client`)
+        res.send({
+          link: url
+        })
+      })
+    }
+  })
+})
+
+export { ImageRouter, UploadProvider }

old_src/lib/web/imageRouter/lutim.ts

@@ -0,0 +1,34 @@
+import lutim from 'old_src/lib/web/imageRouter/lutim'
+
+import { config } from '../../config'
+import { logger } from '../../logger'
+import { UploadProvider } from './index'
+
+const LutimUploadProvider: UploadProvider = {
+  uploadImage: (imagePath, callback) => {
+    if (!callback || typeof callback !== 'function') {
+      logger.error('Callback has to be a function')
+      return
+    }
+
+    if (!imagePath) {
+      callback(new Error('Image path is missing or wrong'), undefined)
+      return
+    }
+
+    if (config.lutim && config.lutim.url) {
+      lutim.setAPIUrl(config.lutim.url)
+      logger.debug(`Set lutim URL to ${lutim.getAPIUrl()}`)
+    }
+
+    lutim.uploadImage(imagePath)
+      .then(function (json) {
+        logger.debug(`SERVER uploadimage success: ${JSON.stringify(json)}`)
+        callback(undefined, lutim.getAPIUrl() + json.msg.short)
+      }).catch(function (err) {
+        callback(new Error(err), undefined)
+      })
+  }
+}
+
+export { LutimUploadProvider }

old_src/lib/web/imageRouter/minio.ts

@@ -0,0 +1,60 @@
+import path from 'path'
+import fs from 'fs'
+import { Client } from 'old_src/lib/web/imageRouter/minio'
+
+import { config } from '../../config'
+import { getImageMimeType } from '../../utils/functions'
+import { logger } from '../../logger'
+import { UploadProvider } from './index'
+
+let MinioUploadProvider: UploadProvider
+
+if (config.minio.endPoint !== undefined) {
+  const minioClient = new Client({
+    endPoint: config.minio.endPoint,
+    port: config.minio.port,
+    useSSL: config.minio.secure,
+    accessKey: config.minio.accessKey,
+    secretKey: config.minio.secretKey
+  })
+
+  MinioUploadProvider = {
+    uploadImage: (imagePath, callback): void => {
+      if (!imagePath) {
+        callback(new Error('Image path is missing or wrong'), undefined)
+        return
+      }
+
+      if (!callback || typeof callback !== 'function') {
+        logger.error('Callback has to be a function')
+        return
+      }
+
+      fs.readFile(imagePath, function (err, buffer) {
+        if (err) {
+          callback(new Error(err.message), undefined)
+          return
+        }
+
+        const key = path.join('uploads', path.basename(imagePath))
+        const protocol = config.minio.secure ? 'https' : 'http'
+
+        const metaData = {
+          ContentType: getImageMimeType(imagePath)
+        }
+
+        minioClient.putObject(config.s3bucket, key, buffer, buffer.length, metaData, function (err, _) {
+          if (err) {
+            callback(new Error(err.message), undefined)
+            return
+          }
+          const hidePort = [80, 443].includes(config.minio.port)
+          const urlPort = hidePort ? '' : `:${config.minio.port}`
+          callback(undefined, `${protocol}://${config.minio.endPoint}${urlPort}/${config.s3bucket}/${key}`)
+        })
+      })
+    }
+  }
+}
+
+export { MinioUploadProvider }

old_src/lib/web/imageRouter/s3.ts

@@ -0,0 +1,59 @@
+import fs from 'fs'
+import path from 'path'
+import AWS from 'aws-sdk'
+
+import { config } from '../../config'
+// import { getImageMimeType } from '../../utils'
+import { logger } from '../../logger'
+import { UploadProvider } from './index'
+
+const awsConfig = new AWS.Config(config.s3)
+const s3 = new AWS.S3(awsConfig)
+
+const S3UploadProvider: UploadProvider = {
+  uploadImage: (imagePath, callback) => {
+    if (!imagePath) {
+      callback(new Error('Image path is missing or wrong'), undefined)
+      return
+    }
+
+    if (!callback || typeof callback !== 'function') {
+      logger.error('Callback has to be a function')
+      return
+    }
+
+    fs.readFile(imagePath, function (err, buffer) {
+      if (err) {
+        callback(new Error(err.message), undefined)
+        return
+      }
+      const params = {
+        Bucket: config.s3bucket,
+        Key: path.join('uploads', path.basename(imagePath)),
+        Body: buffer
+      }
+
+      // ToDo: This does not exist (anymore?)
+      // const mimeType = getImageMimeType(imagePath)
+      // if (mimeType) { params.ContentType = mimeType }
+
+      logger.debug(`S3 object parameters: ${JSON.stringify(params)}`)
+      s3.putObject(params, function (err, _) {
+        if (err) {
+          callback(new Error(err.message), undefined)
+          return
+        }
+
+        let s3Endpoint = 's3.amazonaws.com'
+        if (config.s3.endpoint) {
+          s3Endpoint = config.s3.endpoint
+        } else if (config.s3.region && config.s3.region !== 'us-east-1') {
+          s3Endpoint = `s3-${config.s3.region}.amazonaws.com`
+        }
+        callback(undefined, `https://${s3Endpoint}/${config.s3bucket}/${params.Key}`)
+      })
+    })
+  }
+}
+
+export { S3UploadProvider }