otf-frontend/server/src/feathers/services/file-transfer/file-transfer.class.js

   1 /*  Copyright (c) 2019 AT&T Intellectual Property.                             #\r
   2 #                                                                              #\r
   3 #   Licensed under the Apache License, Version 2.0 (the "License");            #\r
   4 #   you may not use this file except in compliance with the License.           #\r
   5 #   You may obtain a copy of the License at                                    #\r
   6 #                                                                              #\r
   7 #       http://www.apache.org/licenses/LICENSE-2.0                             #\r
   8 #                                                                              #\r
   9 #   Unless required by applicable law or agreed to in writing, software        #\r
  10 #   distributed under the License is distributed on an "AS IS" BASIS,          #\r
  11 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #\r
  12 #   See the License for the specific language governing permissions and        #\r
  13 #   limitations under the License.                                             #\r
  14 ##############################################################################*/\r
  15 \r
  16 \r
  17 const Response = require('http-response-object');\r
  18 const Readable = require('stream').Readable;\r
  19 const { createModel } = require('mongoose-gridfs');\r
  20 const AdmZip = require('adm-zip');\r
  21 const errors = require('@feathersjs/errors');\r
  22 const mongoose = require('mongoose');\r
  23 const ObjectID = require('mongodb').ObjectID;\r
  24 const {\r
  25         Aborter,\r
  26         BlockBlobURL,\r
  27         BlobURL,\r
  28         downloadBlobToBuffer,\r
  29         uploadStreamToBlockBlob\r
  30   } = require("@azure/storage-blob");\r
  31 \r
  32 \r
  33 class Service {\r
  34         constructor (options) {\r
  35                 this.options = options || {};\r
  36                 // this.File = createModel({\r
  37                 //      collection: 'fs',\r
  38                 //      model: 'File',\r
  39                 //      mongooseConnection: mongoose.connection\r
  40                 // });\r
  41         }\r
  42 \r
  43         async find (params) {\r
  44                 return new Response(200, {});\r
  45         }\r
  46 \r
  47         async get (id, params) {\r
  48                 if(!id){\r
  49                         throw new errors.BadRequest("File id is required");\r
  50                 }\r
  51 \r
  52                 // Get Blob url\r
  53                 const blob = BlobURL.fromContainerURL(this.options.app.get('azureStorageContainerUrl'), id);\r
  54                 const stats = await blob.getProperties().catch(err => {\r
  55                         throw new errors.NotFound();\r
  56                 });\r
  57                 // const content = await blob.download(Aborter.none, 0);\r
  58                 const buffer = Buffer.alloc(stats.contentLength);\r
  59                 await downloadBlobToBuffer(\r
  60                         Aborter.timeout(30 * 60 * 1000),\r
  61                         buffer,\r
  62                         blob,\r
  63                         0,\r
  64                         undefined,\r
  65                         {\r
  66                           blockSize: 4 * 1024 * 1024, // 4MB block size\r
  67                           parallelism: 20, // 20 concurrency\r
  68                         }\r
  69                   );\r
  70 \r
  71                 return buffer;\r
  72         }\r
  73 \r
  74         async create (data, params) {\r
  75         const files = params.files;\r
  76 \r
  77         if (!files || files.length === 0) {\r
  78             throw new BadRequest("No files found to upload")\r
  79         }\r
  80 \r
  81                 let promises = [];\r
  82                 \r
  83         files.forEach(file => {\r
  84             let promise = new Promise(async (resolve, reject) => {\r
  85 \r
  86                                 let exists, filename, blob, blockBlob;\r
  87                                 // Creates the file id and checks that there isn't already a file with that name\r
  88                                 do {\r
  89 \r
  90                                         filename = ObjectID().toString();\r
  91                                         \r
  92                                         blob = BlobURL.fromContainerURL(this.options.app.get('azureStorageContainerUrl'), filename);\r
  93                                         blockBlob = BlockBlobURL.fromBlobURL(blob);\r
  94                                         exists = await blockBlob.getProperties().catch(err => {\r
  95                                                 if(err.statusCode == 404){\r
  96                                                         exists = false;\r
  97                                                 }\r
  98                                         });\r
  99 \r
 100                                 } while (exists);\r
 101         \r
 102                                 blockBlob.upload(Aborter.none, file.buffer.toString(), file.size).then(\r
 103                                         result => {\r
 104                                                 result._id = filename;\r
 105                                                 resolve(result);\r
 106                                         }\r
 107                                 ).catch(\r
 108                                         error => {\r
 109                                                 reject(error);\r
 110                                         }\r
 111                                 );\r
 112 \r
 113             })\r
 114 \r
 115             promises.push(promise);\r
 116         });\r
 117 \r
 118         const result = await Promise.all(promises);\r
 119         \r
 120         return result;\r
 121         }\r
 122 \r
 123         \r
 124 \r
 125         async update (id, data, params) {\r
 126                 return new Response(200, {});\r
 127         }\r
 128 \r
 129         async patch (id, data, params) {\r
 130                 return new Response(200, {});\r
 131         }\r
 132 \r
 133         async remove (id, params) {\r
 134                 // let err = await this.callUnlinkFile(id).then(err => {\r
 135         //     return err;\r
 136         // });\r
 137 \r
 138         // if(err){\r
 139         //     throw errors.GeneralError(err);\r
 140         // }        \r
 141 \r
 142         return new Response(200, {});\r
 143         }\r
 144 \r
 145         readFile (id) {\r
 146                 return new Promise(resolve => {\r
 147                         // FileModel.readById(context.id, (err, content) => resolve(content));\r
 148                         let stream = this.FileModel.readById(id);\r
 149         \r
 150                         stream.on('error', (err) => resolve(err));\r
 151                         stream.on('data', (content) => resolve(content));\r
 152                         stream.on('close', (res) => resolve(res));\r
 153                         // api.on(event, response => resolve(response));\r
 154                 });\r
 155         }\r
 156         \r
 157         async callReadFile (id) {\r
 158                 return this.readFile(id);\r
 159         }\r
 160         \r
 161         async createRobotResponse(content){\r
 162         \r
 163                 let re;\r
 164         \r
 165                 await new Promise((resolve, reject) => {\r
 166                         let newObj = {};\r
 167                         let read = new Readable();\r
 168                         read.push(content);\r
 169                         read.push(null);\r
 170                         let z = new AdmZip(content);\r
 171                         let entries = z.getEntries();\r
 172                         entries.forEach(zipEntry => {\r
 173                                 newObj[zipEntry.name] = zipEntry.getData().toString('utf8');\r
 174                                 // console.log(zipEntry.toString()); // outputs zip entries information\r
 175                                 // console.log(zipEntry.getData().toString('utf8')); \r
 176                         });\r
 177                         resolve(newObj);\r
 178                 }).then(res => {\r
 179                         re = res;\r
 180                         //console.log(re);\r
 181                 }).catch(err => {\r
 182                         console.log(err);\r
 183                 });\r
 184         \r
 185                 return re;\r
 186         }\r
 187 \r
 188         unlinkFile(id) {\r
 189         \r
 190                 return new Promise(resolve => {\r
 191                         \r
 192                         //FileModel.readById(context.id, (err, content) => resolve(content));\r
 193                         this.FileModel.unlinkById(id, (err) => resolve(err));\r
 194                         //api.on(event, response => resolve(response));\r
 195                 });\r
 196         }\r
 197         \r
 198         async callUnlinkFile(id) {\r
 199                 return await this.unlinkFile(id);\r
 200         }\r
 201 }\r
 202 \r
 203 \r
 204 \r
 205 module.exports = function (options) {\r
 206         return new Service(options);\r
 207 };\r
 208 \r
 209 module.exports.Service = Service;\r