GovernmentDataResourceCenter/api/app/lib/controllers/latestMetadata/index.js

'use strict';

const moment = require("moment/moment");

//获取资源目录
async function getResourceCatalog(ctx) {
   try {
      const models = ctx.fs.dc.models;
      const rslt = await models.ResourceCatalog.findAll({
         order: [['id', 'asc']],
      });
      ctx.status = 200;
      ctx.body = rslt;
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         "message": "获取资源目录失败"
      }
   }
}
//新建资源目录
async function postResourceCatalog(ctx) {
   try {
      const { name, code } = ctx.request.body;
      const models = ctx.fs.dc.models;
      const postOne = await models.ResourceCatalog.findOne({
         where: { $or: [{ name: name }, { code: code }] }
      });
      if (postOne) {
         ctx.status = 400;
         ctx.body = { message: '该资源目录名称或代码已存在' }
      } else {
         if (!name || !code) {
            ctx.body = { message: '参数不全，请重新配置' }
            ctx.status = 400;
         } else {
            await models.ResourceCatalog.create(ctx.request.body);
            ctx.body = { message: '新建资源目录成功' }
            ctx.status = 200;
         }
      }
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         "message": "新建资源目录失败"
      }
   }
}
//修改资源目录
async function putResourceCatalog(ctx) {
   try {
      const { id } = ctx.params;
      const { name, code, description } = ctx.request.body;
      const models = ctx.fs.dc.models;
      let resourceCatalogInfo = await models.ResourceCatalog.findOne({ where: { id } });
      if (resourceCatalogInfo) {
         const putOne = await models.ResourceCatalog.findOne({ where: { id: { $not: id }, $or: [{ name: name }, { code: code }] } });
         if (putOne) {
            ctx.status = 400;
            ctx.body = { message: '该资源目录名称或代码已存在' }
         } else {
            await models.ResourceCatalog.update(ctx.request.body, { where: { id: id } });
            ctx.status = 200;
            ctx.body = { message: '修改资源目录成功' }
         }
      } else {
         ctx.status = 400;
         ctx.body = { message: '该资源目录不存在' }
      }
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         "message": "修改资源目录失败"
      }
   }
}
//删除资源目录
async function delResourceCatalog(ctx) {
   const transaction = await ctx.fs.dc.orm.transaction();
   try {
      const models = ctx.fs.dc.models;
      const { id } = ctx.params;
      let resourceCatalogInfo = await models.ResourceCatalog.findOne({ where: { id } });
      if (resourceCatalogInfo) {
         let deletable = true;
         let childResourceCatalogInfo = await models.ResourceCatalog.findOne({ where: { parent: id } });
         let databaseInfo = await models.MetadataDatabase.findOne({ where: { catalog: id } });
         let fileInfo = await models.MetadataFile.findOne({ where: { catalog: id } });
         let restapiInfo = await models.MetadataRestapi.findOne({ where: { catalog: id } });
         let dataSourceInfo = await models.DataSource.findOne({ where: { mountPath: id } });
         if (childResourceCatalogInfo || databaseInfo || fileInfo || restapiInfo || dataSourceInfo) {
            ctx.status = 400;
            ctx.body = { message: '存在关联数据，请删除相关数据，再删除该资源目录' }
            deletable = false;
         }
         if (deletable) {
            await models.ResourceCatalog.destroy({
               where: { id: id },
               transaction
            })
            await transaction.commit();
            ctx.status = 200;
            ctx.body = { message: '删除资源目录成功' }
         }
      } else {
         ctx.status = 400;
         ctx.body = { message: '该资源目录不存在' }
      }
   } catch (error) {
      await transaction.rollback();
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = { message: '删除资源目录失败' }
   }
}
//获取库表元数据列表
async function getMetadataDatabases(ctx) {
   try {
      const models = ctx.fs.dc.models;
      const { catalog, limit, offset, keywords, orderBy = 'createAt', orderDirection = 'desc', id = null, resourceId } = ctx.query;
      const where = {};
      if (catalog) {
         where.catalog = catalog;
      }
      if (id) {
         where.parent = id;
      }
      if (resourceId) {
         where.id = resourceId;
      }

      if (keywords) {
         where['$or'] = [{ name: { $iLike: `%${keywords}%` } },
         { code: { $iLike: `%${keywords}%` } },
         { type: { $iLike: `%${keywords}%` } }]
      }
      const findObj = {
         include: [
            {
               model: models.User,
               attributes: ['id', 'name', 'username'],
            },
            {
               model: models.TagDatabase,
               include: [{
                  model: models.Tag,
               }]
            }],
         where: where,
         order: [[orderBy, orderDirection]],
         distinct: true
      }
      if (Number(limit) > 0 && Number(offset) >= 0) {
         findObj.offset = Number(offset) * Number(limit);
         findObj.limit = Number(limit);
      }
      const rslt = await models.MetadataDatabase.findAndCountAll(findObj);
      ctx.status = 200;
      ctx.body = rslt;
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         "message": "获取库表元数据列表失败"
      }
   }
}
//获取文件元数据列表
async function getMetadataFiles(ctx) {
   try {
      const models = ctx.fs.dc.models;
      const { catalog, limit, offset, keywords, orderBy = 'updateAt', orderDirection = 'desc', resourceId } = ctx.query;
      const where = { catalog: catalog };
      //文件类型关键字查询时需匹配fileName不能为空。
      //因存在编辑时将文件删除，但未重新上传直接点击取消的情况，此时文件已删除不可恢复，数据字段fileName更新为null
      if (keywords) {
         where['$or'] = [{ name: { $iLike: `%${keywords}%` } }, { type: { $iLike: `%${keywords}%` }, fileName: { $not: null } }]
      }
      if (resourceId) {
         where.id = resourceId;
      }
      const findObj = {
         include: [
            // {
            //     model: models.User,
            //     attributes: ['id', 'name', 'username'],
            // },
            {
               model: models.TagFile,
               include: [{
                  model: models.Tag,
               }]
            }],
         where: where,
         order: [[orderBy, orderDirection]],
         distinct: true
      };
      if (Number(limit) > 0 && Number(offset) >= 0) {
         findObj.offset = Number(offset) * Number(limit);
         findObj.limit = Number(limit);
      }
      const rslt = await models.MetadataFile.findAndCountAll(findObj);
      ctx.status = 200;
      ctx.body = rslt;
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         "message": "获取文件元数据列表失败"
      }
   }
}
//获取接口元数据列表
async function getMetadataRestapis(ctx) {
   try {
      const models = ctx.fs.dc.models;
      const { catalog, limit, offset, keywords, orderBy = 'createAt', orderDirection = 'desc', resourceId } = ctx.query;
      const where = { catalog: catalog };
      if (keywords) {
         where.name = { $iLike: `%${keywords}%` };
      }
      if (resourceId) {
         where.id = resourceId;
      }
      const findObj = {
         include: [
            {
               model: models.User,
               attributes: ['id', 'name', 'username'],
            },
            {
               model: models.TagRestapi,
               include: [{
                  model: models.Tag,
               }]
            }],
         where: where,
         order: [[orderBy, orderDirection]],
         distinct: true
      };
      if (Number(limit) > 0 && Number(offset) >= 0) {
         findObj.offset = Number(offset) * Number(limit);
         findObj.limit = Number(limit);
      }
      const rslt = await models.MetadataRestapi.findAndCountAll(findObj);
      ctx.status = 200;
      ctx.body = rslt;
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         "message": "获取接口元数据列表失败"
      }
   }
}
//获取元数据模型
async function getMetadataModels(ctx) {
   try {
      const models = ctx.fs.dc.models;
      const { modelTypes } = ctx.query;
      let rslt = [];
      if (modelTypes) {
         rslt = await models.MetaModel.findAll({
            where: {
               modelType: { $in: modelTypes.split(',') }
            }
         });
      }
      ctx.status = 200;
      ctx.body = rslt;
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         "message": "获取元数据模型失败"
      }
   }
}

//新建库表元数据
async function postMetadataDatabases(ctx) {
   try {
      const { name, code, catalog, parent } = ctx.request.body;
      const models = ctx.fs.dc.models;
      const where = { $or: [{ name: name }, { code: code }] };
      if (parent) {
         where.parent = parent;
      } else {
         where.parent = null;
         where.catalog = catalog;
      }
      const postOne = await models.MetadataDatabase.findOne({
         where: where
      });
      if (postOne) {
         ctx.status = 400;
         ctx.body = { message: '同一父节点下该元数据名称或代码已存在' }
      } else {
         if (!name || !code || !catalog) {
            ctx.body = { message: '参数不全，请重新配置' }
            ctx.status = 400;
         } else {
            await models.MetadataDatabase.create({ createAt: moment(), ...ctx.request.body });
            ctx.body = { message: '新建元数据成功' }
            ctx.status = 200;
         }
      }
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         "message": "新建元数据失败"
      }
   }
}

//修改库表元数据
async function putMetadataDatabases(ctx) {
   try {
      const { id } = ctx.params;
      const { catalog, name, code } = ctx.request.body;
      const models = ctx.fs.dc.models;
      let metadataDatabaseInfo = await models.MetadataDatabase.findOne({ where: { id } });
      if (metadataDatabaseInfo) {
         const where = { id: { $not: id }, $or: [{ name: name }, { code: code }] }
         if (metadataDatabaseInfo.parent) {
            where.parent = metadataDatabaseInfo.parent;
         } else {
            where.parent = null;
            where.catalog = catalog;
         }
         const putOne = await models.MetadataDatabase.findOne({ where: where });
         if (putOne) {
            ctx.status = 400;
            ctx.body = { message: '同一父节点下该元数据名称或代码已存在' }
         } else {
            await models.MetadataDatabase.update({ updateAt: moment(), ...ctx.request.body }, { where: { id: id } });
            ctx.status = 200;
            ctx.body = { message: '修改元数据成功' }
         }
      } else {
         ctx.status = 400;
         ctx.body = { message: '该元数据不存在' }
      }
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         "message": "修改元数据失败"
      }
   }
}
//删除库表元数据
async function delMetadataDatabases(ctx) {
   const transaction = await ctx.fs.dc.orm.transaction();
   try {
      const models = ctx.fs.dc.models;
      const { id } = ctx.params;
      let metadataDatabaseInfo = await models.MetadataDatabase.findOne({ where: { id } });
      if (metadataDatabaseInfo) {
         let deletable = true;
         let childMetadataDatabaseInfo = await models.MetadataDatabase.findOne({ where: { parent: id } });
         if (childMetadataDatabaseInfo) {
            ctx.status = 400;
            ctx.body = { message: '存在关联子类元数据，请删除相关数据，再删除该元数据' }
            deletable = false;
         } else {
            let tagDatabaseInfo = await models.TagDatabase.findOne({ where: { database: id } });
            if (tagDatabaseInfo) {
               ctx.status = 400;
               ctx.body = { message: '该元数据已被打标' }
               deletable = false;
            } else {
               let resourceConsumptionInfo = await models.ResourceConsumption.findOne({
                  where: {
                     resourceId: id,
                     resourceName: metadataDatabaseInfo.name,
                     resourceType: '库表'
                  }
               });
               if (resourceConsumptionInfo) {
                  ctx.status = 400;
                  ctx.body = { message: '该元数据存在资源申请' }
                  deletable = false;
               }
            }
         }
         if (deletable) {
            await models.MetadataDatabase.destroy({
               where: { id: id },
               transaction
            })
            await transaction.commit();
            ctx.status = 200;
            ctx.body = { message: '删除元数据成功' }
         }
      } else {
         ctx.status = 400;
         ctx.body = { message: '该元数据不存在' }
      }
   } catch (error) {
      await transaction.rollback();
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = { message: '删除元数据失败' }
   }
}
//获取库表元数据基本信息
async function getMetadataDatabasesById(ctx) {
   try {
      const models = ctx.fs.dc.models;
      const { id } = ctx.params;
      const findObj = {
         include: [
            {
               model: models.User,
               attributes: ['id', 'name', 'username'],
            },
            {
               model: models.TagDatabase,
               include: [{
                  model: models.Tag,
               }]
            }],
         where: { id: id },
      }
      const rslt = await models.MetadataDatabase.findOne(findObj);
      ctx.status = 200;
      ctx.body = rslt;
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         "message": "获取元数据基本信息失败"
      }
   }
}

//打标元数据
async function postTagMetadata(ctx) {
   const transaction = await ctx.fs.dc.orm.transaction();
   try {
      const { tags, database, file, restapi } = ctx.request.body;
      const models = ctx.fs.dc.models;
      if (tags.length && (database || file || restapi)) {
         if (database) {
            await models.TagDatabase.destroy({ where: { database: database }, transaction });
            const data = tags.map(tag => { return { tagId: tag, database: database } });
            if (data.length)
               await models.TagDatabase.bulkCreate(data, { transaction });
         }
         if (file) {
            await models.TagFile.destroy({ where: { file: file }, transaction });
            const data = tags.map(tag => { return { tagId: tag, file: file } });
            if (data.length)
               await models.TagFile.bulkCreate(data, { transaction });
         }
         if (restapi) {
            await models.TagRestapi.destroy({ where: { restapi: restapi }, transaction });
            const data = tags.map(tag => { return { tagId: tag, restapi: restapi } });
            if (data.length)
               await models.TagRestapi.bulkCreate(data, { transaction });
         }
         await transaction.commit();
         ctx.status = 204;
      } else {
         ctx.body = { message: '参数不全，请重新配置' }
         ctx.status = 400;
      }
   } catch (error) {
      await transaction.rollback();
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         "message": "打标元数据失败"
      }
   }
}

//获取元数据已打标数据
async function getTagMetadata(ctx) {
   try {
      const models = ctx.fs.dc.models;
      const { id } = ctx.params;
      const { type } = ctx.query;
      let rslt = [];
      if (type === 'database') {
         rslt = await models.Tag.findAll({
            where: { '$tagDatabases.database$': id },
            include: [{
               model: models.TagDatabase,
            }],
            order: [['id', 'asc']],
         });
      }
      if (type === 'file') {
         rslt = await models.Tag.findAll({
            where: { '$tagFiles.file$': id },
            include: [{
               model: models.TagFile,
            }],
            order: [['id', 'asc']],
         });
      }
      if (type === 'restapi') {
         rslt = await models.Tag.findAll({
            where: { '$tagRestapis.restapi$': id },
            include: [{
               model: models.TagRestapi,
            }],
            order: [['id', 'asc']],
         });
      }
      ctx.status = 200;
      ctx.body = rslt;
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         "message": "获取元数据已打标数据失败"
      }
   }
}
//申请资源
async function postMetadataResourceApplications(ctx) {
   try {
      const { resourceName, applyBy, resourceType, resourceId } = ctx.request.body;
      if (!resourceName || !applyBy || !resourceType || !resourceId) {
         ctx.status = 400;
         ctx.body = { message: '参数不全，请重新申请资源' }
      } else {
         const models = ctx.fs.dc.models;
         const postOne = await models.ResourceConsumption.findOne({
            where: { applyBy: applyBy, resourceName: resourceName, resourceId, resourceType, approve_remarks: null }
         });
         if (postOne) {
            ctx.status = 400;
            ctx.body = { message: '该用户已申请过该元数据资源' }
         } else {
            await models.ResourceConsumption.create({ applyAt: moment(), approveState: '审批中', ...ctx.request.body });
            ctx.body = { message: '申请资源成功' }
            ctx.status = 200;
         }
      }
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         "message": "申请资源失败"
      }
   }
}

//获取元数据资源申请记录
async function getMetadataResourceApplications(ctx) {
   try {
      const models = ctx.fs.dc.models;
      const { resourceNames, type } = ctx.query;
      let rslt = [];
      if (resourceNames && type) {
         rslt = await models.ResourceConsumption.findAll({
            where: { resourceName: { $in: resourceNames.split(',') }, resourceType: type }
         });
      }
      ctx.status = 200;
      ctx.body = rslt;
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         "message": "获取元数据资源申请记录失败"
      }
   }
}

//新建文件元数据
async function postMetadataFiles(ctx) {
   try {
      const { name, catalog, type, fileName } = ctx.request.body;
      const models = ctx.fs.dc.models;
      const postOne = await models.MetadataFile.findOne({
         where: { name: name, catalog: catalog }
      });
      if (postOne) {
         ctx.status = 400;
         ctx.body = { message: '该资源目录下元数据名称已存在' }
      } else {
         if (!name || !catalog || !type || !fileName) {
            ctx.body = { message: '参数不全，请重新配置' }
            ctx.status = 400;
         } else {
            await models.MetadataFile.create({ createAt: moment(), ...ctx.request.body });
            ctx.body = { message: '新建元数据成功' }
            ctx.status = 200;
         }
      }
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         "message": "新建元数据失败"
      }
   }
}
//修改文件元数据
async function putMetadataFiles(ctx) {
   try {
      const { id } = ctx.params;
      const { updateFileName } = ctx.query;
      const { catalog, name, type } = ctx.request.body;
      const models = ctx.fs.dc.models;
      let metadataFileInfo = await models.MetadataFile.findOne({ where: { id } });
      if (metadataFileInfo) {
         if (updateFileName) {//编辑时，将文件删除，后又取消，则更新文件名为null
            await models.MetadataFile.update({ updateAt: moment(), fileName: null }, { where: { id: id } });
            ctx.status = 204;
         } else {
            if (!name || !catalog || !type) {
               ctx.body = { message: '参数不全，请重新配置' }
               ctx.status = 400;
            } else {
               const putOne = await models.MetadataFile.findOne({ where: { id: { $not: id }, catalog: catalog, name: name } });
               if (putOne) {
                  ctx.status = 400;
                  ctx.body = { message: '该元数据名称已存在' }
               } else {
                  await models.MetadataFile.update({ updateAt: moment(), ...ctx.request.body }, { where: { id: id } });
                  ctx.status = 200;
                  ctx.body = { message: '修改元数据成功' }
               }
            }
         }
      } else {
         ctx.status = 400;
         ctx.body = { message: '该元数据不存在' }
      }
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         "message": "修改元数据失败"
      }
   }
}
//删除文件元数据
async function delMetadataFiles(ctx) {
   const transaction = await ctx.fs.dc.orm.transaction();
   try {
      const models = ctx.fs.dc.models;
      const { id } = ctx.params;
      let metadataFileInfo = await models.MetadataFile.findOne({ where: { id } });
      if (metadataFileInfo) {
         let deletable = true;
         let tagFileInfo = await models.TagFile.findOne({ where: { file: id } });
         if (tagFileInfo) {
            ctx.status = 400;
            ctx.body = { message: '该元数据已被打标' }
            deletable = false;
         } else {
            let resourceConsumptionInfo = await models.ResourceConsumption.findOne({
               where: {
                  resourceName: metadataFileInfo.name,
                  resourceType: '文件'
               }
            });
            if (resourceConsumptionInfo) {
               ctx.status = 400;
               ctx.body = { message: '该元数据存在资源申请' }
               deletable = false;
            }
         }
         if (deletable) {
            await models.MetadataFile.destroy({
               where: { id: id },
               transaction
            })
            await transaction.commit();
            ctx.status = 200;
            ctx.body = { message: '删除元数据成功' }
         }
      } else {
         ctx.status = 400;
         ctx.body = { message: '该元数据不存在' }
      }
   } catch (error) {
      await transaction.rollback();
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = { message: '删除元数据失败' }
   }
}

//新建接口元数据
async function postMetadataRestapis(ctx) {
   try {
      const { name, catalog, method, url } = ctx.request.body;
      const models = ctx.fs.dc.models;
      const postOne = await models.MetadataRestapi.findOne({
         where: { name: name, catalog: catalog }
      });
      if (postOne) {
         ctx.status = 400;
         ctx.body = { message: '该资源目录下元数据名称已存在' }
      } else {
         if (!name || !catalog || !method || !url) {
            ctx.body = { message: '参数不全，请重新配置' }
            ctx.status = 400;
         } else {
            await models.MetadataRestapi.create({ createAt: moment(), ...ctx.request.body });
            ctx.body = { message: '新建元数据成功' }
            ctx.status = 200;
         }
      }
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         "message": "新建元数据失败"
      }
   }
}

//修改接口元数据
async function putMetadataRestapis(ctx) {
   try {
      const { id } = ctx.params;
      const { catalog, name, method, url } = ctx.request.body;
      const models = ctx.fs.dc.models;
      let metadataRestapiInfo = await models.MetadataRestapi.findOne({ where: { id } });
      if (metadataRestapiInfo) {
         if (!name || !catalog || !method || !url) {
            ctx.body = { message: '参数不全，请重新修改' }
            ctx.status = 400;
         } else {
            const putOne = await models.MetadataRestapi.findOne({ where: { id: { $not: id }, catalog: catalog, name: name } });
            if (putOne) {
               ctx.status = 400;
               ctx.body = { message: '该元数据名称已存在' }
            } else {
               await models.MetadataRestapi.update({ updateAt: moment(), ...ctx.request.body }, { where: { id: id } });
               ctx.status = 200;
               ctx.body = { message: '修改元数据成功' }
            }
         }
      } else {
         ctx.status = 400;
         ctx.body = { message: '该元数据不存在' }
      }
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         "message": "修改元数据失败"
      }
   }
}
//删除接口元数据
async function delMetadataRestapis(ctx) {
   const transaction = await ctx.fs.dc.orm.transaction();
   try {
      const models = ctx.fs.dc.models;
      const { id } = ctx.params;
      let metadataRestapiInfo = await models.MetadataRestapi.findOne({ where: { id } });
      if (metadataRestapiInfo) {
         let deletable = true;
         let tagRestapiInfo = await models.TagRestapi.findOne({ where: { restapi: id } });
         if (tagRestapiInfo) {
            ctx.status = 400;
            ctx.body = { message: '该元数据已被打标' }
            deletable = false;
         } else {
            let resourceConsumptionInfo = await models.ResourceConsumption.findOne({
               where: {
                  resourceName: metadataRestapiInfo.name,
                  resourceType: '接口'
               }
            });
            if (resourceConsumptionInfo) {
               ctx.status = 400;
               ctx.body = { message: '该元数据存在资源申请' }
               deletable = false;
            }
         }
         if (deletable) {
            await models.MetadataRestapi.destroy({
               where: { id: id },
               transaction
            })
            await transaction.commit();
            ctx.status = 200;
            ctx.body = { message: '删除元数据成功' }
         }
      } else {
         ctx.status = 400;
         ctx.body = { message: '该元数据不存在' }
      }
   } catch (error) {
      await transaction.rollback();
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = { message: '删除元数据失败' }
   }
}

//获取对表的库与字段信息
async function listStructuredData(ctx) {
   try {
      const models = ctx.fs.dc.models;
      const { id, parent } = ctx.query;

      let field = await models.MetadataDatabase.findAll({ where: { parent: id } }) || []
      let database = await models.MetadataDatabase.findOne({ where: { id: parent } }) || {}

      ctx.status = 200;
      ctx.body = {
         field: field,
         database: database
      };
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         "message": "获取元数据资源申请记录失败"
      }
   }
}

//发布REST服务
async function publishingServices (ctx) {
   let message = "发布REST服务失败"
   try {
      const models = ctx.fs.dc.models;
      const data = ctx.request.body;
      const { method, url } = data


      const postOne = await models.RestfulApi.findOne({ where: { method: method, url: url } });
      if (postOne) {
         message = '路由和请求方式重复'
         throw ''
      }

      await models.RestfulApi.create(data)

      ctx.body = { message: '发布REST服务成功' }
      ctx.status = 200;

   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         "message": message
      }
   }
}
module.exports = {
   getResourceCatalog,
   postResourceCatalog,
   putResourceCatalog,
   delResourceCatalog,
   getMetadataDatabases,
   getMetadataFiles,
   getMetadataRestapis,
   getMetadataModels,
   postMetadataDatabases,
   putMetadataDatabases,
   delMetadataDatabases,
   getMetadataDatabasesById,
   postTagMetadata,
   getTagMetadata,
   postMetadataResourceApplications,
   getMetadataResourceApplications,
   postMetadataFiles,
   putMetadataFiles,
   delMetadataFiles,
   postMetadataRestapis,
   putMetadataRestapis,
   delMetadataRestapis,
   listStructuredData,
   publishingServices
}