tplus-pos/dist/domain/retail/quantity/Quantity2ToQuantityProcessor.js

pos module

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Quantity2ToQuantityProcessor = undefined;

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

require('../../../commom/Challenger');

var _UnitTypeProcessor = require('../../unit/UnitTypeProcessor');

var _tplusPoslogin = require('tplus-poslogin');

var _Enum = require('../../../commom/Enum');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 *数量2改变相关处理
 * 固定多计量的场合，计算数量1
 * 浮动多计量的场合，计算换算率
 * @export
 * @class Quantity2ToQuantityProcessor
 * @auther 马坚
 */
var Quantity2ToQuantityProcessor = exports.Quantity2ToQuantityProcessor = function () {
  function Quantity2ToQuantityProcessor() {
    (0, _classCallCheck3.default)(this, Quantity2ToQuantityProcessor);
  }

  (0, _createClass3.default)(Quantity2ToQuantityProcessor, null, [{
    key: 'execute',

    /**
    *  数量2改变
    * @param {*} detail
    */
    value: function execute(detail) {
      var quantityDecimalDigits = (0, _tplusPoslogin.PosInitData)("QuantityPrecision");
      var proportionRatePrecision = (0, _tplusPoslogin.PosInitData)("ProportionRatePrecision");

      var unitType = _UnitTypeProcessor.UnitTypeProcessor.execute(detail.Unit);

      if (unitType === _Enum.UnitType.Single) {
        return;
      }
      // 计量单位换算率
      var unitExchangeRate = detail.UnitExchangeRate;
      var quantity2 = detail.Quantity2;
      // 主计量
      var idBaseUnit = detail.Inventory.Idunit;
      if (!idBaseUnit) {
        console.error("多计量单位时，主计量不能为空");
      }

      var idUnit = detail.Idunit;
      if (unitType == _Enum.UnitType.Fixed) {
        // 固定多计量的场合，换算率不变，计算数量
        if (idBaseUnit == idUnit) {
          // 计量单位1为主计量的场合，说明计量单位2为辅计量
          detail.Quantity = Math.Multiply(quantity2, unitExchangeRate).Round(quantityDecimalDigits);
        } else {
          // 当计量单位1为辅计量的场合，说明计量单位2为主计量
          detail.Quantity = Math.Divide(quantity2, unitExchangeRate, true).Round(quantityDecimalDigits);
        }
      }
      if (unitType == _Enum.UnitType.Float) {
        // 固定多计量的场合，数量2改变，数量不变，计算换算率

        var quantity = detail.Quantity;
        if (idBaseUnit == idUnit) {
          // 计量单位1为主计量的场合，说明计量单位2为辅计量
          detail.UnitExchangeRate = Math.Divide(quantity, quantity2, true).Round(proportionRatePrecision);
        } else {
          // 当计量单位1为辅计量的场合，说明计量单位2为主计量
          detail.UnitExchangeRate = Math.Divide(quantity2, quantity, true).Round(proportionRatePrecision);
        }
      }

      if (idBaseUnit == idUnit) {
        detail.BaseQuantity = detail.Quantity;
        detail.SubQuantity = detail.Quantity2;
      } else {
        detail.BaseQuantity = detail.Quantity2;
        detail.SubQuantity = detail.Quantity;
      }
    }
  }]);
  return Quantity2ToQuantityProcessor;
}();
//# sourceMappingURL=Quantity2ToQuantityProcessor.js.map