LA19032-SiemensWarehouse.git

var soap = require("soap");
 
// 一、立库堆垛机
const srm = {
  common: {},
  // 发送立库堆垛机取放货任务
  sendSrmTask(srmId, taskId, sourcePlace, toPlace, pallet) {
    return new Promise((resolve, reject) => {
      const url = `/api/wcf/entry`;
      const params = {
        type: "srm", // 设备类型：tran=立库输送机，srm=立库堆垛机，rgv=RGV
        method: "sendSrmTask", // 方法名称
        // 参数
        params: {
          srmId: srmId,
          taskId: taskId,
          sourcePlace: sourcePlace,
          toPlace: toPlace,
          pallet: pallet
        }
      };
      this.common.ajax(url, params, res => {
        resolve(res);
      });
    });
  },
  // 发送立库堆垛机移动任务,参数：srmId 堆垛机编号、taskId 任务号，toPlace 移动目标点）
  // 返回值：1 发送成功、0、发送失败、2、其它问题
  sendSrmMove(srmId, taskId, sourcePlace, toPlace) {
    return new Promise((resolve, reject) => {
      var args = {
        srmId: srmId,
        taskId: taskId,
        sourcePlace: sourcePlace,
        toPlace: toPlace
      };
      soap.createClient(this.url, (err, client) => {
        if (err) {
          console.log(err);
        }
        if (!client.SendSrmMove) {
          reject(new Error("WebService SendSrmMove 未定义"));
          return;
        }
        client.SendSrmMove(args, (err, result) => {
          if (!err) {
            resolve(result);
          }
        });
      });
    });
  },
  // 发送立库堆垛机急停,参数：srmId 堆垛机编号
  sendSrmEStop(srmId) {
    return new Promise((resolve, reject) => {
      var args = {
        srmId: srmId
      };
      soap.createClient(this.url, (err, client) => {
        if (err) {
          console.log(err);
        }
        if (!client.SendSrmEStop) {
          reject(new Error("WebService SendSrmEStop 未定义"));
          return;
        }
        client.SendSrmEStop(args, (err, result) => {
          if (!err) {
            resolve(result);
          }
        });
      });
    });
  },
  // 发送立库堆垛机解警,参数：srmId 堆垛机编号
  srmRlsAlert(srmId) {
    return new Promise((resolve, reject) => {
      var args = {
        srmId: srmId
      };
      soap.createClient(this.url, (err, client) => {
        if (err) {
          console.log(err);
        }
        if (!client.SrmRlsAlert) {
          reject(new Error("WebService SrmRlsAlert 未定义"));
          return;
        }
        client.SrmRlsAlert(args, (err, result) => {
          if (!err) {
            resolve(result);
          }
        });
      });
    });
  },
  // 发送立库堆垛机任务删除,参数：srmId 堆垛机编号
  sendSrmDelete(srmId) {
    return new Promise((resolve, reject) => {
      var args = {
        srmId: srmId
      };
      soap.createClient(this.url, (err, client) => {
        if (err) {
          console.log(err);
        }
        if (!client.SendSrmDelete) {
          reject(new Error("WebService SendSrmDelete 未定义"));
          return;
        }
        client.SendSrmDelete(args, (err, result) => {
          if (!err) {
            resolve(result);
          }
        });
      });
    });
  },
  // 根据SrmEntity 数据结构获取当前设备号对应的设备信息
  getSrmInfo(srmId) {
    srmId = Number(srmId);
    return new Promise((resolve, reject) => {
      const url = `/api/wcf/entry`;
      const params = {
        type: "srm", // 设备类型：tran=立库输送机，srm=立库堆垛机，rgv=RGV
        method: "getSrmInfo", // 方法名称
        // 参数
        params: {
          srmId: srmId
        }
      };
      this.common.ajax(url, params, res => {
        resolve(res);
      });
    });
  },
  // 根据设备号，查询任务是否完成 参数：srmId,堆垛机号
  isTaskFinish(srmId) {
    return new Promise((resolve, reject) => {
      const url = `/api/wcf/entry`;
      const params = {
        type: "srm", // 设备类型：tran=立库输送机，srm=立库堆垛机，rgv=RGV
        method: "isTaskFinish", // 方法名称
        // 参数
        params: {
          srmId: srmId
        }
      };
      this.common.ajax(url, params, res => {
        resolve(res);
      });
    });
  },
  // 根据设备号，查询任务是否完成 参数：srmId,堆垛机号
  sendSrmTaskFinishConfirm(srmId) {
    return new Promise((resolve, reject) => {
      const url = `/api/wcf/entry`;
      const params = {
        type: "srm", // 设备类型：tran=立库输送机，srm=立库堆垛机，rgv=RGV
        method: "sendSrmTaskFinishConfirm", // 方法名称
        // 参数
        params: {
          srmId: srmId
        }
      };
      this.common.ajax(url, params, res => {
        resolve(res);
      });
    });
  },
  // 根据设备号，获取设备是否准备就绪并可执行新任务
  isReady(srmId) {
    return new Promise((resolve, reject) => {
      const url = `/api/wcf/entry`;
      const params = {
        type: "srm", // 设备类型：tran=立库输送机，srm=立库堆垛机，rgv=RGV
        method: "isReady", // 方法名称
        // 参数
        params: {
          srmId: srmId
        }
      };
      this.common.ajax(url, params, res => {
        resolve(res);
      });
    });
  }
};
 
// 二、立库输送机
const tran = {
  common: {},
  // 根据TransEntity  数据结构获取当前设备号对应的设备信息
  getSrmConveyorStationInfo(transPlaceId) {
    return new Promise((resolve, reject) => {
      const url = `/api/wcf/entry`;
      const params = {
        type: "tran", // 设备类型：tran=立库输送机，srm=立库堆垛机，rgv=RGV
        method: "getSrmConveyorStationInfo", // 方法名称
        // 参数
        params: {
          transPlaceId: transPlaceId
        }
      };
      this.common.ajax(url, params, res => {
        resolve(res);
      });
    });
  },
  // 发送重量确认
  sendWeightOk(transId, isOk) {
    return new Promise((resolve, reject) => {
      var args = {
        transId: transId,
        isOk: isOk
      };
      soap.createClient(this.url, (err, client) => {
        if (err) {
          console.log(err);
        }
        if (!client.SendWeightOk) {
          reject(new Error("WebService SendWeightOk 未定义"));
          return;
        }
        client.SendWeightOk(args, (err, result) => {
          if (!err) {
            resolve(result);
          }
        });
      });
    });
  },
  // 发送货物尺寸的理论数据
  sendGoodsSize(transId, length, width, height) {
    return new Promise((resolve, reject) => {
      const url = `/api/wcf/entry`;
      const params = {
        type: "tran", // 设备类型：tran=立库输送机，srm=立库堆垛机，rgv=RGV
        method: "sendGoodsSize", // 方法名称
        // 参数
        params: {
          transId: transId,
          length: length,
          width: width,
          height: height
        }
      };
      this.common.ajax(url, params, async res => {
        resolve(res);
      });
    });
  },
  // 通知输送线进料
  sendGoodsReady(startId, endId, taskId) {
    return new Promise((resolve, reject) => {
      const url = `/api/wcf/entry`;
      const params = {
        type: "tran", // 设备类型：tran=立库输送机，srm=立库堆垛机，rgv=RGV
        method: "sendGoodsReady", // 方法名称
        // 参数
        params: {
          startId: startId,
          endId: endId,
          taskId: taskId
        }
      };
      this.common.ajax(url, params, async res => {
        resolve(res);
      });
    });
  },
  // 根据设备号，查询货物重量
  getGoodsWeight(transId) {
    return new Promise((resolve, reject) => {
      const url = `/api/wcf/entry`;
      const params = {
        type: "tran", // 设备类型：tran=立库输送机，srm=立库堆垛机，rgv=RGV
        method: "getGoodsWeight", // 方法名称
        // 参数
        params: {
          transId: transId
        }
      };
      this.common.ajax(url, params, async res => {
        resolve(res);
      });
    });
  },
  // 根据设备号，查询货物条码
  GetGoodsBarcode(transId) {
    return new Promise((resolve, reject) => {
      var args = {
        transId: transId
      };
      soap.createClient(this.url, (err, client) => {
        if (err) {
          console.log(err);
        }
        if (!client.GetGoodsBarcode) {
          reject(new Error("WebService GetGoodsBarcode 未定义"));
          return;
        }
        client.GetGoodsBarcode(args, (err, result) => {
          if (!err) {
            resolve(result);
          }
        });
      });
    });
  },
  // 根据设备号，查询货物外观是否合格
  isPassed(transId) {
    return new Promise((resolve, reject) => {
      const url = `/api/wcf/entry`;
      const params = {
        type: "tran", // 设备类型：tran=立库输送机，srm=立库堆垛机，rgv=RGV
        method: "isPassed", // 方法名称
        // 参数
        params: {
          transId: transId
        }
      };
      this.common.ajax(url, params, async res => {
        resolve(res);
      });
    });
  }
};
 
// 三、RGV
const rgv = {
  common: {},
  isRgvReady(rgvId) {
    return new Promise((resolve, reject) => {
      const url = `/api/wcf/entry`;
      const params = {
        type: "rgv", // 设备类型：tran=立库输送机，srm=立库堆垛机，rgv=RGV
        method: "isRgvReady", // 方法名称
        // 参数
        params: {
          rgvId: rgvId
        }
      };
      this.common.ajax(url, params, res => {
        resolve(res);
      });
    });
  },
  // 发送RGV任务,参数：deviceId RGV编号、taskId 任务号、sourcePlce 起始位置编号、toPlace 目的位置编号,barcode 料车条码,taskType 指令码）
  // PS：指令码：1,取放货 2，移动
  // 返回值：1 发送成功、0、发送失败、2、其它问题
  sendRgvTask(deviceId, taskId, sourcePlace, toPlace, taskType) {
    return new Promise((resolve, reject) => {
      const url = `/api/wcf/entry`;
      const params = {
        type: "rgv", // 设备类型：tran=立库输送机，srm=立库堆垛机，rgv=RGV
        method: "sendRgvTask", // 方法名称
        // 参数
        params: {
          deviceId,
          taskId,
          sourcePlace,
          toPlace,
          taskType
        }
      };
      this.common.ajax(url, params, res => {
        resolve(res);
      });
    });
  },
  // 发送立库Rgv任务删除,参数：rgvId--Rgv编号,taskId--任务号）
  sendRgvDelete(srmId) {
    return new Promise((resolve, reject) => {
      var args = {
        srmId: srmId
      };
      soap.createClient(this.url, (err, client) => {
        if (err) {
          console.log(err);
        }
        if (!client.SendRgvDelete) {
          reject(new Error("WebService SendRgvDelete 未定义"));
          return;
        }
        client.SendRgvDelete(args, (err, result) => {
          if (!err) {
            resolve(result);
          }
        });
      });
    });
  },
  // 发送立库Rgv解警,参数：rgvId--Rgv编号）
  sendRgvRlsAlert(srmId) {
    return new Promise((resolve, reject) => {
      var args = {
        srmId: srmId
      };
      soap.createClient(this.url, (err, client) => {
        if (err) {
          console.log(err);
        }
        if (!client.SendRgvRlsAlert) {
          reject(new Error("WebService SendRgvRlsAlert 未定义"));
          return;
        }
        client.SendRgvRlsAlert(args, (err, result) => {
          if (!err) {
            resolve(result);
          }
        });
      });
    });
  },
  // 根据RgvEntity 数据结构获取当前设备号对应的设备信息
  getRgvInfo(rgvId) {
    return new Promise((resolve, reject) => {
      const url = `/api/wcf/entry`;
      const params = {
        type: "rgv", // 设备类型：tran=立库输送机，srm=立库堆垛机，rgv=RGV
        method: "getRgvInfo", // 方法名称
        // 参数
        params: {
          rgvId: rgvId
        }
      };
      this.common.ajax(url, params, async res => {
        resolve(res.data);
      });
    });
  },
  // 当前入库口RGV是否可用：是否可用由WMS的设备管理中读取对应入库口的RGV的是否可用为“是”的
  async getRgvEnable(rgvId) {
    return new Promise((resolve, reject) => {
      const url = "/api/wcs/getRgvInfo";
      const params = {
        rgvId: rgvId
      };
      this.common.ajax(
        url,
        params,
        async res => {
          this.log(res.msg);
          if (res.result) {
            resolve(res.data.enable === 1);
          } else {
            resolve(false);
          }
        },
        true
      );
    });
  },
  // 根据任务号获取任务是否完成
  isTaskFinish(rgvId) {
    return new Promise((resolve, reject) => {
      const url = `/api/wcf/entry`;
      const params = {
        type: "rgv", // 设备类型：tran=立库输送机，srm=立库堆垛机，rgv=RGV
        method: "isTaskFinish", // 方法名称
        // 参数
        params: {
          rgvId
        }
      };
      this.common.ajax(url, params, res => {
        resolve(res);
      });
    });
  },
  // 发送Rgv任务完成确认,参数：rgvId--Rgv编号）
  sendRgvFinishConfirm(rgvId) {
    return new Promise((resolve, reject) => {
      const url = `/api/wcf/entry`;
      const params = {
        type: "rgv", // 设备类型：tran=立库输送机，srm=立库堆垛机，rgv=RGV
        method: "sendRgvFinishConfirm", // 方法名称
        // 参数
        params: {
          rgvId
        }
      };
      this.common.ajax(url, params, res => {
        resolve(res);
      });
    });
  }
};
 
export { srm, tran, rgv };