examSystem-Anxin/src/app/canvas-share-data.service.ts

import { HttpClient } from '@angular/common/http';
import { Injectable } from '@angular/core';
import { ReplaySubject } from 'rxjs';
import { Observable } from 'rxjs';
import { GameMode } from './working-area/model/gameMode';

@Injectable({
  providedIn: 'root'
})
export class CanvasShareDataService {
  constructor(private http: HttpClient) { }
  private _sendMessage: ReplaySubject<any> = new ReplaySubject<any>(1);

  examDisposalNodesData; // 考生进入时获取当前试卷的处置节点
  examFacilityAssetsData; // 考生进入时获取当前试卷要考察的消防设施  
  examOriginaleveryStoreyData: any; // 考生答卷 总平面图/楼层/区域 楼层数据
  hiddenBasicInfoFacilities: any = []; // 考生答卷 当前楼层需要隐藏的基本信息素材



  isChange: boolean = false; // 数据 是否改动

  selectTemplateData: any; // 选择当前 模板数据

  // 总平面图/建筑 楼层
  selectStorey: any = { area: '', details: '' }; // 选择当前 楼层 数据
  originalcompanyBuildingData: any; // 单位/建筑 数据
  originaleveryStoreyData: any; // 总平面图/楼层/区域 楼层数据
  // 总平面图/建筑 楼层

  // 处置 节点
  allDisposalNode: any = []; // 所有 处置节点
  allNodeMarkers: any = { highlightMarkers: {}, markers: {} }; // 灾情 标签信息
  selectPanelPoint: DisposalNodeData = new DisposalNodeData(); // 当前数据节点
  selectPanelPointBaseData: any = { description: '', notes: '', weather: '', airTemperature: '', windDirection: '', windScale: '' }; // 当前 数据节点 对应 父级节点
  customizeDisposalNode: any; // 新建 自定义数据节点 底图+名称
  // 处置 节点

  /**
  * 游戏模式
  */
  gameMode: GameMode = GameMode.BasicInformation;

  facilityAssetsName = new Map<string, string>([
    ['消防水池', '消防水池'],
    ['疏散楼梯', '疏散楼梯'],
    ['消防电梯', '消防电梯'],
    ['避难区域', '避难区域'],
    ['安全出口', '安全出口'],
    ['地上消火栓', '室外消火栓'],
    ['地下消火栓', '室外消火栓'],
    ['室内消火栓', '室内消火栓'],
    ['供水管网', '供水管网'],
    ['湿式自动喷淋系统', '湿式自动喷淋系统'],
    ['水幕系统', '水幕系统'],
    ['消防泵房', '消防泵房'],
    ['水泵接合器（地上）', '水泵接合器'],
    ['水泵接合器（地下）', '水泵接合器'],
    ['水泵接合器（墙壁）', '水泵接合器'],
    ['水泵接合器（喷淋）', '水泵接合器'],
    ['水泵接合器（消防）', '水泵接合器'],
    ['消防水泵房', '消防水泵房'],
    ['箱式消火栓', '箱式消火栓'],
    ['固定水炮', '消防水炮'],
    ['消防水罐', '储水罐'],
    ['消防水罐2', '储水罐'],
    ['卧式水罐', '储水罐'],
    ['消防泵', '水泵'],
    ['泡沫泵', '水泵'],
    ['泡沫泵房', '泡沫站'],
    ['泡沫栓', '泡沫栓'],
    ['泡沫枪', '泡沫枪'],
    ['泡沫发生器', '泡沫发生器'],
    ['消防管网', '消防管网'],
    ['泡沫管网', '消防管网'],
    ['DCS控制室', 'DCS控制室']
  ]);

  /** * 向其他组件发送信息 *
  * @param message 需要发送的信息 * @returns {Observavle<any>} */
  public sendMessage(message: any) {
    this._sendMessage.next(message);
  }
  public getMessage(): Observable<any> {
    return this._sendMessage.asObservable();
  }

  //分段上传
  sectionUpload(companyId: string, file) {
    let data = { filename: file.name }
    return new Promise((resolve, reject) => {
      this.http.post(`/api/NewMultipartUpload/PlanPlatform/${companyId}/DisposalNode`, {}, { params: data }).subscribe(async (data: any) => { //初始化分段上传
        let objectName = data.objectName
        let uploadId = data.uploadId
        let PartNumberETag = []; //每次返回需要保存的信息
        //分块 处理
        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/${objectName}?uploadId=${uploadId}&partNumber=${i + 1}`, formData).subscribe((data: any) => {
              let msg = { "partNumber": data.partNumber || null, "eTag": data.eTag || null }
              resolve(msg) // 调用 promise 内置方法处理成功
            })
          });
          PartNumberETag.push(result)

          if (PartNumberETag.length === allSlice) { //分块上传完成
            let data = PartNumberETag
            let paramsData = { uploadId: uploadId }
            this.http.post(`/api/CompleteMultipartUpload/PlanPlatform/${objectName}`, data, { params: paramsData }).subscribe(data => {
              resolve(objectName)
            })
          }
        }//for循环

        //分块 处理
      })
    })
  }

  // 处置节点 筛选出 匹配数据 匹配不到 return undefined
  findDisposalNode(parentId: string = null, name: string = null) {
    if (parentId && name) { // 匹配 父id, name
      const returnData = this.allDisposalNode.find(item => item.parentId === parentId && item.name === name);
      return returnData;
    } else { // 匹配 id
      const returnData = this.allDisposalNode.find(item => item.id === parentId);
      return returnData;
    }
  }
  /**
   * 更新建筑数据
   */
  public updateBuildingData() {
    // 删除建筑数据中当前层数据
    Object.keys(this.originalcompanyBuildingData.data).forEach((key) => {
      if (this.originalcompanyBuildingData.data[key].FloorId === this.selectStorey.id) {
        delete this.originalcompanyBuildingData.data[key];
      }
    });
    // 新增当前层数据到建筑数据
    Object.keys(this.originaleveryStoreyData.data).forEach((key) => {
      this.originalcompanyBuildingData.data[key] = this.originaleveryStoreyData.data[key];
    });
  }
  /**
   * 删除建筑数据中当前楼层的数据
   */
  public deleteBuildingDataByCurrentFloorData(): void {
    Object.keys(this.originaleveryStoreyData.data).forEach((key) => {
      // 删除建筑数据
      delete this.originalcompanyBuildingData.data[key];
    });
  }
  /**
   * 获取单位毗邻信息
   */
  public getCompanyAdjoinInfo(): CompanyAdjoinInfo[] {
    const list: CompanyAdjoinInfo[] = [];
    Object.keys(this.originalcompanyBuildingData.data).forEach((key) => {
      const item = this.originalcompanyBuildingData.data[key];
      if (item.Name === '毗邻') {
        const adjoin = new CompanyAdjoinInfo();
        adjoin.AssetId = item.Id;
        adjoin.Id = '';
        adjoin.ImageUrls = [];
        adjoin.CompanyId = sessionStorage.getItem('companyId');
        item.PropertyInfos.forEach(element => {
          if (element.PropertyName === '方向') {
            adjoin.Direction = Number(element.PropertyValue);
          } else if (element.PropertyName === '名称/编号') {
            adjoin.Name = element.PropertyValue;
          } else if (element.PropertyType === PropertyType.Image) {
            adjoin.ImageUrls.push(element.PropertyValue);
          }
        });
        list.push(adjoin);
      }
    });
    return list;
  }
  /**
   * 获取建筑毗邻信息
   */
  public getBuildingAdjoinInfo(): BuildingAdjoinInfo[] {
    const list: BuildingAdjoinInfo[] = [];
    Object.keys(this.originalcompanyBuildingData.data).forEach((key) => {
      const item = this.originalcompanyBuildingData.data[key];
      if (item.Name === '毗邻') {
        const adjoin = new BuildingAdjoinInfo();
        adjoin.AssetId = item.Id;
        adjoin.Id = '';
        adjoin.BuildingId = this.selectStorey.buildingId;
        adjoin.ImageUrls = [];
        item.PropertyInfos.forEach(element => {
          if (element.PropertyName === '方向') {
            adjoin.Direction = Number(element.PropertyValue);
          } else if (element.PropertyName === '名称/编号') {
            adjoin.Name = element.PropertyValue;
          } else if (element.PropertyType === PropertyType.Image) {
            adjoin.ImageUrls.push(element.PropertyValue);
          }
        });
        list.push(adjoin);
      }
    });
    return list;
  }
  /**
   * 获取单位重点部位
   */
  public getCompanyImportantLocations(): CompanyImportantLocationInfo[] {
    const list: CompanyImportantLocationInfo[] = [];
    Object.keys(this.originalcompanyBuildingData.data).forEach((key) => {
      const item = this.originalcompanyBuildingData.data[key];
      if (item.Name === '重点部位') {
        const important = new CompanyImportantLocationInfo();
        important.AssetId = item.Id;
        important.Id = '';
        important.ImageUrls = [];
        important.CompanyId = sessionStorage.getItem('companyId');
        item.PropertyInfos.forEach(element => {
          if (element.PropertyName === '名称/编号') {
            important.Name = element.PropertyValue;
          } else if (element.PropertyType === PropertyType.Image) {
            important.ImageUrls.push(element.PropertyValue);
          } else if (element.PropertyName === '主要危险性') {
            important.Hazards = element.PropertyValue;
          } else if (element.PropertyName === '使用性质') {
            important.Nature = element.PropertyValue;
          } else if (element.PropertyName === '所在位置') {
            important.Position = element.PropertyValue;
          } else if (element.PropertyName === '建筑结构') {
            important.Structure = element.PropertyValue;
          }
        });
        list.push(important);
      }
    });
    return list;
  }
  /**
   * 获取建筑重点部位
   */
  public getBuildingImportantLocations(): BuildingImportantLocationInfo[] {
    const list: BuildingImportantLocationInfo[] = [];
    Object.keys(this.originalcompanyBuildingData.data).forEach((key) => {
      const item = this.originalcompanyBuildingData.data[key];
      if (item.Name === '重点部位') {
        const important = new BuildingImportantLocationInfo();
        important.AssetId = item.Id;
        important.Id = '';
        important.ImageUrls = [];
        important.BuildingId = this.selectStorey.buildingId;
        important.BuildingAreaId = item.FloorId;
        item.PropertyInfos.forEach(element => {
          if (element.PropertyName === '名称/编号') {
            important.Name = element.PropertyValue;
          } else if (element.PropertyType === PropertyType.Image) {
            important.ImageUrls.push(element.PropertyValue);
          } else if (element.PropertyName === '主要危险性') {
            important.Hazards = element.PropertyValue;
          } else if (element.PropertyName === '使用性质') {
            important.Nature = element.PropertyValue;
          } else if (element.PropertyName === '所在位置') {
            important.Position = element.PropertyValue;
          } else if (element.PropertyName === '建筑结构') {
            important.Structure = element.PropertyValue;
          }
        });
        list.push(important);
      }
    });
    return list;
  }
  /**
   * 获取单位消防设施
   */
  public getAllCompanyFacilityAssetInfo(): CompanyFacilityAssetInfo[] {
    const list: CompanyFacilityAssetInfo[] = [];
    Object.keys(this.originalcompanyBuildingData.data).forEach((key) => {
      const item = this.originalcompanyBuildingData.data[key];
      if (this.facilityAssetsName.has(item.Name)) {
        const facility = new CompanyFacilityAssetInfo();
        facility.CompanyId = sessionStorage.getItem('companyId');
        facility.AssetId = item.Id;
        facility.Id = '';
        facility.Name = this.facilityAssetsName.get(item.Name);
        facility.AssetName = item.Name;
        facility.PropertyInfos = [];
        item.PropertyInfos.forEach(e => {
          var p: PropertyInfo = new PropertyInfo();
          p.Enabled = e.Enabled;
          p.Order = e.Order;
          p.PhysicalUnit = e.PhysicalUnit;
          p.PropertyName = e.PropertyName;
          p.PropertyType = e.PropertyType;
          p.PropertyValue = e.PropertyValue.toString();
          p.Required = e.Required;
          p.RuleName = e.RuleName;
          p.RuleValue = e.RuleValue;
          p.Tag = e.Tag;
          p.Visible = e.Visible;
          facility.PropertyInfos.push(p);
        });
        facility.SitePlanId = item.FloorId;
        list.push(facility);
      }
    });
    return list;
  }
  /**
   * 获取建筑消防设施
   */
  public getAllBuildingFacilityAssetInfo(): BuildingFacilityAssetInfo[] {
    const list: BuildingFacilityAssetInfo[] = [];
    Object.keys(this.originalcompanyBuildingData.data).forEach((key) => {
      const item = this.originalcompanyBuildingData.data[key];
      if (this.facilityAssetsName.has(item.Name)) {
        const facility = new BuildingFacilityAssetInfo();
        facility.BuildingId = this.selectStorey.buildingId;
        facility.AssetId = item.Id;
        facility.Id = '';
        facility.Name = this.facilityAssetsName.get(item.Name);
        facility.AssetName = item.Name;
        facility.PropertyInfos = [];
        item.PropertyInfos.forEach(e => {
          var p: PropertyInfo = new PropertyInfo();
          p.Enabled = e.Enabled;
          p.Order = e.Order;
          p.PhysicalUnit = e.PhysicalUnit;
          p.PropertyName = e.PropertyName;
          p.PropertyType = e.PropertyType;
          p.PropertyValue = e.PropertyValue.toString();
          p.Required = e.Required;
          p.RuleName = e.RuleName;
          p.RuleValue = e.RuleValue;
          p.Tag = e.Tag;
          p.Visible = e.Visible;
          facility.PropertyInfos.push(p);
        });
        facility.BuildingAreaId = item.FloorId;
        list.push(facility);
      }
    });
    return list;
  }
  /**
   * 反序列化对象
   * @param json 字符串
   */
  public deserialize<T>(json: any): T {
    const obj: T = JSON.parse(
      json,
      (_, val) => {
        if (val === null) { return null; }
        if (Array.isArray(val) || typeof val !== 'object') {
          return val;
        }
        return Object.entries(val).reduce((a, [key, val]) => {
          const count = key.length;
          if (count > 1) {
            a[key[0].toUpperCase() + key.substring(1, count)] = val;
          } else {
            a[key] = val;
          }
          return a;
        }, {});
      }
    );
    return obj;
  }
}

/**
 * 单位毗邻
 */
export class CompanyAdjoinInfo {
  public CompanyId: string;
  public Id: string;
  public Name: string;
  public Direction: number;
  public ImageUrls: string[] = [];
  public AssetId: string;
}
/**
 * 建筑毗邻
 */
export class BuildingAdjoinInfo {
  public BuildingId: string;
  public Id: string;
  public Name: string;
  public Direction: number;
  public ImageUrls: string[];
  public AssetId: string;
}
/**
 * 建筑重点部位
 */
export class BuildingImportantLocationInfo {
  public BuildingId: string;
  public BuildingAreaId: string;
  public Id: string;
  public Name: string;
  public Position: string;
  public Structure: string;
  public Nature: string;
  public Hazards: string;
  public ImageUrls: string[];
  public AssetId: string;
}
/**
 * 单位重点部位
 */
export class CompanyImportantLocationInfo {
  public CompanyId: string;
  public Id: string;
  public Name: string;
  public Position: string;
  public Structure: string;
  public Nature: string;
  public Hazards: string;
  public ImageUrls: string[];
  public AssetId: string;
}
/**
 * 单位消防素材信息
 */
export class CompanyFacilityAssetInfo {
  public Id: string;
  public Name: string;
  public AssetName: string;
  public PropertyInfos: PropertyInfo[];
  public AssetId: string;
  public CompanyId: string;
  public SitePlanId: string;
}
/**
 * 建筑消防素材信息
 */
export class BuildingFacilityAssetInfo {
  public Id: string;
  public Name: string;
  public AssetName: string;
  public PropertyInfos: PropertyInfo[];
  public AssetId: string;
  public BuildingId: string;
  public BuildingAreaId: string;
}
/**
 * 属性
 */
export class PropertyInfo {
  // 标记位
  public Tag: string;
  // 属性书序
  public Order: number;
  // 是否启用
  public Enabled: boolean;
  // 是否可见
  public Visible: boolean;
  // 必填
  public Required: boolean;
  // 验证规则名称
  public RuleName: string;
  // 验证规则值
  public RuleValue: string;
  // 物理单位
  public PhysicalUnit: string;
  // 属性名称
  public PropertyName: string;
  // 属性类型
  public PropertyType: PropertyType;
  // 属性值
  public PropertyValue: string;
}
/**
 * 属性类型。
 */
export enum PropertyType {
  // 单行文本。
  SingleText,
  // 多行文本。
  MultipleText,
  // 数值。
  Numeric,
  // 图片。
  Image,
  // 图片数值，专用于描述图片数量。
  ImageNumeric,
  // 方向
  Direction,
  // 布尔类型。
  Boolean,
  // 供给区域
  SupplyArea,
  // 供给类型
  SupplyType
}
/**
 * 处置节点
 */
export class DisposalNode {
  /**
   * 编号
   */
  public Id: string;
  /**
   * 名称
   */
  public Name: string;
  /**
   * 等级
   */
  public Level: number;
  /**
   * 排序
   */
  public Order: number;
  /**
   * 详情
   */
  public Description: string;
  /**
   * 注意事项
   */
  public Notes: string;
  /**
   * 天气
   */
  public Weather: string;
  /**
   * 气温
   */
  public AirTemperature?: number;
  /**
   * 风向
   */
  public WindDirection: Direction;
  /**
   * 风力等级
   */
  public WindScale: WindScale;
  /**
   * 图片名称
   */
  public ImageNames: string[];
  /**
   * 图片地址
   */
  public ImageUrls: string[];
  /**
   * 父节点编号
   */
  public ParentId: string;
  /**
   * 灾情编号
   */
  public DisasterId: string;
  /**
   * 预案组件编号
   */
  public PlanComponentId: string;
  /**
   * 单位编号
   */
  public CompanyId: string;
  /**
   * 总平面图编号
   */
  public SitePlanId: string;
  /**
   * 建筑编号
   */
  public BuildingId: string;
  /**
   * 建筑区域编号
   */
  public BuildingAreaId: string;
}
/**
 * 方向。
 */
export enum Direction {
  /**
   * 东
   */
  East,
  /**
   * 西
   */
  West,
  /**
   * 南
   */
  South,
  /**
   * 北
   */
  North,
  /**
   * 东南
   */
  Southeast,
  /**
   * 西南
   */
  Southwest,
  /**
   * 东北
   */
  Northeast,
  /**
   * 西北
   */
  Northwest
}
/**
 * 风力等级
 */
export enum WindScale {
  WS0,
  WS1,
  WS2,
  WS3,
  WS4,
  WS5,
  WS6,
  WS7,
  WS8,
  WS9,
  WS10,
  WS11,
  WS12,
  WS13,
  WS14,
  WS15,
  WS16,
  WS17,
  WS18
}
/**
 * 处置节点数据
 */
export class DisposalNodeData {
  /**
   * 编号
   */
  public Id: string;
  /**
   * 数据
   */
  public Data: any;
  /**
   * 版本号
   */
  public Version: string;
  /**
   * 图片地址
   */
  public BackgroundImageUrl: string;
  /**
 * 图片地址
 */
  public BackgroundImageAngle: number;
  /**
   * 处置节点编号
   */
  public DisposalNodeId: string;
  /**
   * 预案组件编号
   */
  public PlanComponentId: string;
}
/**
 * 楼层节点数据
 */
export class FloorNodeData {
  /**
   * 存量
   */
  public Stock: Map<string, AssetData> = new Map<string, AssetData>();
  /**
   * 增量
   */
  public Increment: Map<string, AssetData> = new Map<string, AssetData>();
  /**
   * 用户定义的增量。
   */
  public DefinedIncrement: Map<string, AssetData> = new Map<string, AssetData>();
}
/**
 * 素材数据
 */
export class AssetData {
  /// <summary>
  /// 模板编号
  /// </summary>
  public TemplateId: string;
  /// <summary>
  /// 编号
  /// </summary>
  public Id: string;
  /// <summary>
  /// 名称
  /// </summary>
  public Name: string;
  /// <summary>
  /// 角度
  /// </summary>
  public Angle: number;
  /// <summary>
  /// 颜色
  /// </summary>
  public Color: string;
  /// <summary>
  /// 坐标
  /// </summary>
  public Point: PIXI.Point;
  /// <summary>
  /// 宽度
  /// </summary>
  public Width: number;
  /// <summary>
  /// 高度
  /// </summary>
  public Height: number;
  /// <summary>
  /// 是否启用
  /// </summary>
  public Enabled: boolean;
  /// <summary>
  /// 填充方式
  /// </summary>
  public FillMode: FillMode;
  /// <summary>
  /// 图片地址
  /// </summary>
  public ImageUrl: string;
  /// <summary>
  /// 是否固定大小
  /// </summary>
  public FixedSize: boolean;
  /// <summary>
  /// 点路径
  /// </summary>
  public MultiPoint: PIXI.Point[];
  /// <summary>
  /// 建筑ID
  /// </summary>
  public BuildingId: string;
  /// <summary>
  /// 单位ID
  /// </summary>
  public CompanyId: string;
  /// <summary>
  /// 楼层编号
  /// </summary>
  public FloorId: string;
  /// <summary>
  /// 楼层名称
  /// </summary>
  public FloorName: string;
  /// <summary>
  /// 消防要素编号
  /// </summary>
  public FireElementId: string;
  /// <summary>
  /// 属性列表
  /// </summary>
  public PropertyInfos: PropertyInfo[];
  /// <summary>
  /// 交互方式
  /// </summary>
  public InteractiveMode: InteractiveMode;
  /// <summary>
  /// 是否来自建筑
  /// </summary>
  public IsFromBuilding: boolean;
  /// <summary>
  /// 渲染方式。
  /// </summary>
  public DrawMode: ImageType;
  /// <summary>
  /// 9宫格边框数值。
  /// </summary>
  public Border: Border;
  /// <summary>
  /// 厚度。
  /// </summary>
  public Thickness: number;
  /// <summary>
  /// 素材类型
  /// </summary>
  public GameMode: GameMode;
}
/**
 * 填充模式
 */
export enum FillMode {
  Color,
  Image
}
/**
 * 交互方式
 */
export enum InteractiveMode {
  /**
   * 单点。
   */
  Single,
  /**
   * 多点不闭合。
   */
  Multiple,
  /**
   * 多点闭合。
   */
  MultipleClosed
}
/**
 * 图片显示类型
 */
export enum ImageType {
  Simple = 0,
  Sliced = 1,
  Tiled = 2,
  Filled = 3
}
/**
 * 边框
 */
export class Border {

  public x: number;

  public y: number;

  public z: number;

  public w: number;
}