/**
* Created by Mai on 2017/6/21.
*/
var projectObj = {
project: null,
mainSpread: null,
mainController: null,
gljSpreed: null,
beforeMainTreeSelectedChange: function (pre) {
/*if (node) {
subViewObj.saveComments(node);
}*/
},
// CSL, 2018-02-09 用于测试显示。使用示例：projectObj.testDisplay(‘总额’, 100);
testDisplay: function (caption, value) {
let c = "";
if (caption) c = caption + ": ";
let s = ` ${c}${value}`;
$("#testDisplay").html(s);
},
selectedChangeNowTime: 0,
selectedChangeDelayTime: 20,
treeSelectedChanged: function (node) {
let me = this;
let project = projectObj.project;
let mainSheet = projectObj.mainController.sheet;
let init = true;
//设置选中行底色和恢复前选中行底色
let refreshNodes = [node];
if (!project.mainTree.preSelected) {
refreshNodes.push(project.mainTree.items[0]);
} else {
refreshNodes.push(project.mainTree.preSelected);
init = !(project.mainTree.preSelected == node);
}
mbzm_obj.nodeChanged = init;
project.mainTree.preSelected = node;
projectObj.setNodesStyle(projectObj.mainController.sheet, refreshNodes);
function delayOpr(callback) {
let nowTime = Date.now();
me.selectedChangeNowTime = nowTime;
setTimeout(function () {
if (nowTime - me.selectedChangeNowTime == 0) {
callback();
}
}, me.selectedChangeDelayTime);
}
delayOpr(function () {
if ($("#linkComments").hasClass("active")) {
subViewObj.loadComments(node);
}
let nodeID = node ? node.getID() : null;
gljOprObj.mainTreeSelectedChange = gljOprObj.selectedNodeId != nodeID;
if (init) subObj.initNavItem(node);
if (calcTools.isBill(node)) subObj.setTZJNRValue(node);
/*
2018-11-9 在NavItem里设置了默认显示的item,在里执行了click这个操作所以这两个操作不用重复执行了
gljOprObj.showDataIfRationSelect(node);
if (activeSubSheetIsCalcProgram())
calcProgramObj.refreshCalcProgram(node, 3);*/
});
},
refreshBaseActn: function (tree) {
let setButtonValid = function (valid, btn) {
if (!projectReadOnly && valid) {
btn.removeClass("disabled");
} else {
btn.addClass("disabled");
}
};
let selected = tree.selected,
that = projectObj;
const validNodes = projectObj.mainController.getValidNodesWithinSelection();
const canUpLevel = function (nodes) {
if (!nodes.length || projectObj.project.isBillsLocked()) {
return false;
}
const firstNode = nodes[0];
const lastNode = nodes[nodes.length - 1];
if (firstNode.depth() <= 1) {
// 首节点是树结构的第一/二层节点，灰显。
return false;
}
if (firstNode.sourceType !== commonConstants.SourceType.BILLS) {
// 首节点是定额/量价/工料机，灰显。
return false;
} else {
if (lastNode.data.type == billType.BILL && lastNode.nextSibling) {
// 末节点是清单有后兄弟
if (lastNode.data.calcBase) {
// 有基数计算
return false;
}
if (lastNode.children.length > 0 && lastNode.children[0].sourceType !== commonConstants.SourceType.BILLS) {
// 有子项,并且子项不是清单
return false;
}
}
}
return true;
};
const canDownLevel = function (nodes) {
if (!nodes.length || projectObj.project.isBillsLocked()) {
return false;
}
const firstNode = nodes[0];
if (firstNode.depth() === 0) {
// 首节点是树结构的第一层节点，灰显。
return false;
}
if (firstNode.sourceType !== commonConstants.SourceType.BILLS) {
// 首节点是定额/量价/工料机，灰显。
return false;
} else {
const preNode = firstNode.preSibling;
if (!preNode) {
// 首节点无前兄弟，灰显
return false;
} else if (preNode.data.calcBase) {
// 首节点前兄弟有基数计算
return false;
}
if (preNode.children.length > 0) {
//前兄弟有子项，子项是分项，灰显。
if (firstNode.data.type == billType.BILL && preNode.children[0].sourceType !== commonConstants.SourceType.BILLS) {
// 首节点是清单，首节点前兄弟子项不是清单
return false;
}
}
}
return true;
};
const canUpMove = function (nodes) {
if (!nodes.length) {
return false;
}
const firstNode = nodes[0];
if (firstNode && firstNode.preSibling) {
if (firstNode.sourceType == commonConstants.SourceType.BILLS) {
if (projectObj.project.isBillsLocked()) {
return false;
}
if (firstNode.data.type == billType.DXFY && firstNode.data.isAdd !== 1) {
return false;
}
}
return true;
}
return false;
};
const canDownMove = function (nodes) {
if (!nodes.length) {
return false;
}
const lastNode = nodes[nodes.length - 1];
if (lastNode && lastNode.nextSibling) {
if (lastNode.sourceType == commonConstants.SourceType.BILLS) {
if (projectObj.project.isBillsLocked()) {
return false;
}
if (lastNode.data.type == billType.DXFY && lastNode.data.isAdd !== 1) {
return false;
}
}
return true;
}
return false;
};
setButtonValid(projectObj.project.Ration.canAdd(selected), $("#insertRation"));
setButtonValid(ifCanDelete(), $("#delete"));
setButtonValid(canUpLevel(validNodes), $("#upLevel"));
setButtonValid(canDownLevel(validNodes), $("#downLevel"));
setButtonValid(canUpMove(validNodes), $("#upMove"));
setButtonValid(canDownMove(validNodes), $("#downMove"));
setButtonValid(!projectObj.project.isBillsLocked(), $("#ZLFB_btn"));
},
checkCommonField: function (editingText, colSetting) {
let value;
if (colSetting.data.decimal) {
value = Number(editingText);
if (number_util.isNumber(value)) {
if (colSetting.data.decimal) {
value = value.toDecimal(colSetting.data.decimal);
}
} else {
value = null;
alert("当前输入的数据类型不正确，请重新输入。");
}
} else {
value = editingText;
}
return value;
},
checkFormulaValidField: function (editingText, colSetting) {
let value = Number(editingText);
if (isNaN(value)) return value;
if (!value) {
try {
let exp = new Expression("");
exp.Expression(editingText);
value = Number(exp.Evaluate());
} catch (error) {
value = null;
}
}
if (value != undefined || value != null) {
if (colSetting.data.decimal) {
value = value.toDecimal(colSetting.data.decimal);
}
} else if (editingText && editingText !== "") {
value = null;
alert("当前输入的数据类型不正确，请重新输入。");
}
return value;
},
checkSpreadEditingText: function (editingText, colSetting) {
if (colSetting.data.field === "contain" || colSetting.data.field === "feesIndex.common.unitFee" || colSetting.data.field === "feesIndex.common.totalFee") {
//colSetting.data.field === 'quantity'
return this.checkFormulaValidField(editingText, colSetting);
} else if (colSetting.data.field === "programID") {
return this.project.calcProgram.compiledTemplateMaps[editingText];
} else if (colSetting.data.field === "subType") {
if (typeof editingText !== "number") return volumePriceMaps[editingText];
else return editingText;
} else {
return this.checkCommonField(editingText, colSetting);
}
},
getVisibleRows: function (sRow, count) {
let rst = [];
let nodes = projectObj.project.mainTree.items;
for (let i = sRow, len = nodes.length; i < len; i++) {
if (count <= 0) {
break;
}
if (nodes[i].visible) {
rst.push(i);
count--;
}
}
return rst;
},
//根据列标段设置焦点单元格
setActiveCell(field, moveScroll) {
projectObj.mainSpread.focus(true);
let mainSheet = projectObj.mainSpread.getActiveSheet();
TREE_SHEET_HELPER.massOperationSheet(mainSheet, function () {
let fieldCol = colSettingObj.getColByField(field);
if (fieldCol) {
if (moveScroll) {
mainSheet.showColumn(fieldCol, GC.Spread.Sheets.HorizontalPosition.center);
}
mainSheet.setActiveCell(projectObj.project.mainTree.selected.serialNo(), fieldCol);
}
});
},
//获取粘贴更改的单元格（粘贴时，跳过隐藏行）
checkSpreadChangedCells: function (info) {
let rst = { refreshRows: [], changedCells: [] };
//获取显示行号
let vRows = projectObj.getVisibleRows(info.row, info.rowCount);
let vCount = vRows.length;
let lastRow = null,
count = 0;
for (let cell of info.changedCells) {
cell.text = info.sheet.getCell(cell.row, cell.col).text();
if (cell.row !== lastRow) {
count++;
lastRow = cell.row;
}
if (count <= vCount) {
if (vRows[count - 1] !== cell.row) {
rst.refreshRows.push(cell.row);
}
rst.changedCells.push({ row: vRows[count - 1], col: cell.col, text: cell.text });
} else {
rst.refreshRows.push(cell.row);
}
}
rst.refreshRows = Array.from(new Set(rst.refreshRows));
return rst;
},
updateBillsCode: function (node, value) {
let project = projectObj.project,
me = this;
let stdMatchCode, formatCode, matchs;
let searchStdBillsAndUpdate = function (stdCode, formatCode) {
let orgCode = node.data.code ? node.data.code.substr(0, 9) : "";
if (projectObj.project.projectInfo.engineeringInfo.bill_lib.length === 0 || updateCodeCheck(value, stdCode === orgCode)) {
normalUpdate(node, value, stdCode === orgCode);
} else if (projectObj.project.projectInfo.engineeringInfo.bill_lib.length > 0) {
let libId = projectObj.project.projectInfo.engineeringInfo.bill_lib[0].id;
CommonAjax.post("/stdBillsEditor/getStdBillsByCode", { userId: userID, billsLibId: libId, code: stdCode }, function (data) {
if (data) {
function sortItems(serialItems, items) {
for (let item of items) {
for (let serialItem of serialItems) {
if (item.id === serialItem.id) {
item.serialNo = serialItem.serialNo;
}
}
}
items.sort(function (a, b) {
let rst = 0;
if (a.serialNo > b.serialNo) {
rst = 1;
} else if (a.serialNo < b.serialNo) {
rst = -1;
}
return rst;
});
}
function updateBeforeInsert(node, data) {
node.data.name = data.name;
if (node.data.type == billType.BX) {
//从清单库中找到标准清单的话，要把补项改成分项
node.data.type = billType.FX;
}
}
if (/\//.test(data.unit)) {
let existB = projectObj.project.Bills.sameStdCodeBillsData(data.code);
if (existB) {
updateBeforeInsert(node, data);
data.unit = existB.unit;
project.Bills.replaceBills(node.source, data, formatCode);
projectObj.mainController.refreshTreeNode([node], false);
} else {
ConfirmModal.stdBillsUnit.check(
data,
function (std) {
updateBeforeInsert(node, data);
project.Bills.replaceBills(node.source, std, formatCode);
projectObj.mainController.refreshTreeNode([node], false);
},
function () {
projectObj.mainController.refreshTreeNode([node], false);
}
);
}
} else {
updateBeforeInsert(node, data);
project.Bills.replaceBills(node.source, data, formatCode);
projectObj.mainController.refreshTreeNode([node], false);
}
} else {
normalUpdate(node, value);
}
});
}
};
//分部分项、措施项目才匹配
let withinValidFixed = false;
let matchFixedFlags = [fixedFlag.SUB_ENGINERRING, fixedFlag.MEASURE];
let rootNode = getRootFixedNode(node);
if (rootNode && rootNode.data.flagsIndex && rootNode.data.flagsIndex.fixed && matchFixedFlags.includes(rootNode.data.flagsIndex.fixed.flag)) {
withinValidFixed = true;
}
if (
withinValidFixed &&
(node.data.type == billType.FX || node.data.type == billType.BX || (node.data.type == billType.BILL && node.source.children.length == 0))
) {
//是分项、补项或者叶子清单的情况下才需要查找替换
if (value && value.length === 9) {
//&& /^[\d]+$/.test(value) 去掉全数字判断 07-31 zhang
stdMatchCode = value;
formatCode = project.Bills.newFormatCode(stdMatchCode);
searchStdBillsAndUpdate(stdMatchCode, formatCode);
return;
} else if (value && value.length === 12) {
//&& /^[\d]+$/.test(value) 去掉全数字判断 07-31 zhang
stdMatchCode = value.substr(0, 9);
matchs = project.Bills.sameStdCode(stdMatchCode, node.data.code);
if (matchs.indexOf(value) === -1) {
searchStdBillsAndUpdate(stdMatchCode, value);
return;
} else {
hintBox.infoBox(
"系统提示",
"已存在该编码的清单，是否继续？",
2,
function () {
searchStdBillsAndUpdate(stdMatchCode, value);
},
function () {
me.mainController.refreshTreeNode([node], false);
},
["确定", "取消"]
);
return;
}
}
}
normalUpdate(node, value);
function normalUpdate(billnode, codeValue, onNeedCheck) {
//在标准库中没有找到清单时改分项为补项再更新
let toBX = false;
if (onNeedCheck !== true && billnode.data.type == billType.FX) {
billnode.data.type = billType.BX;
toBX = true;
}
project.Bills.updateField(billnode.source, "code", codeValue, toBX);
me.mainController.refreshTreeNode([billnode], false);
}
function updateCodeCheck(value, sameStdCode) {
//如果前9位相同，只改前三位，则只更新编号就行了，不用做其它处理
return sameStdCode && value && value.length == 12;
}
},
updateRationCode: function (node, value) {
if (!isDef(node.data.code) && (!isDef(value) || value.toString().trim() == "")) {
return;
}
if (projectObj.project.projectInfo.engineeringInfo.ration_lib.length === 0) {
alert("当前项目无定额库，请添加定额库。");
this.mainController.refreshTreeNode([node], false);
} else {
let libId = parseInt($("#stdRationLibSelect").val());
CommonAjax.post("/complementaryRation/api/getRationItem", { user_id: userID, rationRepId: libId, code: value }, function (data) {
if (data) {
projectObj.project.Ration.replaceRation(node.source, data);
projectObj.project.ration_glj.addRationGLJ(node.source, data);
} else {
alert('当前库中找不到定额"' + value + '"');
}
projectObj.mainController.refreshTreeNode([node], false);
});
}
},
updateCode: function (node, value) {
let project = projectObj.project;
if (node.sourceType === project.Bills.getSourceType()) {
this.updateBillsCode(node, value); // 新清单不适合实时计算，下面套什么还不能确定，无数量计算也无意义
} else if (node.sourceType === project.Ration.getSourceType()) {
if (value && typeof value == "string") {
//小写转换成大写
value = value.toUpperCase();
}
project.Ration.updateRationCodes([{ node: node, value: value }]);
// this.updateRationCode(node, value); // 新套定额适合实时计算
// 这里因异步问题暂时缺少工料机价格。该过程移到：ration_glj.js的refreshAfterSave方法中。
}
},
updateNodeField: function (node, value, filedID, callback) {
if (node.data[filedID] == value) {
return;
}
let data = {
type: node.sourceType,
data: {
ID: node.data.ID,
},
};
data.data[filedID] = value;
$.bootstrapLoading.start();
projectObj.project.updateNodes([data], function () {
node.data[filedID] = value;
if (callback) {
callback();
}
$.bootstrapLoading.end();
});
},
updateCellValue: function (node, value, colSetting, editingText) {
let project = projectObj.project,
fieldName = colSetting.data.field;
if (node.sourceType == ModuleNames.ration_glj) {
project.ration_glj.updateFromMainSpread(value, node, fieldName);
} else if (calcTools.isGljRation(node)) {
if (fieldName === "feesIndex.common.unitFee") fieldName = "marketUnitFee";
gljOprObj.updateRationTypeGLJ(value, node, fieldName, editingText);
} else if (fieldName === "remark") {
projectObj.updateNodeField(node, value, "remark");
} else if (fieldName === "feeRate" && value == null) {
project.FeeRate.cleanFeeRateID(node);
} else if (value !== calcFees.getFee(node.data, fieldName) || fieldName == "quantity") {
//工程量需要进行转换，所以做特殊处理
if (fieldName === "code" && value != "" && !calcTools.isVolumePrice(node)) {
projectObj.updateCode(node, value);
} else if (fieldName === "unit" && node.sourceType == ModuleNames.bills) {
node.updateData[fieldName] = value;
node.changed = true;
if (node.data.quantity) {
node.updateData.quantity = scMathUtil.roundForObj(node.data.quantity, getDecimal("quantity", node)); //修改清单单位的时候清单工程量要重新4舍5入;
}
project.calcProgram.calcAndSave(node);
} else if (fieldName === "feeRate") {
project.FeeRate.updateFeeRateFromBills(value, node, fieldName);
} else if (fieldName === "contain") {
//编辑含量
project.Ration.updateContain(value, node);
} else if (
fieldName === "quantity" ||
fieldName === "marketUnitFee" ||
fieldName === "feesIndex.common.unitFee" ||
fieldName === "feesIndex.common.totalFee" ||
fieldName === "calcBase" ||
fieldName === "programID" ||
fieldName === "subType" ||
fieldName === "isSubcontract"
) {
if (fieldName === "quantity") {
quantityEditObj.checkingAndUpdate(editingText, node);
return;
} else if (fieldName === "marketUnitFee" || fieldName === "feesIndex.common.unitFee" || fieldName === "feesIndex.common.totalFee") {
if (isNaN(value)) {
// 输入的是无效的字符
alert("当前输入的数据类型不正确，请重新输入。");
projectObj.mainController.refreshTreeNode([node]);
return;
}
// if (value) {
if (fieldName === "feesIndex.common.unitFee") {
value = parseFloat(value).toDecimal(decimalObj.decimal("unitPrice", node));
//当前是量价/人材机，综合单价可输入，输入的值读取到市场单价，重算综合单价。
if (node.sourceType == ModuleNames.ration && node.data.type != rationType.ration) {
fieldName = "marketUnitFee";
} else if (node.sourceType == ModuleNames.bills) {
node.updateData.calcFlag = treeNodeCalcFlag.customUnitPrice;
}
} else if (fieldName === "feesIndex.common.totalFee") {
value = scMathUtil.roundForObj(value, getDecimal("totalPrice", node));
node.updateData.calcFlag = treeNodeCalcFlag.customTotalPrice;
}
// }
} else if (fieldName === "calcBase") {
//zhong
if (value === undefined || value === null || value.toString().trim() === "") {
value = "";
}
if (value === node.data.calcBase) {
return;
}
node.data.userCalcBase = value;
project.calcBase.calculate(node);
if (!project.calcBase.success) {
let activeCell = projectObj.mainSpread.getActiveSheet().getSelections()[0];
projectObj.mainController.refreshTreeNode([node]);
return;
} else if (value === "") {
//删除清单基数，要清空费用
calcTools.clearFees(node);
}
// if (value) {value = parseFloat(value).toDecimal(decimalObj.decimal("totalPrice", node))};
}
//计算基数赋值要经过解析和标准化，已在calculate里赋值
if (fieldName !== "calcBase") {
calcTools.setFieldValue(node, fieldName, value);
projectObj.mainController.refreshTreeNode([node]); // 量价，输入单价x，反算单价x1，第二次输入单价x，单价不再反算。（实际反算了，没刷新）
}
project.calcProgram.calcAndSave(node);
gljOprObj.showRationGLJSheetData();
} else {
//不涉及计算的，只改updateData的值就好了
if (node.sourceType === project.Bills.getSourceType()) {
if (fieldName === "maxPrice" || fieldName === "minPrice") {
if (value == null) {
value = "";
} else {
value = scMathUtil.roundToString(value, getDecimal("unitPrice", node));
}
}
project.Bills.updateField(node.source, fieldName, value, false);
}
node.updateData[fieldName] = value;
node.changed = true;
if (colSetting.data.wordWrap) {
this.mainSpread.getActiveSheet().autoFitRow(node.serialNo());
}
project.calcProgram.calcAndSave(node);
// projectObj.mainController.refreshTreeNode([node]);
}
} else {
projectObj.mainController.refreshTreeNode([node], false);
}
},
mainSpreadLeaveCell: function (sender, info) {
let colSetting = projectObj.mainController.setting.cols[info.col];
projectObj.lastCol = colSetting;
projectObj.lastCell = { row: info.row, col: info.col };
if (colSetting.data.field === "quantity") {
SheetDataHelper.hideMoreButton();
}
},
//repaint 动态下拉框
mainSpreadEnterCell: function (sender, info) {
let colSetting = projectObj.mainController.setting.cols[info.col];
if (
colSetting.data.field === "unit" ||
(projectObj.lastCol && projectObj.lastCol.data.field === "unit") ||
colSetting.data.field === "subType" ||
(projectObj.lastCol && projectObj.lastCol.data.field === "subType") ||
colSetting.data.field === "programID" ||
(projectObj.lastCol && projectObj.lastCol.data.field === "programID")
) {
let rects = [];
rects.push(info.sheet.getCellRect(info.row, info.col));
if (projectObj.lastCell) {
rects.push(info.sheet.getCellRect(projectObj.lastCell.row, projectObj.lastCell.col));
}
for (let rect of rects) {
info.sheet.repaint(rect);
}
}
},
//滚动造价书鼠标时，工程量的更多按钮跟着移动
TopRowChanged: function (type, info) {
let colSetting = projectObj.mainController.setting.cols[info.sheet.getActiveColumnIndex()];
if (colSetting.data.field === "quantity") {
SheetDataHelper.moveMoreButton(info.sheet);
}
},
mainSpreadEditStarting: function (sender, info) {
let project = projectObj.project;
let node = project.mainTree.items[info.row];
let fieldName = projectObj.mainController.setting.cols[info.col].data.field;
let value = info.sheet.getValue(info.row, info.col);
if (fieldName === "code" && node && calcTools.isRationItem(node) && isDef(node.data.code) && isDef(value)) {
if (isDef(node.data.prefix) && node.data.prefix !== rationPrefix.none) {
value = value.replace(new RegExp(node.data.prefix), "");
}
value = value.replace(new RegExp(rationPrefix.replace), "");
info.sheet.setValue(info.row, info.col, value);
}
if (node && fieldName == "quantity" && (node.data.quantityEXP !== null || node.data.quantityEXP !== undefined)) {
info.sheet.setValue(info.row, info.col, node.data.quantityEXP);
}
},
onCellDoubleClick: function (sender, info) {
let project = projectObj.project;
if (info.row && info.col) {
let node = project.mainTree.items[info.row];
let fieldName = projectObj.mainController.setting.cols[info.col].data.field;
if (fieldName == "marketUnitFee") {
if (gljOprObj.hasComposition(node.data, true)) {
alert("当前人材机的市场价由组成物计算得出，不可直接修改。");
return;
}
}
if (fieldName == "code" && node) {
projectObj.showBillOrRationLib(node);
}
}
},
showBillOrRationLib(node) {
let BILLS = projectObj.project.Bills;
let code = node.data.code ? node.data.code : "";
if (node.sourceType == ModuleNames.bills) {
//当清单是“分部分项工程”、“措施项目工程”时，要展开清单规则节点
if (BILLS.isFXorBX(node) || (node.data.type == billType.BILL && BILLS.isMeasure(node))) {
//是分项或补项，是清单并且属于措施项目节点
if (!billsGuidance.bills.tree) {
doAfterLoadGuidance = function () {
billsGuidance.locateAtBills(code);
doAfterLoadGuidance = null;
};
} else {
billsGuidance.locateAtBills(code);
}
if (!$("#zy").is(":visible")) {
$("#stdBillsGuidanceTab").click();
}
}
}
if (node.sourceType == ModuleNames.ration) {
//在定额编码中双击，如果右侧定额库没有展开，则自动展开。
if (node.data.type != rationType.ration) return; //只有定额类型才需要自动展开，其它都不用
let libID = node.data.libID;
if (node.data.from === "cpt") {
libID = node.data.fromUser ? `${rationLibObj.compleRationLibId}*${node.data.fromUser}` : rationLibObj.compleRationLibId;
}
if (!rationLibObj.tree) {
if (isDef(libID)) sessionStorage.setItem("stdRationLib", libID);
rationLibObj.doAfterGetRationTree = function () {
this.locateAtRation(libID, code);
this.doAfterGetRationTree = null;
};
} else {
if ($("#stdRationLibSelect").select().val() != libID) {
let libOpts = $("#stdRationLibSelect").find("option");
for (let libOpt of libOpts) {
if ($(libOpt).val() == libID) {
$(libOpt).prop("selected", "selected");
break;
}
}
$("#stdRationLibSelect").change();
rationLibObj.doAfterGetRationTree = function () {
this.locateAtRation(libID, code);
this.doAfterGetRationTree = null;
};
} else {
rationLibObj.locateAtRation(node.data.libID, code);
}
}
if (!$("#de").is(":visible")) $("#stdRationTab").click();
}
},
onColumnWidthChanged: function (sender, info) {
// CSL,2018.07.25
if (info.colList.includes(4) || info.colList.includes(5)) {
let items = projectObj.project.mainTree.items;
let sheet = projectObj.mainSpread.getActiveSheet();
for (let i = 0; i < items.length; i++) {
let need = false;
if (items[i].data.itemCharacterText) {
sheet.getCell(i, 4).wordWrap(true);
need = true;
}
if (items[i].data.jobContentText) {
sheet.getCell(i, 5).wordWrap(true);
need = true;
}
if (need) sheet.autoFitRow(i);
}
}
},
onClipboardPasting: function (sender, info) {
let rIdx = info.sheet.getActiveRowIndex();
let node = projectObj.project.mainTree.items[rIdx];
if (!node.parent) {
info.cancel = true;
hintBox.infoBox("系统提示", "大项费用不允许粘贴！", 1);
return false;
}
let colName = projectObj.project.projSetting.main_tree_col.cols[info.cellRange.col].data.field;
if (node.sourceType === projectObj.project.Ration.getSourceType() && colName == "code") {
info.cancel = true;
function getNodeType(node) {
let t = null;
if (calcTools.isRationItem(node)) t = 1;
else if (calcTools.isBill(node)) {
if (calcTools.isBill_FB(node)) t = 2;
else if (calcTools.isBill_FX(node) || calcTools.isBill_BX(node)) t = 3;
else if (calcTools.isBill_BILL(node)) t = 4;
}
return t;
}
function getPasteTextArr(info) {
let copyText = info.pasteData.text.trim();
if (!copyText) return null;
let spliter = "";
if (copyText.includes("\r\n")) {
spliter = "\r\n";
} else if (copyText.includes("\n")) {
// 兼容Unix、Mac 等系统回车换行符
spliter = "\n";
} else {
spliter = "\r";
}
let rows = copyText.split(spliter);
let rstArr = [];
for (let row of rows) {
row = row.trim();
row = row.split("\t");
rstArr.push(row);
}
return rstArr;
}
function getPasteNodes(node, nodeType, count) {
let nodesArr = [];
let curNode = null;
for (let i = rIdx; i < rIdx + count; i++) {
curNode = projectObj.project.mainTree.items[i];
if (curNode && calcTools.isSameTypeNode(curNode, node)) {
nodesArr.push(curNode);
} else {
curNode = projectObj.project.mainTree.items[i - 1];
break;
}
}
if (nodesArr.length < count) {
if (projectObj.project.mainTree.selected != curNode) projectObj.project.mainTree.selected = curNode;
let add = count - nodesArr.length;
for (let i = 0; i < add; i++) {
switch (nodeType) {
case 1:
curNode = projectObj.project.Ration.addNewRationFast(rationType.ration);
break;
case 2:
curNode = ProjectController.addFB(projectObj.project, projectObj.mainController);
break;
case 3:
curNode = ProjectController.addFX(projectObj.project, projectObj.mainController);
break;
case 4:
curNode = ProjectController.addBills(projectObj.project, projectObj.mainController);
break;
}
if (!curNode) {
hintBox.infoBox("系统提示", "插入新结点出错，粘贴失败！", 1);
return nodesArr;
} else {
nodesArr.push(curNode);
if (projectObj.project.mainTree.selected != curNode) projectObj.project.mainTree.selected = curNode;
}
}
}
return nodesArr;
}
function doPaste(nodes, nodeType, datas) {
if (nodeType == 1) {
// 批量粘贴定额有严重的异步问题，这里要和清单分开处理
let updateRationCodes = [];
for (let i = 0; i < datas.length; i++) {
let ptNode = nodes[i];
let code = datas[i][0];
// 编号去掉“换、借、补”等多余的字
code = code.replace(new RegExp(rationPrefix.complementary), "");
code = code.replace(new RegExp(rationPrefix.borrow), "");
code = code.replace(new RegExp(rationPrefix.replace), "");
updateRationCodes.push({ node: ptNode, value: code });
}
projectObj.project.Ration.updateRationCodes(updateRationCodes);
} else {
for (let i = 0; i < datas.length; i++) {
let ptNode = nodes[i];
let code = datas[i][0];
if (!(ptNode.data && ptNode.data.code && ptNode.data.code.sameText(code))) {
projectObj.updateCode(ptNode, code);
}
}
}
projectObj.mainController.refreshTreeNode(nodes);
}
let tagType = getNodeType(node);
if (!tagType) {
hintBox.infoBox("系统提示", "该树结点类型不支持从项目编码列粘贴！", 1);
return false;
}
let datas = getPasteTextArr(info);
if (!datas) return;
let pasteNodes = getPasteNodes(node, tagType, datas.length);
doPaste(pasteNodes, tagType, datas);
}
},
mainSpreadEditEnded: function (sender, info) {
let project = projectObj.project;
let node = project.mainTree.items[info.row];
project.withinBillsLocked(node);
let colSetting = projectObj.mainController.setting.cols[info.col];
let fieldName = projectObj.mainController.setting.cols[info.col].data.field;
//提前处理
if (fieldName === "code" || fieldName === "name" || fieldName === "unit") {
info.editingText = info.editingText ? info.editingText.toString().replace(new RegExp(/[\r,\n]/g), "") : info.editingText;
}
// 检查输入类型等
let value = projectObj.checkSpreadEditingText(info.editingText, colSetting);
projectObj.updateCellValue(node, value, colSetting, info.editingText);
// 自动行高
const autoHeight = project.property.displaySetting.autoHeight;
if (autoHeight) {
projectObj.mainSpread.getActiveSheet().autoFitRow(info.row);
}
},
msClipboardChanged: function (sender, info) {
let colSettings = projectObj.mainController.setting.cols;
let cDatas = sheetCommonObj.getTableData(info.sheet, colSettings);
sheetCommonObj.copyTextToClipboard(cDatas);
return;
},
mainSpreadRangeChanged: function (sender, info) {
let project = projectObj.project,
setting = projectObj.mainController.setting;
let changedObj = projectObj.checkSpreadChangedCells(info);
let refreshNodes = [];
for (let row of changedObj.refreshRows) {
refreshNodes.push(project.mainTree.items[row]);
}
let updateRationCodes = []; //更新定额编码时要用同步的方式
if (changedObj.changedCells.length > 0) {
for (let changedCell of changedObj.changedCells) {
let node = project.mainTree.items[changedCell.row];
let colSetting = setting.cols[changedCell.col];
let value = projectObj.checkSpreadEditingText(changedCell.text, colSetting);
if (colSetting.data.field == "code" && node.sourceType == project.Ration.getSourceType() && node.data.type == rationType.ration) {
//如果是更新定额的编码
updateRationCodes.push({ node: node, value: value });
} else {
projectObj.updateCellValue(node, value, colSetting, changedCell.text);
}
}
}
if (updateRationCodes.length > 0) {
project.Ration.updateRationCodes(updateRationCodes);
}
if (refreshNodes.length > 0) {
projectObj.mainController.refreshTreeNode(refreshNodes);
}
},
checkMainSpread: function () {
if (!this.mainSpread) {
this.mainSpread = SheetDataHelper.createNewSpread($("#billsSpread")[0]);
sheetCommonObj.spreadDefaultStyle(this.mainSpread);
this.mainSpread.getActiveSheet().selectionPolicy(GC.Spread.Sheets.SelectionPolicy.muliRange);
this.mainSpread.getActiveSheet().name("mainSheet");
this.mainSpread.getActiveSheet().options.isProtected = true;
this.mainSpread.getActiveSheet().options.frozenlineColor = "#ababab";
}
},
refreshMainSpread: function () {
if (this.mainSpread) {
this.mainSpread.refresh();
}
},
loadProjectData: function () {
var that = this;
this.project = PROJECT.createNew(scUrlUtil.GetQueryString("project"), userID);
let startTime = +new Date();
$.bootstrapLoading.start();
this.project.loadDatas(function (err) {
projectInfoObj.refreshTotalPriceSpan(); // 工具栏中的总造价信息
let mTime = +new Date();
//projectInfoObj.showProjectInfo(that.project.projectInfo);
//快速列设置
if (!colSettingObj.getVisible("itemCharacterText")) {
switchTznrHtml(true);
}
if (colSettingObj.getVisible("itemCharacterText")) {
switchTznrHtml(false);
}
if (!err) {
that.project.projectGLJ.calcQuantity(true); //计算分部分项和技术措施项目消耗量;
let quantityTime = +new Date();
// that.project.property = projectObj.project.projectInfo.property;
if (typeof overwriteRationCalcBases === "function") overwriteRationCalcBases(that.project.property.taxType);
if (typeof overwriteFeeTypesWhenHasProperty === "function") {
overwriteFeeTypesWhenHasProperty(that.project.property.engineeringName);
that.project.calcProgram.compileAllTemps();
}
//that.project.calcProgram.compileAllTemps();
that.project.calcBase.init(that.project);
// that.project.calcFields = JSON.parse(JSON.stringify(cpFeeTypes));
// that.project.initCalcFields();
let str = JSON.stringify(that.project.projSetting.main_tree_col);
that.project.projSetting.mainGridSetting = JSON.parse(str);
that.project.projSetting.mainGridSetting.frozenCols = 4;
TREE_SHEET_HELPER.initSetting($("#billsSpread")[0], that.project.projSetting.mainGridSetting);
that.project.projSetting.mainGridSetting.setAutoFitRow = MainTreeCol.getEvent("setAutoFitRow");
that.project.projSetting.mainGridSetting.cols.forEach(function (col) {
col.data.splitFields = col.data.field.split(".");
if (col.data.getText && Object.prototype.toString.apply(col.data.getText) === "[object String]") {
col.data.getText = MainTreeCol.getEvent(col.data.getText);
}
if (col.readOnly && Object.prototype.toString.apply(col.readOnly) === "[object String]") {
col.readOnly = MainTreeCol.getEvent(col.readOnly);
}
if (col.data.cellType && Object.prototype.toString.apply(col.data.cellType) === "[object String]") {
let getCellType = MainTreeCol.getEvent(col.data.cellType);
col.data.cellType = getCellType;
}
// if (col.data.digit && Object.prototype.toString.apply(col.data.digit) === "[object String]") {
// col.data.decimal = that.project.getDecimal(col.data.digit);
// col.data.formatter = MainTreeCol.getNumberFormatter(col.data.decimal);
// }
if (col.data.field === "code") {
col.data.formatter = "@";
}
col.setAutoHeight = MainTreeCol.getEvent("setAutoHeight");
col.editChecking = MainTreeCol.getEvent("editChecking");
// 根据配置设置自动行高,在这里先做个标记，然后对每个单元格单独配置
if (col.data.field === "name" || col.data.field === "itemCharacterText" || col.data.field === "jobContentText" || col.data.field === "adjustState") {
col.data.autoHeight = true;
col.showHint = true;
}
if (col.data.field === "quantity" || col.data.field === "remark") {
col.showHint = true;
}
// 综合单价、综合合价，小数部分应补0对齐。 CSL
// if (col.data.field.hasSubStr("common")){
if (col.data.field.hasSubStr(".totalFee")) col.data.formatter = MainTreeCol.getNumberFormatter(decimalObj.ration.totalPrice, true);
else if (col.data.field.hasSubStr(".unitFee")) col.data.formatter = MainTreeCol.getNumberFormatter(decimalObj.ration.unitPrice, true);
// }
});
that.mainController = TREE_SHEET_CONTROLLER.createNew(
that.project.mainTree,
that.mainSpread.getActiveSheet(),
that.project.projSetting.mainGridSetting
);
that.mainController.bind("refreshBaseActn", that.refreshBaseActn);
that.mainController.bind(TREE_SHEET_CONTROLLER.eventName.beforeTreeSelectedChange, that.beforeMainTreeSelectedChange);
that.mainController.bind(TREE_SHEET_CONTROLLER.eventName.treeSelectedChanged, that.treeSelectedChanged);
gljCol.initGljCol(
that.project.projSetting.glj_col ? that.project.projSetting.glj_col.showAdjustPrice : false,
that.project.property.tenderSetting.showTenderFields ? that.project.property.tenderSetting.showTenderFields : false,
true
);
that.mainController.showTreeData();
subObj.initSubSpread(); //初始化主界面下方的表格
if (!projectReadOnly) {
that.mainSpreadEscKey(that.mainSpread, that.mainSpreadEditStarting, that.mainSpreadEditEnded);
sheetCommonObj.bindEnterKey(that.mainSpread, that.mainSpreadEnterKey);
}
setTimeout(function () {
that.mainSpread.getActiveSheet().startEdit(); //这两句需要挺多时间,而又需要在editend 事件前触发，而这些又不影响计算，所以这里用异步的方法
that.mainSpread.getActiveSheet().endEdit();
that.mainSpread.bind(GC.Spread.Sheets.Events.EditEnded, that.mainSpreadEditEnded);
that.mainSpread.bind(GC.Spread.Sheets.Events.EditStarting, that.mainSpreadEditStarting);
}, 100);
that.mainSpread.bind(GC.Spread.Sheets.Events.SelectionChanged, that.amountAreaNumber); //选中统计专用，节点相关操作在treeSelectedChanged里些
that.mainSpread.bind(GC.Spread.Sheets.Events.LeaveCell, that.mainSpreadLeaveCell);
that.mainSpread.bind(GC.Spread.Sheets.Events.EnterCell, that.mainSpreadEnterCell);
that.mainSpread.bind(GC.Spread.Sheets.Events.RangeChanged, that.mainSpreadRangeChanged);
that.mainSpread.bind(GC.Spread.Sheets.Events.ClipboardChanged, that.msClipboardChanged);
that.mainSpread.bind(GC.Spread.Sheets.Events.ButtonClicked, that.onButtonClick);
that.mainSpread.bind(GC.Spread.Sheets.Events.CellDoubleClick, that.onCellDoubleClick);
that.mainSpread.bind(GC.Spread.Sheets.Events.ColumnWidthChanged, that.onColumnWidthChanged);
that.mainSpread.bind(GC.Spread.Sheets.Events.ClipboardPasting, that.onClipboardPasting);
//工程量悬浮窗移动事件
that.mainSpread.bind(GC.Spread.Sheets.Events.TopRowChanged, that.TopRowChanged);
//let loadOtherStartTime = +new Date();
//if(!projectReadOnly){
that.loadMainSpreadContextMenu();
//}
socketObject.connect("main", { projectReadOnly: !!projectReadOnly, user: { ...projectObj.project.projectInfo.opener } }); //连接socket服务器
let endTime = +new Date();
console.log(`时间——${endTime - startTime}`);
that.project.projectMarkChecking(); //是否需要重新进行造价计算
autoFlashHeight();
that.loadFocusLocation();
projectObj.refreshMainSpread();
//定位到会话中的选项
let mainTabFocus = sessionStorage.getItem("mainTab") ? sessionStorage.getItem("mainTab") : "#tab_zaojiashu";
$(mainTabFocus).click();
if (projectReadOnly) {
sheetCommonObj.disableSpread(that.mainSpread);
}
if (projectObj.project.projectInfo.lastFileVer != VERSION) projectObj.project.calcProgram.doTenderCalc(); // 打开标段后，进行一次全部计算，包括调价计算。
$.bootstrapLoading.end();
} else {
}
const onceAlert = getLocalCache(commonConstants.StorageKey.ONCE_MAIN_LOADED);
if (onceAlert) {
alert(onceAlert);
removeLocalCache(commonConstants.StorageKey.ONCE_MAIN_LOADED);
}
});
},
//mainSpread有一些单元格进入编辑状态后，会动态改变值，公用的bindEscKey方法不适用
mainSpreadEscKey: function (workBook, editStarting = null, editEnded = null) {
workBook.commandManager().register("myEsc", function () {
let sheet = workBook.getActiveSheet();
if (editStarting) {
sheet.unbind(GC.Spread.Sheets.Events.EditStarting);
}
if (editEnded) {
sheet.unbind(GC.Spread.Sheets.Events.EditEnded);
}
let row = sheet.getActiveRowIndex();
let col = sheet.getActiveColumnIndex();
let orgV = sheet.getValue(row, col);
let node = projectObj.project.mainTree.items[row];
let field = colSettingObj.getFieldByCol(col);
//进入编辑状态后改变了单元格值的时候特殊处理
if (isDef(field) && field === "code") {
if (
node &&
node.sourceType === projectObj.project.Ration.getSourceType() &&
node.data.type === rationType.ration &&
isDef(node.data.code) &&
isDef(node.data.prefix) &&
node.data.prefix !== rationPrefix.none
) {
orgV = node.data.prefix + orgV;
}
} else if (isDef(field) && field === "quantity") {
orgV = isDef(node) && isDef(node.data.quantity) ? node.data.quantity : "";
}
if (!isDef(orgV)) {
orgV = "";
}
if (sheet.isEditing()) {
sheet.endEdit();
sheet.setValue(row, col, orgV);
}
if (editStarting) {
sheet.bind(GC.Spread.Sheets.Events.EditStarting, editStarting);
}
if (editEnded) {
sheet.bind(GC.Spread.Sheets.Events.EditEnded, editEnded);
}
});
workBook.commandManager().setShortcutKey(null, GC.Spread.Commands.Key.esc, false, false, false, false);
workBook.commandManager().setShortcutKey("myEsc", GC.Spread.Commands.Key.esc, false, false, false, false);
},
mainSpreadEnterKey: function () {
let me = projectObj;
let sheet = me.mainSpread.getActiveSheet();
let orgRow = sheet.getActiveRowIndex();
let orgCol = sheet.getActiveColumnIndex();
let orgField = colSettingObj.getFieldByCol(orgCol);
let selected = me.project.mainTree.items[orgRow];
if (sheet.isEditing()) {
sheet.endEdit();
}
//正常情况，焦点应该是在下一行的同一列
let newRow = orgRow + 1,
newCol = orgCol;
//getColByField getVisible都不提出来，减少调用次数
if (selected) {
//在分项/补项的编码单元格回车，焦点应跳动至本行的工程量单元格
if (
orgField &&
orgField === "code" &&
selected.sourceType === me.project.Bills.getSourceType() &&
[billType.FX, billType.BX].includes(selected.data.type)
) {
let quantityCol = colSettingObj.getColByField("quantity");
let quantityVisible = colSettingObj.getVisible("quantity");
if (quantityCol !== null && quantityVisible !== false) {
newRow = orgRow;
newCol = quantityCol;
}
} else if (
orgField &&
orgField === "quantity" &&
selected.sourceType === me.project.Bills.getSourceType() &&
[billType.FX, billType.BX].includes(selected.data.type)
) {
//在分项/补项的工程量单元格回车，如果其下有定额/量价/人材机，焦点应跳动至其下第一条定额/量价/人材机的工程量，如果是空行，则跳到至第一条定额xx的编码；
if (selected.children.length !== 0 && !(isDef(selected.children[0].data.code) && selected.children[0].data.code.toString().trim() !== "")) {
let codeCol = colSettingObj.getColByField("code");
let codeVisible = colSettingObj.getVisible("code");
newRow = orgRow + 1;
if (codeCol !== null && codeVisible !== false) {
newCol = codeCol;
}
}
//如果其下没有定额/量价/人材机，则自动在其下插入一条定额空行，在其后自动插入一条分项空行，焦点跳动至定额空行的编码单元格。
else if (selected.children.length === 0) {
//分项没有后兄弟，且没有锁定清单时在其后插入分项
if (
!selected.nextSibling &&
!(projectObj.project.projectInfo.property.lockBills && projectObj.project.withinBillsLocked(projectObj.project.mainTree.selected))
) {
ProjectController.addFX(me.project, me.mainController);
//将焦点行设置成原本的行，以插入定额
me.mainController.setTreeSelected(me.project.mainTree.items[orgRow]);
}
/*
2021-04-26 只插入清单不插入定额
//插入定额
me.project.Ration.addNewRation(null, rationType.ration, function () {
newRow = sheet.getActiveRowIndex();
let codeCol = colSettingObj.getColByField('code');
let codeVisible = colSettingObj.getVisible('code');
if(codeCol !== null && codeVisible !== false){
newCol = codeCol;
}
sheet.setActiveCell(newRow, newCol);
},true,null,false); */
}
}
//在定额/量价/人材机的编码单元格回车，焦点应跳动至本行的工程量单元格
else if (orgField && orgField === "code" && selected.sourceType === me.project.Ration.getSourceType()) {
let quantityCol = colSettingObj.getColByField("quantity");
let quantityVisible = colSettingObj.getVisible("quantity");
if (quantityCol !== null && quantityVisible !== false) {
newRow = orgRow;
newCol = quantityCol;
}
}
//在定额/量价/人材机的工程量单元格回车
else if (orgField && orgField === "quantity" && selected.sourceType === me.project.Ration.getSourceType()) {
let nextSibling = selected.nextSibling;
//如果其后有定额/量价/人材机(空行:编码为空不算)，焦点应跳动至下一行定额/量价/人材机的工程量，不需处理
//如果其后没有定额/量价/人材机(空行也没有)，则自动在其后插入一行定额空行，焦点跳动至定额空行的编码单元格
/* if(!nextSibling){
let codeCol = colSettingObj.getColByField('code');
let codeVisible = colSettingObj.getVisible('code');
me.project.Ration.addNewRation(null, rationType.ration, function () {
newRow = sheet.getActiveRowIndex();
if(codeCol !== null && codeVisible !== false){
newCol = codeCol;
}
sheet.setActiveCell(newRow, newCol);
}, true,null,false);
} */
//如果其后有定额空行，焦点跳动至定额空行的编码单元格
if (nextSibling && !(isDef(nextSibling.data.code) && nextSibling.data.code.toString().trim() !== "")) {
let codeCol = colSettingObj.getColByField("code");
let codeVisible = colSettingObj.getVisible("code");
if (codeCol !== null && codeVisible !== false) {
newRow = orgRow + 1;
newCol = codeCol;
}
}
}
//在清单的编码单元格回车，如果清单是叶子节点，焦点跳动至本行的工程量单元格
else if (
orgField &&
orgField === "code" &&
selected.sourceType === me.project.Bills.getSourceType() &&
selected.data.type === billType.BILL &&
selected.source.children.length === 0
) {
let quantityCol = colSettingObj.getColByField("quantity");
let quantityVisible = colSettingObj.getVisible("quantity");
if (quantityCol && quantityVisible) {
newRow = orgRow;
newCol = quantityCol;
}
}
}
//设置焦点
sheet.setActiveCell(newRow, newCol);
//触发表格事件
me.mainController.setTreeSelected(me.project.mainTree.items[newRow]); //SelectionChanged
me.mainSpreadLeaveCell({ type: "LeaveCell" }, { sheet: sheet, sheetName: sheet.name(), cancel: false, row: orgRow, col: orgCol });
me.mainSpreadEnterCell({ type: "EnterCell" }, { sheet: sheet, sheetName: sheet.name(), cancel: false, row: newRow, col: newCol });
},
isInsertEquipmentVisable: function (selected) {
//浙江不管是预算或者工程量清单，都是隐藏，overwrite文件重写
if (this.project.property.valuationType !== "ration") {
//属于预算项目的情况下，在固定清单可见
//属于的固定清单
let belongFlag = cbTools.getBelongFlag(selected);
if (belongFlag && belongFlag === fixedFlag.EQUIPMENT_ACQUISITION_FEE) {
return true;
}
return false;
}
return true;
},
//取安全生产费
getSaveProductionCostCode: function () {
//公路云里18的清单范本安全生产费是102-3的；养护云里浙江养护的安全生产费是102-4。
return "102-4";
},
// 注册自定义插入清单数量
registerFlexibleInsertBillMenu: function (name) {
const project = projectObj.project;
const insertBillsHtml = `${name} 行`;
return sheetCommonObj.registerInputContextMenuItem("insertBills", insertBillsHtml, "fa-sign-in", async function () {
if (project.mainTree.selected.data.type == billType.DXFY) {
if (project.mainTree.selected.data.calcBase && project.mainTree.selected.data.calcBase != "") {
alert("当前有基数计算,不能插入子项。");
return;
}
}
try {
const number = +$("#insert-bills-number").val();
if (!number) {
return;
}
$.bootstrapLoading.start();
const postData = ProjectController.getBillsPostData(number);
const newNodes = await ProjectController.addBillsByData(postData, true);
projectObj.mainController.setTreeSelected(newNodes[0]);
projectObj.selectColAndFocus(project.mainTree.selected);
projectObj.refreshBaseActn(project.mainTree);
} catch (err) {
console.log(err);
if (!$("hintBox_form").is(":visible")) {
alert(err);
}
} finally {
$.bootstrapLoading.end();
}
});
},
// 注册自定义插入定额数量
registerFlexibleInsertRatoinMenu: function () {
const project = projectObj.project;
const insertRationHtml = `插入定额 行`;
return sheetCommonObj.registerInputContextMenuItem("insertRation", insertRationHtml, "fa-sign-in", async function () {
try {
const number = +$("#insert-ration-number").val();
if (!number) {
return;
}
$.bootstrapLoading.start();
const newData = [];
for (let i = 0; i < number; i++) {
newData.push({ itemQuery: null, rationType: rationType.ration });
}
await project.Ration.addMultiRation(newData);
projectObj.setActiveCell("code", true);
projectObj.refreshBaseActn(project.mainTree);
} catch (err) {
console.log(err);
if (!$("hintBox_form").is(":visible")) {
alert(err);
}
} finally {
$.bootstrapLoading.end();
}
});
},
loadMainSpreadContextMenu: function () {
var project = this.project,
spread = this.mainSpread,
controller = this.mainController;
let insertBillsName =
project.projectInfo.property &&
[commonConstants.ValuationType.BOQ, commonConstants.ValuationType.BILL_BUDGET].includes(project.projectInfo.property.valuationType)
? "插入清单"
: "插入项目节"; //右键“插入清单”改文字为“插入项目节”，工程量清单中保持不变。
$.contextMenu({
selector: "#billsSpread",
selectableSubMenu: true,
build: function ($trigger, e) {
projectObj.cusRationCombCheck(spread.getActiveSheet());
var target = SheetDataHelper.safeRightClickSelection($trigger, e, spread);
controller.setTreeSelected(controller.tree.items[target.row]);
return target.hitTestType === GC.Spread.Sheets.SheetArea.viewport || target.hitTestType === GC.Spread.Sheets.SheetArea.rowHeader;
},
items: {
insertRootBill: {
name: "插入大项费用",
icon: "fa-sign-in",
disabled: function () {
return projectReadOnly || (projectObj.project.isBillsLocked() && project.withinBillsLocked(project.mainTree.selected));
//return project.mainTree.selected ? project.mainTree.selected.sourceType !== project.Bills.getSourceType() : false;
},
callback: function (key, opt) {
ProjectController.addRootBill(project, controller);
},
visible: function (key, opt) {
return project.mainTree.selected && project.mainTree.selected.parent == null;
},
},
insertFB: {
name: "插入分部",
icon: "fa-sign-in",
disabled: function () {
if (projectReadOnly) {
return true;
}
let selected = project.mainTree.selected;
if (projectObj.project.isBillsLocked() == false && selected && selected.sourceType == project.Bills.getSourceType()) {
if (selected.data.type == billType.FB) {
return false;
}
if (isFlag(selected.data) && selected.data.flagsIndex.fixed.flag == fixedFlag.SUB_ENGINERRING) {
//焦点行是分部分项工程
if (selected.children.length > 0) {
return selected.children[0].data.type == billType.FX || selected.children[0].data.type == billType.BX; //焦点行是分部分项工程，且子项是分项或补项
} else {
return false;
}
}
}
return true; //除了清单，其它类型都只读
},
callback: function (key, opt) {
ProjectController.addFB(project, controller);
projectObj.selectColAndFocus(project.mainTree.selected);
},
visible: function (key, opt) {
if (project.mainTree.selected) {
return project.Bills.isFBFX(project.mainTree.selected); //不属于分部分项的话隐藏
} else {
return false;
}
},
},
insertFX: {
name: "插入分项",
icon: "fa-sign-in",
disabled: function () {
if (projectReadOnly) {
return true;
}
let selected = project.mainTree.selected;
if (projectObj.project.isBillsLocked() == false && selected && selected.sourceType == project.Bills.getSourceType()) {
if (selected.data.type == billType.FX || selected.data.type == billType.BX) {
//焦点行是分项，有效显示
return false;
}
if (selected.data.type == billType.FB) {
//点行是分部，
if (selected.children.length > 0) {
//且有子项，子项是分部，灰显。
return selected.children[0].data.type == billType.FB;
} else {
return false;
}
}
if (isFlag(selected.data) && selected.data.flagsIndex.fixed.flag == fixedFlag.SUB_ENGINERRING) {
//焦点行是分部分项工程
if (selected.children.length > 0) {
return selected.children[0].data.type == billType.FB; //焦点行是分部分项工程，且子项是分部时灰显
} else {
return false;
}
}
}
return true; //除了清单，其它类型都只读
},
callback: function (key, opt) {
ProjectController.addFX(project, controller);
projectObj.selectColAndFocus(project.mainTree.selected);
},
visible: function (key, opt) {
if (project.mainTree.selected) {
return project.Bills.isFBFX(project.mainTree.selected); //不属于分部分项的话隐藏
} else {
return false;
}
},
},
insertBills: {
type: projectObj.registerFlexibleInsertBillMenu(insertBillsName),
disabled: function () {
if (projectReadOnly) {
return true;
}
let selected = project.mainTree.selected;
if (
!(projectObj.project.isBillsLocked() == true && project.withinBillsLocked(selected)) &&
selected &&
selected.sourceType === project.Bills.getSourceType()
) {
return false;
}
return true;
},
visible: function (key, opt) {
if (project.mainTree.selected) {
return project.Bills.isFBFX(project.mainTree.selected) == true ? false : true;
} else {
return false;
}
},
},
spr1: "--------",
insertRation: {
type: projectObj.registerFlexibleInsertRatoinMenu(),
disabled: function () {
if (projectReadOnly) {
return true;
}
// var selected = project.mainTree.selected;
// return project.Ration.addRationChecking(selected); // Vincent, 2018-01-02
// 工具栏要加按钮，且不能隐藏。菜单可以隐藏，两者又必须统一，所以启用新规则。怕以后又要改回来，所以保留。 CSL, 2018-01-02
return !project.Ration.canAdd(project.mainTree.selected);
},
visible: function (key, opt) {
let rst = true;
if (compilationName === "内蒙古高速公路日常养护估算(2021)") return false;
return rst;
},
},
insertGLJ: {
name: "插入工料机",
icon: "fa-sign-in",
disabled: function () {
if (projectReadOnly) {
return true;
}
// var selected = project.mainTree.selected;
// return project.Ration.addRationChecking(selected); // Vincent, 2018-01-02
return !project.Ration.canAdd(project.mainTree.selected);
},
callback: function (key, opt) {
let selected = project.mainTree.selected;
if (selected.data.calcBase && selected.data.calcBase != "") {
alert("当前有基数计算，不能插入定额/量价/工料机。");
return;
}
getGLJData("insert"); // ProjectController.addRation(project, controller, rationType.volumePrice);
},
visible: function (key, opt) {
let rst = true;
if (compilationName === "内蒙古高速公路日常养护估算(2021)") return false;
return rst;
},
},
insertLJ: {
name: "插入量价", //插入量价不需要自动定位到编号列
icon: "fa-sign-in",
disabled: function () {
if (projectReadOnly) {
return true;
}
return !project.Ration.canAdd(project.mainTree.selected);
},
visible: function (key, opt) {
let rst = true;
if (compilationName === "内蒙古高速公路日常养护估算(2021)") rst = false;
return rst;
},
callback: function (key, opt) {
/* project.Ration.addNewRation(null,rationType.volumePrice,function (newNode) {
projectObj.selectColAndFocus(newNode,null);
},true);*/
},
items: {
insertLabour: {
name: "人工",
icon: "fa-sign-in",
callback: function (key) {
project.Ration.insertVolumePrice(gljType.LABOUR);
},
},
insertMaterial: {
name: "材料",
icon: "fa-sign-in",
callback: function (key) {
project.Ration.insertVolumePrice(gljType.GENERAL_MATERIAL);
},
},
insertMachine: {
name: "机械",
icon: "fa-sign-in",
callback: function (key) {
project.Ration.insertVolumePrice(gljType.GENERAL_MACHINE);
},
},
},
},
insertMaterial: {
name: "按清单名称插入材料", //插入量价不需要自动定位到编号列
icon: "fa-sign-in",
disabled: function () {
if (projectReadOnly) {
return true;
}
return !project.Ration.canAdd(project.mainTree.selected);
},
visible: function (key, opt) {
let rst = true;
if (compilationName === "内蒙古高速公路日常养护估算(2021)") return false;
return rst;
},
callback: function (key, opt) {
//名称取清单名称，单位取清单单位
let selected = project.mainTree.selected;
let billNode = selected;
if (selected.sourceType == project.Ration.getSourceType()) billNode = selected.parent;
let ext = { name: billNode.data.name, unit: billNode.data.unit };
project.Ration.insertVolumePrice(gljType.GENERAL_MATERIAL, ext);
},
},
insertEquipment: {
name: "插入设备",
icon: "fa-sign-in",
disabled: function () {
if (projectReadOnly) {
return true;
}
return !project.Ration.canAdd(project.mainTree.selected);
},
callback: function (key, opt) {
let selected = project.mainTree.selected;
if (selected.data.calcBase && selected.data.calcBase != "") {
alert("当前有基数计算，不能插入定额/量价/工料机。");
return;
}
getGLJData("insertEquipment"); // ProjectController.addRation(project, controller, rationType.volumePrice);
},
visible: function (key, opt) {
//2018-11-08 新需求，这个按钮先隐藏，有需要再放开
let selected = project.mainTree.selected;
return projectObj.isInsertEquipmentVisable(selected);
},
},
spr2: "--------",
calc_installation_fee: {
name: "计取安装费用",
icon: "fa-sign-in",
disabled: function () {
if (projectReadOnly) {
return true;
}
return false;
},
callback: function (key, opt) {
installationFeeObj.showCalcInstallSettingDiv();
},
visible: function (key, opt) {
return projectObj.project.isInstall();
},
},
cleanzmhs: {
name: "清空定额调整",
icon: "fa-remove",
callback: function (key, opt) {
let selected = project.mainTree.selected;
projectObj.project.Ration.updateRationCodes([{ node: selected, value: selected.data.code }], true);
},
visible: function (key, opt) {
let selected = project.mainTree.selected;
if (selected && selected.sourceType == ModuleNames.ration) {
return true;
}
return false;
},
disabled: function () {
let selected = project.mainTree.selected;
if (projectReadOnly) {
return true;
}
if (selected && selected.data.type != rationType.ration) {
return true;
}
return false;
},
},
setBookMark: {
name: "设置书签批注",
icon: "fa-flag",
disabled: function () {
if (projectReadOnly || !project.mainTree.selected || project.mainTree.selected.sourceType == ModuleNames.ration_glj) {
return true;
}
return false;
},
items: {
cancelMark: {
name: "取消书签批注",
icon: "fa-remove",
disabled: function () {
const selected = project.mainTree.selected;
return !(selected && selected.data.bookmarkBackground);
},
callback: function () {
locateObject.setOrCancelBookmark(project.mainTree.selected, null);
},
},
markE2F2C5: {
name: function () {
return locateObject.getDescribeByColor("E2F2C5");
},
icon: "fa-square annotate-color-1",
callback: function () {
locateObject.setOrCancelBookmark(project.mainTree.selected, "E2F2C5");
},
},
markF9E2CF: {
name: function () {
return locateObject.getDescribeByColor("F9E2CF");
},
icon: "fa-square annotate-color-2",
callback: function () {
locateObject.setOrCancelBookmark(project.mainTree.selected, "F9E2CF");
},
},
markF2EFD9: {
name: function () {
return locateObject.getDescribeByColor("F2EFD9");
},
icon: "fa-square annotate-color-3",
callback: function () {
locateObject.setOrCancelBookmark(project.mainTree.selected, "F2EFD9");
},
},
markF5D1DA: {
name: function () {
return locateObject.getDescribeByColor("F5D1DA");
},
icon: "fa-square annotate-color-4",
callback: function () {
locateObject.setOrCancelBookmark(project.mainTree.selected, "F5D1DA");
},
},
markE3E3E3: {
name: function () {
return locateObject.getDescribeByColor("E3E3E3");
},
icon: "fa-square annotate-color-5",
callback: function () {
locateObject.setOrCancelBookmark(project.mainTree.selected, "E3E3E3");
},
},
markB6F3F2: {
name: function () {
return locateObject.getDescribeByColor("B6F3F2");
},
icon: "fa-square annotate-color-6",
callback: function () {
locateObject.setOrCancelBookmark(project.mainTree.selected, "B6F3F2");
},
},
markECE0F5: {
name: function () {
return locateObject.getDescribeByColor("ECE0F5");
},
icon: "fa-square annotate-color-7",
callback: function () {
locateObject.setOrCancelBookmark(project.mainTree.selected, "ECE0F5");
},
},
},
},
delete: {
name: "删除",
icon: "fa-remove",
disabled: function () {
return !ifCanDelete();
},
callback: function () {
var selected = project.mainTree.selected;
if (selected.sourceType == project.Bills.getSourceType() && selected.data.type == billType.FB && selected.children.length <= 0) {
//选中的是分部，并且没有子项，直接删除
project.Bills.deleteSelectedNodes(); //project.Bills.deleteSelectedNode();
} else {
$("#delete_row").modal({ show: true }); //弹出删除提示框;
}
},
},
calculateAll_RationContent: {
name: "造价计算",
icon: "fa-calculator",
callback: function () {
$.bootstrapLoading.start();
setTimeout(function () {
project.calcProgram.calcAllNodesAndSave();
$.bootstrapLoading.end();
}, 100);
},
disabled: function () {
if (projectReadOnly) {
return true;
}
},
visible: function (key, opt) {
//2019-11-11 新需求重新开放右键“造价计算”。
return true;
},
},
spr4: "--------",
copyBlock: {
name: "复制整块",
icon: "fa-copy",
disabled: function () {
if (projectReadOnly) {
return true;
}
let selection = projectObj.mainSpread.getActiveSheet().getSelections()[0];
let firstNode = projectObj.project.mainTree.items[selection.row]; //当多选的情况，用mainTree.selected判断不正确,要用第一个选中的节点
for (let i = 0; i < selection.rowCount; i++) {
//多选的时候判断所有与第一个节点同级的节点
let temNode = projectObj.project.mainTree.items[selection.row + i];
if (firstNode.getParentID() == temNode.getParentID()) {
if (BlockController.copyBtnDisable(temNode) == true) {
return true;
}
}
}
return false;
},
callback: function () {
$.bootstrapLoading.start();
//let selected = project.mainTree.selected;
let selections = projectObj.mainSpread.getActiveSheet().getSelections();
setTimeout(function () {
BlockController.copyBlock(selections[0]);
$.bootstrapLoading.end();
}, 100);
},
},
pasteBlock: {
name: "粘贴整块",
icon: "fa-paste",
disabled: function () {
if (projectReadOnly) {
return true;
}
return BlockController.pasteBtnDisable(project.mainTree.selected);
},
callback: function () {
BlockController.pasteBlock(project.mainTree.selected);
},
},
recoverDeletedNodes: {
name: "恢复删除节点",
icon: "fa-undo",
disabled: function () {
return BlockController.recoverBlockDisabled();
},
callback: function () {
BlockController.recoverBlock();
},
},
editEngineer: {
name: "编辑工程内容",
icon: "fa-edit",
disabled: function () {
return projectReadOnly;
},
visible: function (key, opt) {
let selected = project.mainTree.selected;
return selected.sourceType == ModuleNames.bills && project.Bills.isEngineerEst(selected); //当焦点行是“专业工程暂估价”时，右键可见并有效。
},
callback: function () {
let node = project.mainTree.selected; //project.Bills.getNodeByFlag(project.mainTree.selected,fixedFlag.ENGINEERING_ESITIMATE);
if (node) {
projectObj.editContent(node, "engineeringContent");
}
},
},
editService: {
name: "编辑服务内容",
icon: "fa-edit",
disabled: function () {
return projectReadOnly;
},
visible: function (key, opt) {
let selected = project.mainTree.selected;
return selected.sourceType == ModuleNames.bills && project.Bills.isTotalService(selected); //当焦点行是“总承包服务费”时，右键可见并有效。
},
callback: function () {
let node = project.mainTree.selected; //project.Bills.getNodeByFlag(project.mainTree.selected,fixedFlag.TURN_KEY_CONTRACT);
if (node) {
projectObj.editContent(node, "serviceContent");
}
},
},
editAccording: {
name: "编辑签证及索赔依据",
icon: "fa-edit",
disabled: function () {
return projectReadOnly;
},
visible: function (key, opt) {
let selected = project.mainTree.selected;
return selected.sourceType == ModuleNames.bills && project.Bills.isClaimVisa(selected); //当焦点行是“签证及索赔计价”时，右键可见并有效。
},
callback: function () {
let node = project.mainTree.selected; //project.Bills.getNodeByFlag(project.mainTree.selected,fixedFlag.CLAIM_VISA);
if (node) {
projectObj.editContent(node, "claimVisa");
}
},
},
replaceMaterial: {
name: "智能材料替换",
icon: "fa-edit",
disabled: function (key, opt) {
if (projectReadOnly) {
return true;
}
let selected = project.mainTree.selected;
return selected.sourceType == ModuleNames.bills ? !(project.Bills.isFXorBX(selected) || selected.source.children.length == 0) : true; //是分项、补项或叶子清单才有效;
},
callback: function () {
MaterialController.replaceMaterial([project.mainTree.selected]);
},
visible: function (key, opt) {
//2018-11-15 暂时隐藏
return false;
},
},
createBlocks: {
name: "生成组价模板",
icon: "fa-puzzle-piece",
disabled: function (key, opt) {
if (projectReadOnly) {
return true;
}
let selected = project.mainTree.selected;
return selected.sourceType != ModuleNames.bills;
},
callback: function () {
blockLibObj.checkShow();
},
visible: function (key, opt) {
let rst = G_SHOW_BLOCK_LIB;
if (compilationName === "内蒙古高速公路日常养护估算(2021)") rst = false;
return rst;
// return G_SHOW_BLOCK_LIB;
},
},
},
});
},
// 计算node及node的所有父项
converseCalculateBills: function (node) {
projectObj.project.calcProgram.calcAndSave(node);
},
// 获取上次退出时的焦点位置
loadFocusLocation: function (orow, ocol) {
const projectId = scUrlUtil.GetQueryString("project");
let row = gljUtil.isDef(orow) ? orow : getLocalCache("lastRow:" + projectId);
let col = gljUtil.isDef(ocol) ? ocol : getLocalCache("lastCol:" + projectId);
if (row == null || col == null) {
//默认焦点定位到造价书的第一行“分项”。
col = 1;
row = 0;
for (let i = 0; i < this.mainController.tree.items.length; i++) {
let node = this.mainController.tree.items[i];
if (node && node.sourceType == ModuleNames.bills && (node.data.type === billType.FX || node.data.type === billType.BX)) {
//默认字位到第一条分项或补项
row = i;
break;
}
}
}
row = parseInt(row);
col = parseInt(col);
const sheet = this.mainSpread.getActiveSheet();
sheet.setSelection(row, col, 1, 1);
row = row < this.mainController.tree.items.length ? row : 0;
this.mainController.setTreeSelected(this.mainController.tree.items[row]); //触发树节点选中事件
sheet.showRow(row, GC.Spread.Sheets.VerticalPosition.center);
},
// 选中区域合计数字
amountAreaNumber: function (e, info) {
if (info.newSelections === undefined || info.newSelections.length <= 0) {
return false;
}
const selectedArea = info.newSelections[0];
const sheet = info.sheet;
if (selectedArea.colCount <= 1 && selectedArea.rowCount <= 1) {
return false;
}
//获取最左最右坐标
let maxCell = { row: selectedArea.row, col: selectedArea.col + selectedArea.colCount };
let maxCellX = sheet.getCellRect(maxCell.row, maxCell.col).x
? sheet.getCellRect(maxCell.row, maxCell.col).x
: sheet.getCellRect(maxCell.row, maxCell.col - 1).x;
let minCell = { row: selectedArea.row, col: selectedArea.col };
let minCellX = sheet.getCellRect(minCell.row, minCell.col).x
? sheet.getCellRect(minCell.row, minCell.col).x
: sheet.getCellRect(minCell.row, minCell.col + 1).x;
// 获取鼠标位置
let x = window.event.clientX;
let y = window.event.clientY;
// 匹配数字或小数
const regular = /^([0-9]+[.]{1}[0-9]+)$|^([1-9]{1}\d*)$/;
// 小数点最高位数
let max = 0;
let total = 0;
let counter = 0;
let notNumber = false; //如果有非数字，则不显示
for (let col = selectedArea.col; col < selectedArea.colCount + selectedArea.col; col++) {
for (let row = selectedArea.row; row < selectedArea.rowCount + selectedArea.row; row++) {
const value = sheet.getCell(row, col).text();
if (!regular.test(value)) {
if (value) notNumber = true;
continue;
}
counter++;
// 获取当前数据小数位数
let pointPosition = value.toString().indexOf(".");
pointPosition = pointPosition < 0 ? pointPosition : pointPosition + 1;
const current = pointPosition > 0 ? value.toString().substring(pointPosition, value.toString().length).length : 0;
max = current > max ? current : max;
total += parseFloat(value);
}
}
// 如果不为0则悬浮显示
if (notNumber === false && total > 0 && counter > 1) {
const div = $(
''
);
div.css({
position: "absolute",
border: "1px #C0C0C0 solid",
background: "#fff",
boxShadow: "1px 2px 5px rgba(0,0,0,0.4)",
});
div.children("p").css({
textAlign: "center",
padding: 8,
marginBottom: 2,
});
div.children("p").first().css({
borderBottom: "1px #C0C0C0 solid",
});
const totalString = total.toFixed(max);
// input长度
const inputWidth = totalString.length * 8;
// 计算是否会超出显示范围
const baseWidth = 48;
const baseHeight = 81;
const canvasWidth = $("#billsSpreadvp_vp").width();
const canvasHeight = $("#billsSpreadvp_vp").height();
//x = x + baseWidth + inputWidth > canvasWidth ? x - baseWidth - inputWidth : x;
x = maxCellX + baseWidth + inputWidth > canvasWidth ? minCellX - baseWidth - inputWidth : maxCellX + baseWidth;
y = y + baseHeight > canvasHeight ? y - baseHeight : y;
//test
let testT = sheet.getParent().hitTest(x, y);
//test
div.css({
left: x,
top: y,
});
div.children().children("#total").width(inputWidth).val(totalString);
$("body").append(div);
// 用于判断是否要关闭窗体
setTimeout(function () {
isTotalShowing = true;
}, 200);
}
},
onButtonClick: function (e, info) {
let colSetting = projectObj.mainController.setting.cols[info.col];
let node = projectObj.project.mainTree.items[info.row];
let fieldName = colSetting.data.field;
if (fieldName == "isSubcontract") {
projectObj.onSubcontractClick(node);
} else if (fieldName == "isEstimate") {
projectObj.onIsEstimateClick(node, info);
} else if (fieldName == "evaluationProject") {
projectObj.onEvaluationProjectClic(node, info);
} else if (fieldName == "unitPriceAnalysis") {
projectObj.onUnitPriceAnalysisClick(node, info);
} else if (fieldName == "appraisalBills" || fieldName == "lockUnitPrice" || fieldName == "outPutMaxPrice" || fieldName == "outPutLimitPrice") {
projectObj.onCasCadeButtonClick(node, info, fieldName);
}
},
onEvaluationProjectClic: function (node, info) {
let checkboxValue = info.sheet.getCell(info.row, info.col).value();
let newval = checkboxValue ? 0 : 1;
projectObj.project.updateEvalproject(newval, node.data, function (programID) {
node.updateData.evaluationProject = newval;
node.updateData.programID = programID;
node.changed = true;
projectObj.project.calcProgram.calcAndSave(node);
});
},
setAndGetCheckBoxVal: function (info) {
let checkboxValue = info.sheet.getCell(info.row, info.col).value();
let cell = info.sheet.getCell(info.row, info.col),
newval = 0;
if (checkboxValue) {
newval = 0;
cell.value(newval);
} else {
newval = 1;
cell.value(newval);
}
return newval;
},
onIsEstimateClick: function (node, info) {
let newval = projectObj.setAndGetCheckBoxVal(info);
if (MainTreeCol.readOnly.bills(node)) {
projectObj.updateNodeField(node, newval, "isEstimate");
} else if (node.data.projectGLJID) {
//更新的是定额类型的工料机或者是显示在造价书页面的主材、设备
console.log(node);
let updateData = { id: node.data.projectGLJID, field: "is_evaluate", value: newval };
projectObj.project.projectGLJ.pGljUpdate(updateData);
}
},
onUnitPriceAnalysisClick: function (unode, info) {
let updateDatas = [],
nodes = [];
let newval = projectObj.setAndGetCheckBoxVal(info);
//仅对大项费用、清单有效，修改父项清单，子项清单跟随修改。
if (unode.sourceType == ModuleNames.bills) unitPriceAnalysisUpdate(unode, newval);
if (updateDatas.length > 0) {
$.bootstrapLoading.start();
projectObj.project.updateNodes(updateDatas, function () {
for (let n of nodes) {
n.data.unitPriceAnalysis = newval;
}
projectObj.mainController.refreshTreeNode(nodes);
$.bootstrapLoading.end();
});
}
function unitPriceAnalysisUpdate(node, val) {
updateDatas.push(getUnitPriceUpdataData(node, val));
nodes.push(node);
if (node.children.length > 0 && node.children[0].sourceType == ModuleNames.bills) {
//仅对大项费用、清单有效
for (let i = 0; i < node.children.length; i++) {
unitPriceAnalysisUpdate(node.children[i], val);
}
}
}
function getUnitPriceUpdataData(node, val) {
let data = {
type: node.sourceType,
data: {
ID: node.data.ID,
unitPriceAnalysis: val,
},
};
return data;
}
},
onCasCadeButtonClick: function (node, info, fieldName) {
let checkboxValue = info.sheet.getCell(info.row, info.col).value();
let cell = info.sheet.getCell(info.row, info.col),
newval = true;
if (checkboxValue == true) {
newval = false;
} else {
newval = true;
}
projectObj.project.updateCasCadeBills(node, newval, fieldName, fieldName != "lockUnitPrice");
},
onSubcontractClick: function (node) {
//点击分包费checkbox
if (node.updateData.isSubcontract) node.updateData.isSubcontract = false;
else node.updateData.isSubcontract = true;
node.changed = true;
projectObj.project.calcProgram.calcAndSave(node);
},
//根据节点获取行style(颜色、字体加粗)
getNodeColorStyle: function (sheet, node, tree) {
let colorSetting = optionsOprObj.getOption(optionsOprObj.optionsTypes.COLOROPTS);
let mapping = {
DEFAULT: "DEFAULT",
SELECTED: "SELECTED",
DXFY: "DXFY",
FB: "FB",
UNLEAFBILL: "UNLEAFBILL",
FX: "FX",
BX: "BX",
UNCBBILL: "UNCBBILL",
CBBILL: "CBBILL",
ZCSB: "ZCSB",
};
let styleMap = null;
tree ? "" : (tree = this.project.mainTree);
//中文字段名，由于同一节点中，中文字体大小和数字字体大小不同
if (colorSetting == null) {
return null;
}
let stringFields = ["code", "subType", "name", "unit", "itemCharacterText", "jobContentText", "adjustState", "calcBase", "programID", "ruleText"];
if (!isDef(node)) {
return null;
}
//清单大类
if (node.sourceType === this.project.Bills.getSourceType()) {
//大项费用
if (node.data.type === billType.DXFY) {
styleMap = mapping.DXFY;
}
//分部
if (node.data.type === billType.FB) {
styleMap = mapping.FB;
}
//分项
else if (node.data.type === billType.FX) {
styleMap = mapping.FX;
}
//补项
else if (node.data.type === billType.BX) {
styleMap = mapping.BX;
}
//清单
else if (node.data.type === billType.BILL) {
//非叶子节点的清单
if (node.source.children.length > 0) {
styleMap = mapping.UNLEAFBILL;
}
//未使用基数计算的叶子节点的清单
else if (node.source.children.length === 0 && (!isDef(node.data.calcBase) || node.data.calcBase === "")) {
styleMap = mapping.UNCBBILL;
}
//使用基数计算的叶子节点的清单
else if (node.source.children.length === 0 && isDef(node.data.calcBase && node.data.calcBaseValue !== "")) {
styleMap = mapping.CBBILL;
}
}
}
//定额下的主材、设备
else if (node.sourceType === this.project.ration_glj.getSourceType()) {
styleMap = mapping.ZCSB;
} else {
styleMap = mapping.DEFAULT;
}
let styleSetting = colorSetting[styleMap];
let defaultSetting = colorSetting[mapping.DEFAULT];
if (!isDef(styleSetting)) {
return null;
}
let style = new GC.Spread.Sheets.Style();
//设置style属性
for (let attr in styleSetting) {
if (attr !== "stringFont" && attr !== "numFont") {
style[attr] = styleSetting[attr] === "default" || !isDef(styleSetting[attr]) ? defaultSetting[attr] : styleSetting[attr];
}
//暂时不开放字体设置，开放的话只能每个单元格进入此方法
/* else {
if(stringFields.indexOf(colSetting.data.field) > 0){
style.font = styleSetting.stringFont === 'default' || !isDef(styleSetting.stringFont) ? defaultSetting.stringFont : styleSetting.stringFont;
}
else {
style.font = styleSetting.numFont === 'default' || !isDef(styleSetting.numFont) ? defaultSetting.numFont : styleSetting.numFont;
}
}*/
}
//选中行-替换底色
if (node === tree.selected) {
style.backColor = colorSetting[mapping.SELECTED]["backColor"];
}
if (_ && !_.isEmpty(node.data.bookmarkBackground)) style.backColor = "#" + node.data.bookmarkBackground; //设置书签和批注背景色
//大项费用加粗（数字与中文字符大小不一问题由字体造成，暂时不考虑分别设置大小）
/* if(node.sourceType === this.project.Bills.getSourceType() && node.data.type === billType.DXFY){
style.font = 'bold 14px Arial';
}*/
style.borderLeft = new GC.Spread.Sheets.LineBorder("#D4D4D4", GC.Spread.Sheets.LineStyle.thin);
style.borderTop = new GC.Spread.Sheets.LineBorder("#D4D4D4", GC.Spread.Sheets.LineStyle.thin);
style.borderRight = new GC.Spread.Sheets.LineBorder("#D4D4D4", GC.Spread.Sheets.LineStyle.thin);
style.borderBottom = new GC.Spread.Sheets.LineBorder("#D4D4D4", GC.Spread.Sheets.LineStyle.thin);
return style;
},
//大项费用则字体加粗，String 15px, Number 13px
getBoldFontStyle: function (node, colSetting) {
let style = new GC.Spread.Sheets.Style();
if (node.sourceType !== this.project.Bills.getSourceType() || node.data.type !== billType.DXFY) {
return null;
}
//备注暂无字段
let stringFields = ["code", "subType", "name", "unit", "itemCharacterText", "jobContentText", "adjustState", "calcBase", "programID", "ruleText"];
style.font = "bold 14px Arial";
return style;
},
//设置节点style
setNodesStyle: function (sheet, nodes, tree) {
let me = this;
TREE_SHEET_HELPER.massOperationSheet(sheet, function () {
for (let node of nodes) {
if (node && node.serialNo() != -1) {
sheet.getRange(node.serialNo(), -1, 1, -1).backColor(me.getNodeColorStyle(sheet, node, tree).backColor);
}
}
});
},
loadLockBillsButton: function () {
if (projectObj.project.projectInfo.property.lockBills == true) {
//$("a[name='lockBills']").attr("data-original-title","解锁清单");
$("a[name='lockBills']").html(' 解锁清单');
} else {
//$("a[name='lockBills']").attr("data-original-title","锁定清单");
$("a[name='lockBills']").html(' 锁定清单');
}
},
editContent: function (node, fieldID) {
//右键编辑工程内容、服务内容、签证及索赔依据
let infoText = "请输入";
switch (fieldID) {
case "engineeringContent":
infoText += "工程内容:";
break;
case "serviceContent":
infoText += "服务内容:";
break;
case "claimVisa":
infoText += "签证及索赔依据:";
break;
}
hintBox.valueBox(infoText, node.data[fieldID], function () {
let newValue = hintBox.value;
projectObj.updateNodeField(node, newValue, fieldID);
});
},
ifItemCharHiden: function (setting) {
//项目特征及内容列是否隐藏
if (this.itemCol == null || this.itemCol == undefined) {
this.itemCol = _.find(setting.cols, function (item) {
return item.data.field == "itemCharacterText";
});
}
return this.itemCol ? !this.itemCol.visible : true;
},
onCommonTotalFeeButtonClick: function (hitinfo) {
let me = calcBaseView;
let node = projectObj.project.mainTree.items[hitinfo.row] ? projectObj.project.mainTree.items[hitinfo.row] : null;
if (hitinfo.sheet.getParent() === projectObj.mainSpread) {
projectObj.mainController.setTreeSelected(node);
}
hitinfo.sheet.setActiveCell(hitinfo.row, hitinfo.col);
calcBaseView.confirmBtn.attr("toggle", "commonTotalFee");
//changeCalcBaseFeeRate('commonTotalFee');//公路上不需要费率选项页
changeCalcBaseFeeRate("calcBase");
$("#tabCalcBase").tab("show");
calcBaseView.initCalctor("bills");
//feeRateObject.showSelectModal(hitinfo);
},
selectColAndFocus: function (newNode, field = "code") {
//选中单元格并设置焦点
if (newNode) {
if (field != null) projectObj.mainController.sheet.setSelection(newNode.serialNo(), colSettingObj.getColByField(field), 1, 1); //自动定位到编号单元格
projectObj.mainSpread.focus();
}
},
cusRationCombCheck: function (sheet) {
//检查自定义定额编号下拉框，右键的时候不自动消失，现手动结束编辑，并删除元素
if (sheet.isEditing()) {
sheet.endEdit();
}
if ($("#rationCheckBox").is(":visible")) $("#rationCheckBox").parent().parent().remove();
},
};
// 点击合计框中的复制
$("body").on("click", "#total-tips a", function () {
const totalElement = $(this).parent().siblings("p").find("#total");
totalElement.select();
document.execCommand("Copy");
$(this).text("已复制");
});
// 合计框点击其他位置关闭
let isTotalShowing = false;
$("body").on("click", function (e) {
if (isTotalShowing && !$(e.target).is("#total-tips") && !$(e.target).is("#total-tips p") && !$(e.target).is("#total-tips p a")) {
$("#total-tips").remove();
isTotalShowing = false;
}
});
/*$('#insert').click(function () {
var controller = projectObj.mainController, project = projectObj.project;
var selected = controller.tree.selected;
if (!selected || selected.sourceType === project.Bills.getSourceType()) {
ProjectController.addBills(project, controller);
} else if (selected.sourceType === project.Ration.getSourceType()) {
ProjectController.addRation(project, controller, selected.data.type);
};
});*/
$("#delete").click(function () {
let project = projectObj.project;
let selected = project.mainTree.selected;
if (isSingleSelect() && selected.sourceType == project.Bills.getSourceType() && selected.data.type == billType.FB && selected.children.length <= 0) {
//选中的是分部，并且没有子项，直接删除
project.Bills.deleteSelectedNode();
} else {
$("#delete_row").modal({ show: true }); //弹出删除提示框;
}
});
// TODO 造价书节点的升降级、上下移都是异步的，不等服务器响应直接进行前端更新的。有风险，后续可能需要改。
// 节流，防止快速触发
const throttleTime = 400;
const throttleUpLevel = _.throttle(() => {
const controller = projectObj.mainController;
const project = projectObj.project;
const mainTreeNodes = controller.getValidNodesWithinSelection();
const billsNodes = mainTreeNodes.map((node) => node.source);
const orgParent = mainTreeNodes[0].parent;
project.Bills.multiUpLevelBills(project.Bills.tree, billsNodes);
controller.multiUpLevel(mainTreeNodes);
const refreshNodes = [orgParent, ...mainTreeNodes];
controller.refreshTreeNode(refreshNodes);
projectObj.project.calcProgram.calcNodesAndSave(refreshNodes);
}, throttleTime);
$("#upLevel").click(throttleUpLevel);
const throttleDownLevel = _.throttle(() => {
const controller = projectObj.mainController;
const project = projectObj.project;
const mainTreeNodes = controller.getValidNodesWithinSelection();
const billsNodes = mainTreeNodes.map((node) => node.source);
const orgParent = mainTreeNodes[0].parent;
const preNode = mainTreeNodes[0].preSibling; //降级前的前一节点变成降级后新的父节点，要重新计算
project.Bills.multiDownLevelBills(project.Bills.tree, billsNodes);
controller.multiDownLevel(mainTreeNodes);
controller.refreshTreeNode([orgParent, ...mainTreeNodes]);
projectObj.converseCalculateBills(preNode);
}, throttleTime);
$("#downLevel").click(throttleDownLevel);
$("#insertRation").click(function () {
// projectObj.project.Ration.addNewRation(null,rationType.ration);
// 连续点工具栏的插入定额按钮，显示树结构画线有问题。
// projectObj.project.Ration.addNewRationFast(rationType.ration,projectObj.selectColAndFocus);
//2020-01-08 要限制定额数量，所以还是要用等回传信息的方式插入定额
projectObj.project.Ration.addNewRation(null, rationType.ration, projectObj.selectColAndFocus, false);
});
const throttleUpMove = _.throttle(() => {
const controller = projectObj.mainController;
const project = projectObj.project;
const mainTreeNodes = controller.getValidNodesWithinSelection();
const sourceNodes = mainTreeNodes.map((node) => node.source);
const firstNode = mainTreeNodes[0];
if (firstNode.sourceType === commonConstants.SourceType.BILLS) {
project.Bills.multiUpMoveBills(project.Bills.tree, sourceNodes);
controller.multiUpMove(mainTreeNodes);
} else if (firstNode.sourceType === commonConstants.SourceType.RATION) {
project.Ration.changeMultiPos(mainTreeNodes[0].preSibling.source, sourceNodes);
controller.multiUpMove(mainTreeNodes);
}
}, throttleTime);
$("#upMove").click(throttleUpMove);
const throttleDownMove = _.throttle(() => {
const controller = projectObj.mainController;
const project = projectObj.project;
const mainTreeNodes = controller.getValidNodesWithinSelection();
const sourceNodes = mainTreeNodes.map((node) => node.source);
const firstNode = mainTreeNodes[0];
if (firstNode.sourceType === commonConstants.SourceType.BILLS) {
project.Bills.multiDownMoveBills(project.Bills.tree, sourceNodes);
controller.multiDownMove(mainTreeNodes);
} else if (firstNode.sourceType === commonConstants.SourceType.RATION) {
const nextSource = mainTreeNodes[mainTreeNodes.length - 1].nextSibling.source;
const reverseSource = [...sourceNodes].reverse();
project.Ration.changeMultiPos(nextSource, reverseSource);
controller.multiDownMove(mainTreeNodes);
}
}, throttleTime);
$("#downMove").click(throttleDownMove);
$("a[name='lockBills']").click(function () {
//点击锁定/解锁清单
let lockBills = projectObj.project.projectInfo.property.lockBills;
lockBills = !lockBills;
projectObj.project.updateLockBills(lockBills, function () {
var controller = projectObj.mainController,
project = projectObj.project;
var selected = controller.tree.selected;
let nodes = _.filter(project.mainTree.items, { sourceType: ModuleNames.bills });
controller.refreshTreeNode(nodes);
projectObj.mainController.setTreeSelected(selected); //触发树节点选中事件
projectObj.loadLockBillsButton();
});
});
$("#ZLFB_btn").click(function () {
zlfb_object.getSectionInfo();
});
//显示至..
let displayLevel = function (nodes, depth, type) {
let refreshNodes = [];
function getExpandedController() {
if (["X", "M", "J", "XM"].includes(type)) {
//项、目、节、细目
return function expandedControl(nodes, depth) {
for (let node of nodes) {
let nodeDepth = node.depth();
if (nodeDepth <= depth) {
let expanded =
(nodeDepth === depth && !node.children[0]) || (nodeDepth < depth && node.children[0] && node.children[0].data.type === billType.BILL)
? true
: false;
node.setExpanded(expanded);
refreshNodes.push(node);
if (nodeDepth < depth) {
expandedControl(node.children, depth);
}
}
}
};
} else {
return function expandedControl(nodes) {
for (let node of nodes) {
if (node.sourceType === projectObj.project.Bills.getSourceType()) {
let expanded = true;
if (type === "ZDCXM") {
expanded = !node.children[0] || (node.children[0] && node.children[0].sourceType !== projectObj.project.Ration.getSourceType()) ? true : false;
}
node.setExpanded(expanded);
refreshNodes.push(node);
expandedControl(node.children);
}
}
};
}
}
getExpandedController()(nodes, depth);
let sheet = projectObj.mainSpread.getActiveSheet();
TREE_SHEET_HELPER.massOperationSheet(sheet, function () {
TREE_SHEET_HELPER.refreshNodesVisible(refreshNodes, projectObj.mainSpread.getActiveSheet(), true);
});
};
// 数据接口
$("#open-export-modal").click(() => {
CommonHeader.doAfterValidateVersion(
() => $("#interface-export-modal").modal("show"),
() => alert(`${commonUtil.getVersionText()}不提供此功能。`)
// () => $('#interface-export-modal').modal('show'), // 暂时
);
});
//导入下拉
$("#importSpan").click(function () {
$('[data-toggle="tooltip"]').tooltip("hide");
$("#import").modal("show");
});
$("#importDropDown").click(function () {
$('[data-toggle="tooltip"]').tooltip("hide");
});
$("body").click(function () {
//点击完后隐藏子菜单
if ($("#subDisplay").is(":visible")) {
$("#subDisplay").removeClass("show");
}
});
let enterDisplayA = false;
//鼠标移到显示至，自动弹出子菜单
$("#displayA").mouseenter(function (e) {
enterDisplayA = true;
$("#subDisplay").addClass("show");
});
$("#displayA").mouseleave(function () {
enterDisplayA = false;
});
$("#moreMenu > a").mouseenter(function () {
if (!enterDisplayA) {
$("#subDisplay").removeClass("show");
}
});
//项
$("#displayX").click(function () {
displayLevel(projectObj.project.mainTree.items, 1, "X");
});
//目
$("#displayM").click(function () {
displayLevel(projectObj.project.mainTree.items, 2, "M");
});
//节
$("#displayJ").click(function () {
displayLevel(projectObj.project.mainTree.items, 3, "J");
});
//细目
$("#displayXM").click(function () {
displayLevel(projectObj.project.mainTree.items, 4, "XM");
});
//最底层细目
$("#displayZDCXM").click(function () {
displayLevel(projectObj.project.mainTree.items, null, "ZDCXM");
});
//定额
$("#displayDE").click(function () {
displayLevel(projectObj.project.mainTree.items, null, "DE");
});
$("#poj-set").on("show.bs.modal", function () {
let setCalcFlag = function (obj, val, curFlag) {
obj.val(val);
if (val === curFlag) {
obj.prop("checked", true);
} else {
obj.prop("checked", false);
}
};
if (projectObj.project) {
//江西重定义了leafBillGetFeeType的内容
// 预算：bill, 正算，rationPrice: 2,
// 清单：ration, 反算，rationPriceConverse: 1,
let defaultCalcMode = projectObj.project.property.valuationType !== "ration" ? leafBillGetFeeType.rationPrice : leafBillGetFeeType.rationPriceConverse;
let ft =
projectObj.project.property.billsCalcMode !== undefined && projectObj.project.property.billsCalcMode !== null
? projectObj.project.property.billsCalcMode
: defaultCalcMode;
let zg =
projectObj.project.property.zanguCalcMode !== undefined && projectObj.project.property.zanguCalcMode !== null
? projectObj.project.property.zanguCalcMode
: zanguCalcType.common;
setCalcFlag($("#rationContent"), leafBillGetFeeType.rationContent, ft);
setCalcFlag($("#rationPriceConverse"), leafBillGetFeeType.rationPriceConverse, ft);
setCalcFlag($("#rationPrice"), leafBillGetFeeType.rationPrice, ft);
setCalcFlag($("#billsPrice"), leafBillGetFeeType.billsPrice, ft);
setCalcFlag($("#zangu_common"), zanguCalcType.common, zg);
setCalcFlag($("#zangu_gatherMaterial"), zanguCalcType.gatherMaterial, zg);
let showAdjustPrice = projectObj.project.projSetting.glj_col ? projectObj.project.projSetting.glj_col.showAdjustPrice : false;
showAdjustPrice === true ? $("#tab_poj-settings-6").show() : $("#tab_poj-settings-6").hide();
projDisplayView.init();
calcOptions.init();
}
let propertyInfo = projectObj.project.projectInfo.property;
//关于计算-价差预备费//预算项目才有
if (propertyInfo.valuationType !== "ration") {
$("#jcybf").show();
//年造价增涨率,单位为%
$("#costGrowthRate").val(propertyInfo.costGrowthRate ? propertyInfo.costGrowthRate * 100 : 0);
//增涨计费年限
$("#growthPeriod").val(propertyInfo.growthPeriod ? propertyInfo.growthPeriod : 0);
}
});
function isKeyNumber(keyCode) {
// 数字
if (keyCode >= 48 && keyCode <= 57) {
return true;
} else if (keyCode >= 96 && keyCode <= 105) {
//小键盘数字
return true;
} else if (keyCode == 8 || keyCode == 46 || keyCode == 37 || keyCode == 39 || keyCode == 108 || keyCode == 110) {
// Backspace, del, 左右方向键
return true;
} else if (keyCode >= 112 && keyCode <= 123) {
//F1 -F12
return true;
}
return false;
}
//年造价增涨率
$("#costGrowthRate").keydown(function (e) {
return isKeyNumber(e.keyCode);
});
//计费年限
$("#growthPeriod").keydown(function (e) {
return isKeyNumber(e.keyCode);
});
//恢复默认列设置
$("#recColSetting").click(function () {
let libID = projectObj.project.property.colLibID ? projectObj.project.property.colLibID : null;
if (!libID) {
alert("项目没有绑定标准列设置");
return;
}
$(this).addClass("disabled");
CommonAjax.post(
"/project/getDefaultColSetting",
{ libID: libID },
function (rstData) {
if (!rstData || rstData.length === 0) {
alert("标准列设置没有数据");
$("#recColSetting").removeClass("disabled");
return;
}
let sheet = colSettingObj.settingSpread.getActiveSheet();
SheetDataHelper.massOperationSheet(sheet, function () {
for (let row = 0; row < sheet.getRowCount(); row++) {
sheet.setValue(row, 0, rstData.main_tree_col.cols[row].visible);
}
});
$("#recColSetting").removeClass("disabled");
},
function () {
$("#recColSetting").removeClass("disabled");
}
);
});
//恢复默认系统设置
$("#property_default").click(function () {
let project = projectObj.project,
projectID = project.ID();
/*
* 清除窗口比例缓存
* */
//清单精灵/指引窗口比例
removeLocalCache("stdBillsGuidanceTabmainWidth");
removeLocalCache("stdBillsGuidanceTabmainSideWidth");
// 清单展开状态
window.sessionStorage.removeItem("stdBillsGuidanceExpState");
//定额库窗口比例
removeLocalCache("stdRationTabmainWidth");
removeLocalCache("stdRationTabmainSideWidth");
removeLocalCache("dedeTopDivHeight");
removeLocalCache("dedeBottomDivHeight");
//查找定位窗口比例
removeLocalCache("locateTabmainWidth");
removeLocalCache("locateTabmainSideWidth");
removeLocalCache("locatelocateTopDivHeight");
removeLocalCache("locatelocateBottomDivHeight");
//块模板库窗口比例
removeLocalCache("kmbkkmbkTopDivHeight");
removeLocalCache("kmbkkmbkMidDivHeight");
removeLocalCache("kmbkkmbkBottomDivHeight");
//主界面窗口比例
removeLocalCache("mainVerticaltop_divHeight");
removeLocalCache("mainVerticalbottom_divHeight");
//造价书下方-人材机和项目特征文本
removeLocalCache("subRcjsubSpreadWidth");
removeLocalCache("subRcjitemTextDivWidth");
//造价书下方-子目换算下调整状态和辅助值
removeLocalCache("subRcjitemTextDivWidth");
removeLocalCache("subRcjitemTextDivWidth");
//造价书下方-特征及内容窗口比例
removeLocalCache("subZmhscoeSpreadWidth");
removeLocalCache("subZmhsassDivWidth");
//人材机汇总窗口比例
removeLocalCache("projectGljprojectGljTopHeight");
removeLocalCache("projectGljprojectGljBottomHeight");
//补充人材机库
removeLocalCache("compleGLjleftContentWidth");
removeLocalCache("compleGLjmidContentWidth");
removeLocalCache("compleGLjrightContentWidth");
//补充定额库
removeLocalCache("compleRationleftContentWidth");
removeLocalCache("compleRationmainContentWidth");
removeLocalCache("compleRationzmhsContentWidth");
removeLocalCache("compleRationrationItemsSheetHeight");
removeLocalCache("compleRationsubContentHeight");
removeLocalCache("compleRationmainSpreadHeight");
removeLocalCache("compleRationcontentSpreadHeight");
//在后台恢复一些设置
CommonAjax.post("/pm/api/defaultSettings", { user_id: userID, projectID: projectID }, function (rstData) {
window.location.href = `/main?project=${projectID}`;
});
});
$("#property_ok").click(function () {
let project = projectObj.project,
projectID = project.ID(),
properties = {},
options = {},
labourCoes = {},
rations = [],
bills = [],
mixDatas = {
projectID: projectID,
updateType: "update",
properties: properties,
options: options,
labourCoes: labourCoes,
rations: rations,
bills: bills,
},
reCalcBills = false,
reCalcRations = false;
let b = parseInt($("input[name='calcFlag']:checked").val());
if (b !== project.property.billsCalcMode) {
properties["property.billsCalcMode"] = b;
project.property.billsCalcMode = b;
reCalcBills = true;
}
let zg = parseInt($("input[name='zangu']:checked").val());
if (zg !== project.property.zanguCalcMode) {
properties["property.zanguCalcMode"] = zg;
project.property.zanguCalcMode = zg;
reCalcRations = true;
}
//价差预备费,预算项目才有
if (project.property.valuationType !== "ration") {
let costGrowthRateV = $("#costGrowthRate").val(),
costGrowthRate = costGrowthRateV ? parseFloat(costGrowthRateV / 100) : 0,
growthPeriodV = $("#growthPeriod").val(),
growthPeriod = growthPeriodV ? parseFloat(growthPeriodV) : 0;
if (project.property.costGrowthRate !== costGrowthRate) {
properties["property.costGrowthRate"] = costGrowthRate;
project.property.costGrowthRate = costGrowthRate;
reCalcBills = true;
}
if (project.property.growthPeriod !== growthPeriod) {
properties["property.growthPeriod"] = growthPeriod;
project.property.growthPeriod = growthPeriod;
reCalcBills = true;
}
}
//基本信息
if (basicInfoView.toUpdate(basicInfoView.orgDatas, basicInfoView.datas)) {
let saveData = basicInfoView.toSaveDatas(basicInfoView.datas);
projectObj.project.property.basicInformation = saveData;
properties["property.basicInformation"] = saveData;
}
//工程特征
let diffBillsPriceFeatureDatas = [];
if (projFeatureView.toUpdate(projFeatureView.orgDatas, projFeatureView.datas)) {
let saveData = projFeatureView.toSaveDatas(projFeatureView.datas);
projectObj.project.property.projectFeature = saveData;
properties["property.projectFeature"] = saveData;
//内蒙古养估、广东农村等有些特征修改后，需要刷新指标基价(清单单价)
//*
if (billsUnitPriceFeature) {
for (let idx = 0; idx < projFeatureView.orgDatas.length; idx++) {
if (projFeatureView.orgDatas[idx].value !== projFeatureView.datas[idx].value) {
diffBillsPriceFeatureDatas.push(projFeatureView.datas[idx]);
}
}
}
//*/
}
// 清单限价
const maxPriceRate = $("#max-price-rate") && +$("#max-price-rate").val();
if (commonUtil.isNumber(maxPriceRate) && maxPriceRate !== projectObj.project.property.maxPriceRate) {
properties["property.maxPriceRate"] = maxPriceRate;
}
const minPriceRate = $("#min-price-rate") && +$("#min-price-rate").val();
if (commonUtil.isNumber(minPriceRate) && minPriceRate !== projectObj.project.property.minPriceRate) {
properties["property.minPriceRate"] = minPriceRate;
}
//清单工程量精度
let newBillsDecimalDatas = billsDecimalView.toBillsDecimalDatas(billsDecimalView.cache);
if (billsDecimalView.toUpdate(billsQuanDecimal.datas, newBillsDecimalDatas)) {
billsQuanDecimal.datas = newBillsDecimalDatas;
reCalcBills = true;
properties["property.billsQuantityDecimal"] = newBillsDecimalDatas;
}
//小数位数
let updateDecimal = m_getDecimalData($("input", "#poj-settings-decimal"));
if (toUpdateDecimal(decimalObj, updateDecimal)) {
let frChanged = decimalObj.feeRate != updateDecimal.feeRate;
setDecimal(decimalObj, updateDecimal);
if (frChanged) {
project.calcProgram.compileAllTemps();
}
reCalcRations = true;
reCalcBills = true;
properties["property.decimal"] = updateDecimal;
}
// 呈现选项
projDisplayView.updateChecking(properties);
//列设置（独立逻辑，只是通过项目属性确定按钮触发）
if (colSettingObj.dataChanged()) {
colSettingObj.updateColSetting();
}
//系统选项
if (optionsOprObj.needToSaveGeneralOpts()) {
let v1 = optionsOprObj.rationQuanACToBillsQuan.prop("checked"),
v2 = optionsOprObj.rationQuanACToRationUnit.prop("checked"),
progressiveType = parseInt($("input[name='progressiveType']:checked").val());
options.updateData = {
rationQuanACToBillsQuan: v1,
rationQuanACToRationUnit: v2,
progressiveType: progressiveType,
};
optionsOprObj.options[optionsOprObj.optionsTypes.GENERALOPTS].progressiveType = progressiveType;
}
if (calcOptions.updateChecking(properties)) {
reCalcRations = true;
}
// 人工系数
if (labourCoeView.needSave()) {
let libID = $("#std_labour_coe_files").children("option:selected").val();
let libName = $("#std_labour_coe_files").children("option:selected").text();
labourCoes.updateData = { libID: libID, libName: libName, newItemArr: labourCoeView.needUpdateDatas };
project.labourCoe.refreshData(labourCoes.updateData); // 全编译所用到的人工系数来自project.labourCoe，所以必须先刷新project.labourCoe
project.calcProgram.compileAllTemps();
reCalcRations = true;
reCalcBills = true;
}
// 重新计算树节点
let changedNodes = [];
if (reCalcRations)
// 定额动，全部计算。算完先不存储，和后面的数据一起提交，一次通讯。
changedNodes = project.calcProgram.calcAllNodes(calcAllType.catAll);
else if (reCalcBills)
// 清单动，可以只计算清单。
changedNodes = project.calcProgram.calcAllNodes(calcAllType.catBills);
if (changedNodes.length > 0) {
for (let node of changedNodes) {
let data = calcTools.cutNodeForSave(node);
if (node.sourceType == "ration") rations.push(data);
else if (node.sourceType == "bills") bills.push(data);
}
}
function hasMixData() {
return (
Object.keys(mixDatas.properties).length > 0 ||
mixDatas.options.updateData ||
mixDatas.labourCoes.updateData ||
mixDatas.rations.length > 0 ||
mixDatas.bills.length > 0
);
}
function needToReload(mixDatas) {
if (Object.keys(mixDatas.labourCoes).length > 0) {
return true;
}
if (Object.keys(mixDatas.properties).length > 0) {
if (
mixDatas.properties.hasOwnProperty("property.billsCalcMode") ||
mixDatas.properties.hasOwnProperty("property.zanguCalcMode") ||
mixDatas.properties.hasOwnProperty("property.calcOptions") ||
mixDatas.properties.hasOwnProperty("property.costGrowthRate") ||
mixDatas.properties.hasOwnProperty("property.growthPeriod") ||
mixDatas.properties.hasOwnProperty("property.billsQuantityDecimal") ||
mixDatas.properties.hasOwnProperty("property.decimal") ||
mixDatas.properties.hasOwnProperty("property.displaySetting")
) {
return true;
}
}
return false;
}
if (hasMixData()) {
CommonAjax.post("/pm/api/updateMixDatas", { user_id: userID, mixDataArr: mixDatas }, function (rstData) {
const doAferSuccess = () => {
$.bootstrapLoading.end();
//需要重载页面
if (needToReload(mixDatas)) {
window.location.href = "/main?project=" + projectID;
} else {
if (mixDatas.properties.hasOwnProperty("property.maxPriceRate")) {
projectObj.project.property.maxPriceRate = maxPriceRate;
}
if (mixDatas.properties.hasOwnProperty("property.minPriceRate")) {
projectObj.project.property.minPriceRate = minPriceRate;
}
if (mixDatas.properties.hasOwnProperty("property.basicInformation")) {
basicInfoView.orgDatas = basicInfoView.toViewDatas(mixDatas.properties["property.basicInformation"]);
}
if (mixDatas.properties.hasOwnProperty("property.projectFeature")) {
projFeatureView.orgDatas = projFeatureView.toViewDatas(mixDatas.properties["property.projectFeature"]);
}
if (mixDatas.options && mixDatas.options.updateData) {
let v1 = mixDatas.options.updateData["rationQuanACToBillsQuan"],
v2 = mixDatas.options.updateData["rationQuanACToRationUnit"],
progressiveType = mixDatas.options.updateData["progressiveType"];
optionsOprObj.updateOptions(optionsOprObj.options, { type: optionsOprObj.optionsTypes.GENERALOPTS, opt: "rationQuanACToBillsQuan", value: v1 });
optionsOprObj.updateOptions(optionsOprObj.options, { type: option - sOprObj.optionsTypes.GENERALOPTS, opt: "rationQuanACToRationUnit", value: v2 });
optionsOprObj.updateOptions(optionsOprObj.options, {
type: optionsOprObj.optionsTypes.GENERALOPTS,
opt: "progressiveType",
value: progressiveType,
});
}
}
};
// 改变清单库
if (rstData && rstData.billLibs) {
projectObj.project.projectInfo.engineeringInfo.bill_lib = rstData.billLibs;
$("#stdBillsGuidanceLibSelect").empty();
if ($("#zy").is(":visible")) {
billsGuidance.initLibs(rstData.billLibs);
}
}
// 需要改变费率
if (rstData && rstData.newFeeLibID) {
$.bootstrapLoading.start();
feeRateObject.feeRateSTDLoaded = false;
feeRateObject.feeRateSTDList = [];
projectObj.project.FeeRate.changeFeeRateStandard(rstData.newFeeLibID, doAferSuccess);
} else {
doAferSuccess();
}
});
}
if (diffBillsPriceFeatureDatas.length > 0) {
//刷新指标基价
if (billsGuidance.bills.tree) {
chkAndResetBills(billsGuidance.bills.workBook.getActiveSheet(), billsGuidance.bills.tree.items);
billsGuidance.bills.workBook.refresh();
} else {
chkAndResetBills(null);
}
}
});
function testShow() {
var controller = projectObj.mainController,
project = projectObj.project;
var selected = controller.tree.selected,
parent = selected.parent;
var showinfo = "";
var showN = false;
var cancelText = "否";
if (selected.sourceType == project.Bills.getSourceType() && selected.data.type == billType.FB && selected.children.length > 0) {
//选中的是分部，并且有子项
if (isSingleSelect() || selectionChecking()) {
showinfo =
"
";
showN = true;
cancelText = "取消";
}
}
$("#delete_showinfo").html(showinfo);
showN == true ? $("#deleteN").show() : $("#deleteN").hide();
$("#deleteCancel").text(cancelText);
function selectionChecking() {
let selection = projectObj.mainSpread.getActiveSheet().getSelections()[0];
let mainTreeMap = {};
for (let i = 0; i < selection.rowCount; i++) {
let tem_node = controller.tree.items[selection.row + i];
if (i == 0) {
//第一个直接添加;
mainTreeMap[tem_node.getID()] = tem_node;
} else {
project.Bills.setNodeToMap(tem_node, mainTreeMap);
}
}
let nodes = changeMapToArray(mainTreeMap);
if (nodes.length == 1) {
return true;
}
return false;
}
}
$("#delete_row").on("show.bs.modal", function (e) {
//这里用show,在shown之前调用，页面不会出现按钮闪现的情况
var controller = projectObj.mainController,
project = projectObj.project;
var selected = controller.tree.selected,
parent = selected.parent;
var showinfo = "";
var showN = false;
var cancelText = "否";
if (selected.sourceType == project.Bills.getSourceType() && selected.data.type == billType.FB && selected.children.length > 0) {
//选中的是分部，并且有子项
if (isSingleSelect() || selectionChecking()) {
showinfo =
"
";
showN = true;
cancelText = "取消";
}
} else if (isSingleSelect() && mbzm_obj.hasReferenceRation(selected)) {
//“有模板关联的定额”右键点击删除，弹窗提示“删除主子目时将删除对应的关联子目，是否继续？ 是 否” (只有单选中一条定额并且是有模板关联的定额)
showinfo = "";
}
$("#delete_showinfo").html(showinfo);
showN == true ? $("#deleteN").show() : $("#deleteN").hide();
$("#deleteCancel").text(cancelText);
function selectionChecking() {
let selection = projectObj.mainSpread.getActiveSheet().getSelections()[0];
let mainTreeMap = {},
nodes = [];
for (let i = 0; i < selection.rowCount; i++) {
let tem_node = controller.tree.items[selection.row + i];
if (i == 0) {
//第一个直接添加;
mainTreeMap[tem_node.getID()] = tem_node;
} else {
project.Bills.setNodeToMapAndArray(tem_node, mainTreeMap, nodes);
}
}
if (nodes.length == 1) {
return true;
}
return false;
}
});
function changeMapToArray(map) {
let newArray = [];
for (let key in map) {
newArray.push(map[key]);
}
return newArray;
}
$("#deleteY").click(function () {
//正常删除，级联删除子项
let project = projectObj.project;
project.Bills.deleteSelectedNodes();
});
$("#deleteN").click(function () {
//不删除子项
let controller = projectObj.mainController,
project = projectObj.project;
let selected = controller.tree.selected,
parent = selected.parent;
if (selected) {
let preNode = selected.preSibling;
let nextNode = selected.nextSibling;
if (preNode) {
//有前兄弟
if (preNode.children.length > 0 && preNode.children[0].data.type != selected.children[0].data.type) {
//并且前兄弟子项和焦点行子项类别不同。
alert("删除分部会导致分部和分项同级，不允许该操作！");
return;
}
} else if (nextNode) {
if (nextNode.data.type != selected.children[0].data.type) {
alert("删除分部会导致分部和分项同级，不允许该操作！ ");
return;
}
}
project.Bills.singleDeleteBills(selected, controller);
}
});
function isSingleSelect() {
//是否选中造价书中的单行
let selections = projectObj.mainSpread.getActiveSheet().getSelections();
if (selections[0].rowCount == 1) {
return true;
}
return false;
}
function ifCanDelete() {
if (projectReadOnly) {
return false;
}
let selections = projectObj.mainSpread.getActiveSheet().getSelections();
let tree = projectObj.project.mainTree;
let selected = projectObj.project.mainTree.selected;
if (selections[0].rowCount == 1) {
//选中单行
return canDelete(selected);
} else {
return canDelete_m(selections[0]);
}
function canDelete(node, m_selection) {
if (node) {
if (node.sourceType === projectObj.project.Bills.getSourceType()) {
if (node.data.type == billType.DXFY && node.data.isAdd != 1) {
return false;
}
if (projectObj.project.isBillsLocked() == true && projectObj.project.withinBillsLocked(node)) {
return false;
}
if (projectObj.project.Bills.hasFlags(node)) {
return false;
}
}
if (m_selection != true && node.sourceType === projectObj.project.ration_glj.getSourceType()) {
//多选的时候不做这一项判断
return false;
}
return true;
} else {
return false;
}
}
function canDelete_m(selection) {
for (let i = 0; i < selection.rowCount; i++) {
if (tree.items[selection.row + i] == undefined || tree.items[selection.row + i] == null) {
return false;
}
if (i == 0 && tree.items[selection.row].sourceType === projectObj.project.ration_glj.getSourceType()) {
return false;
}
if (canDelete(tree.items[selection.row + i], true) == false) {
return false;
}
}
return true;
}
}
function canInsertRationNode(selected) {
//判断是否能插入定额、量价、定额类型工料机, false 不能，true能
if (!selected) return false;
let project = projectObj.project;
if (selected.sourceType == ModuleNames.bills && selected.data.type == billType.DXFY) {
return false;
} else if (!(project.Bills.isMeasure(selected) || project.Bills.isFBFX(selected))) {
return false;
} else if (selected.sourceType == ModuleNames.bills && selected.source.children.length > 0) {
return false;
} else {
return true;
}
}
let importJson = null;
//选择导入的excel文件
$("#customFile").change(function () {
let file = $(this)[0];
let excelFile = file.files[0];
$("#uploadAlert").hide();
if (excelFile) {
let xlsReg = /xls$/g;
if (excelFile.name && xlsReg.test(excelFile.name)) {
showUploadAlert(false, "请选择xlsx文件");
$(this).val("");
return;
}
$(".custom-file-label").text(`${file.files[0].name}`);
$("#uploadAlert").hide();
$.bootstrapLoading.start();
$("#loadingPage").css("z-index", "2000");
//前端解析excel数据
if (importJson) {
importJson = null;
}
let excelIo = new GC.Spread.Excel.IO();
let sDate = +new Date();
excelIo.open(
excelFile,
function (json) {
importJson = json;
console.log(json);
console.log(`解析Excel文件时间：${+new Date() - sDate}`);
$.bootstrapLoading.end();
},
function (e) {
$.bootstrapLoading.end();
alert(e.errorMessage);
}
);
}
});
//线上nginx请求体最大设置为100m
//从excel导入清单
$("#importConfirm").click(function () {
let me = this;
$(me).addClass("disabled");
try {
$.bootstrapLoading.start();
$("#loadingPage").css("z-index", "2000");
let formData = new FormData();
let file = $("#customFile")[0];
if (file.files.length <= 0) {
throw "未选择文件";
}
let projectID = scUrlUtil.GetQueryString("project");
if (!projectID || projectID <= 0) {
throw "项目数据出错";
}
let sDate = +new Date();
formData.append("projectID", projectID);
let importBillsData = importBills.extactDatas(importJson.sheets);
if (importBillsData.length === 0) {
throw "excel无有效数据";
}
let compressData = LZString.compressToUTF16(JSON.stringify(importBillsData));
formData.append("compressData", compressData);
let eDate = +new Date();
console.log(`解析excel数据时间：${eDate - sDate}`);
$.ajax({
url: "/bills/import",
type: "POST",
data: formData,
cache: false,
contentType: false,
processData: false,
success: function (response) {
if (response.err === 0) {
// 成功则关闭窗体
$("#import").modal("hide");
//更新前端
doAfterImport(response.data);
if ($.bootstrapLoading.isLoading()) {
$.bootstrapLoading.end();
}
} else {
const message = response.msg !== undefined ? response.msg : "上传失败!";
$.bootstrapLoading.end();
alert(message);
}
$(me).removeClass("disabled");
},
error: function (jqXHR) {
alert(`与服务器通信发生错误${jqXHR.status} ${jqXHR.statusText}`);
$.bootstrapLoading.end();
$(me).removeClass("disabled");
},
});
} catch (err) {
console.log(err);
showUploadAlert(false, err);
$(me).removeClass("disabled");
if ($.bootstrapLoading.isLoading()) {
$.bootstrapLoading.end();
}
}
});
function showUploadAlert(success, msg) {
if (!success) {
$("#uploadAlert").removeClass("alert-success");
$("#uploadAlert").addClass("alert-danger");
} else {
$("#uploadAlert").removeClass("alert-danger");
$("#uploadAlert").addClass("alert-success");
}
$("#uploadAlert").text(msg);
$("#uploadAlert").show();
}
//导入清单到一个固定行位置后，更新数据
function doAfterImportPosition(positionData) {
let nodes = projectObj.project.mainTree.nodes;
let bills_datas = projectObj.project.Bills.datas;
let ration_datas = projectObj.project.Ration.datas;
let quantity_detail_datas = projectObj.project.quantity_detail.datas;
let ration_glj_datas = projectObj.project.ration_glj.datas;
let ration_coe_datas = projectObj.project.ration_coe.datas;
let ration_install_datas = projectObj.project.ration_installation.datas;
let delNodes = [];
for (let billID of positionData.remove.bill) {
if (nodes["id_" + billID]) {
delNodes.push(nodes["id_" + billID]);
}
//清除清单数据
_.remove(bills_datas, { ID: billID });
//清除清单工程量明细数据
_.remove(quantity_detail_datas, { billID: billID });
}
for (let rationID of positionData.remove.ration) {
//清除定额数据
_.remove(ration_datas, { ID: rationID });
//清除定额下的相关数据
_.remove(ration_glj_datas, { rationID: rationID });
_.remove(ration_coe_datas, { rationID: rationID });
_.remove(ration_install_datas, { rationID: rationID });
_.remove(quantity_detail_datas, { rationID: rationID });
}
//删除节点
if (delNodes.length > 0) {
//通过固定清单获得删除节点的起始行索引
let beginRow = null;
if (positionData.fixedBill) {
let fixedNode = nodes["id_" + positionData.fixedBill.ID];
if (fixedNode) {
beginRow = projectObj.project.mainTree.items.indexOf(fixedNode) + 1;
}
}
//删除主树节点
projectObj.mainController.m_delete(delNodes, beginRow);
//删除清单树节点
let delIdNodes = [];
for (let delNode of delNodes) {
delIdNodes.push(delNode.source);
}
projectObj.project.Bills.tree.m_delete(delIdNodes);
}
if (positionData.insert.bill.length > 0) {
//设置flagsIndex
for (let insertBill of positionData.insert.bill) {
insertBill.flagsIndex = {};
if (insertBill.flags) {
insertBill.flags.forEach(function (flag) {
insertBill.flagsIndex[flag.fieldName] = flag;
});
}
}
//插入清单节点
projectObj.project.Bills.tree.insertByDatas(positionData.insert.bill);
projectObj.project.Bills.datas = projectObj.project.Bills.datas.concat(positionData.insert.bill);
//插入主树节点
let newNodes = projectObj.project.mainTree.insertByDatas(positionData.insert.bill);
for (let node of newNodes) {
node.source = projectObj.project.Bills.tree.nodes["id_" + node.getID()];
node.data = node.source.data;
node.sourceType = projectObj.project.Bills.getSourceType();
if (node.data.fees) {
node.data.feesIndex = getFeeIndex(node.data.fees);
}
}
ProjectController.syncDisplayNewNodes(projectObj.mainController, newNodes);
}
}
//导入后更新操作
function doAfterImport(resData) {
if (resData && resData.length > 0) {
for (let data of resData) {
doAfterImportPosition(data);
}
//如果清单未锁定，导入后锁定清单
if (!projectObj.project.projectInfo.property.lockBills) {
$("a[name='lockBills']").click();
}
$.bootstrapLoading.end();
//重算
projectObj.project.calcProgram.calcAllNodesAndSave(calcAllType.catAll, function () {
projectObj.project.projectGLJ.loadData(function () {
$.bootstrapLoading.end();
});
});
}
}
//下载导入清单示例文件
$("#uploadExample").click(function () {
window.location.href = "/bills/downloadExamp";
});
$(function () {
//清空导入清单选择文件
$("#import").on("show.bs.modal", function () {
$("#customFile").val("");
$("#uploadAlert").hide();
$(".custom-file-label").text(`请选择上传文件`);
});
$("#import").on("hidden.bs.modal", function () {
//恢复选择表高度
$("#uploadSheets").height("");
$("#uploadSheets").hide();
$("#uploadSheetsHead").hide();
});
/* $("#billsSpread").mouseover(function(){
spreadAutoFocus(projectObj.mainSpread,subSpread);
});
$("#subSpread").mouseover(function(){
spreadAutoFocus(subSpread,projectObj.mainSpread);
});
*/
$("#paste_confirm").click(function () {
let selected = projectObj.project.mainTree.selected;
let blockData = BlockController.getBlockData();
let position = $("input[name='pastePositionRadio']:checked").val();
BlockController.confirmPaste(blockData, selected, position);
$("#pastePosition").modal("hide");
});
$("#div_createBlocks").on("show.bs.modal", function () {
function getBlockCategoriesHtml(Categories) {
let result = "";
if (Categories.length <= 0) return result;
for (let c of Categories) {
result += '";
}
return result;
}
let sHtml = getBlockCategoriesHtml(blockLibObj.getCategories());
$("#select_block_category").html(sHtml);
$("#select_block_category")[0].selectedIndex = 0;
$("#ckb_block_exist_cover").prop("checked", false);
});
$("#div_cloneOptions").on("show.bs.modal", function () {
let s = "";
switch (blockLibObj.cloneType) {
case 1:
s = "一对一克隆";
break;
case 2:
s = "一对多克隆";
break;
case 3:
s = "多对多克隆";
break;
}
s = `${s}`;
$("#clone_option_title").html(`快速组价 (${s})`);
if (calcTools.isBudgetProject()) {
$("#clone_option_code").prop("checked", false);
$("#clone_option_name").prop("checked", true);
} else {
$("#clone_option_code").prop("checked", true);
$("#clone_option_name").prop("checked", false);
}
$("#clone_option_unit").prop("checked", true);
$("#clone_option_quantity").prop("checked", true);
$("#clone_option_cover").prop("checked", true);
});
$("#btn_block_createBlocks").click(async function () {
if ($("#select_block_category")[0].options.length < 1) return;
let cID = $("#select_block_category").val();
let selected = projectObj.project.mainTree.selected;
let cover = $("#ckb_block_exist_cover").prop("checked");
async function createBlocks(aNode, categoryID) {
async function createBlock(node) {
if (node.data.name == undefined || node.data.name == "") return; // 清单名称为空，不生成块模板文件
if (node.children.length == 0) return;
// 封装成伟城的块文件格式，直接调用伟城接口（定额这里的业务太多太庞杂，不要再重做一遍，尽量共用，维护代价小）
// 块文件要构建自己的树结构，所以也有自己的一部分数据。两种结构揉合在一起，显得有点杂乱，但利大于弊。
let vBlock_WC = {
compilationID: projectObj.project.projectInfo.compilation,
firstNodeType: node.data.type,
isFBFX: projectObj.project.Bills.isFBFX(node),
copyTime: +new Date(),
datas: [],
};
let ration_glj_Map = _.groupBy(projectObj.project.ration_glj.datas, "rationID");
vBlock_WC.datas.push(BlockController.getNodeDatas(node, ration_glj_Map));
vBlock_WC = JSON.parse(JSON.stringify(vBlock_WC));
// 块文件名称：编号要根据实际情况对父清单的编号进行拼装。
// let newCode = divideObj.getExeBillCode(vBlock_WC.datas[0].ID);
let code = calcTools.getCodeForBlock(node);
let unit = node.data.unit ? node.data.unit : "";
let fileName = code + " " + node.data.name + " " + unit;
fileName = fileName.replace(/^\s+|\s+$/g, ""); // 只去两头空格
let extN = blockLibObj.getSameNameNode(fileName, categoryID);
if (extN) {
if (cover) blockLibObj.assignData(extN, vBlock_WC);
} else await blockLibObj.newNode(2, fileName, categoryID, vBlock_WC);
}
async function createRecursion(node) {
if (!node) return;
if (calcTools.isLeafBill(node)) await createBlock(node);
if (node.firstChild()) await createRecursion(node.firstChild());
if (node.nextSibling) await createRecursion(node.nextSibling);
}
if (calcTools.isLeafBill(aNode)) await createBlock(aNode);
else await createRecursion(aNode.firstChild());
}
await createBlocks(selected, cID);
blockLibObj.loadDetailDatas(blockLibObj.mainTree.selected);
$("#div_createBlocks").modal("hide");
});
$("#btn_block_clone_ok").click(async function () {
let projectNode = projectObj.project.mainTree.selected;
let block = blockLibObj.mainTree.selected;
let options = {};
if ($("#clone_option_code").prop("checked")) options.checkCode = true;
if ($("#clone_option_name").prop("checked")) options.checkName = true;
if ($("#clone_option_unit").prop("checked")) options.checkUnit = true;
if ($("#clone_option_zeroQuantity").prop("checked")) options.zeroQuantity = true;
if ($("#clone_option_cover").prop("checked")) options.overwriteRations = true;
let calcNodes = [];
switch (blockLibObj.cloneType) {
case 1:
let nodes = await blockLibObj.oneToOneClone(projectNode, block, options);
calcNodes = calcNodes.concat(nodes);
break;
case 2:
let bills = calcTools.getLeafBills(projectNode);
for (let bill of bills) {
calcTools.forceSelect(bill);
let nodes = await blockLibObj.oneToOneClone(bill, block, options);
calcNodes = calcNodes.concat(nodes);
}
break;
case 3:
let mtmBills = calcTools.getLeafBills(projectNode);
let mtmBlocks = blockLibObj.mainTree.selected.children;
for (let mtmBill of mtmBills) {
for (let mtmBlock of mtmBlocks) {
calcTools.forceSelect(mtmBill);
let nodes = await blockLibObj.oneToOneClone(mtmBill, mtmBlock, options);
calcNodes = calcNodes.concat(nodes);
}
}
break;
}
if (calcNodes.length > 0) {
projectObj.project.calcProgram.calcNodesAndSave(calcNodes, function () {
installationFeeObj.calcInstallationFee();
});
}
});
function spreadAutoFocus(spread, relateSpread) {
if (relateSpread && relateSpread.getActiveSheet().isEditing()) {
//关联的spread不在编辑状态的情况下，才自动获得焦点;
return;
} else {
spread ? spread.focus() : "";
}
}
//项目为只读
if (projectReadOnly) {
disableTools();
}
});
//项目只读，处理不可操作的工具栏
function disableTools() {
//造价书按钮
$("#insertRation").addClass("disabled");
$("#delete").addClass("disabled");
$("#upLevel").addClass("disabled");
$("#downLevel").addClass("disabled");
$("#upMove").addClass("disabled");
$("#downMove").addClass("disabled");
$("#ZLFB_btn").addClass("disabled");
//$('#switchTznr').addClass('disabled');
$("#uploadLj").addClass("disabled");
$("#uploadGld").addClass("disabled");
$('a[name="lockBills"]').addClass("disabled");
//关于计算
$("#poj-settings-4").find("input").prop("disabled", "disabled");
//小数位数
$("#poj-settings-decimal").find("input").prop("disabled", "disabled");
// 清单限价
$(".limit-price-input").prop("disabled", "disabled");
//人工单价调整
$("#std_labour_coe_files").prop("disabled", "disabled");
//呈现选项
$("#display-setting").find("input").prop("disabled", "disabled");
$("#recColSetting").remove();
//项目属性恢复默认系统设置
$("#property_default").addClass("disabled");
//项目属性确定
$("#property_ok").addClass("disabled");
//清单精灵
$("#elfInsertRation").addClass("disabled");
$("#elfInsertSingle").addClass("disabled");
//模板子目：应用、下一条
$("#apply_mbzm").addClass("disabled");
$("#next_mbzm").addClass("disabled");
//特征及内容
$("#add-rule").find("select").prop("disabled", "disabled");
$("#use-to-current").addClass("disabled");
$("#use-to-all").addClass("disabled");
$(".bottom-tools").remove();
//导入
$("#importConfirm").addClass("disabled");
//选项
$("#generalOpts1").prop("disabled", "disabled");
$("#generalOpts2").prop("disabled", "disabled");
//补充库编辑器
$(".compleRationLib").addClass("disabled");
$(".compleGljLib").addClass("disabled");
//库
//$('#stdBillsGuidanceTab').addClass('disabled');
$("#stdBillsTab").addClass("disabled");
//$('#stdRationTab').addClass('disabled');
$("#blockLibTab").addClass("disabled");
//人材机汇总,选择其他、另存使用
$('a[data-target="#change-unitFile"]').remove();
$('a[data-target="#unitFile-save-as"]').remove();
//费率,选择其他、另存使用、重选标准、统一设置相同参数
$('a[data-target="#change-lv"]').remove();
$('a[data-target="#copy-lv"]').remove();
$("#standardSelect").prop("disabled", "disabled");
$("#cascadeSet").prop("disabled", "disabled");
$("#changeConfirm").prop("disabled", "disabled");
//计算程序标准
$("#calcProgramFileSelect").prop("disabled", "disabled");
//调价
$("#calcPriceOption").prop("disabled", "disabled");
$("#gljPriceTenderCoe").prop("readOnly", true);
$("#tenderGLJQuantity").prop("disabled", "disabled");
$("#tenderRationQuantity").prop("disabled", "disabled");
$("#tenderPrice").prop("disabled", "disabled");
$("#cleanTender").prop("disabled", "disabled");
$("#calcTender").prop("disabled", "disabled");
//分摊
$("#exec_divide_btn").prop("disabled", "disabled");
$("#cancel_divide_btn").prop("disabled", "disabled");
$("#cancel_all_divide_btn").prop("disabled", "disabled");
}
//根据触发改变计算基数、费率弹出框
function changeCalcBaseFeeRate(toggle) {
if (toggle === "calcBase") {
$("#mixedHeader").hide();
$("#normalHeader").show();
$("#calcBaseFeeRate").find(".modal-title").text("计算基数选择").show();
$("#calcBaseExp").remove();
let $textarea = $("