ConstructionOperation/modules/users/controllers/compilation_controller.js

/**
 * 编办控制控制器
 *
 * @author CaiAoLin
 * @date 2017/7/28
 * @compilation
 */
import BaseController from "../../common/base/base_controller";
import CompilationModel from "../models/compilation_model";
import STDRationLibMapModel from "../../common/std/std_ration_lib_map_model";
import STDBillLibListsModel from "../../common/std/std_bills_lib_lists_model";
import STDGLJLibMapModel from "../../common/std/std_glj_lib_map_model";
import STDFeeRateLibsModel from "../../common/std/std_fee_rate_libs_model";
import {
  default as EngineeringConst,
  List as EngineeringList,
} from "../../common/const/engineering";
import BillsTemplateModel from "../models/bills_template_model";
import {
  default as BillsFixedFlagConst,
  List as BillsFixedFlagList,
} from "../../common/const/bills_fixed.js";
import {
  default as BillsTypeFlagConst,
  List as BillsTypeFlagList,
} from "../../common/const/bills_type.js";
import EngineeringLibModel from "../models/engineering_lib_model";
import STDLabourCoesModel from "../../common/std/std_labour_coes_model";
import STDCalcProgramModel from "../../common/std/std_calc_program_model";
const billsGuidanceFc = require("../../std_billsGuidance_lib/facade/facades");
import mainColFacade from "../../main_col_lib/facade/main_col_facade";
import billTemplateFacade from "../../bills_template_lib/facade/bills_template_facade";
import projectFeatureFacade from "../../project_feature_lib/facade/project_feature_facade";
import basicInfoFacade from "../../basic_info_lib/facade/basic_info_facade";
import engineerInfoFacade from "../../engineer_info_lib/facade/engineer_info_facade";
import engineerFeatureFacade from "../../engineer_feature_lib/facade/engineer_feature_facade";
import materialFacade from "../../material_lib/facade/material_facade";
import quantityFacade from "../../main_quantity_lib/facade/quantity_facade";
import economicFacade from "../../economic_lib/facade/economic_facade";
import overHeightFacade from "../../over_height_lib/facade/over_height_facade";
import progressiveFacade from "../../progressive_interval_lib/facade/progressive_facade";
import {
  default as category,
  List as categoryList,
} from "../../common/const/category_const.js";
import locationList from "../../common/const/locationList";

let config = require("../../../config/config.js");
const fs = require("fs");
let _ = require("lodash");

class CompilationController extends BaseController {
  /**
   * 编办管理控制页面
   *
   * @param {object} request
   * @param {object} response
   * @return {void}
   */
  async index(request, response) {
    let id = request.query.id;

    let compilationList = [];
    let selectedCompilation = {};
    try {
      let compilationModel = new CompilationModel();
      compilationList = await compilationModel.getCompilationList();

      if (compilationList.length <= 0) {
        throw "没有数据";
      }
      // 循环查找数据
      for (let tmp of compilationList) {
        if (tmp._id.toString() === id) {
          selectedCompilation = tmp;
          break;
        }
      }

      selectedCompilation =
        Object.keys(selectedCompilation).length <= 0
          ? compilationList[0]
          : selectedCompilation;
      request.session.selectedCompilation = selectedCompilation;
    } catch (error) {
      console.log(error);
    }
    if (
      selectedCompilation.example &&
      Array.isArray(selectedCompilation.example)
    ) {
      selectedCompilation.example = selectedCompilation.example.join(";");
    }
    let renderData = {
      id: id,
      compilationList: compilationList,
      categoryList: categoryList,
      locationList: locationList,
      selectedCompilation: selectedCompilation,
      layout: "users/views/layout/layout",
      LicenseKey: config.getLicenseKey(process.env.NODE_ENV),
    };

    response.render("users/views/compilation/index", renderData);
  }

  /**
   * 新增计价页面
   *
   * @param {object} request
   * @param {object} response
   * @return {void}
   */
  async addValuation(request, response) {
    let name = request.body.name;
    let id = request.body.id;
    let section = request.body.section;

    let responseData = {
      err: 0,
      msg: "",
    };
    try {
      if (id === undefined || id === "") {
        throw "参数错误";
      }

      let insertData = {
        name: name,
      };

      let compilationModel = new CompilationModel();
      let valuationId = await compilationModel.addValuation(
        id,
        section,
        insertData
      );
      if (!valuationId) {
        throw "新增计价规则失败";
      }
      //添加标准工程专业  2018-08-24 不自动添加标准工程了
      /*let engineeringLibModel = new EngineeringLibModel();
            let stdEngs = await engineeringLibModel.addStdLib(valuationId);
            console.log(stdEngs);*/
    } catch (error) {
      console.log(error);
      responseData.err = 1;
      responseData.msg = error;
    }

    response.json(responseData);
  }

  /**
   * 修改计价规则页面
   *
   * @param {object} request
   * @param {object} response
   * @return {void}
   */
  async editValuation(request, response) {
    let selectedCompilation = request.session.selectedCompilation;
    let valuationId = request.params.id;
    let section = request.params.section;

    let compilationList = [];
    let engineeringList = [];
    let valuationData = {};
    let valuationList = {};
    try {
      let compilationModel = new CompilationModel();
      compilationList = await compilationModel.getCompilationList();

      // 获取对应的计价规则数据
      [valuationData, valuationList] = await compilationModel.getValuation(
        selectedCompilation._id,
        valuationId,
        section
      );
      if (Object.keys(valuationData).length <= 0) {
        throw "不存在数据";
      }

      // 获取计价规则中对应的标准库数据
      let engineeringLibModel = new EngineeringLibModel();
      engineeringList = await engineeringLibModel.getLibsByValuationID(
        valuationId
      );
      engineeringList = _.sortBy(engineeringList, ["seq"]);
    } catch (error) {
      console.log(error);
    }

    let renderData = {
      compilationList: compilationList,
      engineeringList: engineeringList,
      selectedCompilation: selectedCompilation,
      valuationData: valuationData,
      valuationList: valuationList,
      valuationId: valuationId,
      section: section,
      layout: "users/views/layout/layout",
      LicenseKey: config.getLicenseKey(process.env.NODE_ENV),
    };
    response.render("users/views/compilation/add", renderData);
  }

  /**
   * 编辑工程专业页面
   *
   * @param {object} request
   * @param {object} response
   * @return {void}
   */
  async editEngineering(request, response) {
    let engineerID = request.params.engineerID;
    let valuationId = request.params.id;
    let section = request.params.section;
    let selectedCompilation = request.session.selectedCompilation;

    let compilationList = [],
      billList = [],
      rationList = [],
      gljList = [],
      feeRateList = [],
      libData = {},
      billsTemplateData = [],
      featureList = [],
      infoList = [],
      engineerInfoList = [],
      progressiveList = [],
      engineerFeatureList = [],
      materialList = [],
      mainQuantityList = [],
      economicList = [],
      overHeightList = [];
    let valuationData = {},
      valuationList = {},
      artificialCoefficientList = [],
      calculationList = [],
      billsGuidanceList = [],
      mainTreeColList = [];
    let billTemplateList = [];
    try {
      let compilationModel = new CompilationModel();
      compilationList = await compilationModel.getCompilationList();

      // 获取标准清单，不绑定编办
      let stdBillLibListsModel = new STDBillLibListsModel();
      billList = await stdBillLibListsModel.getBillList();

      // 获取定额库
      let stdRationLibMapModel = new STDRationLibMapModel();
      //rationList = await stdRationLibMapModel.getRationLib(selectedCompilation._id);
      rationList = await stdRationLibMapModel.getAllRationLibs();

      // 获取工料机库
      let stdGLJLibMapModel = new STDGLJLibMapModel();
      gljList = await stdGLJLibMapModel.getAllGLJLibList();

      // 获取费率标准库
      let stdFeeRateLibsModel = new STDFeeRateLibsModel();
      feeRateList = await stdFeeRateLibsModel.getFeeRateList(
        selectedCompilation._id
      );

      // 获取人工系数标准库
      let stdLabourCoesModel = new STDLabourCoesModel();
      artificialCoefficientList = await stdLabourCoesModel.getLabourCoesList();

      // 获取计算程序库
      let stdCalcProgramModel = new STDCalcProgramModel();
      calculationList = await stdCalcProgramModel.getProgramList(
        selectedCompilation._id
      );

      //获取列设置库
      mainTreeColList = await mainColFacade.getColLibsByCompilationID(
        selectedCompilation._id
      );

      //获取清单模板库
      billTemplateList = await billTemplateFacade.getTemplateLibByCompilationID(
        selectedCompilation._id
      );

      // 获取对应的计价规则数据
      [valuationData, valuationList] = await compilationModel.getValuation(
        selectedCompilation._id,
        valuationId,
        section
      );
      if (Object.keys(valuationData).length <= 0) {
        throw "不存在数据";
      }

      // 获取对应专业工程下的标准库数据
      let engineeringLibModel = new EngineeringLibModel();
      libData = await engineeringLibModel.findDataByCondition({
        _id: engineerID,
      });

      // 获取清单模板数据
      let billsTemplateModel = new BillsTemplateModel();
      billsTemplateData = await billsTemplateModel.getTemplateData(
        valuationId,
        libData.engineering
      );

      //获取清单指引数据
      billsGuidanceList = await billsGuidanceFc.getBillsGuideLibs({
        compilationId: selectedCompilation._id,
        $or: [{ deleted: null }, { deleted: false }],
      });

      //获取工程特征库
      featureList = await projectFeatureFacade.findByCondition(
        { compilationId: selectedCompilation._id },
        null,
        false
      );

      //获取基本信息库
      infoList = await basicInfoFacade.findByCondition({}, null, false);

      engineerInfoList = await engineerInfoFacade.findByCondition(
        {},
        null,
        false
      );

      //获取累进区间库
      progressiveList = await progressiveFacade.findByCondition(
        {},
        null,
        false
      );

      //工程特征指标库
      engineerFeatureList = await engineerFeatureFacade.findByCondition(
        {},
        null,
        false
      );

      //主要工料指标
      materialList = await materialFacade.findByCondition({}, null, false);

      //主要工程量指标
      mainQuantityList = await quantityFacade.findByCondition({}, null, false);

      //主要工程量指标
      economicList = await economicFacade.findByCondition({}, null, false);

      //超高降效
      overHeightList = await overHeightFacade.findByCondition({}, null, false);
    } catch (error) {
      console.log(error);
    }
    //example Array to example String
    if (
      selectedCompilation.example &&
      Array.isArray(selectedCompilation.example)
    ) {
      selectedCompilation.example = selectedCompilation.example.join(";");
    }
    let renderData = {
      section: section,
      valuationId: valuationId,
      compilationList: compilationList,
      selectedCompilation: selectedCompilation,
      libData: libData,
      billList: JSON.stringify(billList),
      rationList: JSON.stringify(rationList),
      gljList: JSON.stringify(gljList),
      artificialCoefficientList: JSON.stringify(artificialCoefficientList),
      feeRateList: JSON.stringify(feeRateList),
      billsTemplateData: JSON.stringify(billsTemplateData),
      billTemplateList: JSON.stringify(billTemplateList),
      mainTreeColList: JSON.stringify(mainTreeColList),
      gljCol: JSON.stringify(libData.glj_col),
      calculationList: JSON.stringify(calculationList),
      billsGuidanceList: JSON.stringify(billsGuidanceList),
      featureList: JSON.stringify(featureList),
      infoList: JSON.stringify(infoList),
      engineerInfoList: JSON.stringify(engineerInfoList),
      progressiveList: JSON.stringify(progressiveList),
      engineerFeatureList: JSON.stringify(engineerFeatureList),
      materialList: JSON.stringify(materialList),
      mainQuantityList: JSON.stringify(mainQuantityList),
      economicList: JSON.stringify(economicList),
      overHeightList: JSON.stringify(overHeightList),
      layout: "users/views/layout/layout",
      LicenseKey: config.getLicenseKey(process.env.NODE_ENV),
    };
    response.render("users/views/compilation/engineering", renderData);
  }

  /**
   * 保存工程专业标准库
   *
   * @param {object} request
   * @param {object} response
   * @return {void}
   */
  async saveEngineering(request, response) {
    let engineerId = request.body.id;

    try {
      if (engineerId === "") {
        throw "id参数错误";
      }

      // 先存入工程专业标准库表
      let engineeringLibModel = new EngineeringLibModel();
      let result = await engineeringLibModel.addLib(engineerId, request.body);
      console.log(result);
      if (!result) {
        throw "保存失败";
      }
    } catch (error) {
      console.log(error);
    }

    response.redirect(request.headers.referer);
  }

  /**
   * 通过工程专业ID删除工程专业
   * @param request
   * @param response
   * @returns {Promise.<void>}
   */
  async deleteEngineer(request, response) {
    let result = {
      error: 0,
    };
    try {
      let data = request.body.data;
      data = JSON.parse(data);
      if (data.id) {
        let engineeringLibModel = new EngineeringLibModel();
        result.data = await engineeringLibModel.deleteById(data.id, true);
      } else {
        throw new Error("提交数据有误");
      }
    } catch (err) {
      console.log(err);
      result.error = 1;
      result.message = err.message;
    }
    response.json(result);
  }

  /**
   * 通过工程专业ID拷贝工程专业
   * @param request
   * @param response
   * @returns {Promise.<void>}
   */
  async copyEngineer(request, response) {
    let result = {
      error: 0,
    };
    try {
      let data = request.body.data;
      data = JSON.parse(data);
      if (data.id) {
        let engineeringLibModel = new EngineeringLibModel();
        result.data = await engineeringLibModel.copyEngineer(data.id);
      } else {
        throw new Error("提交数据有误");
      }
    } catch (err) {
      console.log(err);
      result.error = 1;
      result.message = err.message;
    }
    response.json(result);
  }

  /**
   * 修改保存工程专业信息-用于异步操作
   * @param request
   * @param response
   * @returns {Promise.<void>}
   */
  async updateEngineer(request, response) {
    let result = {
      error: 0,
    };
    try {
      let data = request.body.data;
      data = JSON.parse(data);
      if (data.id && data.updateData) {
        let engineeringLibModel = new EngineeringLibModel();
        result.data = await engineeringLibModel.updateById(
          data.id,
          data.updateData
        );
      } else {
        throw new Error("提交数据有误");
      }
    } catch (err) {
      console.log(err);
      result.error = 1;
      result.message = err.message;
    }
    response.json(result);
  }

  /**
   * 保存计价规则
   *
   * @param {object} request
   * @param {object} response
   * @return {void}
   */
  async saveValuation(request, response) {
    let valuationId = request.body.id;
    try {
      if (valuationId === "") {
        throw "id参数错误";
      }

      let compilationModel = new CompilationModel();
      let result = await compilationModel.saveValuation(
        valuationId,
        request.body
      );
      if (!result) {
        throw "保存失败";
      }
    } catch (error) {
      console.log(error);
    }

    response.redirect(request.headers.referer);
  }

  /**
   * 删除计价规则
   *
   * @param {object} request
   * @param {object} response
   * @return {void}
   */
  async deleteValuation(request, response) {
    let id = request.params.id;
    let section = request.params.section;
    let selectedCompilation = request.session.selectedCompilation;

    try {
      if (
        id === undefined ||
        id === "" ||
        section === undefined ||
        section === ""
      ) {
        throw "参数错误";
      }

      //先删除对应的工程专业
      let engineeringLibModel = new EngineeringLibModel();
      await engineeringLibModel.deleteByValuationID(id);

      //删除计价规则
      let compilationModel = new CompilationModel();
      let result = compilationModel.deleteValuation(
        selectedCompilation._id,
        id,
        section
      );
      if (!result) {
        throw "删除失败";
      }
    } catch (error) {
      console.log(error);
    }

    response.redirect(request.headers.referer);
  }

  /**
   * 快速切换启用/禁用
   *
   * @param {object} request
   * @param {object} response
   * @return {void}
   */
  async enableSwitch(request, response) {
    let id = request.body.id;
    let section = request.params.section;
    let enable = request.body.enable;

    let responseData = {
      err: 0,
      msg: "",
    };
    try {
      let compilationModel = new CompilationModel();
      let result = await compilationModel.switchEnable(id, section, enable);

      if (!result) {
        throw "新增编办失败";
      }
    } catch (error) {
      console.log(error);
      responseData.err = 1;
      responseData.msg = error;
    }

    response.json(responseData);
  }

  /**
   * 设置计价规则适用类型
   *
   * @param {object} request
   * @param {object} response
   * @return {void}
   */
  async setFileTypes(request, response) {
    let id = request.body.id;
    let section = request.params.section;
    let fileTypes = request.body.fileTypes;

    let responseData = {
      err: 0,
      msg: "",
    };
    try {
      let compilationModel = new CompilationModel();
      let result = await compilationModel.setFileTypes(id, section, fileTypes);

      if (!result) {
        throw "设置类型失败";
      }
    } catch (error) {
      console.log(error);
      responseData.err = 1;
      responseData.msg = error;
    }

    response.json(responseData);
  }

  /**
   * 发布/取消编办
   *
   * @param {object} request
   * @param {object} response
   * @return {void}
   */
  async release(request, response) {
    let id = request.body.id;
    let release = request.body.status;
    release = parseInt(release);

    let responseData = {
      err: 0,
      msg: "",
    };
    try {
      let compilationModel = new CompilationModel();
      let result = await compilationModel.release(id, release);

      if (!result) {
        throw "发布编办失败";
      }
    } catch (error) {
      console.log(error);
      responseData.err = 1;
      responseData.msg = error;
    }

    response.json(responseData);
  }

  /**
   * 新增编办操作
   *
   * @param {object} request
   * @param {object} response
   * @return {void}
   */
  async addCompilation(request, response) {
    let name = request.body.name;
    let responseData = {
      err: 0,
      msg: "",
    };
    try {
      let sessionManager = request.session.managerData;
      let insertData = {
        name: name,
        creator: sessionManager.userID,
      };

      let compilationModel = new CompilationModel();
      let result = await compilationModel.add(insertData);

      if (!result) {
        throw "新增编办失败";
      }
    } catch (error) {
      console.log(error);
      responseData.err = 1;
      responseData.msg = error;
    }

    response.json(responseData);
  }

  async setDescription(request, response) {
    let compilationId = request.body.id;
    let description = request.body.description;
    try {
      let compilationModel = new CompilationModel();
      await compilationModel.setDescription(compilationId, description);
      response.json({ err: 0, msg: "", data: null });
    } catch (err) {
      response.json({ err: 1, msg: err, data: null });
    }
  }
  async setEdition(request, response) {
    let compilationId = request.body.id;
    let edition = request.body.edition;
    try {
      let compilationModel = new CompilationModel();
      await compilationModel.setEdition(compilationId, edition);
      response.json({ err: 0, msg: "", data: null });
    } catch (err) {
      response.json({ err: 1, msg: err, data: null });
    }
  }
  async setSerialNumber(request, response) {
    let compilationId = request.body.id;
    let serialNumber = request.body.serialNumber;
    try {
      let compilationModel = new CompilationModel();
      await compilationModel.setSerialNumber(compilationId, serialNumber);
      response.json({ err: 0, msg: "", data: null });
    } catch (err) {
      response.json({ err: 1, msg: err, data: null });
    }
  }
  async setOverWriteUrl(request, response) {
    let compilationId = request.body.id;
    let overWriteUrl = request.body.overWriteUrl;
    try {
      let compilationModel = new CompilationModel();
      //绝对路径
      let absoluteUrl = request.app.locals.rootDir + overWriteUrl;
      //文件是否存在
      let fileExists = fs.existsSync(absoluteUrl);
      let pricePropertiesTemplate = [],
        consumeAmtPropertiesTemplate = [];
      if (fileExists && fs.statSync(absoluteUrl).isFile()) {
        //读取配置文件并赋值
        let overWriteExports = require(absoluteUrl);
        if (overWriteExports) {
          pricePropertiesTemplate = overWriteExports.pricePropertiesTemplate
            ? overWriteExports.pricePropertiesTemplate
            : [];
          consumeAmtPropertiesTemplate =
            overWriteExports.consumeAmtPropertiesTemplate
              ? overWriteExports.consumeAmtPropertiesTemplate
              : [];
        }
      }
      await compilationModel.setOverWriteUrl(
        compilationId,
        overWriteUrl,
        pricePropertiesTemplate,
        consumeAmtPropertiesTemplate
      );
      response.json({ err: 0, msg: "", data: null });
    } catch (err) {
      console.log(err);
      response.json({ err: 1, msg: err, data: null });
    }
  }
  async setExample(request, response) {
    let compilationId = request.body.id,
      example = request.body.example;
    try {
      let compilationModel = new CompilationModel();
      await compilationModel.setExample(compilationId, example);
      response.json({ err: 0, msg: "success", data: null });
    } catch (err) {
      console.log(err);
      response.json({ err: 1, msg: err, data: null });
    }
  }

  /**
   * 模板设置页面
   *
   * @param {object} request
   * @param {object} response
   * @return {void}
   */
  async billsTemplate(request, response) {
    let billList = {};
    let valuationList = {};
    let valuationData = {};
    let compilationList = [];
    let billsTemplateData = [];

    let selectedCompilation = request.session.selectedCompilation;
    let engineering = request.params.engineering;
    let valuationId = request.params.id;
    let section = request.params.section;

    try {
      let compilationModel = new CompilationModel();
      // 获取对应的计价规则数据
      [valuationData, valuationList] = await compilationModel.getValuation(
        selectedCompilation._id,
        valuationId,
        section
      );
      compilationList = await compilationModel.getCompilationList();

      // 获取标准清单
      let stdBillLibListsModel = new STDBillLibListsModel();
      billList = await stdBillLibListsModel.getBillList(
        selectedCompilation._id
      );

      // 获取清单模板数据
      let billsTemplateModel = new BillsTemplateModel();
      billsTemplateData = await billsTemplateModel.getTemplateData(
        valuationId,
        engineering
      );
    } catch (error) {
      console.log(error);
    }

    let renderData = {
      engineering: engineering,
      billList: JSON.stringify(billList),
      billsTemplateData: JSON.stringify(billsTemplateData),
      billsFixedFlagList: JSON.stringify(BillsFixedFlagList),
      billsTypeFlagList: JSON.stringify(BillsTypeFlagList),
      valuationData: valuationData,
      valuationList: valuationList,
      selectedCompilation: selectedCompilation,
      compilationList: compilationList,
      valuationId: valuationId,
      section: section,
      layout: "users/views/layout/layout",
      LicenseKey: config.getLicenseKey(process.env.NODE_ENV),
    };
    response.render("users/views/compilation/template", renderData);
  }

  /**
   * 清单模板，更新数据操作
   *
   * @param request
   * @param response
   */
  async updateBillsTemplate(request, response) {
    let engineering = request.params.engineering;
    let valuationId = request.params.id;
    let section = request.params.section;
    let data = JSON.parse(request.body.data);

    let billsTemplateModel = new BillsTemplateModel();
    let result = await billsTemplateModel.updateTemplate(
      valuationId,
      engineering,
      data
    );

    if (result) {
      response.json({ error: 0, message: "", data: data });
    } else {
      response.json({ error: 1, message: "更新数据错误", data: null });
    }
  }

  async copyRationLibs(req, res) {
    const { valuationID, engineeringID } = JSON.parse(req.body.data);
    try {
      const engineeringLibModel = new EngineeringLibModel();
      await engineeringLibModel.copyRationLibsToOthers(
        valuationID,
        engineeringID
      );
      res.json({ error: 0, message: "复制成功", data: null });
    } catch (err) {
      res.json({ error: 1, message: String(err), data: null });
    }
  }

  async copyValuation(req, res) {
    const compilationModel = new CompilationModel();
    const { compilationID, valuationType, orgValuationID, newName } =
      JSON.parse(req.body.data);
    try {
      await compilationModel.copyValuation(
        compilationID,
        valuationType,
        orgValuationID,
        newName
      );
      res.json({ error: 0, message: "复制成功", data: null });
    } catch (err) {
      res.json({ error: 1, message: String(err), data: null });
    }
  }

  async addEngineer(request, response) {
    let engineeringLibModel = new EngineeringLibModel();
    try {
      await engineeringLibModel.addEngineer(request.body);
    } catch (error) {
      console.log(error);
    }
    response.redirect(request.headers.referer);
  }

  /**
   * 更改编办所属办事处信息
   *
   * @param request
   * @param response
   * @return {Promise.<void>}
   */
  async changeCategory(request, response) {
    let valuationId = request.body.id;
    let category = request.body.category;
    category = parseInt(category);
    try {
      let compilationModel = new CompilationModel();
      let result = await compilationModel.updateCategory(valuationId, category);
      if (result) {
        response.json({ error: 0, message: "", data: null });
      } else {
        response.json({ error: 1, message: "更新数据错误", data: null });
      }
    } catch (error) {
      response.json({ error: 1, message: "更新数据错误", data: null });
    }
  }

  /**
   * 更改编办默认工程所在工
   *
   * @param request
   * @param response
   * @return {Promise.<void>}
   */
  async changeLocation(request, response) {
    let compilationId = request.body.id;
    let location = request.body.location;
    try {
      let compilationModel = new CompilationModel();
      let result = await compilationModel.updateLocation(
        compilationId,
        location
      );
      if (result) {
        response.json({ error: 0, message: "", data: null });
      } else {
        response.json({ error: 1, message: "更新数据错误", data: null });
      }
    } catch (error) {
      response.json({ error: 1, message: "更新数据错误", data: null });
    }
  }

  /**
   * 更改编办默认工程所在工
   *
   * @param request
   * @param response
   * @return {Promise.<void>}
   */
  async changeFreeUse(request, response) {
    let compilationId = request.body.id;
    let freeUse = request.body.freeUse;
    try {
      let compilationModel = new CompilationModel();
      let result = await compilationModel.updateFreeUse(compilationId, freeUse);
      if (result) {
        response.json({ error: 0, message: "", data: null });
      } else {
        response.json({ error: 1, message: "更新数据错误", data: null });
      }
    } catch (error) {
      response.json({ error: 1, message: "更新数据错误", data: null });
    }
  }

  /**
   * 更改编办信息
   *
   * @param request
   * @param response
   * @return {Promise.<void>}
   */
  async changeCompilation(request, response) {
    let compilationId = request.body.id;
    let update = request.body.update;
    try {
      let compilationModel = new CompilationModel();
      let result = await compilationModel.updateById(compilationId, update);
      if (result) {
        response.json({ error: 0, message: "", data: null });
      } else {
        response.json({ error: 1, message: "更新数据错误", data: null });
      }
    } catch (error) {
      response.json({ error: 1, message: "更新数据错误", data: null });
    }
  }

  /**
   * 更改编办地区
   *
   * @param request
   * @param response
   * @return {Promise.<void>}
   */
  async setCompilationArea(request, response) {
    let compilationId = request.body.id;
    let compilationArea = request.body.compilationArea;
    try {
      let compilationModel = new CompilationModel();
      await compilationModel.setCompilationArea(compilationId, compilationArea);
      response.json({ err: 0, msg: "", data: null });
    } catch (err) {
      response.json({ err: 1, msg: err, data: null });
    }
  }
}

export default CompilationController;