You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2031 lines
70 KiB
2031 lines
70 KiB
import { Component, OnInit, Inject ,ViewChild} from '@angular/core'; |
|
import { MatTreeFlatDataSource, MatTreeFlattener } from '@angular/material/tree'; |
|
import { FlatTreeControl } from '@angular/cdk/tree'; |
|
import { HttpClient,HttpHeaders, HttpEventType } from '@angular/common/http'; |
|
import { MatDialog, MatDialogRef, MAT_DIALOG_DATA } from '@angular/material/dialog'; |
|
import { FormControl } from '@angular/forms'; |
|
import { MatSnackBar ,MatSnackBarConfig} from '@angular/material/snack-bar'; |
|
import format from 'date-fns/format'; |
|
import { TreeService } from '../../http-interceptors/tree.service' |
|
import { FileUploader, FileItem } from 'ng2-file-upload' |
|
// import { House } from '../../interface' |
|
import { AddHouseInfo } from './addhouseinfo.component' |
|
import { DomSanitizer } from '@angular/platform-browser' |
|
import { Injectable } from "@angular/core" |
|
import { filter } from 'rxjs/operators'; |
|
import { async } from '@angular/core/testing'; |
|
import { MatTableDataSource } from '@angular/material/table'; |
|
import { isNgTemplate } from '@angular/compiler'; |
|
import * as _ from 'lodash'; |
|
// import Swiper from 'swiper'; |
|
import { LookMaster } from './lookmaster.component' |
|
import { Router,ActivatedRoute } from '@angular/router' |
|
|
|
@Component({ |
|
selector: 'app-basicinfo', |
|
templateUrl: './basicinfo.component.html', |
|
styleUrls: ['./basicinfo.component.scss'] |
|
}) |
|
export class BasicinfoComponent implements OnInit { |
|
unitinfo:any={ |
|
id: '', |
|
name: '', //单位信息名字 |
|
usci: '', //单位信用代码 |
|
contacts: '', //联系人 |
|
phone: '', //联系电话 |
|
address: '', //单位地址 |
|
imageUrl: '', //图片地址 |
|
location: '', //单位地理位置 |
|
modifiedTime: '', //信息修改时间 |
|
organizationId: '', //所属组织机构 |
|
organizationName: '', //组织机构名称 |
|
buildingTypes: [ |
|
{ |
|
id:'', |
|
name:'' |
|
} |
|
] |
|
} |
|
|
|
uploader:FileUploader = new FileUploader({ //初始化上传事件 ng2-upload |
|
url: `/api/Objects/PlanPlatform/${sessionStorage.getItem('companyId')}`, |
|
method: "POST", |
|
itemAlias: "uploadedfile", |
|
autoUpload: false, |
|
removeAfterUpload:true //上传之后是否在队列中移除，如果不移除就会出现无法上传第二次的情况 |
|
}); |
|
|
|
|
|
|
|
|
|
private _transformer = (node, level: number) => { //初始化tree |
|
return { |
|
expandable: !!node.children && node.children.length > 0, |
|
name: node.name, |
|
level: level, |
|
id: node.id, |
|
parentId: node.parentId, |
|
children: node.children |
|
}; |
|
} |
|
treeControl = new FlatTreeControl<any>(node => node.level, node => node.expandable); |
|
treeFlattener = new MatTreeFlattener(this._transformer, node => node.level, node => node.expandable, node => node.children); |
|
dataSource = new MatTreeFlatDataSource(this.treeControl, this.treeFlattener); |
|
|
|
myControl = new FormControl(); |
|
|
|
isorganizationbox = false//控制辖区中队框的显示隐藏 |
|
selectedorganization: any//所选的辖区中队 |
|
selectedorganizationid:any //所选的辖区中队的id |
|
highhouse = false//控制高层表单的显示 |
|
houses: any = [] //存储当前单位的建筑信息 |
|
defaultbuildingTypes :any //存储当前建筑的默认类型的id |
|
buildingTypesname:any//存储当前建筑的默认类型name |
|
buildingCustomData:any //存储当前建筑的自定义信息 |
|
allunittype: any //所有单位类型 |
|
allorganizing:any = [] //所有组织机构 |
|
constructor(private router:Router,private route:ActivatedRoute,private http: HttpClient, private tree: TreeService, private sanitizer: DomSanitizer, public dialog: MatDialog,public snackBar: MatSnackBar) { } |
|
|
|
|
|
unitId : any //当前单位id |
|
ngOnInit(): void { |
|
this.getallunittype() |
|
this.getorganization() |
|
this.getunitallbuilding() |
|
this.unitId = this.route.snapshot.queryParams.id |
|
sessionStorage.setItem("companyId",this.route.snapshot.queryParams.id); |
|
} |
|
//获得所有单位类型 |
|
getallunittype() { |
|
this.http.get("/api/BuildingTypes/Simple").subscribe(data => { |
|
this.allunittype = data |
|
}) |
|
} |
|
//获得所有组织机构 |
|
getorganization() { |
|
this.http.get('/api/Organizations').subscribe( |
|
(data: any) => { |
|
this.allorganizing = data; |
|
this.dataSource.data = this.tree.toTree(data); |
|
this.getunitinfo(); |
|
} |
|
) |
|
} |
|
//获得当前单位的基本信息 |
|
CompanyId |
|
getunitinfo(){ |
|
|
|
this.http.get(`/api/Companies/${this.unitId}`).subscribe((data:any)=>{ |
|
if(data.buildingTypes.length){ |
|
sessionStorage.setItem('buildingTypeId',data.buildingTypes[0].id) |
|
}else{ |
|
sessionStorage.setItem('buildingTypeId',"") |
|
} |
|
let node |
|
this.allorganizing.forEach(item => { |
|
if(item.id == data.organizationId){ |
|
node = item |
|
} |
|
}); |
|
if(node){ |
|
if(!node.parentId){ |
|
this.selectedorganization = node.name |
|
}else{ |
|
let namearr = [node.name] |
|
let targetId = node.parentId; // 临时变量 |
|
for(let i = 0; i < node.level ; i++){ |
|
this.allorganizing.forEach(item => { |
|
if(item.id == targetId ){ |
|
namearr.push(item.name) |
|
targetId = item.parentId; // 临时变量更新没有副作用 |
|
} |
|
}); |
|
} |
|
namearr.reverse() |
|
let str = '' |
|
namearr.forEach(item=>{ |
|
str += '/' + item |
|
}) |
|
this.selectedorganization = str.substr(1) |
|
} |
|
} |
|
|
|
this.unitinfo = data |
|
this.selectedorganizationid = data.organizationId |
|
if(data.imageUrl){ |
|
this.imgsrc = data.imageUrl |
|
} |
|
if(data.buildingTypes[0]){ |
|
this.defaultbuildingTypes = data.buildingTypes[0].id |
|
this.buildingTypesname = data.buildingTypes[0].name |
|
} |
|
}) |
|
} |
|
//石油化工 装置信息 勾选框 |
|
checkboxchange(item,e){ |
|
if(item.buildingBasicGroups){ |
|
item.buildingBasicGroups.forEach(item=>{ |
|
if(item.name != "基本信息" && item.name != "装置信息"){ |
|
item.submitted = e.checked |
|
} |
|
}) |
|
} |
|
} |
|
|
|
unitallbuilding:any = []//用于存储当前单位所有的建筑 |
|
buildinginfoId:any = []//用于存储当前单位所有具体建筑的id |
|
presentbuildinfoId:any // 用于存储当前单位第一个建筑的id |
|
bigfor:any//循环（储罐信息+罐区信息）大组 |
|
npdata:any = [] |
|
newnpdata:any //用于存储石油化工 储罐信息/罐区情况的 datasource |
|
|
|
basicCategoryId:any //当前单位所有建筑中位于第一个的建筑id |
|
deviceinfodata:any=[];//用于存储石油化工装置信息的数组 |
|
zhuangzhiinfodatasource:any = [] //用于存储石油化工装置信息表格的数据来源 |
|
newzhuangzhiinfodatasource:any= []//存储石油化工装置信息表格的 datasource形式 |
|
devicedataSourcebox:any = [] //存储多个石油化工建筑的不同装置信息表格datasource |
|
//在石油化工模板种点击增加装置信息 |
|
adddeviceinfo(item){ |
|
item.newzhuangzhiinfodatasource.push({ |
|
name:"", |
|
flow:"", |
|
danger:"", |
|
payattentionto:"" |
|
}) |
|
this.devicedataSourcebox[item.buildingId] = new MatTableDataSource<any>(item.newzhuangzhiinfodatasource) |
|
} |
|
//在石油化工模板种点击减少装置信息 |
|
removedeviceinfo(item){ |
|
if(item.newzhuangzhiinfodatasource.length>1){ |
|
item.newzhuangzhiinfodatasource.pop() |
|
}else{ |
|
const config = new MatSnackBarConfig(); |
|
config.verticalPosition = 'top'; |
|
config.duration = 3000 |
|
this.snackBar.open('只剩一行，无法删除','确定',config); |
|
} |
|
this.devicedataSourcebox[item.buildingId] = new MatTableDataSource<any>(item.newzhuangzhiinfodatasource) |
|
} |
|
|
|
//数据格式化函数 将原始数据映射转化为表格需要的datasource |
|
formatHandle(list) { |
|
const result = [{}]; // tag 是从1开始，因此预置索引为0的项 |
|
list.forEach((item) => { |
|
const { tag, propertyName, propertyValue } = item; |
|
if (result[tag] === undefined) { // 初始化对象 |
|
result[tag] = {}; |
|
} |
|
const fieldMap = { // 字段映射，实现自动映射 |
|
'罐区': 'tank', |
|
'储罐编号': 'tankid', |
|
'储存介质': 'tankmedium', |
|
'储罐类型': 'tanktype', |
|
'容量': 'tankcapacity', |
|
'直径': 'tankdiameter', |
|
'高度': 'tankheight', |
|
'顶盖形式': 'tanktectum', |
|
'浮盘材质': 'tanktexture', |
|
'浮盘类型': 'platetype', |
|
'泡沫产生器型号': 'foamgeneratorid', |
|
'泡沫产生器形式': 'foamgeneratortype', |
|
'是否设置氮封惰化保护装置': 'isprotect', |
|
'防护堤高度': 'fendinggroyneheight', |
|
'半固定泡沫灭火接口数量': 'portnum', |
|
'其它设施': 'else' |
|
}; |
|
result[tag][fieldMap[propertyName]] = propertyValue; |
|
}); |
|
result.shift(); // 移除预置的 索引为0 的值 |
|
return result; |
|
} |
|
|
|
//将模板信息加工成附带自定义属性的信息 |
|
getunithouse(data,n,x){ //data是原始模板在此基础上加工 n是当前建筑名称和建筑id、 x是当前循环的item信息 |
|
data[0].buildingtypeId = n.id |
|
data[0].name = x.name |
|
data[0].username =x.name |
|
data[0].buildtype = n.name |
|
data[0].tongyong = true |
|
data[0].index = x.index |
|
if(data[0].buildtype == "石油化工类"){ |
|
data[0].tongyong = false |
|
data[0].isshiyou = true |
|
this.deviceinfodata = data[0].buildingBasicGroups[1].propertyInfos //存储装置信息的初始数据，需要转换成datasource形式 |
|
var map = [] |
|
this.deviceinfodata.forEach((item,index) => { |
|
if(item.tag == ""){ |
|
item.tag = "1" |
|
} |
|
if(!(item.tag in map)){ |
|
map[item.tag] = [] |
|
} |
|
map[item.tag].push(item) |
|
}); |
|
let zhuangzhiinfodatasource = [] |
|
map.forEach((item,index)=>{ |
|
zhuangzhiinfodatasource[index] = {} |
|
item.forEach(i => { |
|
if (i.propertyName == "装置区名称") { |
|
zhuangzhiinfodatasource[index].name = i.propertyValue |
|
} |
|
if (i.propertyName == "工艺流程") { |
|
zhuangzhiinfodatasource[index].flow = i.propertyValue |
|
} |
|
if (i.propertyName == "火灾危险性") { |
|
zhuangzhiinfodatasource[index].danger = i.propertyValue |
|
} |
|
if (i.propertyName == "灭火注意事项") { |
|
zhuangzhiinfodatasource[index].payattentionto = i.propertyValue |
|
} |
|
}); |
|
}) |
|
this.newzhuangzhiinfodatasource =[] //数据去空 |
|
zhuangzhiinfodatasource.forEach(item=>{ |
|
if(item !== "" && item != undefined){ |
|
this.newzhuangzhiinfodatasource.push(item) |
|
} |
|
}) |
|
this.devicedataSourcebox[data[0].buildingId] = new MatTableDataSource<any>(this.newzhuangzhiinfodatasource) |
|
data[0].newzhuangzhiinfodatasource = this.newzhuangzhiinfodatasource |
|
|
|
|
|
//把bigfor分组取出来 先大循环 (储罐信息---储罐信息/罐区情况)为一组 |
|
let noemptybigfordata = data[0].buildingBasicGroups |
|
// if(noemptybigfordata.length > 4){ |
|
// noemptybigfordata.forEach((item,index) => { |
|
// if(!item.submitted && item.name !="装置信息"){ |
|
// noemptybigfordata.splice(index, 1) |
|
// } |
|
// }) |
|
// } |
|
let bigtankgroups = noemptybigfordata.slice(2) |
|
// console.log("bigtankgroups",bigtankgroups) |
|
let proportion = 2; //按照比例切割 |
|
let num = 0; |
|
let bigfor =[]; |
|
for(let i=0;i<bigtankgroups.length;i++){ |
|
if(i % proportion == 0 && i != 0){ |
|
bigfor.push(bigtankgroups.slice(num,i)); |
|
num = i; |
|
} |
|
if((i+1)==bigtankgroups.length){ |
|
bigfor.push(bigtankgroups.slice(num,(i+1))); |
|
} |
|
} |
|
var map2 = [] |
|
let tankdetailindo = [] |
|
let noemptyArr = [] |
|
|
|
//bigfor决定当前储罐分组有几个 |
|
|
|
bigfor.forEach(item=>{ |
|
item[1].propertyInfos.forEach(item => { |
|
if(item.tag == ""){ |
|
item.tag = 1 |
|
} |
|
}); |
|
item[1].propertyInfos = this.formatHandle(item[1].propertyInfos) |
|
|
|
}) |
|
data[0].bigfor = bigfor |
|
} |
|
// if(data[0].buildtype == "地铁类"){ |
|
// data[0].tongyong = true |
|
// // data[0].ditie = true |
|
// } |
|
return data[0] |
|
} |
|
|
|
//点击建筑自定义信息的checkbox |
|
isCustomData = false |
|
checkCustomData(e){ |
|
this.isCustomData = e.checked |
|
} |
|
//增加自定义信息行数 |
|
addCustomData(item){ |
|
item.buildingCustomData.customProperties.push({ |
|
name: "", |
|
value: "" |
|
}) |
|
} |
|
//删除自定义信息行数 |
|
deleteCustomData(item){ |
|
item.buildingCustomData.customProperties.pop() |
|
} |
|
//得到建筑信息数据并进行处理 |
|
allBuildings:any |
|
getunitallbuilding(){ |
|
this.houses = [] |
|
this.unitId = this.route.snapshot.queryParams.id |
|
this.http.get("/api/Buildings",{ |
|
params:{ |
|
companyId:this.unitId |
|
} |
|
}).subscribe(async (data:any)=>{ // 获得当前单位所有的建筑 |
|
this.allBuildings = data |
|
// console.log(data) |
|
if(data.length != 0){ |
|
this.basicCategoryId = data[0].buildingTypes[0].id |
|
this.presentbuildinfoId = data[0].id // 用于存储当前单位第一个建筑的id |
|
for (let i = 0, length = data.length; i < length; i++) {//循环所有建筑 |
|
const n = data[i]; |
|
const index = i; |
|
this.buildinginfoId.push(n.id) |
|
const result = await new Promise((resolve) => { |
|
this.http.get("/api/BuildingBasicInfos",{ // 循环请求当前单位建筑每一个建筑的信息保存到数组中 |
|
params:{ |
|
companyId :this.unitId, |
|
buildingId:n.id, |
|
buildingType:n.buildingTypes[0].id |
|
} |
|
}).subscribe((data)=>{ |
|
//获得当前建筑自定义信息并且添加到item自定义属性上 |
|
let _data = data |
|
this.http.get("/api/BuildingCustomData",{params:{ |
|
buildingId:n.id |
|
}}).subscribe((data:any)=>{ |
|
_data[0].buildingCustomData = data |
|
if(data && data.customProperties.length != 0){ |
|
_data[0].isCustomData = true |
|
}else{ |
|
_data[0].isCustomData = false |
|
_data[0].buildingCustomData ={ |
|
id: "", |
|
customProperties: [ |
|
{ |
|
name: "", |
|
value: "" |
|
} |
|
], |
|
buildingId: _data[0].buildingId |
|
} |
|
} |
|
}) |
|
//为每个建筑添加自定义属性 |
|
data[0].buildingtypeId = n.buildingTypes[0].id |
|
data[0].name = n.name |
|
data[0].username = n.name |
|
data[0].buildtype = n.buildingTypes[0].name |
|
data[0].tongyong = true |
|
data[0].index = index |
|
|
|
if(data[0].buildtype == "石油化工类"){ |
|
data[0].tongyong = false |
|
data[0].isshiyou = true |
|
let noemptydeviceArr = data[0].buildingBasicGroups[1].propertyInfos |
|
noemptydeviceArr.forEach((item,index) => { |
|
if(item.tag == ""){ |
|
noemptydeviceArr.splice(index,1) |
|
} |
|
}); |
|
this.deviceinfodata = noemptydeviceArr //存储装置信息的初始数据，需要转换成datasource形式 |
|
var map = [] |
|
this.deviceinfodata.forEach((item,index) => { |
|
if(!data[0].buildingBasicGroups[1].submitted){ |
|
if(item.tag == ""){ |
|
item.tag = "1" |
|
} |
|
} |
|
|
|
if(!(item.tag in map)){ |
|
map[item.tag] = [] |
|
} |
|
map[item.tag].push(item) |
|
}); |
|
let zhuangzhiinfodatasource = [] |
|
map.forEach((item,index)=>{ |
|
zhuangzhiinfodatasource[index] = {} |
|
item.forEach(i => { |
|
if (i.propertyName == "装置区名称") { |
|
zhuangzhiinfodatasource[index].name = i.propertyValue |
|
} |
|
if (i.propertyName == "工艺流程") { |
|
zhuangzhiinfodatasource[index].flow = i.propertyValue |
|
} |
|
if (i.propertyName == "火灾危险性") { |
|
zhuangzhiinfodatasource[index].danger = i.propertyValue |
|
} |
|
if (i.propertyName == "灭火注意事项") { |
|
zhuangzhiinfodatasource[index].payattentionto = i.propertyValue |
|
} |
|
}); |
|
}) |
|
this.newzhuangzhiinfodatasource =[] //数据去空 |
|
zhuangzhiinfodatasource.forEach(item=>{ |
|
if(item !== "" && item != undefined){ |
|
this.newzhuangzhiinfodatasource.push(item) |
|
} |
|
}) |
|
this.devicedataSourcebox[data[0].buildingId] = new MatTableDataSource<any>(this.newzhuangzhiinfodatasource) |
|
data[0].newzhuangzhiinfodatasource = this.newzhuangzhiinfodatasource |
|
|
|
//把bigfor分组取出来 先大循环 (储罐信息---储罐信息/罐区情况)为一组 |
|
let noemptybigfordata = data[0].buildingBasicGroups |
|
|
|
let bigtankgroups = noemptybigfordata.slice(2) |
|
let proportion = 2; //按照比例切割 |
|
let num = 0; |
|
let bigfor =[]; |
|
for(let i=0;i<bigtankgroups.length;i++){ |
|
if(i % proportion == 0 && i != 0){ |
|
bigfor.push(bigtankgroups.slice(num,i)); |
|
num = i; |
|
} |
|
if((i+1)==bigtankgroups.length){ |
|
bigfor.push(bigtankgroups.slice(num,(i+1))); |
|
} |
|
} |
|
|
|
|
|
|
|
//bigfor决定当前储罐分组有几个 |
|
bigfor.forEach((item,index)=>{ |
|
|
|
item[1].propertyInfos = this.formatHandle(item[1].propertyInfos) |
|
|
|
}) |
|
data[0].bigfor = bigfor |
|
} |
|
resolve(data[0]) //把数据传递出去 |
|
}) |
|
}) |
|
this.houses.push(result) // 并且把他添加到 tab 总体数组中 |
|
} |
|
} |
|
// console.log(666,this.houses) |
|
}) |
|
|
|
} |
|
|
|
unitinfotemplate:any //存储选择不同单位类型时的模板信息 |
|
displayedColumns: string[]=['name', 'flow','danger','payattentionto']; |
|
displayedColumns2: string[]=['tank','tankid', 'tankmedium','tanktype','tankcapacity','tankdiameter', 'tankheight','tanktectum','tanktexture','platetype', 'foamgeneratorid','foamgeneratortype','isprotect','fendinggroyneheight', 'portnum','else']; |
|
devicedataSource:any; //存储石油化工模板中的装置信息表格 |
|
tankinfodatabox:any = [ |
|
[] |
|
] |
|
// dataSourceArr = [] |
|
tankinfodata:any=[];//用于存储石油化工储罐信息的数组 |
|
adddeviceinfo2(e,item){//点击加一行 视图上多一行 |
|
item.bigfor[e][1].propertyInfos.push({ |
|
tank:"", |
|
tankid:"", |
|
tankmedium:"", |
|
tanktype:"", |
|
tankcapacity:"", |
|
tankdiameter:"", |
|
tankheight:"", |
|
tanktectum:"", |
|
tanktexture:"", |
|
platetype:"", |
|
foamgeneratorid:"", |
|
foamgeneratortype:"", |
|
isprotect:"", |
|
fendinggroyneheight:"", |
|
portnum:"", |
|
else:"" |
|
}) |
|
item.bigfor[e][1].propertyInfos = [...item.bigfor[e][1].propertyInfos] |
|
} |
|
removedeviceinfo3(e,item){//点击减一行 |
|
var isdeleted = confirm("确定要删除末行吗？") |
|
if(isdeleted){ |
|
if(item.bigfor[e][1].propertyInfos.length > 1){ |
|
item.bigfor[e][1].propertyInfos.pop() |
|
}else{ |
|
const config = new MatSnackBarConfig(); |
|
config.verticalPosition = 'top'; |
|
config.duration = 3000 |
|
this.snackBar.open('只剩一行，无法删除','确定',config); |
|
} |
|
item.bigfor[e][1].propertyInfos = [...item.bigfor[e][1].propertyInfos] |
|
} |
|
|
|
} |
|
|
|
|
|
//增加储罐大分组 |
|
//在石油化工模板种点击增加储罐信息 |
|
//获得模板信息 |
|
templateinfo:any |
|
gettemplateinfo(typeid){ |
|
|
|
} |
|
|
|
addtankbox(item,bigkey){ |
|
this.http.get("/api/BuildingBasicInfos",{ |
|
params:{ |
|
companyId : this.unitId, |
|
buildingType:item.buildingtypeId |
|
} |
|
}).subscribe((data:any)=>{ |
|
// console.log(1314,data) |
|
// console.log(777,data[0]) |
|
item.bigfor.push([ |
|
{ |
|
id: "", |
|
name: "罐区"+ (item.bigfor.length+ 1), |
|
type: 0, |
|
addMode: 2, |
|
basicGroupId:'', |
|
basicCategoryId: item.basicCategoryId, |
|
buildingBasicId: null, |
|
buildingId: item.buildingId, |
|
companyId: this.unitinfo.id, |
|
enabled: true, |
|
order: item.bigfor.length+2, |
|
propertyInfos:data[0].buildingBasicGroups[2].propertyInfos |
|
}, |
|
{ |
|
addMode: 2, |
|
basicCategoryId:item.basicCategoryId, |
|
buildingBasicId:null, |
|
buildingId: item.buildingId, |
|
companyId: this.unitinfo.id, |
|
enabled: true, |
|
basicGroupId:'', |
|
id: "", |
|
name: "罐区" + (item.bigfor.length+ 1) +"/储罐信息", |
|
order: item.bigfor.length+3, |
|
propertyInfos: [ |
|
{ |
|
else: "", |
|
fendinggroyneheight: "", |
|
foamgeneratorid: "", |
|
foamgeneratortype: "", |
|
isprotect: "", |
|
platetype: "", |
|
portnum: "", |
|
tank: "", |
|
tankcapacity: "", |
|
tankdiameter: "", |
|
tankheight: "", |
|
tankid: "", |
|
tankmedium: "", |
|
tanktectum: "", |
|
tanktexture: "", |
|
tanktype: "" |
|
} |
|
], |
|
type: 1 |
|
} |
|
|
|
]) |
|
}) |
|
|
|
} |
|
//移除储罐大分组 |
|
removetankbox(item,bigkey){ |
|
if(item.bigfor.length > 1){ |
|
var isdeleted = confirm("确定要删除末尾储罐分组吗？") |
|
if(isdeleted){ |
|
item.bigfor.pop() |
|
} |
|
}else{ |
|
const config = new MatSnackBarConfig(); |
|
config.verticalPosition = 'top'; |
|
config.duration = 3000 |
|
this.snackBar.open('只剩唯一储罐，无法删除','确定',config); |
|
} |
|
} |
|
|
|
//新建建筑时把原始建筑数据放进来进行加工处理成可用数据 |
|
async changebuildingdata(data){ |
|
let n = data |
|
let yyy |
|
let result = await new Promise(resolve=>{ |
|
this.http.get("/api/BuildingBasicInfos",{ // 需要请求建筑信息的模板 |
|
params:{ |
|
companyId : this.unitId, |
|
buildingId:data.id, |
|
buildingType:data.buildingTypes[0].id |
|
} |
|
}).subscribe((data)=>{//此时的data才是模板详细信息 |
|
let _data = data |
|
this.http.get("/api/BuildingCustomData",{params:{ //-----处理建筑自定义属性部分 |
|
buildingId:n.id |
|
}}).subscribe(data=>{ |
|
if(data){ |
|
_data[0].isCustomData = true //如果data存在则把自定义属性isCustomData设为true |
|
_data[0].buildingCustomData = data //把建筑自定义信息赋给buildingCustomData自定义属性 |
|
}else{ |
|
_data[0].isCustomData = false |
|
_data[0].buildingCustomData ={ //否则设为false，并且把自定义信息属性赋值为空 |
|
id: "", |
|
customProperties: [ |
|
{ |
|
name: "", |
|
value: "" |
|
} |
|
], |
|
buildingId: _data[0].buildingId |
|
} |
|
} |
|
}) |
|
data[0].buildingtypeId = n.buildingTypes[0].id |
|
data[0].buildtype = n.buildingTypes[0].name |
|
data[0].name = n.name |
|
data[0].username = n.name |
|
data[0].tongyong = true |
|
data[0].index = this.houses.length ////////////////// |
|
if(data[0].buildtype == "石油化工类"){ |
|
data[0].tongyong = false |
|
data[0].isshiyou = true //如果是石油化工则启用石油化工的模板 |
|
this.deviceinfodata = data[0].buildingBasicGroups[1].propertyInfos //存储装置信息表格的初始数据，需要转换成datasource形式 |
|
var map = [] |
|
this.deviceinfodata.forEach((item,index) => { |
|
if(item.tag == ""){ |
|
item.tag = "1" |
|
} |
|
if(!(item.tag in map)){ |
|
map[item.tag] = [] |
|
} |
|
map[item.tag].push(item) |
|
}); |
|
let zhuangzhiinfodatasource = [] |
|
map.forEach((item,index)=>{ |
|
zhuangzhiinfodatasource[index] = {} |
|
item.forEach(i => { |
|
if (i.propertyName == "装置区名称") { |
|
zhuangzhiinfodatasource[index].name = i.propertyValue |
|
} |
|
if (i.propertyName == "工艺流程") { |
|
zhuangzhiinfodatasource[index].flow = i.propertyValue |
|
} |
|
if (i.propertyName == "火灾危险性") { |
|
zhuangzhiinfodatasource[index].danger = i.propertyValue |
|
} |
|
if (i.propertyName == "灭火注意事项") { |
|
zhuangzhiinfodatasource[index].payattentionto = i.propertyValue |
|
} |
|
}); |
|
}) |
|
this.newzhuangzhiinfodatasource =[] //数据去空 |
|
zhuangzhiinfodatasource.forEach(item=>{ |
|
if(item !== "" && item != undefined){ |
|
this.newzhuangzhiinfodatasource.push(item) |
|
} |
|
}) |
|
this.devicedataSourcebox[data[0].buildingId] = new MatTableDataSource<any>(this.newzhuangzhiinfodatasource) //强制渲染表格 |
|
data[0].newzhuangzhiinfodatasource = this.newzhuangzhiinfodatasource |
|
|
|
|
|
//把bigfor分组取出来 先大循环 (储罐信息---储罐信息/罐区情况)为一组 |
|
let bigtankgroups = data[0].buildingBasicGroups.slice(2) |
|
let proportion = 2; //按照比例切割 |
|
let num = 0; |
|
let bigfor =[]; |
|
for(let i=0;i<bigtankgroups.length;i++){ |
|
if(i % proportion == 0 && i != 0){ |
|
bigfor.push(bigtankgroups.slice(num,i)); |
|
num = i; |
|
} |
|
if((i+1)==bigtankgroups.length){ |
|
bigfor.push(bigtankgroups.slice(num,(i+1))); |
|
} |
|
} |
|
var map2 = [] |
|
let tankdetailindo = [] |
|
let noemptyArr = [] |
|
|
|
//bigfor决定当前储罐分组有几个 |
|
|
|
bigfor.forEach(item=>{ |
|
item[1].propertyInfos.forEach(item => { |
|
if(item.tag == ""){ |
|
item.tag = 1 |
|
} |
|
}); |
|
item[1].propertyInfos = this.formatHandle(item[1].propertyInfos) |
|
}) |
|
data[0].bigfor = bigfor |
|
} |
|
if(data[0].buildtype == "地铁类"){ |
|
data[0].tongyong = true |
|
// data[0].ditie = true |
|
} |
|
yyy = data[0] |
|
resolve(yyy) |
|
}) |
|
}) |
|
return result |
|
} |
|
|
|
//点击+号 增加建筑 |
|
addhouseinfo() { |
|
const dialogRef = this.dialog.open(AddHouseInfo, {//调用open方法打开对话框并且携带参数过去 |
|
width: '260px', |
|
data: {unitinfo:this.unitinfo,allBuildings:this.allBuildings,unitId:this.unitId} |
|
}); |
|
dialogRef.afterClosed().subscribe( |
|
async data => { |
|
if(data){ |
|
let newbuilding = await this.changebuildingdata(data) |
|
this.houses.push(newbuilding) |
|
} |
|
} |
|
); |
|
} |
|
|
|
//点击不同的tab选项 |
|
selecttab(e) { |
|
} |
|
|
|
FunData(e){//切割数组 |
|
let proportion = 2; //按照比例切割 |
|
let num = 0; |
|
let _data =[]; |
|
for(let i=0;i<e.length;i++){ |
|
if(i % proportion == 0 && i != 0){ |
|
_data.push(e.slice(num,i)); |
|
num = i; |
|
} |
|
if((i+1)==e.length){ |
|
_data.push(e.slice(num,(i+1))); |
|
} |
|
} |
|
return _data; |
|
} |
|
|
|
|
|
//点击辖区中队树，将选择的辖区中队添加到变量 |
|
add(node) { |
|
// console.log(node) |
|
this.selectedorganizationid = node.id |
|
this.isorganizationbox = false |
|
|
|
if(!node.parentId){ |
|
this.selectedorganization = node.name |
|
}else{ |
|
let namearr = [node.name] |
|
let targetId = node.parentId; // 临时变量 |
|
for(let i = 0; i < node.level ; i++){ |
|
this.allorganizing.forEach(item => { |
|
if(item.id == targetId ){ |
|
namearr.push(item.name) |
|
targetId = item.parentId; // 临时变量更新没有副作用 |
|
} |
|
}); |
|
} |
|
namearr.reverse() |
|
let str = '' |
|
namearr.forEach(item=>{ |
|
str += '/' + item |
|
}) |
|
|
|
this.selectedorganization = str.substr(1) |
|
} |
|
} |
|
|
|
//关闭辖区中队隐藏框 |
|
closeorganizationbox() { |
|
this.isorganizationbox = false |
|
} |
|
|
|
//打开辖区中队隐藏框 |
|
openorganizationbox() { |
|
this.isorganizationbox = true |
|
} |
|
|
|
hasChild = (_: number, node: any) => node.expandable; |
|
|
|
imgsrc = "../../../assets/images/upload.jpg" //没有上传图片时显示的图片，当上传后就会被替换，即保存时需要传的图片地址参数 |
|
// imgsrc = "" |
|
imgUrl = ""//返回来的图片地址后缀 |
|
file: any; //上传的文件 |
|
objectName: any; //上传对象名 |
|
uploadId: any; //上传分块上传事件编号 |
|
isspinner:boolean=false //控制进度圈的显示隐藏 |
|
PartNumberETag: any = []; //分块上传每次返回需要保存的信息 |
|
//change选择文件 |
|
filechange(e) { |
|
this.file = e.target.files[0] || null //上传的文件 |
|
var reader = new FileReader(); |
|
reader.readAsDataURL(this.file); |
|
var image:any = new Image(); |
|
reader.onload = function(){ |
|
image.src = reader.result |
|
} |
|
setTimeout(() => { |
|
if(image.width>=4096 || image.height>=5000 ){ |
|
const config = new MatSnackBarConfig(); |
|
config.verticalPosition = 'top'; |
|
config.duration = 3000 |
|
this.snackBar.open('请选择分辨率小于4096*5000的图片','确定',config); |
|
}else{ |
|
if(this.file){ |
|
this.startUploading() |
|
} |
|
} |
|
|
|
}, 500); |
|
} |
|
//查看单位大图 |
|
lookmaster(){ |
|
const dialogRef = this.dialog.open(LookMaster, {//调用open方法打开对话框并且携带参数过去 |
|
width: '1600px', |
|
height:'900px', |
|
data: {img:this.imgsrc} |
|
}); |
|
dialogRef.afterClosed().subscribe( |
|
|
|
); |
|
} |
|
//上传文件 |
|
startUploading() { |
|
this.isspinner = true |
|
let file = this.file || null //获取上传的文件 |
|
let fileSize = file.size || null //上传文件的总大小 |
|
let shardSize = 5 * 1024 * 1024 //5MB一个分片 |
|
|
|
if (file && fileSize <= shardSize) { //上传文件<=5MB时 |
|
// this.upload() |
|
let formData = new FormData() |
|
formData.append("file",file) |
|
this.http.post(`/api/Objects/PlanPlatform/${sessionStorage.getItem('companyId')}`,formData).subscribe((data:any)=>{ |
|
this.isspinner = false |
|
this.imgUrl = data.objectName |
|
this.imgsrc = `/api/Objects/PlanPlatform/${this.imgUrl}?x-oss-process=image/resize,m_fill,h_170,w_299` |
|
const config = new MatSnackBarConfig(); |
|
config.verticalPosition = 'top'; |
|
config.duration = 3000 |
|
this.snackBar.open('上传成功','确定',config); |
|
}) |
|
} else if (file && fileSize >= shardSize) { //上传文件>5MB时,分块上传 |
|
|
|
let data = { filename: file.name } |
|
this.http.post(`/api/NewMultipartUpload/PlanPlatform/${this.unitinfo.id}`, {}, { params: data }).subscribe((data: any) => { //初始化分段上传 |
|
this.objectName = data.objectName |
|
this.uploadId = data.uploadId |
|
this.subsectionUploading() |
|
}) |
|
} |
|
} |
|
|
|
|
|
|
|
|
|
//小于5MB不需要分块上传 |
|
upload(){ |
|
this.uploader.queue[0].upload();//开始上传 |
|
this.uploader.queue[0].onSuccess = (response, status, headers) => { |
|
// 上传文件成功 |
|
if (status == 201) { |
|
// 上传文件后获取服务器返回的数据 |
|
const config = new MatSnackBarConfig(); |
|
config.verticalPosition = 'top'; |
|
config.duration = 3000 |
|
this.snackBar.open('上传成功','确定',config); |
|
this.isspinner = false |
|
let tempRes = JSON.parse(response); |
|
this.imgUrl = tempRes.objectName |
|
this.imgsrc = `/api/Objects/PlanPlatform/${this.imgUrl}?x-oss-process=image/resize,m_fill,h_170,w_299` |
|
}else { |
|
// 上传文件后获取服务器返回的数据错误 |
|
} |
|
}; |
|
this.uploader.queue[0].onError = (response, status, headers) => { |
|
if (status == 401) { |
|
const config = new MatSnackBarConfig(); |
|
config.verticalPosition = 'top'; |
|
config.duration = 3000 |
|
this.snackBar.open('上传失败','确定',config); |
|
} |
|
}; |
|
} |
|
|
|
//开始分块上传 |
|
async subsectionUploading () { |
|
let file = this.file || null //获取上传的文件 |
|
let fileSize = file.size || null //上传文件的总大小 |
|
let shardSize = 5 * 1024 * 1024 //5MB一个分片 |
|
let allSlice = Math.ceil(fileSize / shardSize) //总文件/5MB===共分多少段 |
|
|
|
for (let i = 0;i < allSlice;i++) { //循环分段上传 |
|
let start = i * shardSize //切割文件开始位置 |
|
let end = Math.min(fileSize, start + shardSize); //切割文件结束位置 |
|
let formData = new FormData() |
|
formData.append("file",file.slice(start, end)) |
|
|
|
// 同步写法实现异步调用 |
|
let result = await new Promise((resolve, reject) => { |
|
// await 需要后面返回一个 promise 对象 |
|
this.http.post(`/api/MultipartUpload/PlanPlatform/${this.objectName}?uploadId=${this.uploadId}&partNumber=${i+1}`,formData).subscribe((data:any)=>{ |
|
let msg = { |
|
"partNumber":data.partNumber || null, |
|
"eTag": data.eTag || null |
|
} |
|
resolve(msg) // 调用 promise 内置方法处理成功 |
|
}) |
|
}); |
|
this.PartNumberETag.push(result) |
|
if (this.PartNumberETag.length === allSlice) { |
|
this.endUploading() |
|
} |
|
} |
|
} |
|
//完成分块上传 |
|
endUploading() { |
|
let data = this.PartNumberETag |
|
let paramsData = { uploadId: this.uploadId } |
|
this.http.post(`/api/CompleteMultipartUpload/PlanPlatform/${this.objectName}`, data, { params: paramsData }).subscribe(data => { |
|
this.imgsrc = `/api/Objects/PlanPlatform/${this.objectName}?x-oss-process=image/resize,m_fill,h_170,w_299` |
|
this.isspinner = false |
|
this.PartNumberETag = [] |
|
this.uploader.clearQueue(); //清空input控件文件 |
|
}) |
|
} |
|
//删除具体建筑 |
|
deletedbuilding(item){ |
|
var isdeleted = confirm("确定要删除此建筑吗？") |
|
if(isdeleted){ |
|
//请求删除接口 |
|
this.http.delete(`/api/Buildings/${item.buildingId}`).subscribe(data=>{ |
|
|
|
const config = new MatSnackBarConfig(); |
|
config.verticalPosition = 'top'; |
|
config.duration = 3000 |
|
this.snackBar.open('删除成功','确定',config); |
|
this.houses.splice(this.houses.findIndex(items=>items==item),1) |
|
}) |
|
} |
|
} |
|
|
|
//提交单位基本信息 |
|
onSubmit(value,invalid,form) { |
|
if(invalid){ |
|
const config = new MatSnackBarConfig(); |
|
config.verticalPosition = 'top'; |
|
config.duration = 3000 |
|
this.snackBar.open('请填写必填项','确定',config); |
|
}else{ |
|
sessionStorage.setItem('buildingTypeId',value.unittype) |
|
let time =new Date() |
|
let body = { |
|
id: this.unitinfo.id, |
|
name: this.unitinfo.name, |
|
usci: value.creditcode, |
|
contacts: value.linkman, |
|
phone: value.linkphone, |
|
address: value.unitaddress, |
|
imageUrl: this.imgsrc, |
|
location: { |
|
x: 0, |
|
y: 0 |
|
}, |
|
modifiedTime: time, |
|
organizationId: this.selectedorganizationid, |
|
organizationName: null, |
|
buildingTypes: [ |
|
{ |
|
id: value.unittype, |
|
name: this.buildingTypesname |
|
} |
|
] |
|
} |
|
this.http.put(`/api/Companies/${this.unitId}`,body).subscribe((data:any)=>{ //修改单位基本信息 |
|
this.getunitinfo() |
|
if(!this.houses.length){ |
|
const config = new MatSnackBarConfig(); |
|
config.verticalPosition = 'top'; |
|
config.duration = 3000 |
|
this.snackBar.open('单位基本信息保存成功，请填写单位建筑模板信息','确定',config); |
|
// alert("单位基本信息保存成功，请填写单位建筑模板信息") |
|
let order = 0 |
|
let addbody = { //请求创建单位基本信息成功后 直接创建出一个主体建筑模板 |
|
id: "",//即将要生成具体建筑的id |
|
name: "主体建筑", |
|
order: order, |
|
enabled: true, |
|
companyId: this.unitinfo.id, |
|
buildingTypes: [ |
|
{ |
|
id: value.unittype, |
|
name: "" |
|
} |
|
] |
|
} |
|
this.http.post("/api/Buildings",addbody,{params:{ |
|
companyId : this.unitId |
|
}}).subscribe(data=>{//首先创建建筑成功了，需要刷出当前建筑类型的模板 |
|
this.getunitallbuilding() |
|
}) |
|
}else{ |
|
const config = new MatSnackBarConfig(); |
|
config.verticalPosition = 'top'; |
|
config.duration = 3000 |
|
this.snackBar.open('保存成功','确定',config); |
|
} |
|
}), |
|
err=>{ |
|
const config = new MatSnackBarConfig(); |
|
config.verticalPosition = 'top'; |
|
config.duration = 3000 |
|
this.snackBar.open('请填写正确信息','确定',config); |
|
} |
|
} |
|
|
|
|
|
} |
|
selected:any |
|
|
|
isshowrule:boolean = false |
|
rulevalue:any |
|
inputchange(e,name,value,item){ |
|
// console.log(e.target.value,name,value,item) |
|
// console.log(item) |
|
if(name == "≥"){ |
|
if(Number(e.target.value)< Number(value)){ |
|
item.isshowrule = true |
|
item.rulevalue = `请输入≥${value}的值` |
|
}else{ |
|
item.isshowrule = false |
|
} |
|
} |
|
if(name == "≤"){ |
|
if(Number(e.target.value) > Number(value)){ |
|
item.isshowrule = true |
|
item.rulevalue = `请输入≤${value}的值` |
|
}else{ |
|
item.isshowrule = false |
|
} |
|
} |
|
if(name == "Range"){ |
|
let rangenum = value.split(",") |
|
// console.log(rangenum) |
|
if(Number(e.target.value) < Number(rangenum[0]) || Number(e.target.value) >= Number(rangenum[1])){ |
|
item.isshowrule = true |
|
item.rulevalue = `请输入位于${Number(rangenum[0])}和${Number(rangenum[1])-1}之间的值` |
|
}else{ |
|
item.isshowrule = false |
|
} |
|
} |
|
} |
|
|
|
//切换建筑类型 |
|
templatebuildtype(n ,item,key){ |
|
this.http.get("/api/Buildings",{ |
|
params:{ |
|
companyId:this.unitId |
|
} |
|
}).subscribe((data:any)=>{ |
|
this.allBuildings = data |
|
this.http.put(`/api/Buildings/${item.buildingId}`,{ //修改当前建筑类型 |
|
id: item.buildingId, |
|
name: item.housename, |
|
order: this.allBuildings[key].order, |
|
enabled: true, |
|
companyId: this.unitinfo.id, |
|
buildingTypes: [ |
|
{ |
|
id: n.id, |
|
name: n.name |
|
} |
|
] |
|
},{ |
|
params:{ |
|
companyId : this.unitId |
|
} |
|
}).subscribe(data=>{ |
|
this.http.get("/api/BuildingBasicInfos",{//请求当前建筑类型的模板信息保存到数组中 |
|
params:{ |
|
companyId :this.unitId, |
|
buildingId:item.buildingId, |
|
buildingType:n.id |
|
} |
|
}).subscribe(data=>{ |
|
this.getunithouse(data,n,item) |
|
this.houses[item.index] = data[0] |
|
|
|
let _data = data |
|
this.http.get("/api/BuildingCustomData",{params:{ |
|
buildingId:item.buildingId |
|
}}).subscribe((data:any)=>{ |
|
_data[0].buildingCustomData = data |
|
if(data && data.customProperties.length != 0){ |
|
_data[0].isCustomData = true |
|
}else{ |
|
_data[0].isCustomData = false |
|
_data[0].buildingCustomData ={ |
|
id: "", |
|
customProperties: [ |
|
{ |
|
name: "", |
|
value: "" |
|
} |
|
], |
|
buildingId: _data[0].buildingId |
|
} |
|
} |
|
}) |
|
}) |
|
}) |
|
}) |
|
|
|
|
|
} |
|
|
|
deviceinfo=[] //用于存储石头化工的第一个表格 |
|
//提交单位模板信息 |
|
onSubmit2(value,item,key,invalid){ |
|
this.http.get("/api/Buildings",{ |
|
params:{ |
|
companyId:this.unitId |
|
} |
|
}).subscribe((data:any)=>{ |
|
this.allBuildings = data |
|
if(invalid){ |
|
const config = new MatSnackBarConfig(); |
|
config.verticalPosition = 'top'; |
|
config.duration = 3000 |
|
this.snackBar.open('请填写必填项','确定',config); |
|
}else{ |
|
this.http.put(`/api/Buildings/${item.buildingId}`,{ //(通用)只修改建筑名称和建筑类型 |
|
id: item.buildingId, |
|
name: value.housename, |
|
order: this.allBuildings[key].order, |
|
enabled: true, |
|
companyId: this.unitinfo.id, |
|
buildingTypes: [ |
|
{ |
|
id: item.buildingtypeId, |
|
name: item.buildtype |
|
} |
|
] |
|
},{params:{ |
|
companyId : this.unitId |
|
}}).subscribe((data:any)=>{ |
|
this.houses[item.index].username = item.name |
|
}, |
|
err=>{ |
|
alert("名称和类型保存失败") |
|
}) |
|
|
|
if(value.checkbuilding){//如果勾选了自定义信息的checkbox |
|
var CustomDataval = [] |
|
for (const key in value) { |
|
if (key.indexOf("CustomData") != -1) { |
|
CustomDataval.push(value[key]) |
|
} |
|
} |
|
let newCustomData = this.FunData(CustomDataval) |
|
let newCustomDataval = [] |
|
newCustomData.forEach(n=>{ |
|
newCustomDataval.push({ |
|
name:n[0], |
|
value:n[1] |
|
}) |
|
}) |
|
let CustomDatabody = { |
|
id: "", |
|
customProperties: newCustomDataval, |
|
buildingId: item.buildingId |
|
} |
|
this.http.post("/api/BuildingCustomData",CustomDatabody,{params:{ |
|
companyId :this.unitId, |
|
buildingId:item.buildingId |
|
}}).subscribe(data=>{ |
|
|
|
}, |
|
err=>{ |
|
alert("自定义信息保存失败") |
|
}) |
|
}else{ |
|
let CustomDatabody = { |
|
id: "", |
|
customProperties: [], |
|
buildingId: item.buildingId |
|
} |
|
this.http.post("/api/BuildingCustomData",CustomDatabody,{params:{ |
|
companyId :this.unitId, |
|
buildingId:item.buildingId |
|
}}).subscribe(data=>{ |
|
|
|
}, |
|
err=>{ |
|
alert("自定义信息保存失败") |
|
}) |
|
} |
|
|
|
|
|
if(item.buildtype != "石油化工类" && item.buildtype != "地铁类"){ |
|
// console.log(this.houses[key]) |
|
// console.log(value) |
|
this.houses[key].buildingBasicGroups[0].propertyInfos.forEach(item => { |
|
|
|
if(item.propertyValue || item.propertyValue == 0){ |
|
// item.propertyValue = "" + value[key] |
|
item.propertyValue = String(item.propertyValue) |
|
} |
|
|
|
}); |
|
let newObj = _.cloneDeep(this.houses[key]) //把数据深拷贝取出来进行操作 |
|
newObj.buildingBasicGroups[0].buildingId = item.buildingId |
|
newObj.buildingBasicGroups[0].companyId = this.unitinfo.id |
|
newObj.buildingBasicGroups[0].submitted = true //把是否提交过变为true |
|
delete newObj.name |
|
delete newObj.username |
|
delete newObj.buildtype |
|
delete newObj.tongyong |
|
delete newObj.index |
|
delete newObj.isCustomData |
|
delete newObj.buildingCustomData |
|
newObj.buildingBasicGroups[0].propertyInfos.forEach(item => { |
|
delete item.isshowrule |
|
delete item.rulevalue |
|
}); |
|
|
|
let body = newObj |
|
let newbody = [] |
|
newbody.push(body) |
|
if(newbody[0].buildingBasicGroups.length){ |
|
this.http.post("/api/BuildingBasicInfos",newbody,{ |
|
params:{ |
|
companyId : this.unitId, |
|
buildingId :newbody[0].buildingId |
|
} |
|
}).subscribe((data:any)=>{ |
|
this.houses[key].id = data[0].id |
|
const config = new MatSnackBarConfig(); |
|
config.verticalPosition = 'top'; |
|
config.duration = 3000 |
|
this.snackBar.open('建筑信息保存成功','确定',config); |
|
}, |
|
err=>{ |
|
const config = new MatSnackBarConfig(); |
|
config.verticalPosition = 'top'; |
|
config.duration = 3000 |
|
this.snackBar.open('请检查输入数据是否有误','确定',config); |
|
}) |
|
} |
|
} |
|
if(item.buildtype == "石油化工类"){ |
|
// console.log(888,item) |
|
let bodyObj = _.cloneDeep(item) |
|
delete bodyObj.name |
|
delete bodyObj.username |
|
delete bodyObj.isshiyou |
|
delete bodyObj.newzhuangzhiinfodatasource |
|
delete bodyObj.tongyong |
|
delete bodyObj.buildtype |
|
delete bodyObj.buildingtypeId |
|
delete bodyObj.bigfor |
|
delete bodyObj.index |
|
delete bodyObj.isCustomData |
|
delete bodyObj.buildingCustomData |
|
// console.log(456,bodyObj) |
|
bodyObj.buildingBasicGroups[0].propertyInfos.forEach(item => { |
|
delete item.isshowrule |
|
delete item.rulevalue |
|
}); |
|
//修改基本信息 |
|
bodyObj.buildingBasicGroups[0].propertyInfos.forEach(item => { |
|
for (const key in value) { |
|
if (item.propertyName == key) { |
|
if(item.propertyValue || item.propertyValue == 0){ |
|
// item.propertyValue = "" + value[key] |
|
item.propertyValue = String(value[key]) |
|
} |
|
|
|
} |
|
} |
|
}); |
|
bodyObj.buildingBasicGroups[0].submitted = true |
|
bodyObj.buildingBasicGroups[0].buildingId = item.buildingId |
|
bodyObj.buildingBasicGroups[0].companyId = this.unitinfo.id |
|
//石油化工类的 装置信息 就提交这个表单——————————————————————————————this.deviceinfo 记得清空 |
|
// console.log(this.deviceinfodata) |
|
if(bodyObj.buildingBasicGroups[1].submitted){ //如果用户点击了并填写了装置信息就提交这个表格数据 |
|
this.deviceinfo = [] |
|
item.newzhuangzhiinfodatasource.forEach((element,index) => { |
|
this.deviceinfo.push({ |
|
propertyName: "装置区名称", |
|
propertyValue: element.name, |
|
propertyType: 0, |
|
required: true, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "", |
|
order:0, |
|
enabled: true, |
|
visible: true, |
|
tag: String(index + 1) |
|
}, |
|
{ |
|
propertyName: "工艺流程", |
|
propertyValue: element.flow, |
|
propertyType: 0, |
|
required: true, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "", |
|
order:1, |
|
enabled: true, |
|
visible: true, |
|
tag: String(index + 1) |
|
}, |
|
{ |
|
propertyName: "火灾危险性", |
|
propertyValue: element.danger, |
|
propertyType: 0, |
|
required: true, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "", |
|
order:2, |
|
enabled: true, |
|
visible: true, |
|
tag: String(index + 1) |
|
}, |
|
{ |
|
propertyName: "灭火注意事项", |
|
propertyValue: element.payattentionto, |
|
propertyType: 1, |
|
required: false, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "", |
|
order:3, |
|
enabled: true, |
|
visible: true, |
|
tag: String(index + 1) |
|
}) |
|
}); |
|
}else{//否则就传一个空的 |
|
this.deviceinfo = [ |
|
{ |
|
propertyName: "装置区名称", |
|
propertyValue: "", |
|
propertyType: 0, |
|
required: true, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag: "1" |
|
}, |
|
{ |
|
propertyName: "工艺流程", |
|
propertyValue: "", |
|
propertyType: 0, |
|
required: true, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag: "1" |
|
}, |
|
{ |
|
propertyName: "火灾危险性", |
|
propertyValue: "", |
|
propertyType: 0, |
|
required: true, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag: "1" |
|
}, |
|
{ |
|
propertyName: "灭火注意事项", |
|
propertyValue: "", |
|
propertyType: 1, |
|
required: false, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag: "1" |
|
} |
|
] |
|
} |
|
bodyObj.buildingBasicGroups[1].propertyInfos = this.deviceinfo |
|
bodyObj.buildingBasicGroups[1].buildingId = item.buildingId |
|
bodyObj.buildingBasicGroups[1].companyId = this.unitinfo.id |
|
|
|
|
|
if(bodyObj.buildingBasicGroups[2].submitted){ //如果勾选了储罐信息 则直接提交当前bodyObj |
|
var map = {}; //用于存储石油化工要提交的储罐信息表单 |
|
for (let key in value) { |
|
if (key.indexOf('tanker') != -1) { |
|
const list = key.split('-'); // 2,tanker,1 |
|
const orderKey = list[0]; // 2 or 3 |
|
if (!(orderKey in map)) { |
|
map[orderKey] = []; // map[2] or map[3] = []; |
|
} |
|
map[orderKey][list[2]] = value[key]; // map[2][1] = xxxxx |
|
} |
|
} |
|
|
|
bodyObj.buildingBasicGroups.splice( 2 , bodyObj.buildingBasicGroups.length) |
|
|
|
// console.log(123, item) |
|
|
|
let basictankinfobody:any = {} |
|
|
|
for(let key in map){//------------------------------------------------------------石油化工 储罐信息 |
|
|
|
|
|
basictankinfobody = { |
|
id: null, |
|
name: "罐区" + (Number(key)-1), |
|
type: 0, |
|
addMode: 2, |
|
basicGroupId:'', |
|
submitted:true, |
|
isOptional:true, |
|
order: Number(key), |
|
enabled: true, |
|
propertyInfos: item.bigfor[Number(key)-2][0].propertyInfos, |
|
basicCategoryId: item.basicCategoryId, |
|
buildingBasicId: null, |
|
buildingId: item.buildingId,//当前建筑id |
|
companyId: this.unitinfo.id//当前企业id |
|
} |
|
|
|
bodyObj.buildingBasicGroups.push(basictankinfobody) |
|
} |
|
|
|
|
|
let basictankchildinfobody:any = []//-------------后续储罐信息以及储罐信息/罐区情况都push到这个数组中 |
|
item.bigfor.forEach(item => { |
|
basictankchildinfobody.push(item[1].propertyInfos) |
|
}); |
|
var _item = item |
|
basictankchildinfobody.forEach((item,index) => { |
|
let tankfieldArr = [] |
|
item.forEach((element,key) => { |
|
tankfieldArr.push( |
|
{ |
|
propertyName: "罐区", |
|
propertyValue: element.tank, |
|
propertyType: 0, |
|
required: false, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:String(key + 1) |
|
}, |
|
{ |
|
propertyName: "储罐编号", |
|
propertyValue: element.tankid, |
|
propertyType: 0, |
|
required: true, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:String(key + 1) |
|
}, |
|
{ |
|
propertyName: "储存介质", |
|
propertyValue: element.tankmedium, |
|
propertyType: 0, |
|
required: true, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:String(key + 1) |
|
}, |
|
{ |
|
propertyName: "储罐类型", |
|
propertyValue: element.tanktype, |
|
propertyType: 0, |
|
required: true, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:String(key + 1) |
|
}, |
|
{ |
|
propertyName: "容量", |
|
propertyValue: element.tankcapacity, |
|
propertyType: 2, |
|
required: true, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "㎡", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:String(key + 1) |
|
}, |
|
{ |
|
propertyName: "直径", |
|
propertyValue:element.tankdiameter, |
|
propertyType: 2, |
|
required: true, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "m", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:String(key + 1) |
|
}, |
|
{ |
|
propertyName: "高度", |
|
propertyValue: element.tankheight, |
|
propertyType: 2, |
|
required: true, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "m", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:String(key + 1) |
|
}, |
|
{ |
|
propertyName: "顶盖形式", |
|
propertyValue: element.tanktectum, |
|
propertyType: 0, |
|
required: false, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:String(key + 1) |
|
}, |
|
{ |
|
propertyName: "浮盘材质", |
|
propertyValue: element.tanktexture, |
|
propertyType: 0, |
|
required: false, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:String(key + 1) |
|
}, |
|
{ |
|
propertyName: "浮盘类型", |
|
propertyValue: element.platetype, |
|
propertyType: 0, |
|
required: false, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:String(key + 1) |
|
}, |
|
{ |
|
propertyName: "泡沫产生器型号", |
|
propertyValue: element.foamgeneratorid, |
|
propertyType: 0, |
|
required: false, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:String(key + 1) |
|
}, |
|
{ |
|
propertyName: "泡沫产生器形式", |
|
propertyValue: element.foamgeneratortype, |
|
propertyType: 0, |
|
required: false, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:String(key + 1) |
|
}, |
|
{ |
|
propertyName: "是否设置氮封惰化保护装置", |
|
propertyValue: element.isprotect, |
|
propertyType: 0, |
|
required: false, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:String(key + 1) |
|
}, |
|
{ |
|
propertyName: "防护堤高度", |
|
propertyValue: element.fendinggroyneheight, |
|
propertyType: 2, |
|
required: true, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "m", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:String(key + 1) |
|
}, |
|
{ |
|
propertyName: "半固定泡沫灭火接口数量", |
|
propertyValue: element.portnum, |
|
propertyType: 2, |
|
required: false, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "个", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:String(key + 1) |
|
}, |
|
{ |
|
propertyName: "其它设施", |
|
propertyValue: element.else, |
|
propertyType: 0, |
|
required: false, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:String(key + 1) |
|
} |
|
) |
|
}); |
|
basictankchildinfobody={// |
|
id: null, |
|
name: "罐区" + Number(index+1) + "/储罐信息", |
|
type: 1, |
|
addMode: 2, |
|
basicGroupId:'', |
|
order: Number(index + 2), |
|
enabled: true, |
|
submitted:true, |
|
isOptional:true, |
|
propertyInfos: tankfieldArr, |
|
basicCategoryId: _item.basicCategoryId, |
|
buildingBasicId: null, |
|
buildingId: _item.buildingId, |
|
companyId: this.unitinfo.id |
|
} |
|
bodyObj.buildingBasicGroups.push(basictankchildinfobody) |
|
}); |
|
}else{ |
|
|
|
|
|
bodyObj.buildingBasicGroups[2].buildingId = item.buildingId |
|
bodyObj.buildingBasicGroups[2].companyId = this.unitinfo.id |
|
bodyObj.buildingBasicGroups[2].propertyInfos.forEach(item=>{ |
|
item.propertyValue = "" |
|
}) |
|
bodyObj.buildingBasicGroups[3].buildingId = item.buildingId |
|
bodyObj.buildingBasicGroups[3].companyId = this.unitinfo.id |
|
bodyObj.buildingBasicGroups[3].propertyInfos = [ |
|
{ |
|
propertyName: "罐区", |
|
propertyValue: "", |
|
propertyType: 0, |
|
required: false, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:"1" |
|
}, |
|
{ |
|
propertyName: "储罐编号", |
|
propertyValue: "", |
|
propertyType: 0, |
|
required: true, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:"1" |
|
}, |
|
{ |
|
propertyName: "储存介质", |
|
propertyValue: "", |
|
propertyType: 0, |
|
required: true, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:"1" |
|
}, |
|
{ |
|
propertyName: "储罐类型", |
|
propertyValue:"", |
|
propertyType: 0, |
|
required: true, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:"1" |
|
}, |
|
{ |
|
propertyName: "容量", |
|
propertyValue: "", |
|
propertyType: 2, |
|
required: true, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "㎡", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:"1" |
|
}, |
|
{ |
|
propertyName: "直径", |
|
propertyValue:"", |
|
propertyType: 2, |
|
required: true, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "m", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:"1" |
|
}, |
|
{ |
|
propertyName: "高度", |
|
propertyValue: "", |
|
propertyType: 2, |
|
required: true, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "m", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:"1" |
|
}, |
|
{ |
|
propertyName: "顶盖形式", |
|
propertyValue: "", |
|
propertyType: 0, |
|
required: false, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:"1" |
|
}, |
|
{ |
|
propertyName: "浮盘材质", |
|
propertyValue:"", |
|
propertyType: 0, |
|
required: false, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:"1" |
|
}, |
|
{ |
|
propertyName: "浮盘类型", |
|
propertyValue: "", |
|
propertyType: 0, |
|
required: false, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:"1" |
|
}, |
|
{ |
|
propertyName: "泡沫产生器型号", |
|
propertyValue:"", |
|
propertyType: 0, |
|
required: false, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:"1" |
|
}, |
|
{ |
|
propertyName: "泡沫产生器形式", |
|
propertyValue: "", |
|
propertyType: 0, |
|
required: false, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:"1" |
|
}, |
|
{ |
|
propertyName: "是否设置氮封惰化保护装置", |
|
propertyValue:"", |
|
propertyType: 0, |
|
required: false, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:"1" |
|
}, |
|
{ |
|
propertyName: "防护堤高度", |
|
propertyValue:"", |
|
propertyType: 2, |
|
required: true, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "m", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:"1" |
|
}, |
|
{ |
|
propertyName: "半固定泡沫灭火接口数量", |
|
propertyValue: "", |
|
propertyType: 2, |
|
required: false, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "个", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:"1" |
|
}, |
|
{ |
|
propertyName: "其它设施", |
|
propertyValue: "", |
|
propertyType: 0, |
|
required: false, |
|
ruleName: "", |
|
ruleValue: "", |
|
physicalUnit: "", |
|
order: 0, |
|
enabled: true, |
|
visible: true, |
|
tag:"1" |
|
} |
|
] |
|
// console.log(888,bodyObj) |
|
bodyObj.buildingBasicGroups.splice(4,bodyObj.buildingBasicGroups.length) |
|
} |
|
|
|
|
|
|
|
let newbodyObj = [] |
|
newbodyObj.push(bodyObj) |
|
// console.log(1111,newbodyObj) |
|
this.http.post("/api/BuildingBasicInfos",newbodyObj,{ |
|
params:{ |
|
companyId : this.unitId, |
|
buildingId :item.buildingId |
|
} |
|
}).subscribe((data:any)=>{ |
|
this.houses[key].id = data[0].id |
|
const config = new MatSnackBarConfig(); |
|
config.verticalPosition = 'top'; |
|
config.duration = 3000 |
|
this.snackBar.open('建筑信息保存成功','确定',config); |
|
// alert("建筑信息保存成功") |
|
}, |
|
err=>{ |
|
const config = new MatSnackBarConfig(); |
|
config.verticalPosition = 'top'; |
|
config.duration = 3000 |
|
this.snackBar.open('请检查输入数据是否有误','确定',config); |
|
}) |
|
} |
|
if(item.buildtype == "地铁类"){ |
|
let newObj = _.cloneDeep(item) |
|
delete newObj.username |
|
delete newObj.name |
|
delete newObj.tongyong |
|
delete newObj.ditie |
|
delete newObj.buildtype |
|
delete newObj.isCustomData |
|
delete newObj.buildingCustomData |
|
newObj.buildingBasicGroups.forEach(item => { |
|
item.propertyInfos.forEach(element => { |
|
delete element.isshowrule |
|
delete element.rulevalue |
|
if( element.propertyValue || element.propertyValue == 0){ |
|
element.propertyValue = String(element.propertyValue) |
|
} |
|
}); |
|
item.buildingId = newObj.buildingId |
|
item.companyId = this.unitinfo.id |
|
item.submitted = true |
|
}); |
|
let newbodyObj2 = [] |
|
newbodyObj2.push(newObj) |
|
this.http.post("/api/BuildingBasicInfos",newbodyObj2,{ |
|
params:{ |
|
companyId : this.unitId, |
|
buildingId :newObj.buildingId |
|
} |
|
}).subscribe((data:any)=>{ |
|
this.houses[key].id = data[0].id |
|
const config = new MatSnackBarConfig(); |
|
config.verticalPosition = 'top'; |
|
config.duration = 3000 |
|
this.snackBar.open('建筑信息保存成功','确定',config); |
|
}, |
|
err=>{ |
|
const config = new MatSnackBarConfig(); |
|
config.verticalPosition = 'top'; |
|
config.duration = 3000 |
|
this.snackBar.open('请检查输入数据是否有误','确定',config); |
|
}) |
|
|
|
} |
|
} |
|
}) |
|
|
|
|
|
}} |