JLH/JLHHJSvr/Excutor/SaveBedNetExcutor.cs

using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using DirectService.Tools;
using JLHHJSvr.BLL;
using JLHHJSvr.Com;
using JLHHJSvr.Com.Model;
using JLHHJSvr.LJException;
using JLHHJSvr.LJFramework.Tools;
using JLHHJSvr.Tools;
using LJLib.DAL.SQL;
using LJLib.Net.SPI.Server;

namespace JLHHJSvr.Excutor
{
    internal sealed class SaveBedNetExcutor : ExcutorBase<SaveBedNetRequest, SaveBedNetResponse>
    {
        Dictionary<string, object> replacements = new Dictionary<string, object>();

        protected override void ExcuteInternal(SaveBedNetRequest request, object state, SaveBedNetResponse rslt)
        {
            var tokendata = BllHelper.GetToken(request.token);
            if (tokendata == null)
            {
                rslt.ErrMsg = "会话已经中断，请重新登录";
                return;
            }
            if (request.bednet == null)
            {
                rslt.ErrMsg = "缺少主表信息";
                return;
            }
            if (request.bednet.bednettypeid <= 0)
            {
                rslt.ErrMsg = "请选择床网类型";
                return;
            }
            if (request.bednetMx == null || !request.bednetMx.Any())
            {
                rslt.ErrMsg = "缺少报价明细";
                return;
            }
            // 检查是否填写床网高度

            foreach (var mx in request.bednetMx)
            {
                if (mx.bednet_height == null || mx.bednet_height <= 0)
                {
                    rslt.ErrMsg = "请填写床网高";
                    return;
                }
                else
                {
                    request.bednet.mattress_height = mx.bednet_height;
                }
            }

            using (var con = new SqlConnection(GlobalVar.ConnectionString))
            using (var cmd = con.CreateCommand())
            {
                con.Open();

                // 初始化属性
                AutoInit.AutoInitS(cmd, request.bednet);

                CulcalateCost(cmd, request.bednet, request.bednetMx, request.spring);

                CulcalateWeight(cmd, request.bednet, request.bednetMx, request.spring);

                using (cmd.Transaction = con.BeginTransaction())
                {
                    try
                    {
                        var dtNow = DateTime.Now;

                        var fields = @"deptid,bednettypeid,mattress_width,mattress_length,mattress_height,if_doublenet,if_doublespring,snake_wire_diameter,
                                        snake_wire_mtrl_formula,snake_wire_mtrl_cost,pocket_around_spring_formula,pocket_around_spring_cost,
                                        pocket_around_fabrics_formula,pocket_around_fabrics_cost,hard_around_mtrl_formula,hard_around_mtrl_cost,
                                        hard_around_hr_formula,hard_around_hr_cost,spring_mtrl_cost,spring_hr_cost,glue_price,glue_mtrl_formula,
                                        glue_mtrl_cost,fabrics1_mtrl_formula,fabrics1_mtrl_cost,fabrics2_mtrl_formula,fabrics2_mtrl_cost,
                                        if_side_iron,side_iron_lossrate,side_iron_price,side_iron_mtrl_formula,side_iron_mtrl_cost,side_iron_hr_formula,
                                        side_iron_hr_cost,cnail_price,cnail_mtrl_formula,cnail_mtrl_cost,cnail_hr_formula,cnail_hr_cost,sponge_mtrlid,
                                        sponge_thickness,sponge_price,sponge_mtrl_formula,sponge_mtrl_cost,sponge_hr_formula,sponge_hr_cost,edge_mtrlid,
                                        edge_price,edge_mtrl_formula,edge_mtrl_cost,edge_hr_formula,edge_hr_cost,fork_qty,fork_price,fork_mtrl_formula,
                                        fork_mtrl_cost,fork_hr_formula,fork_hr_cost,if_rsORwa,rsORwa_price,rsORwa_mtrl_formula,rsORwa_mtrl_cost,rsORwa_hr_formula,
                                        rsORwa_hr_cost,if_sponge_drilling,sponge_drilling_hr_formula,sponge_drilling_hr_cost,total_hr_cost,total_mtrl_cost,
                                        total_fees_cost,total_cost,createtime,createby,bednetname,spring_mtrl_formula,spring_hr_formula,
                                        sponge_mtrl_cost_replace_formula,sponge_hr_cost_replace_formula,edge_mtrl_cost_replace_formula,edge_hr_cost_replace_formula,
                                        fork_mtrl_cost_replace_formula,fork_hr_cost_replace_formula,rsORwa_mtrl_cost_replace_formula,rsORwa_hr_cost_replace_formula,
                                        sponge_drilling_hr_cost_replace_formula,snake_wire_mtrl_cost_replace_formula,taxrate,taxes,commissionrate,commission,fob,
                                        profitrate,nottax_factory_cost,nottax_dept_cost,dept_cost,foreign_cost,extras_cost,dept_profitrate,moneyrate,temp_flag,
                                        felt_mtrlid,felt_qty,felt_price,felt_dscrp,felt_mtrl_formula,felt_mtrl_cost,felt_hr_formula,felt_hr_cost,
                                        felt_mtrl_cost_replace_formula,felt_hr_cost_replace_formula,extras_cost_dscrp,iffork,ifsaleout,autotype,
                                        felt_mtrl_x_cost,felt_hr_x_cost,felt_x_qty,felt_mtrl_x_cost_replace_formula,felt_hr_x_cost_replace_formula,
                                        felt_x_mtrlid,sale_point,packtype,packqty,other_rate,transport_type,packmtrl,packet_mtrl_formula,
                                        packet_hr_formula,packet_mtrl_cost,packet_hr_cost,packet_mtrl_cost_replace_formula,packet_hr_cost_replace_formula,
                                        sponge_height,edge_height,sponge_tc_thickness,sponge_tc_height,sponge_tc_mtrlid,sponge_mtrl_tc_formula,
                                        sponge_mtrl_tc_cost,sponge_mtrl_tc_cost_replace_formula,duo_qv_str,spring_weight_formula,side_iron_weight_formula,
                                        hard_around_weight_formula,fabrics1_weight_formula,fabrics2_weight_formula,felt_weight_formula,cnail_weight_formula,
                                        sponge_weight_formula,sponge_weight_tc_formula,edge_weight_formula,fork_weight_formula,spring_weight_replace_formula,
                                        side_iron_weight_replace_formula,hard_around_weight_replace_formula,fabrics1_weight_replace_formula,
                                        fabrics2_weight_replace_formula,felt_weight_replace_formula,cnail_weight_replace_formula,sponge_weight_replace_formula,
                                        sponge_weight_tc_replace_formula,edge_weight_replace_formula,fork_weight_replace_formula,spring_weight_qty,
                                        side_iron_weight_qty,hard_around_weight_qty,fabrics1_weight_qty,fabrics2_weight_qty,felt_weight_qty,cnail_weight_qty,
                                        sponge_weight_qty,sponge_weight_tc_qty,edge_weight_qty,fork_weight_qty,sum_weight,if_jb";

                        var fieldsMx = @"bednetmxid,bednetid,spring_qty_width,spring_qty_length,bednet_height,wire_mtrlid,springid,if_part,if_15strip,
                                        if_pocket_around,pocket_around_springid,pocket_around_row,pocket_around_wire_price,pocket_around_spring_cost,
                                        pocket_around_fabrics_cost,if_hard_around,hard_around_springid,hard_around_row,hard_around_wire_price,
                                        hard_around_mtrl_cost,hard_around_hr_cost,fabrics1_mtrlid,fabrics1_price,fabrics1_mtrl_cost,fabrics2_mtrlid,
                                        fabrics2_price,fabrics2_mtrl_cost,if_side_iron,side_iron_qty,side_iron_mtrl_cost,side_iron_hr_cost,
                                        pocket_around_spring_cost_replace_formula,pocket_around_fabrics_cost_replace_formula,hard_around_mtrl_cost_replace_formula,
                                        hard_around_hr_cost_replace_formula,fabrics1_mtrl_cost_replace_formula,fabrics2_mtrl_cost_replace_formula,
                                        side_iron_mtrl_cost_replace_formula,side_iron_hr_cost_replace_formula,cnail_mtrl_cost_replace_formula,cnail_mtrl_cost,
                                        cnail_hr_cost_replace_formula,cnail_hr_cost,glue_mtrl_cost_replace_formula,glue_mtrl_cost,spring_mtrl_cost,spring_hr_cost,
                                        spring_mtrl_cost_replace_formula,spring_hr_cost_replace_formula,spring_weight_replace_formula";

                        var fieldsMx_spring = @"bednetmx_partid,bednetmxid,springid,spring_qty_width,spring_qty_length,fabrics1_mtrl_cost,spring_mtrl_cost,
                                                spring_hr_cost,spring_mtrl_cost_replace_formula,spring_hr_cost_replace_formula,spring_weight_replace_formula";

                        if (request.bednet.bednetid <= 0)
                        {
                            //新建
                            fields += ",bednetid,bednetcode";

                            request.bednet.bednetid = BllHelper.GetID(cmd, "u_bednet");
                            request.bednet.createtime = dtNow;
                            request.bednet.createby = tokendata.username;

                            var nettype = new u_bednet_type() { bednettypeid = request.bednet.bednettypeid };
                            DbSqlHelper.SelectOne(cmd, nettype, "typecode");

                            // 编号-年月日+流水
                            request.bednet.bednetcode = $"{nettype.typecode}-{dtNow.ToString("yyyyMMdd")}{(request.bednet.bednetid.Value % 10000).ToString("D4")}";

                            DbSqlHelper.Insert(cmd, "u_bednet", null, request.bednet, fields);
                        }
                        else
                        {
                            //修改
                            foreach (var mx in request.bednetMx)
                            {
                                cmd.CommandText = @"DELETE FROM u_bednetmx_spring WHERE bednetmxid = @bednetmxid";
                                cmd.Parameters.Clear();
                                cmd.Parameters.AddWithValue("@bednetmxid", mx.bednetmxid);
                                cmd.ExecuteNonQuery();
                            }

                            cmd.CommandText = @"DELETE FROM u_bednetmx WHERE bednetid = @bednetid";
                            cmd.Parameters.Clear();
                            cmd.Parameters.AddWithValue("@bednetid", request.bednet.bednetid);
                            cmd.ExecuteNonQuery();

                            DbSqlHelper.Update(cmd, "u_bednet", null, request.bednet, "bednetid", fields);
                        }

                        foreach (var mx in request.bednetMx)
                        {
                            AutoInit.AutoInitS(cmd, mx);

                            mx.bednetid = request.bednet.bednetid;
                            mx.bednetmxid = BllHelper.GetID(cmd, "u_bednetmx");

                            DbSqlHelper.Insert(cmd, "u_bednetmx", null, mx, fieldsMx);

                            if (request.spring != null && request.spring.Any())
                            {
                                foreach (var spring in request.spring)
                                {
                                    AutoInit.AutoInitS(cmd, spring);

                                    spring.bednetmx_partid = request.bednet.bednetid;
                                    spring.bednetmxid = BllHelper.GetID(cmd, "u_bednetmx_spring");

                                    DbSqlHelper.Insert(cmd, "u_bednetmx_spring", null, spring, fieldsMx_spring);
                                }
                            }
                        }

                        var hisprice = new u_his_price
                        {
                            bednetid_mattressid = request.bednet.bednetid,
                            typeid = 0,
                            cmpdate = dtNow,
                            cmpemp = tokendata.username,
                            nottax_dept_cost = 0,
                            dept_cost = 0,
                            foreign_cost = 0
                        };
                        var fieldsHs = "bednetid_mattressid, typeid, cmpdate, cmpemp, nottax_dept_cost, dept_cost, foreign_cost";
                        DbSqlHelper.Insert(cmd, "u_his_price", null, hisprice, fieldsHs);

                        cmd.Transaction.Commit();

                        rslt.bednet = new u_bednet() { bednetid = request.bednet.bednetid, bednetcode = request.bednet.bednetcode };
                    }
                    catch (Exception e)
                    {
                        cmd.Transaction.Rollback();
                        rslt.ErrMsg = e.ToString();
                    }
                }
            }
        }

        private void CulcalateCost(SqlCommand cmd, u_bednet bednet, List<u_bednetmx> mxlist, List<u_bednetmx_spring> springList)
        {
            // 数据准备
            var dept = new u_dept() { deptid = bednet.deptid.Value };
            DbSqlHelper.SelectOne(cmd, dept, "pricelistid");

            var bednetType = new u_bednet_type() { bednettypeid = bednet.bednettypeid };
            DbSqlHelper.SelectOne(cmd, bednetType, "typename");

            var bednetVarList = new List<u_bednet_var>();
            var selectStr = @"SELECT u_bednet_varmx.varid AS varid
	                            ,varkind
	                            ,varcode
	                            ,varname
	                            ,varclass
	                            ,vartype
	                            ,varunit
	                            ,u_bednet_varmx.varvalue AS varvalue
                            FROM u_bednet_var
                            INNER JOIN u_bednet_varmx ON u_bednet_varmx.varid = u_bednet_var.varid";
            var whereList = new List<string>();
            whereList.Add("varkind = @varkind");
            whereList.Add("u_bednet_varmx.pricelistid = @pricelistid");
            whereList.Add(@"(u_bednet_var.varclass = 1
			                    AND (
				                    u_bednet_varmx.bednettypeid = @bednettypeid
				                    OR @bednettypeid = 0
				                    )
			                    )
		                    OR (u_bednet_var.varclass = 0)");
            var param = new Dictionary<string, object>();
            param.Add("@varkind", 0);
            param.Add("@pricelistid", dept.pricelistid);
            param.Add("@bednettypeid", bednet.bednettypeid);
            DbSqlHelper.SelectJoin(cmd, selectStr, ListEx.GetWhereStr(whereList), param, "varid", "varid,varkind,varcode,varname,varclass,vartype,varunit,varvalue", 0, 0, bednetVarList);

            AddDictKeyValue("【床垫宽】", bednet.mattress_width);
            AddDictKeyValue("【床垫长】", bednet.mattress_length);
            AddDictKeyValue("【床垫高】", bednet.mattress_height);
            AddDictKeyValue("【双簧】", bednet.if_doublespring);
            AddDictKeyValue("【弹叉数量】", bednet.fork_qty);
            AddDictKeyValue("【包装方式】", bednet.packtype);
            AddDictKeyValue("【包装数量】", bednet.packqty);
            AddDictKeyValue("【运输方式】", bednet.transport_type);
            AddDictKeyValue("【包装材料】", bednet.packmtrl);
            AddDictKeyValue("【床网类别】", bednetType.typename);

            foreach (var netvar in bednetVarList)
            {
                AddDictKeyValue($"【{netvar.varname}】", netvar.varvalue);
            }

            foreach (var mx in mxlist)
            {
                var spring = new u_spring() { springid = mx.springid };
                DbSqlHelper.SelectOne(cmd, spring, "line_diameter,gram_weight,height,center_diameter");

                // 处理相同公式部分
                CalSameCol(cmd, mx, spring, dept);

                //计算 弹簧材料总成本
                #region 计算 弹簧材料总成本 开始
                if (!string.IsNullOrEmpty(bednet.spring_mtrl_formula))
                {
                    bednet.spring_mtrl_formula = ConvertToEnglishSymbols(bednet.spring_mtrl_formula);

                    mx.spring_mtrl_cost_replace_formula = bednet.spring_mtrl_formula;
                    if (mx.if_part == 0)
                    {
                        //单分区
                        //考虑 四周加硬和四周口袋  扣减 排列数情况
                        if (mx.if_hard_around == 1)
                        {
                            decimal hard_around_row = mx.hard_around_row.Value;
                            if (bednetType.typename.IndexOf("袋装", StringComparison.Ordinal) >= 0) hard_around_row *= 2;

                            mx.spring_mtrl_cost_replace_formula = ReplaceWith(mx.spring_mtrl_cost_replace_formula, "【弹簧排列个数-宽】", $"(【弹簧排列个数-宽】 - {hard_around_row})");
                            mx.spring_mtrl_cost_replace_formula = ReplaceWith(mx.spring_mtrl_cost_replace_formula, "【弹簧计算个数(宽)】", $"(【弹簧计算个数(宽)】 - {hard_around_row})");
                            mx.spring_mtrl_cost_replace_formula = ReplaceWith(mx.spring_mtrl_cost_replace_formula, "【弹簧排列个数-长】", $"(【弹簧排列个数-长】 - {hard_around_row})");
                            mx.spring_mtrl_cost_replace_formula = ReplaceWith(mx.spring_mtrl_cost_replace_formula, "【弹簧计算个数(长)】", $"(【弹簧计算个数(长)】 - {hard_around_row})");
                        }

                        if (mx.if_pocket_around == 1)
                        {
                            decimal pocket_around_row = mx.pocket_around_row.Value;
                            if (bednetType.typename.IndexOf("袋装", StringComparison.Ordinal) >= 0) pocket_around_row *= 2;

                            mx.spring_mtrl_cost_replace_formula = ReplaceWith(mx.spring_mtrl_cost_replace_formula, "【弹簧排列个数-宽】", $"(【弹簧排列个数-宽】 - {pocket_around_row})");
                            mx.spring_mtrl_cost_replace_formula = ReplaceWith(mx.spring_mtrl_cost_replace_formula, "【弹簧计算个数(宽)】", $"(【弹簧计算个数(宽)】 - {pocket_around_row})");
                            mx.spring_mtrl_cost_replace_formula = ReplaceWith(mx.spring_mtrl_cost_replace_formula, "【弹簧排列个数-长】", $"(【弹簧排列个数-长】 - {pocket_around_row})");
                            mx.spring_mtrl_cost_replace_formula = ReplaceWith(mx.spring_mtrl_cost_replace_formula, "【弹簧计算个数(长)】", $"(【弹簧计算个数(长)】 - {pocket_around_row})");
                        }

                        foreach (var replacement in replacements)
                        {
                            mx.spring_mtrl_cost_replace_formula = ReplaceWith(mx.spring_mtrl_cost_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                        }

                        try
                        {
                            var res = LJExprParser.Parse(mx.spring_mtrl_cost_replace_formula);
                            mx.spring_mtrl_cost = res.Result.DecimalValue;

                            bednet.spring_mtrl_cost += mx.spring_mtrl_cost;
                        }
                        catch (Exception ex)
                        {
                            throw new LJCommonException("弹簧材料总成本公式错误!");
                        }
                    }
                    else
                    {
                        //多分区
                        foreach (var springItem in springList)
                        {
                            springItem.spring_mtrl_cost_replace_formula = bednet.spring_mtrl_formula;
                            CalSpringMtrlCol(cmd, dept, mx, springItem);

                            foreach (var replacement in replacements)
                            {
                                mx.spring_mtrl_cost_replace_formula = ReplaceWith(springItem.spring_mtrl_cost_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                            }

                            try
                            {
                                var res = LJExprParser.Parse(springItem.spring_mtrl_cost_replace_formula);
                                springItem.spring_mtrl_cost = res.Result.DecimalValue;

                                mx.spring_mtrl_cost += springItem.spring_mtrl_cost;
                                bednet.spring_mtrl_cost += mx.spring_mtrl_cost;
                            }
                            catch (Exception ex)
                            {
                                throw new LJCommonException("弹簧材料总成本公式错误!");
                            }
                        }
                    }
                }
                #endregion 计算 弹簧材料总成本 结束

                #region 计算 弹簧人工总成本 开始
                if (!string.IsNullOrEmpty(bednet.spring_hr_formula))
                {
                    bednet.spring_hr_formula = ConvertToEnglishSymbols(bednet.spring_hr_formula);
                    mx.spring_hr_cost_replace_formula = bednet.spring_hr_formula;

                    foreach (var replacement in replacements)
                    {
                        mx.spring_hr_cost_replace_formula = ReplaceWith(mx.spring_hr_cost_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(mx.spring_hr_cost_replace_formula);
                        mx.spring_hr_cost = res.Result.DecimalValue;

                        bednet.spring_hr_cost += mx.spring_hr_cost;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("弹簧总人工成本公式错误!");
                    }
                }
                #endregion 计算 弹簧人工总成本 结束

                #region 计算 蛇线材料成本 开始
                if (!string.IsNullOrEmpty(bednet.spring_hr_formula))
                {
                    bednet.snake_wire_mtrl_formula = ConvertToEnglishSymbols(bednet.snake_wire_mtrl_formula);
                    bednet.snake_wire_mtrl_cost_replace_formula = bednet.snake_wire_mtrl_formula;

                    CalSnakeCol(cmd, spring, dept);

                    foreach (var replacement in replacements)
                    {
                        bednet.snake_wire_mtrl_cost_replace_formula = ReplaceWith(bednet.snake_wire_mtrl_cost_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(bednet.snake_wire_mtrl_cost_replace_formula);
                        bednet.snake_wire_mtrl_cost += res.Result.DecimalValue;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("蛇线材料成本公式错误!");
                    }
                }
                #endregion 计算 蛇线材料成本 结束

                #region 计算 四周口袋弹簧成本 开始
                if (!string.IsNullOrEmpty(bednet.pocket_around_spring_formula) && mx.if_pocket_around > 0)
                {
                    bednet.pocket_around_spring_formula = ConvertToEnglishSymbols(bednet.pocket_around_spring_formula);
                    mx.pocket_around_spring_cost_replace_formula = bednet.pocket_around_spring_formula;

                    foreach (var replacement in replacements)
                    {
                        mx.pocket_around_spring_cost_replace_formula = ReplaceWith(mx.pocket_around_spring_cost_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(mx.pocket_around_spring_cost_replace_formula);
                        mx.pocket_around_spring_cost = res.Result.DecimalValue;
                        bednet.pocket_around_spring_cost += mx.pocket_around_spring_cost;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("四周口袋弹簧成本公式错误!");
                    }
                }
                #endregion 计算 四周口袋弹簧成本 结束

                #region 计算 四周口袋无纺布成本 开始
                if (!string.IsNullOrEmpty(bednet.pocket_around_fabrics_formula) && mx.if_pocket_around > 0)
                {
                    bednet.pocket_around_fabrics_formula = ConvertToEnglishSymbols(bednet.pocket_around_fabrics_formula);
                    mx.pocket_around_fabrics_cost_replace_formula = bednet.pocket_around_fabrics_formula;

                    foreach (var replacement in replacements)
                    {
                        mx.pocket_around_fabrics_cost_replace_formula = ReplaceWith(mx.pocket_around_fabrics_cost_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(mx.pocket_around_fabrics_cost_replace_formula);
                        mx.pocket_around_fabrics_cost = res.Result.DecimalValue;
                        bednet.pocket_around_fabrics_cost += mx.pocket_around_fabrics_cost;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("四周口袋无纺布成本公式错误!");
                    }
                }
                #endregion 计算 四周口袋无纺布成本 结束

                #region 计算 四周加硬材料成本 开始
                if (!string.IsNullOrEmpty(bednet.hard_around_mtrl_formula) && mx.if_hard_around > 0)
                {
                    bednet.hard_around_mtrl_formula = ConvertToEnglishSymbols(bednet.hard_around_mtrl_formula);
                    mx.hard_around_mtrl_cost_replace_formula = bednet.hard_around_mtrl_formula;

                    foreach (var replacement in replacements)
                    {
                        mx.hard_around_mtrl_cost_replace_formula = ReplaceWith(mx.hard_around_mtrl_cost_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(mx.hard_around_mtrl_cost_replace_formula);
                        mx.hard_around_mtrl_cost = res.Result.DecimalValue;
                        bednet.hard_around_mtrl_cost += mx.hard_around_mtrl_cost;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("四周加硬材料成本公式错误!");
                    }
                }
                #endregion 计算 四周加硬材料成本 结束

                #region 计算 四周加硬人力成本 开始
                if (!string.IsNullOrEmpty(bednet.hard_around_hr_formula) && mx.if_hard_around > 0)
                {
                    bednet.hard_around_hr_formula = ConvertToEnglishSymbols(bednet.hard_around_hr_formula);
                    mx.hard_around_hr_cost_replace_formula = bednet.hard_around_hr_formula;

                    foreach (var replacement in replacements)
                    {
                        mx.hard_around_hr_cost_replace_formula = ReplaceWith(mx.hard_around_hr_cost_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(mx.hard_around_hr_cost_replace_formula);
                        mx.hard_around_hr_cost = res.Result.DecimalValue;
                        bednet.hard_around_hr_cost += mx.hard_around_hr_cost;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("四周加硬人力成本公式错误!");
                    }
                }
                #endregion 计算 四周加硬人力成本 结束

                #region 计算 入袋无纺布材料成本 开始
                if (!string.IsNullOrEmpty(bednet.hard_around_hr_formula) && bednetType.typename.IndexOf("袋装网") > -1 && mx.fabrics1_mtrlid > 0)
                {
                    bednet.fabrics1_mtrl_formula = ConvertToEnglishSymbols(bednet.fabrics1_mtrl_formula);
                    mx.fabrics1_mtrl_cost_replace_formula = bednet.fabrics1_mtrl_formula;

                    CalSpringMtrlCol2(cmd, bednet, mx, dept, "入袋无纺布");

                    foreach (var replacement in replacements)
                    {
                        mx.fabrics1_mtrl_cost_replace_formula = ReplaceWith(mx.fabrics1_mtrl_cost_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(mx.fabrics1_mtrl_cost_replace_formula);
                        mx.fabrics1_mtrl_cost = res.Result.DecimalValue;
                        bednet.fabrics1_mtrl_cost += mx.fabrics1_mtrl_cost;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("入袋无纺布材料成本公式错误!");
                    }
                }
                #endregion 计算 入袋无纺布材料成本 结束

                #region 计算 胶水材料成本 开始
                if (!string.IsNullOrEmpty(bednet.glue_mtrl_formula))
                {
                    bednet.glue_mtrl_formula = ConvertToEnglishSymbols(bednet.glue_mtrl_formula);
                    mx.glue_mtrl_cost_replace_formula = bednet.glue_mtrl_formula;

                    foreach (var replacement in replacements)
                    {
                        mx.glue_mtrl_cost_replace_formula = ReplaceWith(mx.glue_mtrl_cost_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(mx.glue_mtrl_cost_replace_formula);
                        bednet.glue_mtrl_cost += res.Result.DecimalValue;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("胶水材料成本公式错误!");
                    }
                }
                #endregion 计算 胶水材料成本 结束

                #region 计算 底面无纺布材料成本 开始
                if (!string.IsNullOrEmpty(bednet.hard_around_hr_formula) && bednetType.typename.IndexOf("袋装网") > -1 && mx.fabrics2_mtrlid > 0)
                {
                    bednet.fabrics2_mtrl_formula = ConvertToEnglishSymbols(bednet.fabrics2_mtrl_formula);
                    mx.fabrics2_mtrl_cost_replace_formula = bednet.fabrics2_mtrl_formula;

                    CalSpringMtrlCol2(cmd, bednet, mx, dept, "底面无纺布");

                    foreach (var replacement in replacements)
                    {
                        mx.fabrics2_mtrl_cost_replace_formula = ReplaceWith(mx.fabrics2_mtrl_cost_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(mx.fabrics2_mtrl_cost_replace_formula);
                        mx.fabrics2_mtrl_cost = res.Result.DecimalValue;
                        bednet.fabrics2_mtrl_cost += mx.fabrics2_mtrl_cost;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("底面无纺布材料成本公式错误!");
                    }
                }
                #endregion 计算 底面无纺布材料成本 结束

                #region 计算 边铁人力成本 开始
                if (!string.IsNullOrEmpty(bednet.side_iron_hr_formula) && bednet.if_side_iron == 1 && mx.if_side_iron > 0)
                {
                    bednet.side_iron_hr_formula = ConvertToEnglishSymbols(bednet.side_iron_hr_formula);
                    mx.side_iron_hr_cost_replace_formula = bednet.side_iron_hr_formula;

                    foreach (var replacement in replacements)
                    {
                        mx.side_iron_hr_cost_replace_formula = ReplaceWith(mx.side_iron_hr_cost_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(mx.side_iron_hr_cost_replace_formula);
                        mx.side_iron_hr_cost += res.Result.DecimalValue;
                        bednet.side_iron_hr_cost = mx.side_iron_hr_cost;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("边铁人力成本公式错误!");
                    }
                }
                #endregion 计算 边铁人力成本 结束

                #region  计算 边铁材料成本 开始
                if (!string.IsNullOrEmpty(bednet.side_iron_mtrl_formula) && bednet.if_side_iron == 1 && mx.if_side_iron > 0)
                {
                    bednet.side_iron_mtrl_formula = ConvertToEnglishSymbols(bednet.side_iron_mtrl_formula);
                    mx.side_iron_mtrl_cost_replace_formula = bednet.side_iron_mtrl_formula;

                    foreach (var replacement in replacements)
                    {
                        mx.side_iron_mtrl_cost_replace_formula = ReplaceWith(mx.side_iron_mtrl_cost_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(mx.side_iron_mtrl_cost_replace_formula);
                        mx.side_iron_mtrl_cost = res.Result.DecimalValue;
                        bednet.side_iron_mtrl_cost += mx.side_iron_mtrl_cost;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("边铁材料成本公式错误!");
                    }
                }
                #endregion 计算 边铁材料成本 结束

                #region  计算 C钉/夹码材料 开始
                if (!string.IsNullOrEmpty(bednet.cnail_mtrl_formula))
                {
                    bednet.cnail_mtrl_formula = ConvertToEnglishSymbols(bednet.cnail_mtrl_formula);
                    mx.cnail_mtrl_cost_replace_formula = bednet.cnail_mtrl_formula;

                    foreach (var replacement in replacements)
                    {
                        mx.cnail_mtrl_cost_replace_formula = ReplaceWith(mx.cnail_mtrl_cost_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(mx.cnail_mtrl_cost_replace_formula);
                        mx.cnail_mtrl_cost = res.Result.DecimalValue;
                        bednet.cnail_mtrl_cost += mx.cnail_mtrl_cost;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("C钉/夹码材料成本公式错误!");
                    }
                }
                #endregion 计算 C钉/夹码材料 结束

                #region  计算 C钉/夹码人力成本 开始
                if (!string.IsNullOrEmpty(bednet.cnail_hr_formula))
                {
                    bednet.cnail_hr_formula = ConvertToEnglishSymbols(bednet.cnail_hr_formula);
                    mx.cnail_hr_cost_replace_formula = bednet.cnail_hr_formula;

                    foreach (var replacement in replacements)
                    {
                        mx.cnail_hr_cost_replace_formula = ReplaceWith(mx.cnail_hr_cost_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(mx.cnail_hr_cost_replace_formula);
                        mx.cnail_hr_cost = res.Result.DecimalValue;
                        bednet.cnail_hr_cost += mx.cnail_hr_cost;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("C钉/夹码人力成本公式错误!");
                    }
                }
                #endregion 计算 C钉/夹码人力成本 结束

                #region  计算 海绵包边材料成本 开始
                if (!string.IsNullOrEmpty(bednet.sponge_mtrl_formula) && bednet.sponge_mtrlid > 0)
                {

                    bednet.sponge_mtrl_formula = ConvertToEnglishSymbols(bednet.sponge_mtrl_formula);
                    bednet.sponge_mtrl_cost_replace_formula = bednet.sponge_mtrl_formula;

                    CalSpringMtrlCol2(cmd, bednet, mx, dept, "海绵包边");

                    foreach (var replacement in replacements)
                    {
                        bednet.sponge_mtrl_cost_replace_formula = ReplaceWith(bednet.sponge_mtrl_cost_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(bednet.sponge_mtrl_cost_replace_formula);
                        bednet.sponge_mtrl_cost += res.Result.DecimalValue;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("海绵包边材料成本公式错误!");
                    }
                }
                #endregion 计算 海绵包边材料成本 结束

                #region  计算 海绵包边人力成本 开始
                if (!string.IsNullOrEmpty(bednet.sponge_hr_formula) && bednet.sponge_mtrlid > 0)
                {
                    bednet.sponge_hr_formula = ConvertToEnglishSymbols(bednet.sponge_hr_formula);
                    bednet.sponge_hr_cost_replace_formula = bednet.sponge_hr_formula;

                    foreach (var replacement in replacements)
                    {
                        bednet.sponge_hr_cost_replace_formula = ReplaceWith(bednet.sponge_hr_cost_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(bednet.sponge_hr_cost_replace_formula);
                        bednet.sponge_hr_cost += res.Result.DecimalValue;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("海绵包边人力成本公式错误!");
                    }
                }
                #endregion 计算 海绵包边人力成本 结束

                #region  计算 填充海绵成本 开始
                if (!string.IsNullOrEmpty(bednet.sponge_mtrl_tc_formula) && bednet.sponge_tc_mtrlid > 0)
                {
                    bednet.sponge_mtrl_tc_formula = ConvertToEnglishSymbols(bednet.sponge_mtrl_tc_formula);
                    bednet.sponge_mtrl_tc_cost_replace_formula = bednet.sponge_mtrl_tc_formula;

                    CalSpringMtrlCol2(cmd, bednet, mx, dept, "填充海绵");

                    foreach (var replacement in replacements)
                    {
                        bednet.sponge_mtrl_tc_cost_replace_formula = ReplaceWith(bednet.sponge_mtrl_tc_cost_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(bednet.sponge_mtrl_tc_cost_replace_formula);
                        bednet.sponge_mtrl_tc_cost += res.Result.DecimalValue;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("填充海绵成本公式错误!");
                    }
                }
                #endregion 计算 填充海绵成本 结束

                #region  计算 封边材料成本 开始
                if (!string.IsNullOrEmpty(bednet.edge_mtrl_formula) && bednet.edge_mtrlid > 0)
                {
                    bednet.edge_mtrl_formula = ConvertToEnglishSymbols(bednet.edge_mtrl_formula);
                    bednet.edge_mtrl_cost_replace_formula = bednet.edge_mtrl_formula;

                    CalSpringMtrlCol2(cmd, bednet, mx, dept, "封边");

                    foreach (var replacement in replacements)
                    {
                        bednet.edge_mtrl_cost_replace_formula = ReplaceWith(bednet.edge_mtrl_cost_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(bednet.edge_mtrl_cost_replace_formula);
                        bednet.edge_mtrl_cost += res.Result.DecimalValue;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("封边材料成本公式错误!");
                    }
                }
                #endregion 计算 封边材料成本 结束

                #region  计算 封边人力成本 开始
                if (!string.IsNullOrEmpty(bednet.edge_hr_formula) && bednet.edge_mtrlid > 0)
                {
                    bednet.edge_hr_formula = ConvertToEnglishSymbols(bednet.edge_hr_formula);
                    bednet.edge_hr_cost_replace_formula = bednet.edge_hr_formula;

                    foreach (var replacement in replacements)
                    {
                        bednet.edge_hr_cost_replace_formula = ReplaceWith(bednet.edge_hr_cost_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(bednet.edge_hr_cost_replace_formula);
                        bednet.edge_hr_cost += res.Result.DecimalValue;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("封边人力成本公式错误!");
                    }
                }
                #endregion 计算 封边人力成本 结束

                #region  计算 弹叉材料成本 开始
                if (!string.IsNullOrEmpty(bednet.fork_mtrl_formula) && bednet.fork_qty > 0)
                {
                    bednet.fork_mtrl_formula = ConvertToEnglishSymbols(bednet.fork_mtrl_formula);
                    bednet.fork_mtrl_cost_replace_formula = bednet.fork_mtrl_formula;

                    foreach (var replacement in replacements)
                    {
                        bednet.fork_mtrl_cost_replace_formula = ReplaceWith(bednet.fork_mtrl_cost_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(bednet.fork_mtrl_cost_replace_formula);
                        bednet.fork_mtrl_cost += res.Result.DecimalValue;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("弹叉材料成本公式错误!");
                    }
                }
                #endregion 计算 弹叉材料成本 结束

                #region  计算 弹叉人力成本 开始
                if (!string.IsNullOrEmpty(bednet.fork_hr_formula) && bednet.fork_qty > 0)
                {
                    bednet.fork_hr_formula = ConvertToEnglishSymbols(bednet.fork_hr_formula);
                    bednet.fork_hr_cost_replace_formula = bednet.fork_hr_formula;

                    foreach (var replacement in replacements)
                    {
                        bednet.fork_hr_cost_replace_formula = ReplaceWith(bednet.fork_hr_cost_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(bednet.fork_hr_cost_replace_formula);
                        bednet.fork_hr_cost += res.Result.DecimalValue;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("弹叉材料成本公式错误!");
                    }
                }
                #endregion 计算 弹叉人力成本 结束

                #region  计算 胶条/包角材料成本 开始
                if (!string.IsNullOrEmpty(bednet.rsorwa_mtrl_formula) && bednet.if_rsorwa == 1)
                {
                    bednet.rsorwa_mtrl_formula = ConvertToEnglishSymbols(bednet.rsorwa_mtrl_formula);
                    bednet.rsorwa_mtrl_cost_replace_formula = bednet.rsorwa_mtrl_formula;

                    foreach (var replacement in replacements)
                    {
                        bednet.rsorwa_mtrl_cost_replace_formula = ReplaceWith(bednet.rsorwa_mtrl_cost_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(bednet.rsorwa_mtrl_cost_replace_formula);
                        bednet.rsorwa_mtrl_cost += res.Result.DecimalValue;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("胶条/包角材料成本公式错误!");
                    }
                }
                #endregion 计算 胶条/包角材料成本 结束

                #region  计算 胶条/包角人力成本 开始
                if (!string.IsNullOrEmpty(bednet.rsorwa_hr_formula) && bednet.if_rsorwa == 1)
                {
                    bednet.rsorwa_hr_formula = ConvertToEnglishSymbols(bednet.rsorwa_hr_formula);
                    bednet.rsorwa_hr_cost_replace_formula = bednet.rsorwa_hr_formula;

                    foreach (var replacement in replacements)
                    {
                        bednet.rsorwa_hr_cost_replace_formula = ReplaceWith(bednet.rsorwa_hr_cost_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(bednet.rsorwa_hr_cost_replace_formula);
                        bednet.rsorwa_hr_cost += res.Result.DecimalValue;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("胶条/包角人力成本公式错误!");
                    }
                }
                #endregion 计算 胶条/包角人力成本 结束

                #region  计算 海绵打孔人力成本 开始
                if (!string.IsNullOrEmpty(bednet.sponge_drilling_hr_formula) && bednet.if_sponge_drilling == 1)
                {
                    bednet.sponge_drilling_hr_formula = ConvertToEnglishSymbols(bednet.sponge_drilling_hr_formula);
                    bednet.sponge_drilling_hr_cost_replace_formula = bednet.sponge_drilling_hr_formula;

                    foreach (var replacement in replacements)
                    {
                        bednet.sponge_drilling_hr_cost_replace_formula = ReplaceWith(bednet.sponge_drilling_hr_cost_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(bednet.sponge_drilling_hr_cost_replace_formula);
                        bednet.sponge_drilling_hr_cost += res.Result.DecimalValue;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("海绵打孔人力成本公式错误!");
                    }
                }
                #endregion 计算 海绵打孔人力成本 结束

                #region  计算 上垫层物料成本 开始
                if (!string.IsNullOrEmpty(bednet.felt_mtrl_formula) && bednet.felt_qty > 0)
                {
                    bednet.felt_mtrl_formula = ConvertToEnglishSymbols(bednet.felt_mtrl_formula);
                    bednet.felt_mtrl_cost_replace_formula = bednet.felt_mtrl_formula;

                    CalSpringMtrlCol2(cmd, bednet, mx, dept, "上垫层");

                    foreach (var replacement in replacements)
                    {
                        bednet.felt_mtrl_cost_replace_formula = ReplaceWith(bednet.felt_mtrl_cost_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(bednet.felt_mtrl_cost_replace_formula);
                        bednet.felt_mtrl_cost += res.Result.DecimalValue;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("上垫层物料成本公式错误!");
                    }
                }
                #endregion 计算 上垫层物料成本 结束

                #region  计算 下垫层物料成本 开始
                if (!string.IsNullOrEmpty(bednet.felt_mtrl_formula) && bednet.felt_x_qty > 0)
                {
                    bednet.felt_mtrl_formula = ConvertToEnglishSymbols(bednet.felt_mtrl_formula);
                    bednet.felt_mtrl_x_cost_replace_formula = bednet.felt_mtrl_formula;

                    CalSpringMtrlCol2(cmd, bednet, mx, dept, "下垫层");

                    foreach (var replacement in replacements)
                    {
                        bednet.felt_mtrl_x_cost_replace_formula = ReplaceWith(bednet.felt_mtrl_x_cost_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(bednet.felt_mtrl_x_cost_replace_formula);
                        bednet.felt_mtrl_x_cost += res.Result.DecimalValue;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("下垫层物料成本公式错误!");
                    }
                }
                #endregion 计算 下垫层物料成本 结束

                #region  计算 上垫层人力成本 开始
                if (!string.IsNullOrEmpty(bednet.felt_hr_formula) && bednet.felt_qty > 0)
                {
                    bednet.felt_hr_formula = ConvertToEnglishSymbols(bednet.felt_hr_formula);
                    bednet.felt_hr_cost_replace_formula = bednet.felt_hr_formula;

                    foreach (var replacement in replacements)
                    {
                        bednet.felt_hr_cost_replace_formula = ReplaceWith(bednet.felt_hr_cost_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(bednet.felt_hr_cost_replace_formula);
                        bednet.felt_hr_cost += res.Result.DecimalValue;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("上垫层人力成本公式错误!");
                    }
                }
                #endregion 计算 上垫层人力成本 结束

                #region  计算 下垫层人力成本 开始
                if (!string.IsNullOrEmpty(bednet.felt_hr_formula) && bednet.felt_x_qty > 0)
                {
                    bednet.felt_hr_formula = ConvertToEnglishSymbols(bednet.felt_hr_formula);
                    bednet.felt_hr_x_cost_replace_formula = bednet.felt_hr_formula;

                    CalSpringMtrlCol2(cmd, bednet, mx, dept, "下垫层");

                    foreach (var replacement in replacements)
                    {
                        bednet.felt_hr_x_cost_replace_formula = ReplaceWith(bednet.felt_hr_x_cost_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(bednet.felt_hr_x_cost_replace_formula);
                        bednet.felt_hr_x_cost += res.Result.DecimalValue;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("下垫层物料成本公式错误!");
                    }
                }
                #endregion 计算 下垫层人力成本 结束

                #region  计算 包装总成本 开始
                if (!string.IsNullOrEmpty(bednet.packet_mtrl_formula) && !string.IsNullOrEmpty(bednet.packtype))
                {
                    bednet.packet_mtrl_formula = ConvertToEnglishSymbols(bednet.packet_mtrl_formula);
                    bednet.packet_mtrl_cost_replace_formula = bednet.packet_mtrl_formula;
                    bednet.packet_mtrl_cost_replace_formula = ReplaceWith(bednet.packet_mtrl_cost_replace_formula, "@@", "");

                    foreach (var replacement in replacements)
                    {
                        bednet.packet_mtrl_cost_replace_formula = ReplaceWith(bednet.packet_mtrl_cost_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(bednet.packet_mtrl_cost_replace_formula);
                        bednet.packet_mtrl_cost += res.Result.DecimalValue;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("包装材料成本公式错误!");
                    }
                }
                #endregion 计算 包装总成本 结束

                #region  计算 包装人工成本 开始
                if (!string.IsNullOrEmpty(bednet.packet_hr_formula) && !string.IsNullOrEmpty(bednet.packtype))
                {
                    bednet.packet_hr_formula = ConvertToEnglishSymbols(bednet.packet_hr_formula);
                    bednet.packet_hr_cost_replace_formula = bednet.packet_hr_formula;
                    bednet.packet_hr_cost_replace_formula = ReplaceWith(bednet.packet_hr_cost_replace_formula, "@@", "");

                    foreach (var replacement in replacements)
                    {
                        bednet.packet_hr_cost_replace_formula = ReplaceWith(bednet.packet_hr_cost_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(bednet.packet_hr_cost_replace_formula);
                        bednet.packet_hr_cost += res.Result.DecimalValue;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("包装材料成本公式错误!");
                    }
                }
                #endregion 计算 包装人工成本 结束

                //有外销的  工厂利润率 增加 0.06
                if (bednet.ifsaleout == 1)
                {
                    bednet.sale_point = 0.06M;
                }
            }

            // 计算总材料成本 total_mtrl_cost
            bednet.total_mtrl_cost = new decimal[]
            {
                bednet.spring_mtrl_cost.Value,
                bednet.snake_wire_mtrl_cost.Value,
                bednet.pocket_around_spring_cost.Value,
                bednet.pocket_around_fabrics_cost.Value,
                bednet.hard_around_mtrl_cost.Value,
                bednet.glue_mtrl_cost.Value,
                bednet.fabrics1_mtrl_cost.Value,
                bednet.fabrics2_mtrl_cost.Value,
                bednet.side_iron_mtrl_cost.Value,
                bednet.cnail_mtrl_cost.Value,
                bednet.sponge_mtrl_cost.Value,
                bednet.sponge_mtrl_tc_cost.Value,
                bednet.edge_mtrl_cost.Value,
                bednet.fork_mtrl_cost.Value,
                bednet.rsorwa_mtrl_cost.Value,
                bednet.felt_mtrl_cost.Value,
                bednet.felt_mtrl_x_cost.Value,
                bednet.packet_mtrl_cost.Value
            }.Sum();

            // 计算总人力成本 total_mtrl_cost
            bednet.total_hr_cost = new decimal[]
            {
                bednet.spring_hr_cost.Value,
                bednet.hard_around_hr_cost.Value,
                bednet.side_iron_hr_cost.Value,
                bednet.cnail_hr_cost.Value,
                bednet.sponge_hr_cost.Value,
                bednet.edge_hr_cost.Value,
                bednet.fork_hr_cost.Value,
                bednet.rsorwa_hr_cost.Value,
                bednet.felt_hr_cost.Value,
                bednet.felt_hr_x_cost.Value,
                bednet.packet_hr_cost.Value,
                bednet.sponge_drilling_hr_cost.Value
            }.Sum();

            //1.总成本=总材料成本+总人力成本+ 额外费用
            bednet.total_cost = bednet.total_mtrl_cost + bednet.total_hr_cost + bednet.total_fees_cost;

            //2-不含税出厂价=总成本* ( 工厂利润率 +  外销加点 )
            bednet.nottax_factory_cost = bednet.total_cost * (bednet.profitrate + bednet.sale_point);

            // 3 - 部门不含税价 = 不含税出厂价 / 部门利润率 * 佣金点数 * 额外点数 + fob
            try
            {
                bednet.nottax_dept_cost = bednet.nottax_factory_cost / bednet.dept_profitrate / (1 - (bednet.commission - 1)) * bednet.other_rate + bednet.fob;
            }
            catch (DivideByZeroException)
            {
                // 捕获除以零的异常并处理
                bednet.nottax_dept_cost = 0;  // 或者设置为其他默认值
            }

            // 4 - 税金 = (部门不含税价 * 税率 - 1)
            bednet.taxes = bednet.nottax_dept_cost * (bednet.taxrate - 1);

            // 5 - 部门含税价 = 部门不含税价 * 税率
            bednet.dept_cost = bednet.nottax_dept_cost * bednet.taxrate;

            // 6 - 外币价 = 部门含税价 / 汇率
            if (bednet.moneyrate != 0)
            {
                bednet.foreign_cost = bednet.dept_cost / bednet.moneyrate;
            }
        }

        private void CulcalateWeight(SqlCommand cmd, u_bednet bednet, List<u_bednetmx> mxlist, List<u_bednetmx_spring> springList)
        {
            // 数据准备
            var dept = new u_dept() { deptid = bednet.deptid.Value };
            DbSqlHelper.SelectOne(cmd, dept, "pricelistid");

            var bednetType = new u_bednet_type() { bednettypeid = bednet.bednettypeid };
            DbSqlHelper.SelectOne(cmd, bednetType, "typename");

            foreach (var mx in mxlist)
            {

                #region 计算 钢丝重量 开始
                if (!string.IsNullOrEmpty(bednet.spring_weight_formula))
                {
                    bednet.spring_weight_formula = ConvertToEnglishSymbols(bednet.spring_weight_formula);

                    mx.spring_weight_replace_formula = bednet.spring_weight_formula;
                    if (mx.if_part == 0)
                    {
                        //单分区
                        foreach (var replacement in replacements)
                        {
                            mx.spring_weight_replace_formula = ReplaceWith(mx.spring_weight_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                        }

                        try
                        {
                            var res = LJExprParser.Parse(mx.spring_weight_replace_formula);
                            bednet.spring_weight_qty += res.Result.DecimalValue;
                        }
                        catch (Exception ex)
                        {
                            throw new LJCommonException("钢丝重量公式错误!");
                        }
                    }
                    else
                    {
                        //多分区
                        foreach (var springItem in springList)
                        {
                            springItem.spring_weight_replace_formula = bednet.spring_weight_formula;
                            CalSpringMtrlCol(cmd, dept, mx, springItem);

                            foreach (var replacement in replacements)
                            {
                                springItem.spring_weight_replace_formula = ReplaceWith(springItem.spring_weight_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                            }

                            try
                            {
                                var res = LJExprParser.Parse(springItem.spring_mtrl_cost_replace_formula);
                                bednet.spring_weight_qty += res.Result.DecimalValue;
                            }
                            catch (Exception ex)
                            {
                                throw new LJCommonException("钢丝重量公式错误!");
                            }
                        }
                    }
                }
                #endregion 计算 钢丝重量 结束

                #region  计算 边铁重量 开始
                if (!string.IsNullOrEmpty(bednet.side_iron_weight_formula) && bednet.if_side_iron == 1 && mx.if_side_iron > 0)
                {
                    bednet.side_iron_weight_formula = ConvertToEnglishSymbols(bednet.side_iron_weight_formula);
                    bednet.side_iron_weight_replace_formula = bednet.side_iron_weight_formula;

                    foreach (var replacement in replacements)
                    {
                        bednet.side_iron_weight_replace_formula = ReplaceWith(bednet.side_iron_weight_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(bednet.side_iron_weight_replace_formula);
                        bednet.side_iron_weight_qty += res.Result.DecimalValue;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("边铁重量公式错误!");
                    }
                }
                #endregion 计算 边铁重量 结束

                #region  计算 四周加硬重量 开始
                if (!string.IsNullOrEmpty(bednet.hard_around_weight_formula) && mx.if_hard_around > 0)
                {
                    bednet.hard_around_weight_formula = ConvertToEnglishSymbols(bednet.hard_around_weight_formula);
                    bednet.hard_around_weight_replace_formula = bednet.hard_around_weight_formula;

                    foreach (var replacement in replacements)
                    {
                        bednet.hard_around_weight_replace_formula = ReplaceWith(bednet.hard_around_weight_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(bednet.hard_around_weight_replace_formula);
                        bednet.hard_around_weight_qty += res.Result.DecimalValue;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("四周加硬重量公式错误!");
                    }
                }
                #endregion 计算 四周加硬重量 结束

                #region  计算 入袋无纺布重量 开始
                if (!string.IsNullOrEmpty(bednet.fabrics1_weight_formula) && bednetType.typename.IndexOf("袋装网") > -1 && mx.fabrics1_mtrlid > 0)
                {
                    bednet.fabrics1_weight_formula = ConvertToEnglishSymbols(bednet.fabrics1_weight_formula);
                    bednet.fabrics1_weight_replace_formula = bednet.fabrics1_weight_formula;

                    foreach (var replacement in replacements)
                    {
                        bednet.fabrics1_weight_replace_formula = ReplaceWith(bednet.fabrics1_weight_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(bednet.fabrics1_weight_replace_formula);
                        bednet.fabrics1_weight_qty += res.Result.DecimalValue;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("入袋无纺布重量公式错误!");
                    }
                }
                #endregion 计算 入袋无纺布重量 结束

                #region  计算 面底无纺布重量 开始
                if (!string.IsNullOrEmpty(bednet.fabrics2_weight_formula) && bednetType.typename.IndexOf("袋装网") > -1 && mx.fabrics2_mtrlid > 0)
                {
                    bednet.fabrics2_weight_formula = ConvertToEnglishSymbols(bednet.fabrics2_weight_formula);
                    bednet.fabrics2_weight_replace_formula = bednet.fabrics2_weight_formula;

                    foreach (var replacement in replacements)
                    {
                        bednet.fabrics2_weight_replace_formula = ReplaceWith(bednet.fabrics2_weight_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(bednet.fabrics2_weight_replace_formula);
                        bednet.fabrics2_weight_qty += res.Result.DecimalValue;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("面底无纺布重量公式错误!");
                    }
                }
                #endregion 计算 面底无纺布重量 结束

                #region  计算 上垫层重量 开始
                string felt_weight_formula_replace_formula = "";
                if (!string.IsNullOrEmpty(bednet.felt_mtrl_formula) && bednet.felt_qty > 0)
                {
                    bednet.felt_weight_formula = ConvertToEnglishSymbols(bednet.felt_weight_formula);
                    felt_weight_formula_replace_formula = bednet.felt_weight_formula;

                    CalSpringMtrlCol2(cmd, bednet, mx, dept, "上垫层");

                    foreach (var replacement in replacements)
                    {
                        felt_weight_formula_replace_formula = ReplaceWith(felt_weight_formula_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(felt_weight_formula_replace_formula);
                        bednet.felt_weight_qty += res.Result.DecimalValue;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("上垫层重量公式错误!");
                    }
                }
                #endregion 计算 上垫层重量 结束

                #region  计算 下垫层重量 开始
                string felt_x_weight_formula_replace_formula = "";
                if (!string.IsNullOrEmpty(bednet.felt_weight_formula) && bednet.felt_x_qty > 0)
                {
                    bednet.felt_weight_formula = ConvertToEnglishSymbols(bednet.felt_weight_formula);
                    felt_x_weight_formula_replace_formula = bednet.felt_weight_formula;

                    CalSpringMtrlCol2(cmd, bednet, mx, dept, "下垫层");

                    foreach (var replacement in replacements)
                    {
                        felt_x_weight_formula_replace_formula = ReplaceWith(felt_x_weight_formula_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(felt_x_weight_formula_replace_formula);
                        bednet.felt_weight_qty += res.Result.DecimalValue;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("下垫层重量公式错误!");
                    }
                }

                bednet.felt_weight_replace_formula += felt_weight_formula_replace_formula;
                bednet.felt_weight_replace_formula += Environment.NewLine;
                bednet.felt_weight_replace_formula += felt_x_weight_formula_replace_formula;
                #endregion 计算 下垫层重量 结束


                #region  计算 C钉/夹码重量 开始
                if (!string.IsNullOrEmpty(bednet.cnail_weight_formula))
                {
                    bednet.cnail_weight_formula = ConvertToEnglishSymbols(bednet.cnail_weight_formula);
                    bednet.cnail_weight_replace_formula = bednet.cnail_weight_formula;

                    foreach (var replacement in replacements)
                    {
                        bednet.cnail_weight_replace_formula = ReplaceWith(bednet.cnail_weight_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(bednet.cnail_weight_replace_formula);
                        bednet.cnail_weight_qty += res.Result.DecimalValue;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("C钉/夹码重量公式错误!");
                    }
                }
                #endregion 计算 C钉/夹码重量 结束

                #region  计算 海绵包边重量 开始
                if (!string.IsNullOrEmpty(bednet.sponge_weight_formula) && bednet.sponge_mtrlid > 0)
                {
                    bednet.sponge_weight_formula = ConvertToEnglishSymbols(bednet.sponge_weight_formula);
                    bednet.sponge_weight_replace_formula = bednet.sponge_weight_formula;

                    foreach (var replacement in replacements)
                    {
                        bednet.sponge_weight_replace_formula = ReplaceWith(bednet.sponge_weight_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(bednet.sponge_weight_replace_formula);
                        bednet.sponge_weight_qty += res.Result.DecimalValue;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("海绵包边重量公式错误!");
                    }
                }
                #endregion 计算 海绵包边重量 结束

                #region  计算 填充海绵重量 开始
                if (!string.IsNullOrEmpty(bednet.sponge_weight_tc_formula) && bednet.sponge_tc_mtrlid > 0)
                {
                    bednet.sponge_weight_tc_formula = ConvertToEnglishSymbols(bednet.sponge_weight_tc_formula);
                    bednet.sponge_weight_tc_replace_formula = bednet.sponge_weight_tc_formula;

                    CalSpringMtrlCol2(cmd, bednet, mx, dept, "填充海绵");

                    foreach (var replacement in replacements)
                    {
                        bednet.sponge_weight_tc_replace_formula = ReplaceWith(bednet.sponge_weight_tc_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(bednet.sponge_weight_tc_replace_formula);
                        bednet.sponge_weight_tc_qty += res.Result.DecimalValue;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("填充海绵重量公式错误!");
                    }
                }
                #endregion 计算 填充海绵重量 结束

                #region  计算 封边材料重量 开始
                if (!string.IsNullOrEmpty(bednet.edge_weight_formula) && bednet.edge_mtrlid > 0)
                {
                    bednet.edge_weight_formula = ConvertToEnglishSymbols(bednet.edge_weight_formula);
                    bednet.edge_weight_replace_formula = bednet.edge_weight_formula;

                    CalSpringMtrlCol2(cmd, bednet, mx, dept, "封边");

                    foreach (var replacement in replacements)
                    {
                        bednet.edge_weight_replace_formula = ReplaceWith(bednet.edge_weight_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(bednet.edge_weight_replace_formula);
                        bednet.edge_weight_qty += res.Result.DecimalValue;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("封边材料重量公式错误!");
                    }
                }
                #endregion 计算 封边材料重量 结束

                #region  计算 弹叉材料重量 开始
                if (!string.IsNullOrEmpty(bednet.fork_weight_formula) && bednet.fork_qty > 0)
                {
                    bednet.fork_weight_formula = ConvertToEnglishSymbols(bednet.fork_weight_formula);
                    bednet.fork_weight_replace_formula = bednet.fork_weight_formula;

                    foreach (var replacement in replacements)
                    {
                        bednet.fork_weight_replace_formula = ReplaceWith(bednet.fork_weight_replace_formula, replacement.Key, Convert.ToString(replacement.Value));
                    }

                    try
                    {
                        var res = LJExprParser.Parse(bednet.fork_weight_replace_formula);
                        bednet.fork_weight_qty += res.Result.DecimalValue;
                    }
                    catch (Exception ex)
                    {
                        throw new LJCommonException("弹叉材料重量公式错误!");
                    }
                }
                #endregion 计算 弹叉材料重量 结束
            }

            // 计算总材料成本 total_mtrl_cost
            bednet.sum_weight = new decimal[]
            {
                bednet.spring_weight_qty.Value,
                bednet.side_iron_weight_qty.Value,
                bednet.hard_around_weight_qty.Value,
                bednet.fabrics1_weight_qty.Value,
                bednet.fabrics2_weight_qty.Value,
                bednet.felt_weight_qty.Value,
                bednet.cnail_weight_qty.Value,
                bednet.sponge_weight_qty.Value,
                bednet.sponge_weight_tc_qty.Value,
                bednet.edge_weight_qty.Value,
                bednet.fork_weight_qty.Value
            }.Sum();
        }

        private string ConvertToEnglishSymbols(string input)
        {
            input = input.Replace("（", "(")
                 .Replace("）", ")")
                 .Replace("，", ",")
                 .Replace("。", ".")
                 .Replace("：", ":")
                 .Replace("；", ";")
                 .Replace("“", "\"")
                 .Replace("”", "\"")
                 .Replace("‘", "'")
                 .Replace("’", "'");

            return input;
        }

        private string ReplaceWith(string input, string oldValue, string newValue)
        {
            return input.Replace(oldValue, newValue);
        }

        private void AddDictKeyValue(string key, object value, bool isReplace = true)
        {
            if (!replacements.ContainsKey(key))
            {
                replacements.Add(key, value);
            }
            else if (isReplace)
            {
                replacements[key] = value;
            }
        }

        private void CalSameCol(SqlCommand cmd, u_bednetmx mx, u_spring spring, u_dept dept)
        {
            AddDictKeyValue("【弹簧排列个数-宽】", mx.spring_qty_width);
            AddDictKeyValue("【弹簧排列个数-长】", mx.spring_qty_length);
            AddDictKeyValue("【弹簧计算个数(宽)】", mx.spring_qty_width);
            AddDictKeyValue("【弹簧计算个数(长)】", mx.spring_qty_length);
            AddDictKeyValue("【边铁条数】", mx.side_iron_qty);
            AddDictKeyValue("【条数】", mx.side_iron_qty);
            AddDictKeyValue("【四周口袋-排数】", mx.pocket_around_row);
            AddDictKeyValue("【四周口袋】", mx.if_pocket_around);
            AddDictKeyValue("【四周加硬-排数】", mx.hard_around_row);
            AddDictKeyValue("【四周加硬】", mx.if_hard_around);

            spring.gram_weight /= 1000;
            if (spring.gram_weight > 0)
            {
                AddDictKeyValue("【弹簧重/个】", spring.gram_weight);
                AddDictKeyValue("【弹簧重】", spring.gram_weight);
                AddDictKeyValue("【弹簧克重】", spring.gram_weight * 1000);
            }

            if (mx.bednet_height > 0)
            {
                AddDictKeyValue("【床网高】", mx.bednet_height);
            }

            if (spring.height > 0)
            {
                AddDictKeyValue("【口袋弹簧高度】", spring.height);
            }

            if (spring.center_diameter > 0)
            {
                AddDictKeyValue("【口袋弹簧心径】", spring.center_diameter);
            }

            cmd.CommandText = @"SELECT TOP 1 isnull(u_mtrl_price_pricelist.price, 0) AS price
                                FROM u_mtrl_price_pricelist
                                INNER JOIN u_mtrl_price ON u_mtrl_price.mtrlid = u_mtrl_price_pricelist.mtrlid
                                WHERE cast(u_mtrl_price.name AS DECIMAL(18, 5)) = @line_diameter
	                                AND u_mtrl_price.mtrltype = 0
	                                AND u_mtrl_price_pricelist.pricelistid = @pricelistid";
            cmd.Parameters.Clear();
            cmd.Parameters.AddWithValue("@line_diameter", spring.line_diameter);
            cmd.Parameters.AddWithValue("@pricelistid", dept.pricelistid);
            decimal price = 0;
            using (var reader = cmd.ExecuteReader())
            {
                if (reader.Read())
                {
                    price = Convert.ToDecimal(reader["price"]);

                    price /= 1000;
                }
            }

            if (price > 0)
            {
                AddDictKeyValue("【加硬弹簧单价】", price);
                AddDictKeyValue("【口袋弹簧单价】", price);
                AddDictKeyValue("【弹簧单价】", price);
            }
        }

        /// <summary>
        /// 用于床网报价 弹簧材料总成本 弹簧人工总成本
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="dept"></param>
        /// <param name="mx"></param>
        /// <param name="mx2"></param>
        private void CalSpringMtrlCol(SqlCommand cmd, u_dept dept, u_bednetmx mx, u_bednetmx_spring mx2)
        {
            AddDictKeyValue("【弹簧排列个数-宽】", mx.spring_qty_width);
            AddDictKeyValue("【弹簧排列个数-长】", mx.spring_qty_length);
            AddDictKeyValue("【弹簧计算个数(宽)】", mx.spring_qty_width);
            AddDictKeyValue("【弹簧计算个数(长)】", mx.spring_qty_length);
            AddDictKeyValue("【边铁条数】", mx.side_iron_qty);
            AddDictKeyValue("【条数】", mx.side_iron_qty);

            var spring = new u_spring() { springid = mx.springid };
            DbSqlHelper.SelectOne(cmd, spring, "line_diameter,gram_weight");

            spring.gram_weight /= 1000;
            if (spring.gram_weight > 0)
            {
                AddDictKeyValue("【弹簧重/个】", spring.gram_weight);
                AddDictKeyValue("【弹簧重】", spring.gram_weight);
            }

            cmd.CommandText = @"SELECT TOP 1 isnull(u_mtrl_price_pricelist.price, 0) AS price
                                FROM u_mtrl_price_pricelist
                                INNER JOIN u_mtrl_price ON u_mtrl_price.mtrlid = u_mtrl_price_pricelist.mtrlid
                                WHERE cast(u_mtrl_price.name AS DECIMAL(18, 5)) = @line_diameter
	                                AND u_mtrl_price.mtrltype = 0
	                                AND u_mtrl_price_pricelist.pricelistid = @pricelistid";
            cmd.Parameters.Clear();
            cmd.Parameters.AddWithValue("@line_diameter", spring.line_diameter);
            cmd.Parameters.AddWithValue("@pricelistid", dept.pricelistid);
            decimal price = 0;
            using (var reader = cmd.ExecuteReader())
            {
                if (reader.Read())
                {
                    price = Convert.ToDecimal(reader["price"]);

                    price /= 1000;
                }
            }

            if (price > 0)
            {
                AddDictKeyValue("【弹簧单价】", price);
            }
        }

        /// <summary>
        /// 代码对照wf_replace_var_dw2
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="mx"></param>
        private void CalSpringMtrlCol2(SqlCommand cmd, u_bednet bednet, u_bednetmx mx, u_dept dept, string type)
        {
            var spring = new u_spring() { springid = mx.springid };
            DbSqlHelper.SelectOne(cmd, spring, "line_diameter,gram_weight,center_diameter");

            #region 计算 底面无纺布 开始
            //计算 上下无纺布方数 =(B4+C4)*(B4+D4)/10000
            if ("底面无纺布".Equals(type) && mx.fabrics2_mtrlid > 0)
            {
                decimal fabrics = (mx.bednet_height.Value + bednet.mattress_width.Value) * (mx.bednet_height.Value + bednet.mattress_length.Value) / 10000;
                AddDictKeyValue("【上下无纺布方数】", fabrics);

                decimal fabrics_price = getMtrlPrice(cmd, 2, dept.pricelistid, mx.fabrics2_mtrlid.Value);
                if (fabrics_price > 0) AddDictKeyValue("【无纺布单价】", fabrics_price);
            }
            #endregion 计算 底面无纺布 结束

            #region 计算 入袋无纺布 开始
            //计算 入袋无纺布方数 = (B4+I4+2)*((I4*3.14)+1)/10000
            if ("入袋无纺布".Equals(type) && mx.fabrics1_mtrlid > 0)
            {
                decimal fabrics = (mx.bednet_height.Value + spring.center_diameter.Value + 2) * (spring.center_diameter.Value * (decimal)3.14 + 1) / 10000;
                AddDictKeyValue("【入袋无纺布方数】", fabrics);

                decimal fabrics_price = getMtrlPrice(cmd, 2, dept.pricelistid, mx.fabrics1_mtrlid.Value);
                if (fabrics_price > 0) AddDictKeyValue("【无纺布单价】", fabrics_price);
            }
            #endregion 计算 入袋无纺布 结束

            #region 计算 四周加硬弹簧 开始
            // 主要是要替换  【弹簧克重】   【弹簧单价】
            // 因相同部分已存在，不需要后续
            #endregion 计算 四周加硬弹簧 结束

            #region 计算 海绵包边 开始
            if ("海绵包边".Equals(type) && bednet.sponge_thickness.Value > 0 && bednet.sponge_mtrlid.Value > 0)
            {
                var mtrl_price = new u_mtrl_price() { mtrlid = bednet.sponge_mtrlid };
                DbSqlHelper.SelectOne(cmd, mtrl_price, "name");

                AddDictKeyValue("【物料名称】", mtrl_price.name);

                AddDictKeyValue("【裥棉厚度】", bednet.sponge_thickness.Value);
                AddDictKeyValue("【海绵厚度】", bednet.sponge_thickness.Value);

                if (bednet.sponge_height.Value > 0)
                {
                    AddDictKeyValue("【海绵高】", bednet.sponge_height.Value);
                }

                cmd.CommandText = @"SELECT isnull(u_mtrl_price_pricelist.price, 0) AS price
                                    FROM u_mtrl_price_pricelist
                                    WHERE u_mtrl_price_pricelist.mtrlid = @mtrlid
	                                    AND u_mtrl_price_pricelist.pricelistid = @pricelistid";
                cmd.Parameters.Clear();
                cmd.Parameters.AddWithValue("@mtrlid", bednet.sponge_mtrlid);
                cmd.Parameters.AddWithValue("@pricelistid", dept.pricelistid);
                using (var reader = cmd.ExecuteReader())
                {
                    if (reader.Read())
                    {
                        decimal sponge_price = Convert.ToDecimal(reader["price"]);

                        AddDictKeyValue("【裥棉单价】", sponge_price);
                        AddDictKeyValue("【海绵单价】", sponge_price);
                    }
                }
            }
            #endregion 计算 海绵包边 结束

            #region 计算 填充海绵 开始
            if ("填充海绵".Equals(type) && bednet.sponge_tc_thickness.Value > 0 && bednet.sponge_tc_mtrlid.Value > 0)
            {
                var mtrl_price = new u_mtrl_price() { mtrlid = bednet.sponge_tc_mtrlid };
                DbSqlHelper.SelectOne(cmd, mtrl_price, "name");

                AddDictKeyValue("【物料名称】", mtrl_price.name);

                AddDictKeyValue("【裥棉厚度】", bednet.sponge_tc_thickness.Value);
                AddDictKeyValue("【海绵厚度】", bednet.sponge_tc_thickness.Value);

                if (bednet.sponge_tc_height.Value > 0)
                {
                    AddDictKeyValue("【海绵高】", bednet.sponge_tc_height.Value);
                }

                cmd.CommandText = @"SELECT isnull(u_mtrl_price_pricelist.price, 0) AS price
                                    FROM u_mtrl_price_pricelist
                                    WHERE u_mtrl_price_pricelist.mtrlid = @mtrlid
	                                    AND u_mtrl_price_pricelist.pricelistid = @pricelistid";
                cmd.Parameters.Clear();
                cmd.Parameters.AddWithValue("@mtrlid", bednet.sponge_tc_mtrlid);
                cmd.Parameters.AddWithValue("@pricelistid", dept.pricelistid);
                using (var reader = cmd.ExecuteReader())
                {
                    if (reader.Read())
                    {
                        decimal sponge_price = Convert.ToDecimal(reader["price"]);

                        AddDictKeyValue("【裥棉单价】", sponge_price);
                        AddDictKeyValue("【海绵单价】", sponge_price);
                    }
                }
            }
            #endregion 计算 填充海绵 结束

            #region 计算 封边 开始
            if ("封边".Equals(type) && bednet.edge_mtrlid > 0)
            {
                AddDictKeyValue("【有边铁】", mx.if_side_iron);

                cmd.CommandText = @"SELECT isnull(u_mtrl_price_pricelist.price, 0) AS price
	                                    ,u_mtrl_price.gram_weight
                                    FROM u_mtrl_price_pricelist
                                    INNER JOIN u_mtrl_price ON u_mtrl_price.mtrlid = u_mtrl_price_pricelist.mtrlid
                                    WHERE u_mtrl_price_pricelist.mtrlid = @mtrlid
	                                    AND u_mtrl_price_pricelist.pricelistid = @pricelistid";
                cmd.Parameters.Clear();
                cmd.Parameters.AddWithValue("@mtrlid", bednet.edge_mtrlid);
                cmd.Parameters.AddWithValue("@pricelistid", dept.pricelistid);
                using (var reader = cmd.ExecuteReader())
                {
                    if (reader.Read())
                    {
                        decimal edge_price = Convert.ToDecimal(reader["price"]);
                        decimal edge_weight = Convert.ToDecimal(reader["gram_weight"]);

                        if (edge_price > 0) AddDictKeyValue("【毡单价】", edge_price);
                        if (edge_weight > 0) AddDictKeyValue("【毡克重】", edge_weight);
                    }
                }

                if (bednet.edge_height > 0) AddDictKeyValue("【封边高】", bednet.edge_height);
            }
            #endregion 计算 封边 结束

            #region 计算 上垫层 开始
            if ("上垫层".Equals(type) && bednet.felt_mtrlid > 0)
            {
                cmd.CommandText = @"SELECT isnull(u_mtrl_price_pricelist.price, 0) AS price
	                                    ,u_mtrl_price.gram_weight
                                    FROM u_mtrl_price_pricelist
                                    INNER JOIN u_mtrl_price ON u_mtrl_price.mtrlid = u_mtrl_price_pricelist.mtrlid
                                    WHERE u_mtrl_price_pricelist.mtrlid = @mtrlid
	                                    AND u_mtrl_price_pricelist.pricelistid = @pricelistid";
                cmd.Parameters.Clear();
                cmd.Parameters.AddWithValue("@mtrlid", bednet.felt_mtrlid);
                cmd.Parameters.AddWithValue("@pricelistid", dept.pricelistid);
                using (var reader = cmd.ExecuteReader())
                {
                    if (reader.Read())
                    {
                        decimal felt_price = Convert.ToDecimal(reader["price"]);
                        decimal felt_weight = Convert.ToDecimal(reader["gram_weight"]);

                        if (felt_price > 0) AddDictKeyValue("【垫层物料单价】", felt_price);
                        if (felt_weight > 0) AddDictKeyValue("【垫层物料克重】", felt_weight);
                    }
                }

                if (bednet.felt_qty > 0) AddDictKeyValue("【垫层物料数量】", bednet.felt_qty);
            }
            #endregion 计算 上垫层 结束

            #region 计算 下垫层 开始
            if ("下垫层".Equals(type) && bednet.felt_x_mtrlid > 0)
            {
                cmd.CommandText = @"SELECT isnull(u_mtrl_price_pricelist.price, 0) AS price
	                                    ,u_mtrl_price.gram_weight
                                    FROM u_mtrl_price_pricelist
                                    INNER JOIN u_mtrl_price ON u_mtrl_price.mtrlid = u_mtrl_price_pricelist.mtrlid
                                    WHERE u_mtrl_price_pricelist.mtrlid = @mtrlid
	                                    AND u_mtrl_price_pricelist.pricelistid = @pricelistid";
                cmd.Parameters.Clear();
                cmd.Parameters.AddWithValue("@mtrlid", bednet.felt_x_mtrlid);
                cmd.Parameters.AddWithValue("@pricelistid", dept.pricelistid);
                using (var reader = cmd.ExecuteReader())
                {
                    if (reader.Read())
                    {
                        decimal felt_price = Convert.ToDecimal(reader["price"]);
                        decimal felt_weight = Convert.ToDecimal(reader["gram_weight"]);

                        if (felt_price > 0) AddDictKeyValue("【垫层物料单价】", felt_price);
                        if (felt_weight > 0) AddDictKeyValue("【垫层物料克重】", felt_weight);
                    }
                }

                if (bednet.felt_x_qty > 0) AddDictKeyValue("【垫层物料数量】", bednet.felt_x_qty);
            }
            #endregion 计算 下垫层 结束
        }

        private void CalSnakeCol(SqlCommand cmd, u_spring spring, u_dept dept)
        {
            #region 替换蛇线单价  snake_wire_diameter
            cmd.CommandText = @"SELECT TOP 1 isnull(u_mtrl_price_pricelist.price, 0) AS price
                                FROM u_mtrl_price_pricelist
                                INNER JOIN u_mtrl_price ON u_mtrl_price.mtrlid = u_mtrl_price_pricelist.mtrlid
                                WHERE cast(u_mtrl_price.name AS DECIMAL(18, 5)) = @line_diameter
	                                AND u_mtrl_price.mtrltype = 0
	                                AND u_mtrl_price_pricelist.pricelistid = @pricelistid";
            cmd.Parameters.Clear();
            cmd.Parameters.AddWithValue("@line_diameter", spring.line_diameter);
            cmd.Parameters.AddWithValue("@pricelistid", dept.pricelistid);
            decimal price = 0;
            using (var reader = cmd.ExecuteReader())
            {
                if (reader.Read())
                {
                    price = Convert.ToDecimal(reader["price"]);

                    price /= 1000;
                }
            }

            if (price > 0)
            {
                AddDictKeyValue("【蛇线单价】", price);
            }

            AddDictKeyValue("【蛇线重量】", 0.39);
            #endregion
        }

        private decimal getMtrlPrice(SqlCommand cmd, int mtrltype, int pricelistid, int mtrlid)
        {
            decimal price = 0;
            cmd.CommandText = @"SELECT TOP 1 isnull(u_mtrl_price_pricelist.price, 0) AS price
                                FROM u_mtrl_price_pricelist
                                INNER JOIN u_mtrl_price ON u_mtrl_price.mtrlid = u_mtrl_price_pricelist.mtrlid
                                WHERE u_mtrl_price.mtrlid = @mtrlid
	                                AND u_mtrl_price.mtrltype = @mtrltype
	                                AND u_mtrl_price_pricelist.pricelistid = @pricelistid";
            cmd.Parameters.Clear();
            cmd.Parameters.AddWithValue("@mtrlid", mtrlid);
            cmd.Parameters.AddWithValue("@mtrltype", mtrltype);
            cmd.Parameters.AddWithValue("@pricelistid", pricelistid);
            using (var reader = cmd.ExecuteReader())
            {
                if (reader.Read())
                {
                    price = Convert.ToDecimal(reader["price"]);

                    price /= 1000;
                }
            }

            return price;
        }
    }
}