@wbg-mde/repository
Version:
Managing all common method for file system CRUD operations.
404 lines (403 loc) • 18.4 kB
JavaScript
"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
Object.defineProperty(exports, "__esModule", { value: true });
const project_header_1 = require("../project-data/project.header");
const model_1 = require("@wbg-mde/model");
const app_repo_constants_1 = require("../shared/app.repo.constants");
const app_repo_utility_1 = require("../shared/app.repo.utility");
const template_1 = require("../master-data/template");
const i18n_core_1 = require("../i18n/i18n.core");
const resource_path_1 = require("../resource-path/resource-path");
const appstatus_decorator_1 = require("../decorators/appstatus.decorator");
const DecompressZip = require("decompress-zip");
const path = require("path");
const fs = require("fs");
const copydir = require("copy-dir");
const _ = require("lodash");
const trace_decorator_1 = require("../decorators/trace.decorator");
let StudyImport = class StudyImport {
constructor() {
this.template = new template_1.Template();
this.i18nCore = new i18n_core_1.I18nCore();
this.projectHeader = new project_header_1.ProjectHeader();
this.resourcePath = new resource_path_1.ResourcePath();
}
importStudy(filePath, callback) {
let projectMetadata;
let newProject;
let dbInfo;
let templatePath;
let i18nResourcePath;
let sourcePath = filePath;
let destinationPath = this.getExtractTempDirectory(filePath);
this.updateProgress = callback;
appstatus_decorator_1.StatusTracker.update({ stepIndex: 1 });
this.unzipFile(filePath, destinationPath, () => {
appstatus_decorator_1.StatusTracker.update({ stepIndex: 2 });
this.readProjectInfo(destinationPath, (info) => {
projectMetadata = info;
appstatus_decorator_1.StatusTracker.update({ stepIndex: 3 });
this.checkRequirements(projectMetadata, () => {
appstatus_decorator_1.StatusTracker.update({ stepIndex: 4 });
this.createNewStudy(projectMetadata, (nProject) => {
newProject = nProject;
appstatus_decorator_1.StatusTracker.update({ stepIndex: 5 });
this.copyResourceFilesToNewStudy(newProject, destinationPath, (db, tmpPath, i18nPath) => {
dbInfo = db;
templatePath = tmpPath;
i18nResourcePath = i18nPath;
appstatus_decorator_1.StatusTracker.update({ stepIndex: 6 });
this.updateDbInfoPaths(newProject, dbInfo, () => {
appstatus_decorator_1.StatusTracker.update({ stepIndex: 7 });
this.manageProjectI18nResources(i18nResourcePath, projectMetadata, () => {
appstatus_decorator_1.StatusTracker.update({ stepIndex: 8 });
this.manageProjectTemplates(templatePath, projectMetadata, newProject, () => {
appstatus_decorator_1.StatusTracker.update({ stepIndex: 9 });
this.updateStudyInfo(projectMetadata, newProject, dbInfo, () => {
this.removeTempDirectory(destinationPath);
});
});
});
});
});
});
});
});
});
}
checkRequirements(projectMetadata, callback) {
try {
let dataTypes = app_repo_utility_1.App_Repository_Utility.getTypes(true);
let invalid = false;
let dataType = _.find(dataTypes, (item) => {
return String(item.type).trim().toLowerCase() === String(projectMetadata.type).trim().toLowerCase();
});
if (!dataType) {
invalid = true;
this.updateProgressCallBack(4, { dataType: projectMetadata.type });
}
if (invalid === false) {
callback();
}
}
catch (e) {
app_repo_utility_1.App_Repository_Utility.LogText('Import Study> manageProjectI18nResources > ' + e, 3);
this.updateProgressCallBack(2, { error: e });
}
}
importFromStudy(filePath, options, callback) {
let destinationPath = this.getExtractTempDirectory(filePath);
this.updateProgress = callback;
this.unzipFile(filePath, destinationPath, () => {
let _files = fs.readdirSync(destinationPath);
let _db;
for (let i in _files) {
if ((_files[i]) === app_repo_constants_1.App_Repository_Constants.tempFolder.exportPackageMetadataFile) {
_db = path.join(destinationPath, _files[i]);
break;
}
}
if (_db) {
let _metadata = JSON.parse(fs.readFileSync(_db, 'utf8'));
if (_metadata) {
if (options.docDscr !== true) {
delete _metadata["docDscr"];
}
if (options.stdyDscr !== true) {
delete _metadata["stdyDscr"];
}
}
this.updateProgressCallBack(1, { data: _metadata, options: options });
}
else {
this.updateProgressCallBack(2);
}
});
}
getExtractTempDirectory(filePath) {
let fname = path.basename(filePath, path.extname(filePath));
return path.join(this.resourcePath.getTempDirectory(), app_repo_constants_1.App_Repository_Constants.tempFolder.importPackage, fname);
}
getNewStudyDirectory(newProject) {
if (newProject)
return this.resourcePath.getProjectDirectory(newProject.header._id);
}
updateProgressCallBack(status, info) {
if (this.updateProgress) {
this.updateProgress(status, info);
}
}
unzipFile(filePath, destinationPath, callBack) {
try {
let unzipper = new DecompressZip(filePath);
unzipper.on('error', (err) => {
this.updateProgressCallBack(2);
app_repo_utility_1.App_Repository_Utility.LogText("Extract Error > " + err, 3);
});
unzipper.on('extract', (log) => {
if (callBack) {
callBack();
}
});
unzipper.on('progress', (fileIndex, fileCount) => {
this.updateProgressCallBack(1);
});
unzipper.extract({
path: destinationPath
});
}
catch (e) {
app_repo_utility_1.App_Repository_Utility.LogText('Import Study> unzipFile > ' + e, 3);
this.updateProgressCallBack(2, { error: e });
}
}
readProjectInfo(destinationPath, callback) {
try {
let info = JSON.parse(fs.readFileSync(path.join(destinationPath, app_repo_constants_1.App_Repository_Constants.tempFolder.exportPackageInfoFile), 'utf8'));
callback(info);
}
catch (e) {
app_repo_utility_1.App_Repository_Utility.LogText('Import Study> readProjectInfo > ' + e, 3);
this.updateProgressCallBack(2, { error: e });
}
}
createNewStudy(projectMetadata, callback) {
try {
this.projectHeader.addNewStudy(projectMetadata.type, (projectMetadata.language || app_repo_constants_1.App_Repository_Constants.defaultLanguage), (response) => {
if (response.result === "ok") {
callback(response.project);
}
});
}
catch (e) {
app_repo_utility_1.App_Repository_Utility.LogText('Import Study> createNewStudy > ' + e, 3);
this.updateProgressCallBack(2, { error: e });
}
}
copyResourceFilesToNewStudy(newProject, destinationPath, callback) {
try {
let dbInfo;
let templatePath;
let i18nResourcePath;
copydir(destinationPath, this.getNewStudyDirectory(newProject), (stat, filepath, filename) => {
if (filename === app_repo_constants_1.App_Repository_Constants.tempFolder.exportPackageMetadataFile) {
dbInfo = JSON.parse(fs.readFileSync(filepath, 'utf8'));
return false;
}
if (path.extname(filepath) === app_repo_constants_1.App_Repository_Constants.fileExtention.db) {
dbInfo = JSON.parse(fs.readFileSync(filepath, 'utf8'));
return false;
}
if (filename === app_repo_constants_1.App_Repository_Constants.tempFolder.exportPackageTemplate) {
templatePath = filepath;
return false;
}
if (filename === app_repo_constants_1.App_Repository_Constants.tempFolder.exportPackageI18n) {
i18nResourcePath = filepath;
return false;
}
if (filename === app_repo_constants_1.App_Repository_Constants.tempFolder.exportPackageInfoFile) {
return false;
}
return true;
}, () => {
callback(dbInfo, templatePath, i18nResourcePath);
});
}
catch (e) {
app_repo_utility_1.App_Repository_Utility.LogText('Import Study> copyResourceFilesToNewStudy > ' + e, 3);
this.updateProgressCallBack(2, { error: e });
}
}
manageProjectI18nResources(filepath, projectMetadata, callback) {
try {
let allLanguages = this.i18nCore.getAllI8nResources();
if (allLanguages[projectMetadata.language]) {
callback();
}
else {
this.updateProgressCallBack(3, { i18n: projectMetadata.language });
return false;
}
}
catch (e) {
app_repo_utility_1.App_Repository_Utility.LogText('Import Study> manageProjectI18nResources > ' + e, 3);
this.updateProgressCallBack(2, { error: e });
}
}
manageProjectTemplates(filepath, projectMetadata, newProject, callback) {
try {
let _requests = 0;
this.template.getAllTemplates((response) => {
if (response.result === "ok") {
let _templates = response.data || [];
let _tFileName;
fs.readdirSync(filepath).forEach(file => {
_tFileName = file.replace(/\.[^/.]+$/, "");
let _t = _.find(_templates, (template) => {
return (template.fileName === _tFileName);
});
if (!_t) {
_requests++;
let _tempData = JSON.parse(app_repo_utility_1.App_Repository_Utility.readFile(path.join(filepath, file)).toString());
let _tempMeta = {};
let _tname = _tFileName;
if (_tname.indexOf("_template_") !== -1) {
_tname = _tname.split("_template_")[0];
}
_tempMeta["name"] = _tname;
_tempMeta["fileName"] = _tFileName;
_tempMeta["type"] = projectMetadata.type;
_tempMeta["language"] = projectMetadata.language;
this.template.writeTemplate(_tempMeta, _tempData, (res) => {
_requests--;
if (res.result === "ok") {
this.updateProjectTemlateInfo(_tFileName, projectMetadata, newProject);
}
if (_requests === 0)
callback();
});
}
else {
this.updateProjectTemlateInfo(_tFileName, projectMetadata, newProject);
}
});
if (_requests === 0)
callback();
}
else {
callback();
}
});
}
catch (e) {
callback();
this.updateProgressCallBack(2, { error: e });
}
}
updateProjectTemlateInfo(fieName, projectMetadata, newProject) {
if (projectMetadata.dblngcoretemplate === fieName) {
newProject.header.dblngcoretemplate = fieName;
}
else {
newProject.header.template = fieName;
}
}
updateDbInfoPaths(newProject, dbInfo, callback) {
try {
let _studyId;
if (dbInfo) {
_studyId = dbInfo._id;
this.updateProgressCallBack(1);
let _newPath = this.getNewStudyDirectory(newProject);
if (dbInfo.datasets && dbInfo.datasets.fileDscr) {
let _dsetFileInfo = dbInfo.datasets.fileDscr;
for (let i = 0; i < _dsetFileInfo.length; i++) {
if (_dsetFileInfo[i].filePath)
_dsetFileInfo[i].filePath = path.join(_newPath, _dsetFileInfo[i].filePath.split(_studyId)[1]);
}
}
if (dbInfo.extResources && dbInfo.extResources.length > 0) {
let allResources = this.getAllExternalResources(dbInfo.extResources);
for (let resource of allResources) {
let resourceProp = resource.resDscr.resDscr.resource;
if (resourceProp && !this.isWebURL(resourceProp) && resourceProp.indexOf(_studyId) !== -1) {
resource.resDscr.resDscr.resource = path.join(_newPath, resourceProp.split(_studyId)[1]);
}
}
}
}
callback();
}
catch (e) {
app_repo_utility_1.App_Repository_Utility.LogText('Import Study> updateDbInfoPaths > ' + e, 3);
this.updateProgressCallBack(2, { error: e });
}
}
getAllExternalResources(resources, resultArray, isRec) {
let resourceArray = resources || new Array();
let resArray = resultArray || new Array();
for (let resource of resourceArray) {
if (_.has(resource, 'resDscr')) {
resArray.push(resource);
}
else if (resource.resources) {
this.getAllExternalResources(resource.resources, resArray, true);
}
}
if (isRec === true) {
return true;
}
return resArray;
}
isWebURL(url) {
let regUrl = /^(((ht|f){1}((tp:|tps:)[/][/]){1})|((www.){1}))[-a-zA-Z0-9@:%_\+.~#?&//=]+$/;
if (regUrl.test(url) == true) {
return true;
}
else {
return false;
}
}
updateStudyInfo(projectMetadata, newProject, dbInfo, callback) {
try {
this.updateProgressCallBack(1);
dbInfo._id = newProject.header._id;
newProject.header.name = projectMetadata.name;
newProject.header.status = model_1.ProjectStatus.saved;
this.projectHeader.saveStudy(newProject.header, dbInfo, (response) => {
if (response.result === "ok") {
this.updateProgressCallBack(1, { project: response.data });
}
else {
this.updateProgressCallBack(2);
}
callback();
});
}
catch (e) {
app_repo_utility_1.App_Repository_Utility.LogText('Import Study> updateStudyInfo > ' + e, 3);
this.updateProgressCallBack(2, { error: e });
}
}
removeTempDirectory(filePath) {
try {
let _path = filePath;
let deleteFolderRecursive = function (_p) {
if (fs.existsSync(_p)) {
fs.readdirSync(_p).forEach(function (file, index) {
let curPath = path.join(_p, file);
if (fs.lstatSync(curPath).isDirectory()) {
deleteFolderRecursive(curPath);
}
else {
fs.unlinkSync(curPath);
}
});
fs.rmdirSync(_p);
}
};
deleteFolderRecursive(_path);
}
catch (e) {
app_repo_utility_1.App_Repository_Utility.LogText('Import Study> removeTempDirectory > ' + e, 3);
return true;
}
}
};
StudyImport = __decorate([
trace_decorator_1.Trace({
exclude: ['updateProgressCallBack'],
params: {
getDDIObject: ['*'],
updateStudyInfo: [2],
updateDbInfoPaths: ['*']
}
})
], StudyImport);
exports.StudyImport = StudyImport;