tplus-pos/dist/commom/priceTaxFormula.js

pos module

"use strict";

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

require("./Challenger");

/************************** Formula.js begin*******************/
/**
 * 价税额基础算法
 */

// eslint-disable-next-line no-undef
var FormulaBase = $T.Object.extend({
  init: function init(opt) {
    try {
      this.currentRowData = opt.CurrentRowData;

      //报价是否含税
      this.withTax = opt.PriceWithTax || false;
      this.taxFlag; //含税标识
      this.isInvoice = opt.Invoice || false;

      this.AlreadyRunMethod = false;

      this.pattern = /{(\w*)}/;
      this.currency = opt.CalDirection ? opt.CalDirection : "";
      this.F_Price;

      this.isMultiCurrency = opt.IsMultiCurrency;

      this.unitPriceDecimalDigits = opt.UnitPriceDecimalDigits;
      this.quantityDecimalDigits = opt.QuantityDecimalDigits;
      this.invoiceDecimalDigits = opt.InvoiceDecimalDigits;

      this.exchangeRate = opt.ExchangeRate;

      this.Columns = {
        Price: "OrigPrice", //报价原币
        DiscountPrice: "OrigDiscountPrice", //无税单价原币
        Amount: "OrigDiscountAmount", //金额原币
        DiscountTaxPrice: "OrigTaxPrice", //含税单价原币
        AmountTax: "OrigTaxAmount", //含税金额原币
        TaxRate: "TaxRate", //税率
        DiscountRate: "DiscountRate", //折扣率
        Quantity: "Quantity", //数量
        Tax: "OrigTax", //税额原币
        DiscountAmount: "OrigDiscount", //折扣额原币
        F_Price: "F_Price", //报价本币
        F_DiscountPrice: "DiscountPrice", //无税单价本币
        F_Amount: "DiscountAmount", //无税金额本币
        F_DiscountTaxPrice: "TaxPrice", //含税单价本币
        F_AmountTax: "TaxAmount", //含税金额本币
        F_DiscountAmount: "Discount", //折扣额本币
        F_Tax: "Tax" //本币税额
      };
      if (opt.Columns) {
        this.Columns = opt.Columns;
      }
      this.precision = {
        Price: this.unitPriceDecimalDigits, //报价原币
        DiscountPrice: this.unitPriceDecimalDigits, //无税单价原币
        Amount: 2, //金额原币
        DiscountTaxPrice: this.unitPriceDecimalDigits, //含税单价原币
        AmountTax: 2, //含税金额原币
        TaxRate: 4, //税率
        DiscountRate: 4, //折扣率
        Quantity: this.quantityDecimalDigits, //数量
        Tax: 2, //税额原币
        DiscountAmount: 2, //折扣额原币
        F_Price: this.unitPriceDecimalDigits, //报价本币
        F_DiscountPrice: this.unitPriceDecimalDigits, //无税单价本币
        F_Amount: 2, //无税金额本币
        F_DiscountTaxPrice: this.unitPriceDecimalDigits, //含税单价本币
        F_AmountTax: 2, //含税金额本币
        F_DiscountAmount: 2, //折扣额本币
        F_Tax: 2 //本币税额
      };
      this.invoicePrecision = {
        Price: this.invoiceDecimalDigits, //报价原币
        DiscountPrice: this.invoiceDecimalDigits, //无税单价原币
        Amount: 2, //金额原币
        DiscountTaxPrice: this.invoiceDecimalDigits, //含税单价原币
        AmountTax: 2, //含税金额原币
        TaxRate: 4, //税率
        DiscountRate: 4, //折扣率
        Quantity: this.quantityDecimalDigits, //数量
        Tax: 2, //税额原币
        DiscountAmount: 2, //折扣额原币
        F_Price: this.invoiceDecimalDigits, //报价本币
        F_DiscountPrice: this.invoiceDecimalDigits, //无税单价本币
        F_Amount: 2, //无税金额本币
        F_DiscountTaxPrice: this.invoiceDecimalDigits, //含税单价本币
        F_AmountTax: 2, //含税金额本币
        F_DiscountAmount: 2, //折扣额本币
        F_Tax: 2 //本币税额
      };

      this.Post_Run = null;

      this.formulaList = [];
      var func = ["PriceChange", "DiscountPriceChange", "DiscountTaxPriceChange", "AmountChange", "AmountTaxChange", "TaxRateChange", "QuantityChange", "DiscountAmountChange", "DiscountRateChange", "TaxAmountChange"];
      for (var i = 0, len = func.length; i < len; ++i) {
        this[func[i]].FunctionName = func[i];
        this[func[i]] = this[func[i]].wrap(function (proc) {
          this.CheckData();
          this.formulaList = [];
          //  (function(funcName) { // 进入方法前的初始化字段的方法
          //      if (funcName == 'TaxAmountChange') {
          //          this.SetLastModifiedField(this.Columns['Tax']);
          //      } else {
          //          this.SetLastModifiedField('');
          //      }
          //  }).bind(this)(arguments.callee.__method.FunctionName);
          proc();
          if (this.AlreadyRunMethod == true) {
            this.AlreadyRunMethod = false;
            return;
          }
          this.Run();
          if (this.isMultiCurrency) {
            this.formulaList = [];
            this.CalculateFunctionalCurrency();
          } else {
            this.CopyNativeToFunction(); //复制原币到本币
          }

          //处理税额为0的情况
          this.CalculateWithTaxIsNull();

          if (this.Post_Run && typeof this.Post_Run == "function") {
            this.Post_Run();
          }
        });
      }
    } catch (eex1) {
      console.error(eex1);
    }
  },
  InitArgs: function InitArgs(opt) {
    //初始化
    if (opt) {
      this.init(opt);
    }
  },
  GetExchangeRate: function GetExchangeRate() {

    if (this.currentRowData["ExchangeRate"]) {
      var v = this.currentRowData["ExchangeRate"];
      if (v == null || v == "") return 1;
      return v;
    }
    return 1;
  },
  CheckData: function CheckData() {
    //检查实例参数是否正确
    if (this.currentRowData == null) {
      throw new Error("data is null");
    }
    if (typeof this.withTax != "boolean") {
      throw new Error("PriceWithTax is not bool");
    }
  },
  SetCurrentRowData: function SetCurrentRowData(g) {
    //设置明细对象
    this.currentRowData = g;
  },
  SetPriceWithTax: function SetPriceWithTax(b) {
    //设置报价是否含税
    this.withTax = b;
  },
  SetInvoice: function SetInvoice(b) {
    //设置是否发票
    this.isInvoice = b;
  },
  /**
   * 获取当前列的内容
   * @param {*} colName
   */
  getCellValue: function getCellValue(colName) {
    if (colName) {
      return this.currentRowData[colName];
    }
    return null;
  },
  /**
   * 设置当前列的内容
   * @param {*} colName
   * @param {*} val
   */
  setCellValue: function setCellValue(colName, val) {
    if (colName) {
      this.currentRowData[colName] = val;
    }
  },
  GetFlag: function GetFlag() {
    //获取含税标识
    this.taxFlag = this.getCellValue("TaxFlag") || true;
    //<朱金伟 2008/10/15 修改代码，this.taxFlag首字符有大写，有小写，统一改成小写
    if (this.taxFlag && (this.taxFlag == true || this.taxFlag.toLowerCase() == "true")) {
      return true;
    }
    return false;
  },
  SetFlag: function SetFlag(val) {
    //设置含税标识
    this.setCellValue("TaxFlag", val);
    this.taxFlag = val;
  },
  GetLastModifiedField: function GetLastModifiedField() {
    //获取最后修改字段的值
    return this.getCellValue("LastModifiedField");
  },
  SetLastModifiedField: function SetLastModifiedField(val) {
    //设置最后修改字段的值
    this.setCellValue("LastModifiedField", val);
  },
  ConvertFunctionalCurrency: function ConvertFunctionalCurrency(src, dest) {
    var val = this.getCellValue(this.Columns[src]);
    var pre = this.precision[src];
    if (pre) {
      val = val.Round(pre);
    }
    var ret;
    if (typeof val == "string" || typeof val == "number") {
      if (val === "" || val === undefined || val === null || isNaN(val)) {
        ret = "";
      } else {
        ret = $T.ToFunction(val, this.currency, this.GetExchangeRate(), true);
      }
      if (src == "Price") {
        this.F_Price = ret;
      } else {
        this.setCellValue(this.Columns[dest], ret);
      }
    }
  },
  Run: function Run() {
    // 运行
    try {
      var list = this.formulaList;
      if (list.length <= 0) return;
      var _formulaBase = new $T.Bap.TMath.FormulaBase(this.currentRowData);

      _formulaBase.BeforeSetValue = function (colName, value) {
        if (colName == "F_Price") {
          this.F_Price = value;
          return false;
        }
        if (colName == this.Columns["DiscountRate"]) {
          if (value === "") {
            this.setCellValue(colName, 1);
            return false;
          }
        }
      }.bind(this);
      _formulaBase.BeforeGetValue = function (colName) {
        if (colName == "F_Price") {
          return this.F_Price;
        }
      }.bind(this);
      for (var i = 0, len = list.length; i < len; ++i) {
        _formulaBase.SetExpression(list.pop());
      }
      _formulaBase.SetMapColumns(this.Columns);
      if (this.isInvoice) {
        _formulaBase.SetPrecision(this.invoicePrecision);
      } else {
        _formulaBase.SetPrecision(this.precision);
      }
      _formulaBase.RunParse();
    } catch (exc11) {
      alert("我们的程序发生了问题，请关闭此单据后，重新打开！");
    }
  },
  CalculateDiscount: function CalculateDiscount(ff1, ff2, ff3, ff4) {
    //计算原币折扣额和折扣率
    /*
        报价不为0或不为空时：
        报价含税：
        折扣金额＝报价×数量－含税金额
        折扣＝含税金额/（报价×数量）；
        报价不含税：
        折扣金额＝报价×数量×（1＋税率）－含税金额
        折扣＝金额/（报价×数量）
        */
    var f1, f2;
    var price = this.getCellValue(this.Columns["Price"]);
    if (!Number(price)) return;
    if (this.withTax) {
      if (ff1 || ff2) {
        f1 = ff1;
        f2 = ff2;
      } else {
        /*
                报价含税：
                折扣金额＝报价×数量－含税金额
                折扣＝含税金额/（报价×数量）；
                */

        //折扣金额＝报价×数量－含税金额
        f1 = "{DiscountAmount} = {Price}*{Quantity}-{AmountTax}";
        //折扣＝含税金额/（报价×数量）
        f2 = "{DiscountRate}= {AmountTax}/({Price}*{Quantity})";
      }
    } else {
      if (ff3 || ff4) {
        f1 = ff3;
        f2 = ff4;
      } else {
        /*
                报价不含税：
                折扣金额＝报价×数量×（1＋税率）－含税金额
                折扣＝金额/（报价×数量）
                */

        //折扣金额＝报价×数量×（1＋税率）－含税金额
        f1 = "{DiscountAmount} = ({Price}*{Quantity}*(1+{TaxRate}))@2-{AmountTax}";
        //折扣＝金额/（报价×数量）
        f2 = "{DiscountRate} = {Amount}/({Price}*{Quantity})";
      }
    }

    if (f1) this.formulaList.unshift(f1);
    if (f2) this.formulaList.unshift(f2);
  },
  CalculateFunctionDiscount: function CalculateFunctionDiscount() {
    //计算本币折扣额和折扣率
    var f2 = void 0;

    var price = this.getCellValue(this.Columns["Price"]);
    if (!Number(price)) return;

    this.ConvertFunctionalCurrency("Price", "F_Price");
    //f1 = '{F_Price} = {Price}*'+this.exchangeRate.RoundExchangeRate();

    if (this.withTax) {
      /*
            报价含税：
            折扣金额＝报价×数量－含税金额
            折扣＝含税金额/（报价×数量）；
            */

      //折扣金额＝报价×数量－含税金额
      f2 = "{F_DiscountAmount} = {F_Price}*{Quantity}-{F_AmountTax}";
      //折扣＝含税金额/（报价×数量）
      //f3 = '{DiscountRate} = {F_AmountTax}/({F_Price}*{Quantity})';
    } else {
      /*
            报价不含税：
            折扣金额＝报价×数量×（1＋税率）－含税金额
            折扣＝金额/（报价×数量）
            */

      //折扣金额＝报价×数量×（1＋税率）－含税金额
      f2 = "{F_DiscountAmount} = ({F_Price}*{Quantity}*(1+{TaxRate}))@2-{F_AmountTax}";
      //折扣＝金额/（报价×数量）
      //f3 = '{DiscountRate} = {F_Amount}/({F_Price}*{Quantity})';
    }

    //this.formulaList.unshift(f1);
    this.formulaList.unshift(f2);
    //this.formulaList.unshift(f3);
  },
  CalculateFunctionalCurrency: function CalculateFunctionalCurrency() {
    // 计算本币
    /*
        1. 汇率为1时，原币与本币价税额对应的字段值相等
        2.	汇率不为1时：计算本币价税额
        1)	标识为含税：
        在原币价税额计算完成的基础上，先根据汇率计算本币含税金额，再以本币含税金额为准，进行推算：
        本币含税金额＝原币含税金额*汇率（折算方式：原币*汇率=本位币）
        本币含税金额＝原币含税金额/汇率（折算方式：原币/汇率=本位币）
        判断为“应税外加”时：遵照“应税外加”算法中E规则计算。
        判断为“应税内含”时：遵照“应税内含”算法中C规则计算。取不到本币报价的，按报价*汇率计算
        如果修改的是税额，在按规则计算基础上还要重新计算：
        本币税额＝税额*汇率（折算方式：原币*汇率=本位币）
        本币税额＝税额/汇率（折算方式：原币/汇率=本位币）
        本币金额=本币含税金额－本币税额
        本币单价=本币金额÷数量
        2)	标识为无税：
        在原币价税额计算完成的基础上，先根据汇率计算本币金额，再以本币金额为准，遵照“应税外加”算法中D规则进行推算。（内含算法金额不能直接输入、修改）
        本币金额＝原币金额*汇率（折算方式：原币*汇率=本位币）
        本币金额＝原币金额/汇率（折算方式：原币/汇率=本位币）
        如果修改的是税额，在按规则计算基础上还要重新计算：
        本币税额＝税额*汇率（折算方式：原币*汇率=本位币）
        本币税额＝税额/汇率（折算方式：原币/汇率=本位币）
        本币含税金额＝本币金额+本币税额
        本币含税单价＝本币含税金额÷数量
         3. 原币价税额不变，依据（1）、（2）规则和汇率推算本币价税额。
         */
    if (!this.isMultiCurrency) return;
    if (Number(this.GetExchangeRate()) == 1) {
      this.CopyNativeToFunction(); //复制原币到本币
    } else {
      this.RealCalculateFunction();
      this.Run();
      //如果最后一次修改的字段是税额，则重新计算本币金额和本币单价
      if (this.GetLastModifiedField() == this.Columns["Tax"]) {
        this.CalculateFunctionTaxAmount();
      }
    }
  },
  CopyNativeToFunction: function CopyNativeToFunction() {
    //复制原币到本币

    for (var name in this.Columns) {
      if (typeof this.Columns[name] == "string" && name.indexOf("F_") < 0) {
        try {
          var o = this.getCellValue(this.Columns[name]);
          this.setCellValue(this.Columns["F_" + name], o);
        } catch (exc) {
          console.error(exc);
        }
      }
    }
  },
  RealCalculateFunction: function RealCalculateFunction() {
    if (this.GetFlag()) {
      // 含税
      /*
            1)	输入、修改原币含税金额或标识为含税：
            在原币价税额计算完成的基础上，先根据汇率计算本币含税金额，再以本币含税金额为准，进行推算：
            本币含税金额＝原币含税金额*汇率（折算方式：原币*汇率=本位币）
            本币含税金额＝原币含税金额/汇率（折算方式：原币/汇率=本位币）
            判断为“应税外加”时：遵照“应税外加”算法中E规则计算。
            判断为“应税内含”时：遵照“应税内含”算法中C规则计算。取不到本币报价的，按报价*汇率计算
            2) 如果修改的是税额，在按规则计算基础上还要重新计算：
            本币税额＝税额*汇率（折算方式：原币*汇率=本位币）
            本币税额＝税额/汇率（折算方式：原币/汇率=本位币）
            本币金额=本币含税金额－本币税额
            本币单价=本币金额÷数量
             */
      this.CalculateFunctionWithTax();
    } else {
      //无税
      /*
            1)	输入、修改原币金额或标识为无税：
            在原币价税额计算完成的基础上，先根据汇率计算本币金额，再以本币金额为准，遵照“应税外加”算法中D规则进行推算。（内含算法金额不能直接输入、修改）
            本币金额＝原币金额*汇率（折算方式：原币*汇率=本位币）
            本币金额＝原币金额/汇率（折算方式：原币/汇率=本位币）
            2) 如果修改的是税额，在按规则计算基础上还要重新计算：
            本币税额＝税额*汇率（折算方式：原币*汇率=本位币）
            本币税额＝税额/汇率（折算方式：原币/汇率=本位币）
            本币含税金额＝本币金额+本币税额
            本币含税单价＝本币含税金额÷数量
             */
      this.CalculateFunctionWithoutTax();
    }

    //判断报价是否为空
    var price = this.getCellValue(this.Columns["Price"]);
    if (!Number(price)) {
      var discountAmount = this.getCellValue(this.Columns["DiscountAmount"]);
      if (!Number(discountAmount)) this.setCellValue(this.Columns["F_DiscountAmount"], "");else this.setCellValue(this.Columns["F_DiscountAmount"], $T.ToFunction(discountAmount, this.currency, this.GetExchangeRate(), true));
    }
  },
  CalculateFunctionWithTax: function CalculateFunctionWithTax() {
    //计算含税本币

    this.ConvertFunctionalCurrency("AmountTax", "F_AmountTax");
  },
  CalculateFunctionWithoutTax: function CalculateFunctionWithoutTax() {
    //计算无税本币
    /*
        本币税额＝本币金额×税率
        本币含税金额＝本币金额+本币税额
        本币含税单价＝本币含税金额÷数量
        本币单价＝本币金额÷数量
         报价不为0或不为空时：
        报价含税：
        本币折扣金额＝本币报价×数量－本币含税金额
        折扣＝含税金额/（报价×数量）；
        报价不含税：
        本币折扣金额＝本币报价×数量×（1＋税率）－本币含税金额
        折扣＝金额/（报价×数量）
        */
    var f1, f2, f3, f4;

    this.ConvertFunctionalCurrency("Amount", "F_Amount");

    //本币税额＝本币金额×税率
    f1 = "{F_Tax}={F_Amount}*{TaxRate}";
    //本币含税金额＝本币金额+本币税额
    f2 = "{F_AmountTax} = {F_Amount}+{F_Tax}";

    //本币含税单价＝本币含税金额÷数量
    f3 = "{F_DiscountTaxPrice} = {F_AmountTax}/{Quantity}";
    //本币单价＝本币金额÷数量
    f4 = "{F_DiscountPrice} = {F_Amount}/{Quantity}";

    this.formulaList.unshift(f1);
    this.formulaList.unshift(f2);
    this.formulaList.unshift(f3);
    this.formulaList.unshift(f4);

    this.CalculateFunctionDiscount();
  },
  CalculateFunctionTaxAmount: function CalculateFunctionTaxAmount() {
    //计算税额
    /*
        本币税额＝税额*汇率（折算方式：原币*汇率=本位币）
        本币税额＝税额/汇率（折算方式：原币/汇率=本位币）
        */
    var f1, f2;

    this.formulaList = [];

    this.ConvertFunctionalCurrency("Tax", "F_Tax");

    if (this.GetFlag()) {
      // 含税
      /*
             本币金额=本币含税金额－本币税额
            本币单价=本币金额÷数量
            */
      f1 = "{F_Amount} = {F_AmountTax}-{F_Tax}";

      f2 = "{F_DiscountPrice} = {F_Amount}/{Quantity}"; // 发票
    } else {
      // 无税
      /*
            本币含税金额＝本币金额+本币税额
            本币含税单价＝本币含税金额÷数量
            */
      f1 = "{F_AmountTax} = {F_Amount}+{F_Tax}";

      f2 = "{F_DiscountTaxPrice} = {F_AmountTax}/{Quantity}"; // 发票
    }

    this.formulaList.unshift(f1);
    this.formulaList.unshift(f2);

    this.Run();
  },
  PriceChange: function PriceChange() {
    //报价改变
    /*
        当报价改为0或为空的时候：
        折扣=100%
        含税单价、含税金额、金额、税额、单价、数量、税率、折扣金额不发生变化。
        */
    var price = this.getCellValue(this.Columns["Price"]);
    if (!Number(price)) {
      this.setCellValue(this.Columns["DiscountRate"], 1);
      return false;
    }
    return true;
  },
  DiscountPriceChange: function DiscountPriceChange() {}, //单价改变
  DiscountTaxPriceChange: function DiscountTaxPriceChange() {}, //含税单价改变
  AmountChange: function AmountChange() {}, //金额改变
  AmountTaxChange: function AmountTaxChange() {}, //含税金额改变
  TaxRateChange: function TaxRateChange() {}, //税率改变
  QuantityChange: function QuantityChange() {}, //数量
  DiscountAmountChange: function DiscountAmountChange() {
    //折扣金额
    /*
        当报价为0或为空的时候：
        含税金额=原含税金额-折扣金额
        然后套用含税金额发生变化的算法进行计算
        */
    var price = this.getCellValue(this.Columns["Price"]);
    if (Number(price) == 0) {
      var amount = this.getCellValue(this.Columns["AmountTax"]);
      var discountAmount = this.getCellValue(this.Columns["DiscountAmount"]);
      amount = amount.Round() - discountAmount.Round();
      this.setCellValue(this.Columns["AmountTax"], amount.Round());

      this.AmountTaxChange();
      this.AlreadyRunMethod = true;
      return false;
    }
    return true;
  },
  DiscountRateChange: function DiscountRateChange() {
    //折扣率
    /*
        当报价为0或为空的时候：
        折扣可以修改，但是含税单价、含税金额、金额、税额、单价、数量、税率、折扣金额不发生变化。
         */
    var price = this.getCellValue(this.Columns["Price"]);
    if (Number(price) == 0) {
      return false;
    }
    return true;
  },
  TaxAmountChange: function TaxAmountChange() {}, //税额
  CalculateWithTaxIsNull: function CalculateWithTaxIsNull() {
    //处理税额为0的情况
    var tax = this.getCellValue(this.Columns["Tax"]);
    if (Number(tax) == 0) {
      //含税
      if (this.GetFlag()) {
        //单价=含税单价
        this.setCellValue(this.Columns["DiscountPrice"], this.getCellValue(this.Columns["DiscountTaxPrice"]));
      } else {
        //含税单价=单价
        this.setCellValue(this.Columns["DiscountTaxPrice"], this.getCellValue(this.Columns["DiscountPrice"]));
      }
    }

    //处理本币情况
    var ftax = this.getCellValue(this.Columns["F_Tax"]);
    if (Number(ftax) == 0) {
      //含税
      if (this.GetFlag()) {
        //单价=含税单价
        this.setCellValue(this.Columns["F_DiscountPrice"], this.getCellValue(this.Columns["F_DiscountTaxPrice"]));
      } else {
        //含税单价=单价
        this.setCellValue(this.Columns["F_DiscountTaxPrice"], this.getCellValue(this.Columns["F_DiscountPrice"]));
      }
    }
  }
});

/************************** Formula.js end *******************/

/*-----------------------------应税外含算法 begin----------------------------------------------------*/
/* eslint-disable no-undef */

/**
 * Created by majianb on 2019/4/10.
 * 价税额算法
 */

var FormulaExcludingTax = FormulaBase.extend({
  init: function init(opt) {
    this.base(opt);
  },
  PriceChange: function PriceChange() {
    //报价改变
    /*
        A．录入、修改报价（报价不为0）
        数量、税率、折扣不变，并依次计算：
         A1.报价含税、标识置为含税：
        含税单价＝报价×折扣
        含税金额＝含税单价×数量
        金额＝含税金额÷（1＋税率）
        税额＝含税金额－金额
        单价＝含税金额÷（1＋税率）÷数量 （zhangt依据王莹2012-9-4提出问题进行的修改）
         //折扣金额＝报价×数量－含税金额
        折扣金额＝报价×数量－含税单价×数量（折扣金额避免尾差修改，XXdp202253738，zlj修改 2013-8-27）
         A2.报价不含税、标识置为无税：
        单价＝报价×折扣
        金额＝单价×数量huuuuu
        税额＝金额×税率
        含税金额＝金额＋税额
        含税单价＝含税金额÷数量
        //折扣金额＝报价×数量×（1＋税率）－含税金额
        折扣金额＝报价×数量×（1＋税率）－（单价×数量×（1＋税率））（折扣金额避免尾差修改，XXdp202253738，zlj修改 2013-8-27）
        */
    if (!this.base()) return;

    var f1, f2, f3, f4, f5, f6;

    if (this.withTax) {
      //含税
      this.SetFlag(true);

      //含税单价＝报价×折扣
      f1 = "{DiscountTaxPrice} = {Price}*{DiscountRate}";
      //含税金额＝含税单价×数量
      f2 = "{AmountTax}={DiscountTaxPrice}*{Quantity}";

      //金额＝含税金额÷（1＋税率）
      f3 = "{Amount} = {AmountTax}/(1+{TaxRate})";
      //税额＝含税金额－金额
      f4 = "{Tax} = {AmountTax}-{Amount}";

      //单价＝金额÷数量
      f5 = "{DiscountPrice} = {AmountTax}/(1+{TaxRate})/{Quantity}";
      //折扣金额＝报价×数量－含税金额
      //f6 = '{DiscountAmount} = {Price}*{Quantity}-{AmountTax}';
      // 折扣金额＝报价×数量－含税单价×数量（折扣金额避免尾差修改，XXdp202253738，zlj修改 2013-8-27）
      f6 = "{DiscountAmount} = {Price}*{Quantity}-{DiscountTaxPrice}*{Quantity}";
    } else {
      this.SetFlag(false);

      //单价＝报价×折扣
      f1 = "{DiscountPrice} = {Price}*{DiscountRate}";
      //金额＝单价×数量
      f2 = "{Amount}={DiscountPrice}*{Quantity}";

      //税额＝金额×税率
      f3 = "{Tax} = {Amount}*{TaxRate}";
      //含税金额＝金额＋税额
      f4 = "{AmountTax} = {Amount} + {Tax}";

      //含税单价＝含税金额÷数量
      f5 = "{DiscountTaxPrice} = {AmountTax}/{Quantity}";
      //折扣金额＝报价×数量×（1＋税率）－含税金额
      //f6 = '{DiscountAmount} = ({Price}*{Quantity}*(1+{TaxRate}))@2-{AmountTax}';
      //折扣金额＝报价×数量×（1＋税率）－（单价×数量×（1＋税率））（折扣金额避免尾差修改，XXdp202253738，zlj修改 2013-8-27）
      f6 = "{DiscountAmount} = {Price}*{Quantity}*(1+{TaxRate})-({DiscountPrice}*{Quantity}*(1+{TaxRate}))";
    }
    this.formulaList.unshift(f1);
    this.formulaList.unshift(f2);
    this.formulaList.unshift(f3);
    this.formulaList.unshift(f4);
    this.formulaList.unshift(f5);
    this.formulaList.unshift(f6);
  },
  DiscountPriceChange: function DiscountPriceChange() {
    //单价改变
    /*
        B．录入、修改单价
        则数量、税率、报价不变，标识置为无税，并依次计算：
         金额＝单价×数量
        税额＝金额×税率
        含税金额＝金额＋税额
        含税单价＝含税金额÷数量
         报价不为0或不为空时：
        报价含税：
        折扣金额避免尾差修改，XXdp202253738，zlj修改 2013-8-27
        //折扣金额＝报价×数量－含税金额
        //折扣＝含税金额/（报价×数量）；
        折扣金额＝报价×数量－（单价×数量×（1＋税率））
        折扣=单价×数量×（1+税率）/（报价×数量）
         报价不含税：
        //折扣金额＝报价×数量×（1＋税率）－含税金额
        //折扣＝金额/（报价×数量）
        折扣金额＝报价×数量×（1＋税率）－（单价×数量×（1＋税率））
        折扣=单价×数量/（报价×数量）
        */
    var f1, f2, f3, f4;
    this.SetFlag(false);

    //金额＝单价×数量
    f1 = "{Amount} = {DiscountPrice}*{Quantity}";

    //税额＝金额×税率
    f2 = "{Tax}={Amount}*{TaxRate}";
    //含税金额＝金额＋税额
    f3 = "{AmountTax}={Amount}+{Tax}";

    //含税单价＝含税金额÷数量
    f4 = "{DiscountTaxPrice}={AmountTax}/{Quantity}";

    this.formulaList.unshift(f1);
    this.formulaList.unshift(f2);
    this.formulaList.unshift(f3);
    this.formulaList.unshift(f4);

    var ff1, ff2, ff3, ff4;
    //折扣金额避免尾差修改，XXdp202253738，zlj修改 2013-8-27
    //折扣金额＝报价×数量－（单价×数量×（1＋税率））
    ff1 = "{DiscountAmount} = {Price}*{Quantity}-({DiscountPrice}*{Quantity}*(1+{TaxRate}))";
    //折扣=单价×数量×（1+税率）/（报价×数量）
    //ff2 = '{DiscountRate}= ({DiscountPrice}*{Quantity}*(1+{TaxRate}))/({Price}*{Quantity})';
    //折扣=单价×(1+税率）/报价
    ff2 = "{DiscountRate}= ({DiscountPrice}*(1+{TaxRate}))/{Price}";
    //折扣金额＝报价×数量×（1＋税率）－（单价×数量×（1＋税率））
    ff3 = "{DiscountAmount} = {Price}*{Quantity}*(1+{TaxRate})-({DiscountPrice}*{Quantity}*(1+{TaxRate}))";
    //折扣=单价×数量/（报价×数量）
    //ff4 = '{DiscountRate}= ({DiscountPrice}*{Quantity})/({Price}*{Quantity})';
    //折扣=单价/报价
    ff4 = "{DiscountRate}= {DiscountPrice}/{Price}";

    this.CalculateDiscount(ff1, ff2, ff3, ff4);
  },
  DiscountTaxPriceChange: function DiscountTaxPriceChange() {
    //含税单价改变
    /*
        C．录入、修改含税单价
        则数量、税率、报价不变，标识置为含税，并依次计算：
         含税金额＝含税单价×数量
        金额＝含税金额÷（1＋税率）
        税额＝含税金额－金额
        单价＝含税金额÷（1＋税率）÷数量 （zhangt依据王莹2012-9-4提出问题进行的修改）
         报价不为0或不为空时：
        报价含税：
        //折扣金额避免尾差修改，XXdp202253738，zlj修改 2013-8-27
        //折扣金额＝报价×数量－含税金额
        //折扣＝含税金额/（报价×数量）；
        折扣金额＝报价×数量－含税单价×数量
        折扣=含税单价×数量/（报价×数量）
        报价不含税：
        //折扣金额＝报价×数量×（1＋税率）－含税金额
        //折扣＝金额/（报价×数量）
        折扣金额＝报价×数量×（1＋税率）－含税单价×数量
        折扣=含税单价×数量/（1＋税率）/（报价×数量）
        */
    var f1, f2, f3, f4;
    this.SetFlag(true);

    //含税金额＝含税单价×数量
    f1 = "{AmountTax}={DiscountTaxPrice}*{Quantity}";

    //金额＝含税金额÷（1＋税率）
    f2 = "{Amount} = {AmountTax}/(1+{TaxRate})";
    //税额＝含税金额－金额
    f3 = "{Tax} = {AmountTax}-{Amount}";

    //单价＝金额÷数量
    f4 = "{DiscountPrice} = {AmountTax}/(1+{TaxRate})/{Quantity}";

    this.formulaList.unshift(f1);
    this.formulaList.unshift(f2);
    this.formulaList.unshift(f3);
    this.formulaList.unshift(f4);

    var ff1, ff2, ff3, ff4;
    //折扣金额避免尾差修改，XXdp202253738，zlj修改 2013-8-27
    //折扣金额＝报价×数量－含税单价×数量
    ff1 = "{DiscountAmount} = {Price}*{Quantity}-({DiscountTaxPrice}*{Quantity})";
    //折扣=含税单价×数量/（报价×数量）
    //ff2 = '{DiscountRate}= {DiscountTaxPrice}*{Quantity}/({Price}*{Quantity})';
    //折扣=含税单价/报价
    ff2 = "{DiscountRate}= {DiscountTaxPrice}/{Price}";
    // 折扣金额＝报价×数量×（1＋税率）－含税单价×数量
    ff3 = "{DiscountAmount} = {Price}*{Quantity}*(1+{TaxRate})-({DiscountTaxPrice}*{Quantity})";
    //折扣=含税单价×数量/（1＋税率）/（报价×数量）
    //ff4 = '{DiscountRate}= {DiscountTaxPrice}*{Quantity}/(1+{TaxRate})/({Price}*{Quantity})';
    //折扣=含税单价/（1＋税率）/报价
    ff4 = "{DiscountRate}= {DiscountTaxPrice}/(1+{TaxRate})/{Price}";

    this.CalculateDiscount(ff1, ff2, ff3, ff4);
  },
  AmountChange: function AmountChange() {
    //金额改变
    /*
        D．录入、修改金额
        则数量、税率、报价不变，标识置为无税，并依次计算：
         税额＝金额×税率
        含税金额＝金额+税额
        含税单价＝含税金额÷数量
        单价＝金额÷数量
         报价不为0或不为空时：
        报价含税：
        //折扣金额避免尾差修改，XXdp202253738，zlj修改 2013-8-27
        //折扣金额＝报价×数量－含税金额
        折扣金额＝报价×数量－（金额×（1＋税率））
        折扣=金额×（1+税率）÷（报价×数量）
        //折扣＝含税金额/（报价×数量）；
        报价不含税：
        //折扣金额＝报价×数量×（1＋税率）－含税金额
        //折扣＝金额/（报价×数量）
        折扣金额＝报价×数量×（1＋税率）－（金额×（1＋税率））
        折扣＝金额/（报价×数量）
        */
    var f1, f2, f3, f4;

    //标识置为无税
    this.SetFlag(false);

    //税额＝金额×税率
    f1 = "{Tax}={Amount}*{TaxRate}";
    //含税金额＝金额+税额
    f2 = "{AmountTax} = {Amount}+{Tax}";

    //含税单价＝含税金额÷数量
    f3 = "{DiscountTaxPrice} = {AmountTax}/{Quantity}";
    //单价＝金额÷数量
    f4 = "{DiscountPrice} = {Amount}/{Quantity}";

    this.formulaList.unshift(f1);
    this.formulaList.unshift(f2);
    this.formulaList.unshift(f3);
    this.formulaList.unshift(f4);

    var ff1, ff2, ff3, ff4;

    //折扣金额避免尾差修改，XXdp202253738，zlj修改 2013-8-27
    //折扣金额＝报价×数量－（金额×（1＋税率））
    ff1 = "{DiscountAmount} = {Price}*{Quantity}-({Amount}*(1+{TaxRate}))";
    //折扣=金额×（1+税率）÷（报价×数量）
    ff2 = "{DiscountRate}= {Amount}*(1+{TaxRate})/({Price}*{Quantity})";
    //折扣金额＝报价×数量×（1＋税率）－（金额×（1＋税率））
    ff3 = "{DiscountAmount} = {Price}*{Quantity}*(1+{TaxRate})-({Amount}*(1+{TaxRate}))";
    //折扣＝金额/（报价×数量）
    ff4 = "{DiscountRate}= {Amount}/({Price}*{Quantity})";

    this.CalculateDiscount(ff1, ff2, ff3, ff4);
  },
  AmountTaxChange: function AmountTaxChange() {
    //含税金额改变
    /*
        E．录入、修改含税金额
        则数量、税率、报价不变，标识置为含税，并依次计算：
         金额＝含税金额÷（1＋税率）
        税额＝含税金额－金额
        含税单价＝含税金额÷数量
        单价＝金额÷数量
         报价不为0或不为空时：
        //折扣金额避免尾差修改，XXdp202253738，zlj修改 2013-8-27
        报价含税：
        折扣金额＝报价×数量－含税金额
        折扣＝含税金额/（报价×数量）；
        报价不含税：
        折扣金额＝报价×数量×（1＋税率）－含税金额
        //折扣＝金额/（报价×数量）
        折扣=含税金额÷（1＋税率）÷（报价×数量）
        */
    var f1, f2, f3, f4;

    this.SetFlag(true);

    //金额＝含税金额÷（1＋税率）
    f1 = "{Amount}={AmountTax}/(1+{TaxRate})";
    //税额＝含税金额－金额
    f2 = "{Tax} = {AmountTax} - {Amount}";

    //含税单价＝含税金额÷数量
    f3 = "{DiscountTaxPrice} = {AmountTax}/{Quantity}";
    //单价＝金额÷数量
    f4 = "{DiscountPrice} = {AmountTax}/(1+{TaxRate})/{Quantity}";

    this.formulaList.unshift(f1);
    this.formulaList.unshift(f2);
    this.formulaList.unshift(f3);
    this.formulaList.unshift(f4);

    var ff1, ff2, ff3, ff4;

    //折扣金额避免尾差修改，XXdp202253738，zlj修改 2013-8-27
    //折扣金额＝报价×数量－含税金额
    ff1 = "{DiscountAmount} = {Price}*{Quantity}-{AmountTax}";
    // 折扣＝含税金额/（报价×数量）
    ff2 = "{DiscountRate}= {AmountTax}/({Price}*{Quantity})";
    // 折扣金额＝报价×数量×（1＋税率）－含税金额
    ff3 = "{DiscountAmount} = {Price}*{Quantity}*(1+{TaxRate})-{AmountTax}";
    // 折扣=含税金额÷（1＋税率）÷（报价×数量）
    ff4 = "{DiscountRate}={AmountTax}/(1+{TaxRate})/({Price}*{Quantity})";

    this.CalculateDiscount(ff1, ff2, ff3, ff4);
  },
  TaxRateChange: function TaxRateChange() {
    //税率改变
    /*
        F．录入、修改税率
        F1.标识含税：
        则数量、含税单价、含税金额、报价不变，并依次计算：
         金额＝含税金额÷（1+税率）
        税额=含税金额－金额
        单价＝含税金额÷（1＋税率）÷数量 （zhangt依据王莹2012-9-4提出问题进行的修改）
         报价不为0或不为空时：
        //折扣金额避免尾差修改，XXdp202253738，zlj修改 2013-8-27
        报价含税：
        折扣金额＝报价×数量－含税金额
        折扣＝含税金额/（报价×数量）；
        报价不含税：
        折扣金额＝报价×数量×（1＋税率）－含税金额
        //折扣＝金额/（报价×数量）
        折扣=含税金额÷（1＋税率）÷（报价×数量）
         F2.标识不含税：
        则数量、单价、金额、报价不变，并依次计算：
         税额＝金额×税率
        含税金额＝金额＋税额
        含税单价＝含税金额÷数量
         报价不为0或不为空时：
        //折扣金额避免尾差修改，XXdp202253738，zlj修改 2013-8-27
        报价含税：
        //折扣金额＝报价×数量－含税金额
        //折扣＝含税金额/（报价×数量）；
        折扣金额＝报价×数量－金额×（1+税率）
        折扣=金额×（1+税率）÷（报价×数量）
        报价不含税：
        //折扣金额＝报价×数量×（1＋税率）－含税金额
        折扣金额＝报价×数量×（1＋税率）－金额×（1+税率）
        折扣＝金额/（报价×数量）
        */
    var f1, f2, f3;

    var ff1, ff2, ff3, ff4;

    if (this.GetFlag()) {
      //金额＝含税金额÷（1+税率）
      f1 = "{Amount} = {AmountTax}/(1+{TaxRate})";
      //税额=含税金额－金额
      f2 = "{Tax} = {AmountTax}-{Amount}";
      //if (this.isInvoice) {
      //单价=金额÷数量
      //    f3 = '{DiscountPrice} = {Amount}/{Quantity}';
      //}
      //else {
      //单价=金额÷数量
      f3 = "{DiscountPrice} = {AmountTax}/(1+{TaxRate})/{Quantity}";
      //}

      //折扣金额避免尾差修改，XXdp202253738，zlj修改 2013-8-27
      //折扣金额＝报价×数量－含税金额
      ff1 = "{DiscountAmount} = {Price}*{Quantity}-{AmountTax}";
      //折扣＝含税金额/（报价×数量）
      ff2 = "{DiscountRate}= {AmountTax}/({Price}*{Quantity})";
      // 折扣金额＝报价×数量×（1＋税率）－含税金额
      ff3 = "{DiscountAmount} = {Price}*{Quantity}*(1+{TaxRate})-{AmountTax}";
      // 折扣=含税金额÷（1＋税率）÷（报价×数量）
      ff4 = "{DiscountRate}={AmountTax}/(1+{TaxRate})/({Price}*{Quantity})";
    } else {
      //税额＝金额×税率
      f1 = "{Tax} = {Amount}*{TaxRate}";
      //含税金额＝金额＋税额
      f2 = "{AmountTax} = {Amount} + {Tax}";
      if (this.isInvoice) {
        //含税单价＝含税金额÷数量
        f3 = "{DiscountTaxPrice} = {AmountTax}/{Quantity}";
      } else {
        //含税单价＝含税金额÷数量
        f3 = "{DiscountTaxPrice} = {AmountTax}/{Quantity}";
      }

      //折扣金额避免尾差修改，XXdp202253738，zlj修改 2013-8-27
      //折扣金额＝报价×数量－金额×（1+税率）
      ff1 = "{DiscountAmount} = {Price}*{Quantity}-({Amount}*(1+{TaxRate}))";
      //折扣=金额×（1+税率）÷（报价×数量）
      ff2 = "{DiscountRate}= {Amount}*(1+{TaxRate})/({Price}*{Quantity})";
      // 折扣金额＝报价×数量×（1＋税率）－金额×（1+税率）
      ff3 = "{DiscountAmount} = {Price}*{Quantity}*(1+{TaxRate})-{Amount}*(1+{TaxRate})";
      // 折扣＝金额/（报价×数量）
      ff4 = "{DiscountRate}={Amount}/({Price}*{Quantity})";
    }

    this.formulaList.unshift(f1);
    this.formulaList.unshift(f2);
    this.formulaList.unshift(f3);

    this.CalculateDiscount(ff1, ff2, ff3, ff4);
  },
  QuantityChange: function QuantityChange() {
    //数量
    /*
        G．录入、修改数量
        G1.标识含税：
        则税率、含税单价、报价不变，并依次计算：
         含税金额＝含税单价×数量
        金额＝含税金额÷（1＋税率）
        税额＝含税金额－金额
        单价＝含税金额÷（1＋税率）÷数量 （zhangt依据王莹2012-9-4提出问题进行的修改）
         报价不为0或不为空时：
        //折扣金额避免尾差修改，XXdp202253738，zlj修改 2013-8-27
        报价含税：
        //折扣金额＝报价×数量－含税金额
        //折扣＝含税金额/（报价×数量）；
        折扣金额＝报价×数量－含税单价×数量
        折扣不变
        报价不含税：
        //折扣金额＝报价×数量×（1＋税率）－含税金额
        //折扣＝金额/（报价×数量）
        折扣金额＝报价×数量×（1＋税率）－含税单价×数量
        折扣不变
         G2.标识不含税：
        则税率、单价、报价不变，并依次计算：
         金额＝单价×数量
        税额＝金额×税率
        含税金额＝金额＋税额
        含税单价＝含税金额÷数量
         报价不为0或不为空时：
        //折扣金额避免尾差修改，XXdp202253738，zlj修改 2013-8-27
        报价含税：
        //折扣金额＝报价×数量－含税金额
        //折扣＝含税金额/（报价×数量）；
        折扣金额＝报价×数量－单价×数量×（1＋税率）
        折扣不变
        报价不含税：
        //折扣金额＝报价×数量×（1＋税率）－含税金额
        //折扣＝金额/（报价×数量）
        折扣金额＝报价×数量×（1＋税率）－单价×数量×（1＋税率）
        折扣不变
        */
    var f1, f2, f3, f4;
    var ff1, ff2, ff3, ff4;

    if (this.GetFlag()) {
      //含税金额＝含税单价×数量
      f1 = "{AmountTax} = {DiscountTaxPrice}*{Quantity}";

      //金额＝含税金额÷（1＋税率）
      f2 = "{Amount} = {AmountTax}/(1+{TaxRate})";
      //税额＝含税金额－金额
      f3 = "{Tax} = {AmountTax}-{Amount}";

      //单价＝金额÷数量
      f4 = "{DiscountPrice}={AmountTax}/(1+{TaxRate})/{Quantity}";

      //折扣金额避免尾差修改，XXdp202253738，zlj修改 2013-8-27
      //折扣金额＝报价×数量－含税单价×数量
      ff1 = "{DiscountAmount} = {Price}*{Quantity}-({DiscountTaxPrice}*{Quantity})";
      //折扣不变
      ff2 = null;
      //折扣金额＝报价×数量×（1＋税率）－含税单价×数量
      ff3 = "{DiscountAmount} = {Price}*{Quantity}*(1+{TaxRate})-({DiscountTaxPrice}*{Quantity})";
      //折扣不变
      ff4 = null;
    } else {
      //金额＝单价×数量
      f1 = "{Amount} = {DiscountPrice}*{Quantity}";

      //税额＝金额×税率
      f2 = "{Tax} = {Amount}*{TaxRate}";
      //含税金额＝金额＋税额
      f3 = "{AmountTax} = {Amount}+{Tax}";

      //含税单价＝含税金额÷数量
      f4 = "{DiscountTaxPrice} = {AmountTax}/{Quantity}";

      //折扣金额避免尾差修改，XXdp202253738，zlj修改 2013-8-27
      //折扣金额＝报价×数量－单价×数量×（1＋税率）
      ff1 = "{DiscountAmount} = {Price}*{Quantity}-({DiscountPrice}*{Quantity}*(1+{TaxRate}))";
      //折扣不变
      ff2 = null;
      //折扣金额＝报价×数量×（1＋税率）－单价×数量×（1＋税率）
      ff3 = "{DiscountAmount} = {Price}*{Quantity}*(1+{TaxRate})-({DiscountPrice}*{Quantity}*(1+{TaxRate}))";
      //折扣不变
      ff4 = null;
    }

    this.formulaList.unshift(f1);
    this.formulaList.unshift(f2);
    this.formulaList.unshift(f3);
    this.formulaList.unshift(f4);

    this.CalculateDiscount(ff1, ff2, ff3, ff4);
  },
  DiscountAmountChange: function DiscountAmountChange() {
    //折扣金额
    /*
        H．录入、修改折扣金额
        则数量、税率、报价（报价不为0或不为空）不变，标识置为含税，并依次计算：
         H1.报价含税：
        含税金额＝报价×数量－折扣金额
        含税单价＝含税金额÷数量
        金额＝含税金额÷（1＋税率）
        税额＝含税金额－金额
        单价＝含税金额÷（1＋税率）÷数量 （zhangt依据王莹2012-9-4提出问题进行的修改）
        折扣＝含税金额/（报价×数量）
         H2.报价不含税：
        含税金额＝报价×数量×（1＋税率）－折扣金额
        含税单价＝含税金额÷数量
        金额＝含税金额÷（1＋税率）
        税额＝含税金额－金额
        单价＝含税金额÷（1＋税率）÷数量 （zhangt依据王莹2012-9-4提出问题进行的修改）
        折扣＝金额/（报价×数量）
        */

    if (!this.base()) return;

    var f1, f2, f3, f4, f5, f6;

    this.SetFlag(true);

    if (this.withTax) {
      //含税金额＝报价×数量－折扣金额
      f1 = "{AmountTax} = {Price}*{Quantity} - {DiscountAmount}";
      //含税单价＝含税金额÷数量
      f2 = "{DiscountTaxPrice} = {AmountTax}/{Quantity}";

      //金额＝含税金额÷（1＋税率）
      f3 = "{Amount} = {AmountTax}/(1+{TaxRate})";
      //税额＝含税金额－金额
      f4 = "{Tax} = {AmountTax} - {Amount}";

      //单价＝金额÷数量
      f5 = "{DiscountPrice} = {AmountTax}/(1+{TaxRate})/{Quantity}";
      //折扣＝含税金额/（报价×数量）
      f6 = "{DiscountRate} = {AmountTax}/({Price}*{Quantity})";
    } else {
      //含税金额＝报价×数量×（1＋税率）－折扣金额
      f1 = "{AmountTax} = ({Price}*{Quantity}*(1+{TaxRate}))@2 - {DiscountAmount}";
      //含税单价＝含税金额÷数量
      f2 = "{DiscountTaxPrice} = {AmountTax}/{Quantity}";

      //金额＝含税金额÷（1＋税率）
      f3 = "{Amount} = {AmountTax}/(1+{TaxRate})";
      //税额＝含税金额－金额
      f4 = "{Tax} = {AmountTax}-{Amount}";

      //单价＝金额÷数量
      f5 = "{DiscountPrice} = {AmountTax}/(1+{TaxRate})/{Quantity}";
      //折扣＝金额/（报价×数量）
      f6 = "{DiscountRate} = {Amount}/({Price}*{Quantity})";
    }

    this.formulaList.unshift(f1);
    this.formulaList.unshift(f2);
    this.formulaList.unshift(f3);
    this.formulaList.unshift(f4);
    this.formulaList.unshift(f5);
    this.formulaList.unshift(f6);
  },
  DiscountRateChange: function DiscountRateChange() {
    //折扣率
    /*
        I．录入、修改折扣
        则数量、税率、报价（报价不为0或不为空）不变，并依次计算：
         I1.报价含税、标识置为含税：
        含税单价＝报价×折扣
        含税金额＝含税单价×数量
        金额＝含税金额÷（1＋税率）
        税额＝含税金额－金额
        单价＝含税金额÷（1＋税率）÷数量 （zhangt依据王莹2012-9-4提出问题进行的修改）
        //折扣金额避免尾差修改，XXdp202253738，zlj修改 2013-8-27
        //折扣金额＝报价×数量－含税金额
        折扣金额＝报价×数量－报价×折扣×数量
         I2.报价不含税、标识置为无税：
        单价＝报价×折扣
        金额＝单价×数量
        税额＝金额×税率
        含税金额＝金额＋税额
        含税单价＝含税金额÷数量
        //折扣金额避免尾差修改，XXdp202253738，zlj修改 2013-8-27
        //折扣金额＝报价×数量×（1＋税率）－含税金额
        折扣金额＝报价×数量×（1＋税率）－报价×折扣×数量×（1＋税率）
        */
    if (!this.base()) return;

    var f1, f2, f3, f4, f5, f6;

    if (this.withTax) {
      this.SetFlag(true);

      //含税单价＝报价×折扣
      f1 = "{DiscountTaxPrice} = {Price}*{DiscountRate}";
      //含税金额＝含税单价×数量
      f2 = "{AmountTax} = {DiscountTaxPrice}*{Quantity}";

      //金额＝含税金额÷（1＋税率）
      f3 = "{Amount} = {AmountTax}/(1+{TaxRate})";
      //税额＝含税金额－金额
      f4 = "{Tax} = {AmountTax}-{Amount}";

      //单价＝金额÷数量
      f5 = "{DiscountPrice} = {AmountTax}/(1+{TaxRate})/{Quantity}";
      //折扣金额＝报价×数量－含税金额
      //f6 = '{DiscountAmount} = {Price}*{Quantity} - {AmountTax}';
      //折扣金额＝报价×数量－报价×折扣×数量
      f6 = "{DiscountAmount} = {Price}*{Quantity} - {Price}*{DiscountRate}*{Quantity}";
    } else {
      this.SetFlag(false);

      if (this.isInvoice) {
        //单价＝报价×折扣
        f1 = "{DiscountPrice} = {Price}*{DiscountRate}";
        //金额＝单价×数量
        f2 = "{Amount} = {DiscountPrice}*{Quantity}";
      } else {
        //单价＝报价×折扣
        f1 = "{DiscountPrice} = {Price}*{DiscountRate}";
        //金额＝单价×数量
        f2 = "{Amount} = {DiscountPrice}*{Quantity}";
      }
      //税额＝金额×税率
      f3 = "{Tax} = {Amount}*{TaxRate}";
      //含税金额＝金额＋税额
      f4 = "{AmountTax} = {Amount}+{Tax}";

      //含税单价＝含税金额÷数量
      f5 = "{DiscountTaxPrice} = {AmountTax}/{Quantity}";
      //折扣金额＝报价×数量×（1＋税率）－含税金额
      //f6 = '{DiscountAmount} = ({Price}*{Quantity}*(1+{TaxRate}))@2 - {AmountTax}';
      // 折扣金额＝报价×数量×（1＋税率）－报价×折扣×数量×（1＋税率）
      f6 = "{DiscountAmount} = {Price}*{Quantity}*(1+{TaxRate}) - ({Price}*{DiscountRate}*{Quantity}*(1+{TaxRate}))";
    }

    this.formulaList.unshift(f1);
    this.formulaList.unshift(f2);
    this.formulaList.unshift(f3);
    this.formulaList.unshift(f4);
    this.formulaList.unshift(f5);
    this.formulaList.unshift(f6);
  },
  TaxAmountChange: function TaxAmountChange() {
    //税额
    /*
        J1.标识含税：
        则数量、含税单价、含税金额、税率、折扣、折扣金额、报价不变，并依次计算：
         金额=含税金额－税额
        单价=金额÷数量
          J2.标识不含税：
        则数量、单价、金额、税率、报价不变，并依次计算：
         含税金额＝金额+税额
        含税单价＝含税金额÷数量
         报价不为0或不为空时：
        报价含税：
        折扣金额＝报价×数量－含税金额
        折扣＝含税金额/（报价×数量）；
        报价不含税：
        //折扣金额避免尾差修改，XXdp202253738，zlj修改 2013-8-27
        //折扣金额＝报价×数量×（1＋税率）－含税金额
        //折扣＝金额/（报价×数量）
        折扣金额＝报价×数量×（1＋税率）－单价×数量×（1＋税率）
        折扣不变
         */
    var f1, f2;

    if (this.GetFlag()) {
      //金额=含税金额－税额
      f1 = "{Amount} = {AmountTax} - {Tax}";

      //单价=金额÷数量
      f2 = "{DiscountPrice} = {Amount}/{Quantity}";

      this.formulaList.unshift(f1);
      this.formulaList.unshift(f2);
    } else {
      //含税金额＝金额+税额
      f1 = "{AmountTax} = {Amount}+{Tax}";

      //含税单价＝含税金额÷数量
      f2 = "{DiscountTaxPrice} = {AmountTax}/{Quantity}";

      this.formulaList.unshift(f1);
      this.formulaList.unshift(f2);

      var ff1, ff2, ff3, ff4;

      ff1 = null;
      ff2 = null;
      //折扣金额＝报价×数量×（1＋税率）－单价×数量×（1＋税率）
      ff3 = "{DiscountAmount} = {Price}*{Quantity}*(1+{TaxRate})-({DiscountPrice}*{Quantity}*(1+{TaxRate}))";
      ff4 = null;

      this.CalculateDiscount(ff1, ff2, ff3, ff4);
    }
  },
  CalculateFunctionWithTax: function CalculateFunctionWithTax() {
    //应税外加计算含税本币
    /*
        本币金额＝本币含税金额÷（1＋税率）
        本币税额＝本币含税金额－本币金额
        本币含税单价＝本币含税金额÷数量
        本币单价＝本币金额÷数量
         报价不为0或不为空时：
        报价含税：本币折扣金额＝本币报价×数量－本币含税金额
        折扣＝本币含税金额/（本币报价×数量）；
        报价不含税：本币折扣金额＝本币报价×数量×（1＋税率）－本币含税金额
        折扣＝本币金额/（本币报价×数量）
         */

    this.base();

    var f1, f2, f3, f4;

    //金额＝含税金额÷（1＋税率）
    f1 = "{F_Amount}={F_AmountTax}/(1+{TaxRate})";
    //税额＝含税金额－金额
    f2 = "{F_Tax} = {F_AmountTax} - {F_Amount}";

    //含税单价＝含税金额÷数量
    f3 = "{F_DiscountTaxPrice} = {F_AmountTax}/{Quantity}";
    //单价＝金额÷数量
    //f4 = '{F_DiscountPrice} = {F_Amount}/{Quantity}';
    //单价=含税金额÷（1＋税率）÷数量
    f4 = "{F_DiscountPrice} = {F_AmountTax}/(1+{TaxRate})/{Quantity}";

    this.formulaList.unshift(f1);
    this.formulaList.unshift(f2);
    this.formulaList.unshift(f3);
    this.formulaList.unshift(f4);

    this.CalculateFunctionDiscount();
  },
  CalculateFunctionDiscount: function CalculateFunctionDiscount() {
    var f2 = void 0;

    var price = this.getCellValue(this.Columns["Price"]);
    if (!Number(price)) return;

    this.ConvertFunctionalCurrency("Price", "F_Price");

    /*
        标志含税
            报价含税
                折扣金额=折扣金额＝报价×数量－含税金额
            报价不含税
                折扣金额＝报价×数量×（1＋税率）－含税金额
        标志不含税
            报价含税
                折扣金额＝报价×数量－金额×（1+税率）
            报价不含税
                折扣金额＝报价×数量×（1＋税率）－金额×（1+税率）
        */

    if (this.GetFlag()) {
      if (this.withTax) {
        f2 = "{F_DiscountAmount} = {F_Price}*{Quantity}-{F_AmountTax}";
      } else {
        f2 = "{F_DiscountAmount} = ({F_Price}*{Quantity}*(1+{TaxRate}))-{F_AmountTax}";
      }
    } else {
      if (this.withTax) {
        f2 = "{F_DiscountAmount} = {F_Price}*{Quantity}-{F_Amount}*(1+{TaxRate})";
      } else {
        f2 = "{F_DiscountAmount} = ({F_Price}*{Quantity}*(1+{TaxRate}))-{F_Amount}*(1+{TaxRate})";
      }
    }

    //if (this.withTax) {
    /*
        报价含税：
        折扣金额＝报价×数量－含税金额
        折扣＝含税金额/（报价×数量）；
        */

    //折扣金额＝报价×数量－含税金额
    //    f2 = '{F_DiscountAmount} = {F_Price}*{Quantity}-{F_AmountTax}';
    //折扣＝含税金额/（报价×数量）
    //f3 = '{DiscountRate} = {F_AmountTax}/({F_Price}*{Quantity})';
    // }
    //else {
    /*
        报价不含税：
        折扣金额＝报价×数量×（1＋税率）－含税金额
        折扣＝金额/（报价×数量）
        */

    //折扣金额＝报价×数量×（1＋税率）－含税金额
    //   f2 = '{F_DiscountAmount} = ({F_Price}*{Quantity}*(1+{TaxRate}))@2-{F_AmountTax}';
    //折扣＝金额/（报价×数量）
    //f3 = '{DiscountRate} = {F_Amount}/({F_Price}*{Quantity})';

    // }

    //this.formulaList.unshift(f1);
    this.formulaList.unshift(f2);
    //this.formulaList.unshift(f3);
  }
});

/*-----------------------------应税外含算法 end----------------------------------------------------*/

/******************************************公式工厂类 begin*******************************************************/
var FormulaFactory = {
  GetFormula: function GetFormula(opt) {
    return new FormulaExcludingTax(opt);
  }
};

/******************************************公式工厂类   end*******************************************************/

exports.FormulaFactory = FormulaFactory;
//# sourceMappingURL=priceTaxFormula.js.map