@tomei/media 0.4.0 → 0.4.1

package/dist/medias.js

@@ -1,508 +1,508 @@
-"use strict";
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Medias = void 0;
-const storage_blob_1 = require("@azure/storage-blob");
-const common_1 = require("@nestjs/common");
-const crypto = require("crypto");
-const fs = require("fs");
-const util = require("util");
-const base_medias_1 = require("./base/base.medias");
-const medias_entity_1 = require("./entities/medias.entity");
-const stream_1 = require("stream");
-const cuid = require("cuid");
-const sequelize_1 = require("sequelize");
-class Medias extends base_medias_1.BaseMedias {
-    constructor(mediasRepository, commonService, media) {
-        super(mediasRepository, media);
-        this.blobServiceClient = storage_blob_1.BlobServiceClient.fromConnectionString(process.env.AZURE_STORAGE_CONNECTION_STRING);
-        this.algorithm = 'aes-256-cbc';
-        this.entity = typeof medias_entity_1.MediasModel;
-        this.commonService = commonService;
-        try {
-            this.container = process.env.MEDIA_AZUREBLOB_CONTAINER_NAME;
-            if (!this.container && this.IsStorageTypeAzure()) {
-                throw new common_1.BadRequestException('CONTAINER_NAME Environtment Variable name not found');
-            }
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    async createMedias(isExternalMedias, stream) {
-        try {
-            const media = await super.create();
-            let activityDescription = `Added a new external media Id: ${this.MediaId}.`;
-            if (!isExternalMedias) {
-                activityDescription = `Added a new media Id: ${this.MediaId}.`;
-                await this.createInternalMedias(stream);
-            }
-            if (media) {
-                await this.commonService.addActivityHistory({
-                    Action: 'Add',
-                    Activity: 'Add New Media',
-                    Description: activityDescription,
-                    EntityId: this.MediaId,
-                    EntityValueBefore: '',
-                    EntityValueAfter: JSON.stringify(Object.assign({}, media.get({ plain: true }))),
-                    PerformedById: this.CreatedById,
-                    PerformedAt: this.CreatedAt,
-                }, this.entity, 'create');
-            }
-            return media;
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    async updateMedias(isExternalMedias, stream) {
-        try {
-            const oldMedia = await super.findOne({
-                where: { MediaId: this.MediaId },
-            });
-            const media = await super.update();
-            let activityDescription = `Updated external media Id: ${this.MediaId}.`;
-            if (!isExternalMedias) {
-                await this.updateInternalMedia(stream, oldMedia);
-                activityDescription = `Updated media Id: ${this.MediaId}.`;
-            }
-            if (media) {
-                await this.commonService.addActivityHistory({
-                    Action: 'Update',
-                    Activity: 'Update Media',
-                    Description: activityDescription,
-                    EntityId: this.MediaId,
-                    EntityValueBefore: JSON.stringify(Object.assign({}, oldMedia.get({ plain: true }))),
-                    EntityValueAfter: JSON.stringify(Object.assign({}, media.get({ plain: true }))),
-                    PerformedById: this.UpdatedById,
-                    PerformedAt: this.UpdatedAt,
-                }, this.entity, 'update');
-            }
-            return media;
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    IsStorageTypeAzure() {
-        const mediaStorageType = process.env.MEDIA_STORAGE_TYPE;
-        if (mediaStorageType === 'azure') {
-            return true;
-        }
-        else {
-            return false;
-        }
-    }
-    async updateInternalMedia(stream, oldMedia) {
-        try {
-            this.FileExtension = this.FileExtension.split('.')[0];
-            this.FileName = this.FileName.replace(/\.[^/.]+$/, '');
-            let file;
-            if (this.IsEncryptedYN === 'Y') {
-                file = await this.encrypt(stream.buffer);
-            }
-            else {
-                file = {
-                    buffer: stream.buffer,
-                    isEncrypted: false,
-                };
-            }
-            if (this.IsStorageTypeAzure()) {
-                await this.deleteUploadedFileFromAzure(oldMedia.URL, oldMedia.FileName, oldMedia.FileExtension, oldMedia.IsEncryptedYN);
-                await this.uploadFileToAzure(file);
-            }
-            else {
-                const filePath = super.createSaveLocation();
-                const isDirExist = util.promisify(fs.exists);
-                const isDir = await isDirExist(filePath);
-                if (isDir) {
-                    fs.unlinkSync(this.FilePath);
-                    if (this.IsEncryptedYN === 'Y') {
-                        fs.unlinkSync(this.getIvPath());
-                    }
-                }
-                await this.uploadFileToLocal(file);
-            }
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    async createInternalMedias(stream) {
-        try {
-            this.FileExtension = this.FileExtension.split('.')[0];
-            this.FileName = this.FileName.replace(/\.[^/.]+$/, '');
-            let file;
-            if (this.IsEncryptedYN === 'Y') {
-                file = await this.encrypt(stream.buffer);
-            }
-            else {
-                file = {
-                    buffer: stream.buffer,
-                    isEncrypted: false,
-                };
-            }
-            if (this.IsStorageTypeAzure()) {
-                this.uploadFileToAzure(file);
-            }
-            else {
-                this.uploadFileToLocal(file);
-            }
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    getIvPath() {
-        return super.createSaveLocation() + `/${this.FileName}iv.iv`;
-    }
-    async uploadFileToLocal(file) {
-        try {
-            const savelocation = super.createSaveLocation();
-            const isDirExist = util.promisify(fs.exists);
-            const createDir = util.promisify(fs.mkdir);
-            const isDir = await isDirExist(savelocation);
-            if (!isDir) {
-                await createDir(savelocation, { recursive: true });
-            }
-            const writeFileContent = util.promisify(fs.writeFile);
-            await writeFileContent(this.FilePath, file.buffer);
-            if (file.isEncrypted) {
-                await writeFileContent(this.getIvPath(), file.iv);
-            }
-            const path = {
-                filePath: super.createSaveLocation(),
-                ivFilePath: this.getIvPath() ? this.getIvPath() : '',
-            };
-            return path;
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    async deleteUploadedFileFromLocal(path, isEncryptedYN) {
-        try {
-            const isDirExist = util.promisify(fs.exists);
-            const isDir = await isDirExist(path);
-            if (isDir) {
-                const deleteFile = util.promisify(fs.unlink);
-                await deleteFile(path);
-                if (isEncryptedYN === 'Y') {
-                    await deleteFile(this.getIvPath());
-                }
-            }
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    async uploadFileToAzure(file) {
-        const filePath = await this.uploadFileToAzureStorage(file.buffer, this.ObjectType, this.ObjectId, this.FileName, this.FileExtension);
-        let ivPath;
-        if (this.IsEncryptedYN === 'Y') {
-            ivPath = await this.uploadFileToAzureStorage(file.iv, this.ObjectType, this.ObjectId, this.FileName + 'iv', 'iv');
-        }
-        const path = {
-            filePath,
-            ivFilePath: ivPath,
-        };
-        return path;
-    }
-    async deleteUploadedFileFromAzure(path, FileName, FileExtension, isEncryptedYN) {
-        try {
-            await this.deleteUploadedFileToAzureStorage(path, FileName, FileExtension);
-            if (isEncryptedYN === 'Y') {
-                await this.deleteUploadedFileToAzureStorage(path, FileName + 'iv', '.iv');
-            }
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    async uploadFileToAzureStorage(bufferFile, ObjectType, ObjectId, FileName, FileExtension) {
-        try {
-            const fileName = FileName.replace(/\.[^/.]+$/, '');
-            const path = `${this.container}/${ObjectType}/${ObjectId}`;
-            const blobcontainer = this.blobServiceClient.getContainerClient(path);
-            const blockBlobClient = await blobcontainer.getBlockBlobClient(`${fileName}.${FileExtension}`);
-            await blockBlobClient.uploadData(bufferFile);
-            return path;
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    async deleteUploadedFileToAzureStorage(path, FileName, FileExtension) {
-        const fileName = FileName.replace(/\.[^/.]+$/, '');
-        const blobcontainer = this.blobServiceClient.getContainerClient(path);
-        const blockBlobClient = await blobcontainer.getBlockBlobClient(`${fileName}.${FileExtension}`);
-        return await blockBlobClient.deleteIfExists();
-    }
-    setKey() {
-        try {
-            const key = process.env.MEDIA_ENCRYPT_KEY;
-            if (!key) {
-                throw new common_1.BadRequestException('MEDIA_ENCRYPT_KEY Environtment Variable name not found');
-            }
-            return key;
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    async findFile() {
-        try {
-            let fileBuffer;
-            if (this.IsStorageTypeAzure()) {
-                fileBuffer = await this.getFileFromAzure(this.URL, this.FileName, this.FileExtension);
-            }
-            else {
-                fileBuffer = await this.getFileFromLocal(this.FilePath);
-            }
-            let file = {
-                buffer: fileBuffer,
-                isEncrypted: this.IsEncryptedYN === 'Y' ? true : false,
-            };
-            if (file.isEncrypted) {
-                if (this.IsStorageTypeAzure()) {
-                    file.iv = await this.getFileFromAzure(this.URL, this.FileName + 'iv', 'iv');
-                }
-                else {
-                    file.iv = await this.getFileFromLocal(this.getIvPath());
-                }
-                file = await this.decrypt(file);
-            }
-            return file.buffer;
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    async stream2buffer(stream) {
-        return new Promise((resolve, reject) => {
-            const buffer = Array();
-            stream.on('data', (chunk) => buffer.push(chunk));
-            stream.on('end', () => resolve(Buffer.concat(buffer)));
-            stream.on('error', (err) => reject(`error converting stream - ${err}`));
-        });
-    }
-    async getFileFromAzure(path, FileName, FileExtension) {
-        try {
-            const fileName = FileName.replace(/\.[^/.]+$/, '');
-            const blobcontainer = this.blobServiceClient.getContainerClient(path);
-            const blockBlobClient = await blobcontainer.getBlockBlobClient(`${fileName}.${FileExtension}`);
-            const downloadResponse = await blockBlobClient.download();
-            const ReadStream = new stream_1.Readable().wrap(downloadResponse.readableStreamBody);
-            const file = await this.stream2buffer(ReadStream);
-            return file;
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    async getFileFromLocal(pathfile) {
-        try {
-            const stream = fs.createReadStream(pathfile);
-            const file = await this.stream2buffer(stream);
-            return file;
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    async encrypt(fileBuffer) {
-        try {
-            const key = this.setKey();
-            const iv = crypto.randomBytes(16);
-            const cipher = crypto.createCipheriv(this.algorithm, key, iv);
-            const resultBuffer = Buffer.concat([
-                cipher.update(fileBuffer),
-                cipher.final(),
-            ]);
-            const result = {
-                buffer: resultBuffer,
-                iv,
-                isEncrypted: true,
-            };
-            return result;
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    async decrypt(file) {
-        try {
-            const key = this.setKey();
-            const iv = file.iv;
-            const decipher = crypto.createDecipheriv(this.algorithm, key, iv);
-            const resultBuffer = Buffer.concat([
-                decipher.update(file.buffer),
-                decipher.final(),
-            ]);
-            const result = {
-                buffer: resultBuffer,
-                isEncrypted: false,
-            };
-            return result;
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    async delete() {
-        try {
-            const data = await super.delete();
-            if (this.IsExternalYN === 'N') {
-                if (this.IsStorageTypeAzure()) {
-                    await this.deleteUploadedFileFromAzure(this.URL, this.FileName, this.FileExtension, this.IsEncryptedYN);
-                }
-                else {
-                    await this.deleteUploadedFileFromLocal(this.URL, this.IsEncryptedYN);
-                }
-            }
-            await this.commonService.addActivityHistory({
-                Action: 'Delete',
-                Activity: 'Delete Media',
-                Description: `Deleted media (ID: ${this.MediaId})`,
-                EntityId: this.MediaId,
-                EntityValueBefore: JSON.stringify(data),
-                EntityValueAfter: '',
-                PerformedById: this.UpdatedById,
-                PerformedAt: new Date(),
-            }, this.entity, 'delete');
-            return { message: 'Media has been deleted.' };
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    async postInternal(fileStream, createMediaDto, userId) {
-        try {
-            const mediaAttr = Object.assign(Object.assign({}, createMediaDto), { MediaId: cuid(), IsExternalYN: 'N', ExternalSource: '', URL: '', FilePath: '', CreatedAt: new Date(), UpdatedAt: new Date(), CreatedById: userId, UpdatedById: userId });
-            this.init(mediaAttr);
-            const createdData = await this.createMedias(false, fileStream);
-            return createdData;
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    async postExternal(createMediaDto, userId) {
-        const mediaAttr = Object.assign(Object.assign({}, createMediaDto), { MediaId: cuid(), IsExternalYN: 'Y', CreatedAt: new Date(), UpdatedAt: new Date(), IsEncryptedYN: 'N', FilePath: '', FileName: '', FileExtension: '', CreatedById: userId, UpdatedById: userId });
-        this.init(mediaAttr);
-        await this.createMedias(true);
-        return mediaAttr;
-    }
-    async getAll(rows, page, search) {
-        let searchObj;
-        try {
-            searchObj = search ? JSON.parse(search) : {};
-        }
-        catch (err) {
-            throw new common_1.BadRequestException('Bad value for search.');
-        }
-        const mediaFilter = __rest(searchObj, []);
-        const queryObj = {};
-        Object.entries(mediaFilter).forEach(([key, value]) => {
-            queryObj[key] = {
-                [sequelize_1.Op.substring]: value,
-            };
-        });
-        const offset = rows * (page - 1);
-        const options = {
-            order: [['CreatedAt', 'DESC']],
-            limit: rows,
-            offset,
-            where: queryObj,
-            distinct: true,
-        };
-        return this.findAllWithPagination(options);
-    }
-    async getOne(id) {
-        try {
-            const media = await this.findOne({ where: { MediaId: id } });
-            if (!media) {
-                throw new common_1.NotFoundException(`Media not found with id ${id}`);
-            }
-            return media;
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    async getFile(id) {
-        try {
-            const media = await this.findOne({ where: { MediaId: id } });
-            if (!media) {
-                throw new common_1.NotFoundException(`Media not found with id ${id}`);
-            }
-            this.init(Object.assign({}, media.get({ plain: true })));
-            const fileBuffer = await this.findFile();
-            return {
-                fileBuffer: fileBuffer,
-                resOption: {
-                    'Content-Type': 'application/octet-stream',
-                    'Content-Disposition': `attachment; filename=${media.FileName}.${media.FileExtension}`,
-                    'Content-Length': fileBuffer.length,
-                },
-            };
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    async remove(id, userId) {
-        try {
-            const media = await this.findOne({ where: { MediaId: id } });
-            if (!media) {
-                throw new common_1.NotFoundException(`Media not found with id ${id}`);
-            }
-            const mediaAttr = Object.assign(Object.assign({}, media.get({ plain: true })), { UpdatedAt: new Date(), UpdatedById: userId });
-            this.init(mediaAttr);
-            return await this.delete();
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    async putExternal(id, updatedMediaDto, userId) {
-        try {
-            const media = await this.findOne({ where: { MediaId: id } });
-            if (!media) {
-                throw new common_1.NotFoundException(`Media not found with id ${id}`);
-            }
-            const mediaAttr = Object.assign(Object.assign(Object.assign({}, media.get({ plain: true })), updatedMediaDto), { UpdatedAt: new Date(), UpdatedById: userId });
-            this.init(mediaAttr);
-            return await this.updateMedias(true);
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    async putInternal(fileStream, id, updatedMediaDto, userId) {
-        try {
-            const media = await this.findOne({ where: { MediaId: id } });
-            if (!media) {
-                throw new common_1.NotFoundException(`Media not found with id ${id}`);
-            }
-            const mediaAttr = Object.assign(Object.assign(Object.assign({}, media.get({ plain: true })), updatedMediaDto), { UpdatedAt: new Date(), UpdatedById: userId });
-            this.init(mediaAttr);
-            return await this.updateMedias(false, fileStream);
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-}
-exports.Medias = Medias;
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Medias = void 0;
+const storage_blob_1 = require("@azure/storage-blob");
+const common_1 = require("@nestjs/common");
+const crypto = require("crypto");
+const fs = require("fs");
+const util = require("util");
+const base_medias_1 = require("./base/base.medias");
+const medias_entity_1 = require("./entities/medias.entity");
+const stream_1 = require("stream");
+const cuid = require("cuid");
+const sequelize_1 = require("sequelize");
+class Medias extends base_medias_1.BaseMedias {
+    constructor(mediasRepository, commonService, media) {
+        super(mediasRepository, media);
+        this.blobServiceClient = storage_blob_1.BlobServiceClient.fromConnectionString(process.env.AZURE_STORAGE_CONNECTION_STRING);
+        this.algorithm = 'aes-256-cbc';
+        this.entity = typeof medias_entity_1.MediasModel;
+        this.commonService = commonService;
+        try {
+            this.container = process.env.MEDIA_AZUREBLOB_CONTAINER_NAME;
+            if (!this.container && this.IsStorageTypeAzure()) {
+                throw new common_1.BadRequestException('CONTAINER_NAME Environtment Variable name not found');
+            }
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async createMedias(isExternalMedias, stream) {
+        try {
+            const media = await super.create();
+            let activityDescription = `Added a new external media Id: ${this.MediaId}.`;
+            if (!isExternalMedias) {
+                activityDescription = `Added a new media Id: ${this.MediaId}.`;
+                await this.createInternalMedias(stream);
+            }
+            if (media) {
+                await this.commonService.addActivityHistory({
+                    Action: 'Add',
+                    Activity: 'Add New Media',
+                    Description: activityDescription,
+                    EntityId: this.MediaId,
+                    EntityValueBefore: '',
+                    EntityValueAfter: JSON.stringify(Object.assign({}, media.get({ plain: true }))),
+                    PerformedById: this.CreatedById,
+                    PerformedAt: this.CreatedAt,
+                }, this.entity, 'create');
+            }
+            return media;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async updateMedias(isExternalMedias, stream) {
+        try {
+            const oldMedia = await super.findOne({
+                where: { MediaId: this.MediaId },
+            });
+            const media = await super.update();
+            let activityDescription = `Updated external media Id: ${this.MediaId}.`;
+            if (!isExternalMedias) {
+                await this.updateInternalMedia(stream, oldMedia);
+                activityDescription = `Updated media Id: ${this.MediaId}.`;
+            }
+            if (media) {
+                await this.commonService.addActivityHistory({
+                    Action: 'Update',
+                    Activity: 'Update Media',
+                    Description: activityDescription,
+                    EntityId: this.MediaId,
+                    EntityValueBefore: JSON.stringify(Object.assign({}, oldMedia.get({ plain: true }))),
+                    EntityValueAfter: JSON.stringify(Object.assign({}, media.get({ plain: true }))),
+                    PerformedById: this.UpdatedById,
+                    PerformedAt: this.UpdatedAt,
+                }, this.entity, 'update');
+            }
+            return media;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    IsStorageTypeAzure() {
+        const mediaStorageType = process.env.MEDIA_STORAGE_TYPE;
+        if (mediaStorageType === 'azure') {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    async updateInternalMedia(stream, oldMedia) {
+        try {
+            this.FileExtension = this.FileExtension.split('.')[0];
+            this.FileName = this.FileName.replace(/\.[^/.]+$/, '');
+            let file;
+            if (this.IsEncryptedYN === 'Y') {
+                file = await this.encrypt(stream.buffer);
+            }
+            else {
+                file = {
+                    buffer: stream.buffer,
+                    isEncrypted: false,
+                };
+            }
+            if (this.IsStorageTypeAzure()) {
+                await this.deleteUploadedFileFromAzure(oldMedia.URL, oldMedia.FileName, oldMedia.FileExtension, oldMedia.IsEncryptedYN);
+                await this.uploadFileToAzure(file);
+            }
+            else {
+                const filePath = super.createSaveLocation();
+                const isDirExist = util.promisify(fs.exists);
+                const isDir = await isDirExist(filePath);
+                if (isDir) {
+                    fs.unlinkSync(this.FilePath);
+                    if (this.IsEncryptedYN === 'Y') {
+                        fs.unlinkSync(this.getIvPath());
+                    }
+                }
+                await this.uploadFileToLocal(file);
+            }
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async createInternalMedias(stream) {
+        try {
+            this.FileExtension = this.FileExtension.split('.')[0];
+            this.FileName = this.FileName.replace(/\.[^/.]+$/, '');
+            let file;
+            if (this.IsEncryptedYN === 'Y') {
+                file = await this.encrypt(stream.buffer);
+            }
+            else {
+                file = {
+                    buffer: stream.buffer,
+                    isEncrypted: false,
+                };
+            }
+            if (this.IsStorageTypeAzure()) {
+                this.uploadFileToAzure(file);
+            }
+            else {
+                this.uploadFileToLocal(file);
+            }
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    getIvPath() {
+        return super.createSaveLocation() + `/${this.FileName}iv.iv`;
+    }
+    async uploadFileToLocal(file) {
+        try {
+            const savelocation = super.createSaveLocation();
+            const isDirExist = util.promisify(fs.exists);
+            const createDir = util.promisify(fs.mkdir);
+            const isDir = await isDirExist(savelocation);
+            if (!isDir) {
+                await createDir(savelocation, { recursive: true });
+            }
+            const writeFileContent = util.promisify(fs.writeFile);
+            await writeFileContent(this.FilePath, file.buffer);
+            if (file.isEncrypted) {
+                await writeFileContent(this.getIvPath(), file.iv);
+            }
+            const path = {
+                filePath: super.createSaveLocation(),
+                ivFilePath: this.getIvPath() ? this.getIvPath() : '',
+            };
+            return path;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async deleteUploadedFileFromLocal(path, isEncryptedYN) {
+        try {
+            const isDirExist = util.promisify(fs.exists);
+            const isDir = await isDirExist(path);
+            if (isDir) {
+                const deleteFile = util.promisify(fs.unlink);
+                await deleteFile(path);
+                if (isEncryptedYN === 'Y') {
+                    await deleteFile(this.getIvPath());
+                }
+            }
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async uploadFileToAzure(file) {
+        const filePath = await this.uploadFileToAzureStorage(file.buffer, this.ObjectType, this.ObjectId, this.FileName, this.FileExtension);
+        let ivPath;
+        if (this.IsEncryptedYN === 'Y') {
+            ivPath = await this.uploadFileToAzureStorage(file.iv, this.ObjectType, this.ObjectId, this.FileName + 'iv', 'iv');
+        }
+        const path = {
+            filePath,
+            ivFilePath: ivPath,
+        };
+        return path;
+    }
+    async deleteUploadedFileFromAzure(path, FileName, FileExtension, isEncryptedYN) {
+        try {
+            await this.deleteUploadedFileToAzureStorage(path, FileName, FileExtension);
+            if (isEncryptedYN === 'Y') {
+                await this.deleteUploadedFileToAzureStorage(path, FileName + 'iv', '.iv');
+            }
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async uploadFileToAzureStorage(bufferFile, ObjectType, ObjectId, FileName, FileExtension) {
+        try {
+            const fileName = FileName.replace(/\.[^/.]+$/, '');
+            const path = `${this.container}/${ObjectType}/${ObjectId}`;
+            const blobcontainer = this.blobServiceClient.getContainerClient(path);
+            const blockBlobClient = await blobcontainer.getBlockBlobClient(`${fileName}.${FileExtension}`);
+            await blockBlobClient.uploadData(bufferFile);
+            return path;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async deleteUploadedFileToAzureStorage(path, FileName, FileExtension) {
+        const fileName = FileName.replace(/\.[^/.]+$/, '');
+        const blobcontainer = this.blobServiceClient.getContainerClient(path);
+        const blockBlobClient = await blobcontainer.getBlockBlobClient(`${fileName}.${FileExtension}`);
+        return await blockBlobClient.deleteIfExists();
+    }
+    setKey() {
+        try {
+            const key = process.env.MEDIA_ENCRYPT_KEY;
+            if (!key) {
+                throw new common_1.BadRequestException('MEDIA_ENCRYPT_KEY Environtment Variable name not found');
+            }
+            return key;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async findFile() {
+        try {
+            let fileBuffer;
+            if (this.IsStorageTypeAzure()) {
+                fileBuffer = await this.getFileFromAzure(this.URL, this.FileName, this.FileExtension);
+            }
+            else {
+                fileBuffer = await this.getFileFromLocal(this.FilePath);
+            }
+            let file = {
+                buffer: fileBuffer,
+                isEncrypted: this.IsEncryptedYN === 'Y' ? true : false,
+            };
+            if (file.isEncrypted) {
+                if (this.IsStorageTypeAzure()) {
+                    file.iv = await this.getFileFromAzure(this.URL, this.FileName + 'iv', 'iv');
+                }
+                else {
+                    file.iv = await this.getFileFromLocal(this.getIvPath());
+                }
+                file = await this.decrypt(file);
+            }
+            return file.buffer;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async stream2buffer(stream) {
+        return new Promise((resolve, reject) => {
+            const buffer = Array();
+            stream.on('data', (chunk) => buffer.push(chunk));
+            stream.on('end', () => resolve(Buffer.concat(buffer)));
+            stream.on('error', (err) => reject(`error converting stream - ${err}`));
+        });
+    }
+    async getFileFromAzure(path, FileName, FileExtension) {
+        try {
+            const fileName = FileName.replace(/\.[^/.]+$/, '');
+            const blobcontainer = this.blobServiceClient.getContainerClient(path);
+            const blockBlobClient = await blobcontainer.getBlockBlobClient(`${fileName}.${FileExtension}`);
+            const downloadResponse = await blockBlobClient.download();
+            const ReadStream = new stream_1.Readable().wrap(downloadResponse.readableStreamBody);
+            const file = await this.stream2buffer(ReadStream);
+            return file;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async getFileFromLocal(pathfile) {
+        try {
+            const stream = fs.createReadStream(pathfile);
+            const file = await this.stream2buffer(stream);
+            return file;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async encrypt(fileBuffer) {
+        try {
+            const key = this.setKey();
+            const iv = crypto.randomBytes(16);
+            const cipher = crypto.createCipheriv(this.algorithm, key, iv);
+            const resultBuffer = Buffer.concat([
+                cipher.update(fileBuffer),
+                cipher.final(),
+            ]);
+            const result = {
+                buffer: resultBuffer,
+                iv,
+                isEncrypted: true,
+            };
+            return result;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async decrypt(file) {
+        try {
+            const key = this.setKey();
+            const iv = file.iv;
+            const decipher = crypto.createDecipheriv(this.algorithm, key, iv);
+            const resultBuffer = Buffer.concat([
+                decipher.update(file.buffer),
+                decipher.final(),
+            ]);
+            const result = {
+                buffer: resultBuffer,
+                isEncrypted: false,
+            };
+            return result;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async delete() {
+        try {
+            const data = await super.delete();
+            if (this.IsExternalYN === 'N') {
+                if (this.IsStorageTypeAzure()) {
+                    await this.deleteUploadedFileFromAzure(this.URL, this.FileName, this.FileExtension, this.IsEncryptedYN);
+                }
+                else {
+                    await this.deleteUploadedFileFromLocal(this.URL, this.IsEncryptedYN);
+                }
+            }
+            await this.commonService.addActivityHistory({
+                Action: 'Delete',
+                Activity: 'Delete Media',
+                Description: `Deleted media (ID: ${this.MediaId})`,
+                EntityId: this.MediaId,
+                EntityValueBefore: JSON.stringify(data),
+                EntityValueAfter: '',
+                PerformedById: this.UpdatedById,
+                PerformedAt: new Date(),
+            }, this.entity, 'delete');
+            return { message: 'Media has been deleted.' };
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async postInternal(fileStream, createMediaDto, userId) {
+        try {
+            const mediaAttr = Object.assign(Object.assign({}, createMediaDto), { MediaId: cuid(), IsExternalYN: 'N', ExternalSource: '', URL: '', FilePath: '', CreatedAt: new Date(), UpdatedAt: new Date(), CreatedById: userId, UpdatedById: userId });
+            this.init(mediaAttr);
+            const createdData = await this.createMedias(false, fileStream);
+            return createdData;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async postExternal(createMediaDto, userId) {
+        const mediaAttr = Object.assign(Object.assign({}, createMediaDto), { MediaId: cuid(), IsExternalYN: 'Y', CreatedAt: new Date(), UpdatedAt: new Date(), IsEncryptedYN: 'N', FilePath: '', FileName: '', FileExtension: '', CreatedById: userId, UpdatedById: userId });
+        this.init(mediaAttr);
+        await this.createMedias(true);
+        return mediaAttr;
+    }
+    async getAll(rows, page, search) {
+        let searchObj;
+        try {
+            searchObj = search ? JSON.parse(search) : {};
+        }
+        catch (err) {
+            throw new common_1.BadRequestException('Bad value for search.');
+        }
+        const mediaFilter = __rest(searchObj, []);
+        const queryObj = {};
+        Object.entries(mediaFilter).forEach(([key, value]) => {
+            queryObj[key] = {
+                [sequelize_1.Op.substring]: value,
+            };
+        });
+        const offset = rows * (page - 1);
+        const options = {
+            order: [['CreatedAt', 'DESC']],
+            limit: rows,
+            offset,
+            where: queryObj,
+            distinct: true,
+        };
+        return this.findAllWithPagination(options);
+    }
+    async getOne(id) {
+        try {
+            const media = await this.findOne({ where: { MediaId: id } });
+            if (!media) {
+                throw new common_1.NotFoundException(`Media not found with id ${id}`);
+            }
+            return media;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async getFile(id) {
+        try {
+            const media = await this.findOne({ where: { MediaId: id } });
+            if (!media) {
+                throw new common_1.NotFoundException(`Media not found with id ${id}`);
+            }
+            this.init(Object.assign({}, media.get({ plain: true })));
+            const fileBuffer = await this.findFile();
+            return {
+                fileBuffer: fileBuffer,
+                resOption: {
+                    'Content-Type': 'application/octet-stream',
+                    'Content-Disposition': `attachment; filename=${media.FileName}.${media.FileExtension}`,
+                    'Content-Length': fileBuffer.length,
+                },
+            };
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async remove(id, userId) {
+        try {
+            const media = await this.findOne({ where: { MediaId: id } });
+            if (!media) {
+                throw new common_1.NotFoundException(`Media not found with id ${id}`);
+            }
+            const mediaAttr = Object.assign(Object.assign({}, media.get({ plain: true })), { UpdatedAt: new Date(), UpdatedById: userId });
+            this.init(mediaAttr);
+            return await this.delete();
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async putExternal(id, updatedMediaDto, userId) {
+        try {
+            const media = await this.findOne({ where: { MediaId: id } });
+            if (!media) {
+                throw new common_1.NotFoundException(`Media not found with id ${id}`);
+            }
+            const mediaAttr = Object.assign(Object.assign(Object.assign({}, media.get({ plain: true })), updatedMediaDto), { UpdatedAt: new Date(), UpdatedById: userId });
+            this.init(mediaAttr);
+            return await this.updateMedias(true);
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async putInternal(fileStream, id, updatedMediaDto, userId) {
+        try {
+            const media = await this.findOne({ where: { MediaId: id } });
+            if (!media) {
+                throw new common_1.NotFoundException(`Media not found with id ${id}`);
+            }
+            const mediaAttr = Object.assign(Object.assign(Object.assign({}, media.get({ plain: true })), updatedMediaDto), { UpdatedAt: new Date(), UpdatedById: userId });
+            this.init(mediaAttr);
+            return await this.updateMedias(false, fileStream);
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+}
+exports.Medias = Medias;
 //# sourceMappingURL=medias.js.map