# YoursLC有源低代码

**Repository Path**: crab34/your-lc-active-low-code

## Basic Information

- **Project Name**: YoursLC有源低代码
- **Description**: 让简单的事情保持简单，让复杂的事情成为可能。
既是零代码也是低代码还是全代码，十倍以上提高开发效率并且可以任意扩展
讨论交流QQ群（937494747）
- **Primary Language**: C#
- **License**: MIT
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 147
- **Created**: 2023-09-25
- **Last Updated**: 2023-09-25

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# YoursLC有源低代码

#### V1.9.8更新 20230831

- 可生成一行三列、一行四列录入表样式
- 可以从外部数据库取数（数据规范、生成统计表等），目前只支持mysql、sqlserve、pg、oracle数据库，今后将适配更多数据库
- ......
- 修复了已知bug，部分功能做了优化

 **备注：本次发布，只支持mysql数据库，因时间关系sqlserver数据库还未做适配** 


#### 软件架构
基于net6 MVC + Dapper + LayUI + jquery，支持mysql、sqlserver数据库


#### 帮助

- 帮助文档 https://gitee.com/think9/your-lc-active-low-code/wikis/pages

- YoursLc有源低代码搭建进销存(一)-哔哩哔哩 https://www.bilibili.com/video/BV16k4y1p7Do/
- YoursLc有源低代码搭建进销存(二)-哔哩哔哩 https://www.bilibili.com/video/BV1aV4y127sN/
- YoursLC快速搭建统计报表 https://www.bilibili.com/video/BV12v4y1X7Xq/
- YoursLC简介 https://www.bilibili.com/video/BV18N4y177xx/
- YoursLC快速搭建web应用 https://www.bilibili.com/video/BV1bW4y127os/


#### 介绍
yours你们的、LC是低代码low-code的缩写，中文名称：有源低代码。满足用户高效率、低成本和个性化的需求。YoursLC既是零代码也是低代码还是全代码，几十倍提高效率可以任意扩展，产品无代码搭建了进销存Demo，包括数据规范、数据回写、数据读取等，都是无代码实现，一键可生成全代码。

YoursLC有源低代码有如下特点：

- 共同协作：业务人员当零代码用开发人员做全代码开发，减少沟通成本提高协作效率
- 提升效率：可提高十倍以上开发效率
- 任意扩展：不同于多数低代码工具，我们产品可以任意修改任意扩展
- 用户可控：涉及自定义功能模块运行的代码100%开源
- 简单灵活：操作简单，生成的代码易懂易修改


产品分为两个版本，开发版及发布版

- **发布版可在windows系统直接运行，使用发布版可搭建web应用（即零代码实现）** ，发布版不能修改源代码及调试代码。文件夹“YoursLC发布版-可独立运行”即是发布版；
- 开发版需使用vs2019及以上版本打开，可以搭建web应用、修改源码和调试代码；
-  **开发版使用发布模式无需替换代码也能按照最新设置运行程序，可查看运行效果，最后一键生成源码，然后再启用调式模式进行代码调试和修改** ，如此可大大提高开发效率


#### 功能截图
【数据规范】为录入表指标指定数据规范，可实现自动填写（为文本框赋值）、选择输入（为下拉框、弹出选择设置数据源），包括自动编号、单列选择、多列选择、树形选择
![输入图片说明](image001.png)
【录入指标】录入表的录入项，对应数据表的字段和实体类属性。定义录入表（主表）需首先定义录入指标
![输入图片说明](image002.png)
【自定义录入表步骤】 1：新建主表；2：为主表添加指标并设置指标属性及数据规范；3：为主表添加子表(可选)；4：创建数据表；5：设置自定义事件、数据读取、页面按钮等...；6：表单设计；7：为录入表添加菜单；8：重新生成查看运行效果；9：代码生成并调试测试(需启动调试模式)；10：修改、测试并发布
![输入图片说明](image003.png)
【自定义事件】可对主表的AfterAdd、AfterEdit、AfterFinish、AfterDelete，子表的AfterGridAdd、AfterGridEdit、AfterGridDel事件进行自定义，以上事件分别在添加完成、编辑完成、删除完成后被调用；通过自定义包含参数的sql语句或调用已定义的存储过程，对数据表进行新增、编辑、删除操作，实现数据同步等目的
![输入图片说明](image004.png)
【数据读取】数据读取包括三类：1：读取单值，如选择产品后为产品名称、计量单位等控件赋值；2：读取列表值，为下拉选择赋值，如实现数据联动； 3：自动读取其他录入表数据为子表赋值（更新子表数据）
![输入图片说明](image005.png)
【表单设计】
![输入图片说明](image006.png)
【数据回写】在指定的条件下（适用范围）按照设定的规则对满足条件的录入表数据进行修改
![输入图片说明](image007.png)
【自定义统计报表】可通过两种方式创建统计表：1.基于录入表(视图)创建，统计表的列来源于录入表(视图)或自定义的统计指标；2.一般方式创建，可以自由设置统计表的单元格，单元格可以为自定义的统计指标（参数）或字符
基于录入表(视图)创建，需为统计表指定显示列、查询字段和排序字段等；一般方式创建统计表步骤： 1.新建统计表； 2.编辑行列--将单元格设置为自定义的统计指标或字符（如果统计指标包含条件参数需为条件参数赋值）； 3.定义动态行，实现行统计表行的自增长； 4.定义查询参数(非必须)； 5：为统计表添加菜单；6：【启动发布模式】查看效果；7：代码生成并调试测试(需【启动调试模式】)
统计表基于rdlc报表创建，可使用rdlc报表编辑器在数据列表上添加各类图表
![输入图片说明](image008.png)
【重新生成】重新生成后，将自动【启动发布模式】，【启动发布模式】无需替换代码也能按照最新设置运行程序
![输入图片说明](image009.png)
【生成代码并下载】下载后，参看说明将文件按要求放置，并启动调试模式，【启动调试模式】可使用代码调式功能
![输入图片说明](image010.png) 

#### 生成的代码(无手写)
以下代码全部自动生成，无一行手写

```
/*******************************************************************************
 * Creator:admin 2023-08-01 11:22:45
 * Description: YoursLC有源低代码
*********************************************************************************/

using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc;
using Think9.Controllers.Basic;
using Think9.Models;
using Think9.Services.Base;
using Think9.Services.Basic;
using Think9.Services.Com;
using Think9.Services.CodeBuild;

namespace Think9.Controllers.CodeBuild
{
    public class WarehousingOfGoodsController : BaseController
    {
        private WarehousingOfGoodsService tbWarehousingOfGoods = new WarehousingOfGoodsService();
	private WarehousingDetailsService gridWarehousingDetails = new WarehousingDetailsService();//子表
        private ComService comService = new ComService();
        private readonly string _maintbid = "tb_WarehousingOfGoods";//主表编码
        private readonly string _flowid = "bi_WarehousingOfGoods";//流程编码 bi_基础信息 fw_一般录入表
        private readonly string _tbname = "货品入库";//录入表名称
        private readonly string _split = Think9.Services.Base.BaseConfig.ComSplit;//多选项的字符分割
        private string str;

        #region list列表页面
        /// <summary>
        /// 调试模式下点击左侧菜单触发，菜单路径为主表编码去除tb_前缀
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public override ActionResult Index(int? id)
        {
            string err = CheckCom.CheckedBeforeBegin(_flowid);//检查数据库是否建表等
            if (string.IsNullOrEmpty(err))
            {
                object param = BasicHelp.GetParamObject(CurrentUser);//系统参数可作为数据规范的条件参数
                ViewBag.SelectList = tbWarehousingOfGoods.GetSelectList("list", param);//为查询条件(下拉选择)准备动态数据
                ViewBag.SearchMode = BasicHelp.GetSearchMode(_flowid);//查看编辑模式-录入表管理/权限设置可设置
                //禁用按钮字符，格式[butid1][butid2]，用于按钮权限控制，录入表管理/页面按钮可设置
                ViewBag.DisableBut = tbWarehousingOfGoods.GetDisableButStr("list", CurrentUser);

                return base.Index(id);
            }
            else
            {
                return Json(err);
            }
        }

        /// <summary>
        /// 添加前判断及处理，列表页面点击新增数据按钮触发
        /// </summary>
        /// <param name="type">类型add</param>
        /// <param name="listid">基础信息表自增长，一般录入表对应flowrunlist中的listid</param>
        /// <returns></returns>
        [HttpPost]
        public ActionResult BeforeAdd(string type, string listid)
        {
            string err = "";
            long newid = 0;//自动编号及子表数据初始化等情况需插入空数据并返回自增长id
            try
            {
                CurrentPrcsEntity mPrcs = FlowCom.GetFistStept(_flowid);//得到步骤第一步，基本信息表返回空
                err = mPrcs == null ? "" : mPrcs.ERR;
                if (string.IsNullOrEmpty(err))
                {
                    err = CheckCom.CheckedBeforeAdd(_flowid, mPrcs, CurrentUser);//添加前检测
                    if (string.IsNullOrEmpty(err))
                    {
                        newid = tbWarehousingOfGoods.BeforeAdd(ref err, mPrcs, CurrentUser);//添加前处理

                    }
                }
                if (string.IsNullOrEmpty(err))
                {
                    string pid = mPrcs == null ? "-1" : mPrcs.PrcsId;//当前流程步骤id
                    return Json(SuccessTip("", newid.ToString(), pid));//将当前listid及当前流程步骤id返回
                }
                else
                {
                    return Json(ErrorTip(err));
                }
            }
            catch (Exception ex)
            {   
                Record.AddErr(newid.ToString(), _flowid, "WarehousingOfGoodsController:BeforeAdd", ex);
                return Json(ErrorTip(ex.Message));
            }
        }

        /// <summary>
        /// 编辑前判断及处理，列表页面点击编辑按钮触发
        /// </summary>
        /// <param name="type">类型edit</param>
        /// <param name="listid">基础信息表自增长，一般录入表对应flowrunlist中的listid</param>
        /// <returns></returns>
        [HttpPost]
        public ActionResult BeforeEdit(string type, string listid)
        {
            string err = "";
            CurrentPrcsEntity mPrcs = FlowCom.GetCurrentStept(_flowid, listid); //当前流程步骤，基本信息表返回空
            err = mPrcs == null ? "" : mPrcs.ERR;
            if (string.IsNullOrEmpty(err))
            {
                err = CheckCom.CheckedBeforeEdit(_flowid, listid, mPrcs, CurrentUser);//编辑前检测
                if (string.IsNullOrEmpty(err))
                {
                    err = tbWarehousingOfGoods.BeforeEdit(listid, mPrcs, CurrentUser);//编辑前数据处理
                }
            }
            if (string.IsNullOrEmpty(err))
            {
                string pid = mPrcs == null ? "-1" : mPrcs.PrcsId;//当前流程步骤id
                return Json(SuccessTip("", listid, pid));
            }
            else
            {
                return Json(ErrorTip(err));
            }
        }

        /// <summary>
        /// 数据查看，列表页面点击详细按钮触发
        /// </summary>
        /// <param name="listid">基础信息表自增长，一般录入表对应flowrunlist中的listid</param>
        /// <returns></returns>
        [HttpGet]
        public  ActionResult Detail(string listid)
        {
            TbBasicEntity model = PageCom.GetDetailButon(listid, _flowid);//按钮设置，可在录入表管理/页面按钮中设置
            ViewBag.ListId = listid;
            ViewBag.ButPdf = model.ButPDFDetails;//Pdf是否显示 1显示
            ViewBag.ButDoc = model.ButDOCDetails;//DOC是否显示 1显示
            ViewBag.ButExcel = model.ButExcelDetails;//Excel是否显示 1显示
            ViewBag.ButAtt = model.ButAtt;//附件按钮是否显示 1显示
            ViewBag.ButAttTxt = model.ButAttTxt;//附件按钮标题
            ViewBag.UserId = CurrentUser == null ? "!undefined" : CurrentUser.Account;

            return View();
        }

        /// <summary>
        /// 导出EXCEL,点击导出按钮触发
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public ActionResult ExportData(string json)
		{
		    string err = "";
                    string newFileName = System.Guid.NewGuid().ToString("N") + ".xlsx";
                    string sourcePath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot\\TempFile\\" + newFileName);
                    WarehousingOfGoodsModel model = tbWarehousingOfGoods.ToModel(json);
		    DataTable gridDt = tbWarehousingOfGoods.GetListForExport(model, CurrentUser);
		    RdlcDeviceEntity device = WarehousingOfGoodsService.GetRdlcDevice(gridDt);

			byte[] _byte = RDLCReport.ExportExcelList(ref err, device);
            if (!string.IsNullOrEmpty(err))
			{
				return Json(ErrorTip(err));
			}
            Think9.Util.Helper.FileHelper.CreateFile(sourcePath, _byte);
			string url = "<br><br><div class=\"layui-form-item\" style=\"text-align: center;width: 200px;\"><a href='../TempFile/" + newFileName + "' target ='_blank' class='layui-btn'>点击下载</a></div>";
            return Json(SuccessTip("", url));
		}

        /// <summary>
        /// 批量导出pdf，列表页面点击批量导出按钮触发
        /// </summary>
        /// <param name="idsStr">listid逗号间隔</param>
        /// <returns></returns>
        public JsonResult MergeExport(string idsStr)
        {
            string err = "";
            string directory = Directory.GetCurrentDirectory();
            string sourcePath = Path.Combine(directory, "wwwroot\\TempFile\\" + System.Guid.NewGuid().ToString("N") + "\\");
            Think9.Util.Helper.FileHelper.CreateSuffic(sourcePath);
            string pdfFileName = System.Guid.NewGuid().ToString("N") + ".pdf";

            string[] arr = BaseUtil.GetStrArray(idsStr, ",");
            for (int i = 0; i < arr.GetLength(0); i++)
            {
                if (arr[i] != null)
                {
                    string listid = arr[i].ToString().Trim();
                    RdlcDeviceEntity device = WarehousingOfGoodsService.GetRdlcDevice(listid);
                    byte[] _byte = RDLCReport.ExportPdf(ref err, device);
                    Think9.Util.Helper.FileHelper.CreateFile(sourcePath + "\\" + listid + ".pdf", _byte);
                }
            }
            PdfService.MergePDF(sourcePath, Path.Combine(directory, "wwwroot\\TempFile\\"), pdfFileName);
            string url = "<br><br><div class=\"layui-form-item\" style=\"text-align: center;width: 200px;\"><a href='../TempFile/" + pdfFileName + "' target ='_blank' class='layui-btn'>点击下载</a></div>";
            return Json(SuccessTip("", url));
        }

        /// <summary>
        /// 查看详细，列表页面点击详细按钮触发，将rdlc模板填充数据后转化为pdf等
        /// </summary>
        /// <param name="type">类别pdf、doc、excel</param>
        /// <param name="listid">基础信息表自增长，一般录入表对应flowrunlist中的listid</param>
        /// <returns></returns>
        [HttpGet]
        public ActionResult GetDetail(string type, string listid)
        {
            string err = "";
            listid = ListIdService.GetOriginalListId(listid).ToString();
            FileContentResult file = null;
            RdlcDeviceEntity device = WarehousingOfGoodsService.GetRdlcDevice(listid);
            if (!string.IsNullOrEmpty(device.Err))
            {
                return Json(ErrorTip(device.Err));
            }

            if (type == "html" || type == "_html")
            {
                byte[] _byte = RDLCReport.ExportHtml(ref err, device);
                file = File(_byte, "text/html");
            }
            if (type == "pdf")
            {
                //device.width默认22cm，device.heigh默认29.7cm,可传入其他值，以适应不同文档和打印尺寸
                byte[] _byte = RDLCReport.ExportPdf(ref err, device);
                file = File(_byte, "application/pdf");
            }
            if (type == "doc")
            {
                byte[] _byte = RDLCReport.ExportDocx(ref err, device);
                file = File(_byte, "application/msword", _tbname + DateTime.Today.ToShortDateString() + ".docx");
            }
            if (type == "excel")
            {
                byte[] _byte = RDLCReport.ExportXlsx(ref err, device);
                file = File(_byte, "application/msexcel", _tbname + DateTime.Today.ToShortDateString() + ".xlsx");
            }

            if (string.IsNullOrEmpty(err))
            {
                return file;
            }
            else
            {
                return Json(ErrorTip(err));
            }
        }

        /// <summary>
        /// 数据删除（可处理软删除），列表页面点击删除按钮触发
        /// </summary>
        /// <param name="listid">基础信息表自增长，一般录入表对应flowrunlist的listid</param>
        /// <returns></returns>
        [HttpGet]
        public JsonResult Delete(string listid)
        {
            CurrentPrcsEntity mPrcs = FlowCom.GetCurrentStept(_flowid, listid);//当前流程步骤
            string err = mPrcs == null ? "" : mPrcs.ERR;
            if (string.IsNullOrEmpty(err))
            {
                err = CheckCom.CheckedBeforeDel(_flowid, listid, mPrcs, CurrentUser);//校验 包括权限、锁定等
            }

            try
            {
                if (string.IsNullOrEmpty(err))
                {
                    err = tbWarehousingOfGoods.DelByListId(listid, CurrentUser);
                }
                if (string.IsNullOrEmpty(err))
                {
                    Record.Add(CurrentUser == null ? "!undefined" : CurrentUser.Account, listid, _flowid, "#删除数据#");
                    return Json(SuccessTip("删除成功"));
                }
                else
                {
                    return Json(ErrorTip(err));
                }
            }
            catch (Exception ex)
            {
                Record.AddErr(listid, _flowid, "WarehousingOfGoodsController:Delete", ex);
                return Json(ErrorTip(ex.Message));
            }
        }

        /// <summary>
        /// 批量删除，列表页面点击批量删除按钮触发
        /// </summary>
        /// <param name="idsStr">listid逗号间隔</param>
        /// <returns></returns>
        [HttpPost]
        public JsonResult BatchDel(string idsStr)
        {
            string err = "";
            string showErr = "";
            int numSuccess = 0;
            int numFail = 0;
            string listid = "";
            string[] arr = BaseUtil.GetStrArray(idsStr, ",");
            try
            {
                for (int i = 0; i < arr.GetLength(0); i++)
                {
                    if (arr[i] != null)
                    {
                        listid = arr[i].ToString().Trim();
                        CurrentPrcsEntity mPrcs = FlowCom.GetCurrentStept(_flowid, listid);//当前流程步骤
                        err = mPrcs == null ? "" : mPrcs.ERR;
                        if (string.IsNullOrEmpty(err))
                        {
                            err = CheckCom.CheckedBeforeDel(_flowid, listid, mPrcs, CurrentUser);//检测
                            if (string.IsNullOrEmpty(err))
                            {
                                err = tbWarehousingOfGoods.DelByListId(listid, CurrentUser);
                                if (string.IsNullOrEmpty(err))
                                {
                                    numSuccess++;
                                }
                                else
                                {
                                    showErr += err;
                                    numFail++;
                                }
                            }
                            else
                            {
                                numFail++;
                            }
                        }
                        else
                        {
                            numFail++;
                        }
                    }
                }
                if (string.IsNullOrEmpty(showErr))
                {
                    str = numFail == 0 ? "删除成功" + numSuccess.ToString() + "数据" : "删除成功" + numSuccess + "数据;" + "因数据无效、锁定、权限校验等原因，删除失败" + numFail.ToString() + "数据;";
                    return Json(SuccessTip(str));
                }
                else
                {
                    return Json(ErrorTip(showErr));
                }
            }
            catch (Exception ex)
            {
                Record.AddErr(listid, _flowid, "WarehousingOfGoodsController:BatchDel", ex);
                return Json(ErrorTip(ex.Message));
            }
        }

        /// <summary>
        /// 数据查询，列表页面点击查询按钮触发
        /// </summary>
        /// <param name="model">封装查询条件</param>
        /// <param name="pageInfo">页面信息，包括行数、排序等</param>
        /// <param name="isAll">为all显示所有</param>
        /// <returns></returns>
        [HttpPost]
        public JsonResult GetPageList(WarehousingOfGoodsModel model, PageInfoEntity pageInfo, string isAll)
        {
            if (CurrentUser == null)
            {
                return Json(new { msg = "<span style='color: #FE7300;'>超时 请重新登录</span>", count = -1 });
            }
            pageInfo.field = "listid";//添加次序倒序
            pageInfo.order = "desc";
            long total = 0;
            try
            {
                List<dynamic> list = tbWarehousingOfGoods.GetListForPage(ref total, model, pageInfo, CurrentUser, isAll);
                if (list == null)
                {
                    return Json(new { msg = "<span style='color: #FE7300;'>参数错误</span>", count = -1 });
                }
                else
                {
                    var result = new { code = 0, msg = "", count = total, data = list };
                    return Json(result);
                }
            }
            catch (Exception ex)
            {
                Record.AddErr("", _flowid, "WarehousingOfGoodsController:GetPageList", ex);
                return Json(new { msg = ex.Message, count = -1 });
            }
        }

        /// <summary>
        /// 数据导入，点击数据导入按钮触发
        /// </summary>
        /// <param name="fwid"></param>
        /// <param name="filename">文件名</param>
        /// <param name="list">源字段与目标字段的对应列表</param>
        /// <returns></returns>
        [HttpPost]
        public ActionResult ImportData(string fwid, string filename, List<InfoListEntity> list)
        {
            string err = "";
            string listidsStr = "";
            string msg = "";
            string timeBegin = DateTime.Now.ToString();
            if (CurrentUser == null)
            {
                return Json(ErrorTip("当前用户对象为空"));
            }
            try
            {
                ExcelData excelData = new ExcelData();
                err = excelData.ImportDataFromExcel(ref listidsStr, ref msg, fwid, filename, list, CurrentUser);
                if (!string.IsNullOrEmpty(err))
                {
                    return Json(ErrorTip(err));
                }
                else
                {
                    var resultList = tbWarehousingOfGoods.BatchAfterAdd(ref err, listidsStr, CurrentUser);//添加后数据处理
                    if (!string.IsNullOrEmpty(err))
                    {
                        return Json(ErrorTip(err));
                    }
                    msg = timeBegin + " - " + DateTime.Now.ToString() + " " + msg;
                    return Json(SuccessTip(msg));
                }
            }
            catch (Exception ex)
            {
                Record.AddErr("", _flowid, "WarehousingOfGoodsController:ImportData", ex);
                return Json(ErrorTip(ex.Message));
            }
        }
        #endregion list列表页面

        #region Form编辑页面
        /// <summary>
        /// 录入页面显示
        /// </summary>
        /// <param name="frm">从哪里跳转来的(默认list)：list页面或其他页面跳转，前端依据该值可区别处理</param>
        /// <param name="type">add或edit</param>
        /// <param name="listid">基础信息表自增长，一般录入表与flowrunlist中的listid对应关联</param>
        /// <param name="pid">当前流程步骤id</param>
        /// <returns></returns>
        [HttpGet]
        public ActionResult Form(string frm, string type, string listid, string pid)
        {
            long newid = 0;
            object param = BasicHelp.GetParamObject(CurrentUser);//数据规范中的筛选条件可使用系统参数
            ViewBag.SelectList = tbWarehousingOfGoods.GetSelectList(type, param);//为下拉选择、多选组件选项赋值
            ViewBag.UserId = CurrentUser == null ? "!undefined" : CurrentUser.Account;//当前用户id
            ViewBag.Split = _split;//字符分割，checkbox多选时使用
            ViewBag.FId = _flowid;//流程编码
            //禁用按钮字符，格式[butid1][butid2]，用于按钮权限控制，录入表管理/页面按钮可设置
            ViewBag.DisableBut = tbWarehousingOfGoods.GetDisableButStr("form", CurrentUser);

            ViewBag.Frm = string.IsNullOrEmpty(frm) ? "list" : frm;//list页面和其他页面跳转，前端可区分处理
            if (ViewBag.Frm == "list")
            {
                newid = listid == null ? 0 : long.Parse(listid);
                ViewBag.PrcId = pid;//流程步骤id
                ViewBag.PrcNo = FlowCom.GetFlowNoByID(_flowid, pid);//流程步骤编码
                ViewBag.Type = type;//add或edit
                ViewBag.ListId = newid;
            }
            else
            {
                CurrentPrcsEntity mPrcs = FlowCom.GetFistStept(_flowid);//得到步骤第一步
                string err = mPrcs == null ? "" : mPrcs.ERR;
                if(!string.IsNullOrEmpty(err))
                {
                    return Json(err);
                }
                err = CheckCom.CheckedBeforeAdd(_flowid, mPrcs, CurrentUser);//添加前检测
                if (!string.IsNullOrEmpty(err))
                {
                    return Json(err);
                }
                //添加前处理，如自动编号及子表数据初始化等--主表需插入一条空数据
                newid = tbWarehousingOfGoods.BeforeAdd(ref err, mPrcs, CurrentUser);
                if (!string.IsNullOrEmpty(err))
                {
                    return Json(err);
                }

                ViewBag.PrcId = mPrcs == null ? "-1" : mPrcs.PrcsId;//当前流程步骤id
                ViewBag.PrcNo = FlowCom.GetFlowNoByID(_flowid, ViewBag.PrcId);//流程步骤编码
                ViewBag.Type = "add";
                ViewBag.ListId = newid;
            }

            //包括为录入指标赋初始值--系统指标或默认值
            WarehousingOfGoodsModel model = tbWarehousingOfGoods.GetModel(type, newid, CurrentUser);
            if (model != null)
            {
                return View(model);
            }
            else
            {
                return Json("数据不存在");
            }
        }

        /// <summary>
        /// 数据保存，Form页面点击保存按钮触发
        /// </summary>
        /// <param name="model">主表数据</param>
        /// <param name="gridlist">子表数据</param>
        /// <param name="listid">listid=0表示增加</param>
        /// <param name="prcno">流程步骤编码</param>
        /// <param name="type">add或edit</param>
        /// <param name="att">附件id</param>
        /// <returns></returns>
        [HttpPost]
        public ActionResult SaveData(WarehousingOfGoodsModel model, IEnumerable<GridListEntity> gridlist, long listid, string prcno, string type, string att)
        {
            string err = "";

            try
            {
                if (listid != 0)//编辑
                {
                    err = this.Edit(model, gridlist, listid, prcno);//编辑主子表数据，调用子表的AfterGridEdit事件
                }
                else
                {
                    listid = this.Add(ref err, prcno, model);//添加主表数据

                }
				if (string.IsNullOrEmpty(err) && type == "add")
				{
					AttachmentService.UpdateAttachmentId(listid, _flowid, att);//处理listid=0时添加了附件
				}
                if (string.IsNullOrEmpty(err))
                {
                    List<string> resultList = type == "add" ? tbWarehousingOfGoods.AfterAdd(ref err, listid.ToString(), CurrentUser, model) : tbWarehousingOfGoods.AfterEdit(ref err, listid.ToString(), prcno, CurrentUser, model);//自定义事件
                    string _type = type == "add" ? "自定义事件AfterAdd" : "自定义事件AfterEdit";
                    Record.AddResultList("system", listid.ToString(), _flowid, resultList, _type);
                    if(!string.IsNullOrEmpty(err))
                    {
                        return Json(ErrorTip("自定义事件出现错误：" + err));
                    }

                    resultList = tbWarehousingOfGoods.WriteBackData(ref  err, listid.ToString(),  "edit", CurrentUser,  model);//数据回写
                    Record.AddResultList("system", listid.ToString(), _flowid, resultList, "#数据回写#");
                    if (!string.IsNullOrEmpty(err))
                    {
                       return Json(ErrorTip("数据回写出现错误：" + err));
                    }

                    return Json(SuccessTip("操作成功"));
                }
                else
                {
                    return Json(ErrorTip("操作失败！<br>" + err));
                }
            }
            catch (Exception ex)
            {
                Record.AddErr(listid.ToString(), _flowid, "WarehousingOfGoodsController:SaveData", ex);
                return Json(ErrorTip(ex.Message));
            }
        }

        /// <summary>
        /// 转交下一步--保存数据并流程转交，点击转交按钮触发
        /// </summary>
        /// <param name="model">主表数据model</param>
        /// <param name="gridlist">子表数据列表</param>
        /// <param name="listid">listid=0表示增加</param>
        /// <param name="prcno">流程步骤编码</param>
        /// <param name="type">add或edit</param>
        /// <param name="att">附件id</param>
        /// <returns></returns>
        [HttpPost]
        public ActionResult NextStep(WarehousingOfGoodsModel model, IEnumerable<GridListEntity> gridlist, long listid, string prcno, string type, string att)
        {
            string err = "";

            try
            {
                if (listid != 0)//编辑
                {
                    err = this.Edit(model, gridlist, listid, prcno);//编辑主子表数据，调用子表的AfterGridEdit事件
                }
                else
                {
                    listid = this.Add(ref err, prcno, model);//添加主表数据

                }
				if (string.IsNullOrEmpty(err) && type == "add")
				{
					AttachmentService.UpdateAttachmentId(listid, _flowid, att);//处理listid=0时添加了附件
				}
                if (string.IsNullOrEmpty(err))
                {
                    List<string> resultList = type == "add" ? tbWarehousingOfGoods.AfterAdd(ref err, listid.ToString(), CurrentUser, model) : tbWarehousingOfGoods.AfterEdit(ref err, listid.ToString(), prcno, CurrentUser, model);//自定义事件
                    string _type = type == "add" ? "自定义事件AfterAdd" : "自定义事件AfterEdit";
                    Record.AddResultList("system", listid.ToString(), _flowid, resultList, _type);
                    if (!string.IsNullOrEmpty(err))
                    {
                        return Json(ErrorTip("自定义事件出现错误：" + err));
                    }

                    resultList = tbWarehousingOfGoods.WriteBackData(ref err, listid.ToString(), "edit", CurrentUser,  model);//数据回写
                    Record.AddResultList("system", listid.ToString(), _flowid, resultList, "#数据回写#");
                    if (!string.IsNullOrEmpty(err))
                    {
                       return Json(ErrorTip("数据回写出现错误：" + err));
                    }

                    if (_flowid.StartsWith("bi_"))
                    {
                        return Json(ErrorTip("数据保存成功，基础信息表不能被转交"));
                    }
                    else
                    {
                        return Json(SuccessTip("", listid.ToString()));
                    }
                }
                else
                {
                    return Json(ErrorTip("操作失败！<br>" + err));
                }
            }
            catch (Exception ex)
            {
                Record.AddErr(listid.ToString(), _flowid, "WarehousingOfGoodsController:NextStep", ex);
                return Json(ErrorTip(ex.Message));
            }
        }

        /// <summary>
        /// 结束--保存数据并结束流程，点击结束按钮触发
        /// </summary>
        /// <param name="model">主表数据model</param>
        /// <param name="gridlist">子表数据</param>
        /// <param name="listid">listid=0表示增加</param>
        /// <param name="prcno">流程步骤编码</param>
        /// <param name="type">add或edit</param>
        /// <param name="att">附件id</param>
        /// <returns></returns>
        [HttpPost]
        public ActionResult Finish(WarehousingOfGoodsModel model, IEnumerable<GridListEntity> gridlist, long listid, string prcno, string type, string att)
        {
            if(type == "add")
            {
                return Json(ErrorTip("首次提交不能结束，请保存后再结束"));
            }
            string err = "";

            try
            {
                if (listid != 0)//编辑
                {
                    err = this.Edit(model, gridlist, listid, prcno, "finish");//编辑主子表数据，调用子表的AfterGridFinish事件
                }
                else
                {
                    listid = this.Add(ref err, prcno, model);//添加主表数据

                }
				if (string.IsNullOrEmpty(err) && type == "add")
				{
					AttachmentService.UpdateAttachmentId(listid, _flowid, att);//处理listid=0时添加了附件
				}
                if (string.IsNullOrEmpty(err))
                {
                    List<string> resultList = type == "add" ? tbWarehousingOfGoods.AfterAdd(ref err, listid.ToString(), CurrentUser, model) : tbWarehousingOfGoods.AfterFinish(ref err, listid.ToString(), prcno, CurrentUser, model);//自定义事件 完成后数据处理
                    string _type = type == "add" ? "自定义事件AfterAdd" : "自定义事件AfterFinish";
                    Record.AddResultList("system", listid.ToString(), _flowid, resultList, _type);
                    if (!string.IsNullOrEmpty(err))
                    {
                        return Json(ErrorTip("自定义事件出现错误：" + err));
                    }

                    Record.Add("system", listid.ToString(), _flowid, "#流程结束##锁定数据#");

                    resultList = tbWarehousingOfGoods.WriteBackData(ref err, listid.ToString(), "finish", CurrentUser,  model);//数据回写
                    Record.AddResultList("system", listid.ToString(), _flowid, resultList, "#数据回写#");
                    if (!string.IsNullOrEmpty(err))
                    {
                        return Json(ErrorTip("数据回写出现错误：" + err));
                    }

                    if (_flowid.StartsWith("bi_"))
                    {
                        return Json(SuccessTip("操作成功，数据已被锁定"));
                    }
                    else
                    {
                        return Json(SuccessTip("操作成功"));
                    }
                }
                else
                {
                    return Json(ErrorTip("操作失败！<br>" + err));
                }
            }
            catch (Exception ex)
            {
                Record.AddErr(listid.ToString(), _flowid, "WarehousingOfGoodsController:Finish", ex);
                return Json(ErrorTip(ex.Message));
            }
        }

        /// <summary>
        /// 点击打印按钮触发，将rdlc模板填充数据后转化pdf
        /// </summary>
        /// <param name="type">类别</param>
        /// <param name="listid">数据id</param>
        /// <returns></returns>
        [HttpGet]
        public ActionResult Print(string type, string listid)
        {
            string err = "";
            RdlcDeviceEntity device = WarehousingOfGoodsService.GetRdlcDevice(listid);
            if (string.IsNullOrEmpty(device.Err))
            {
                //device.width默认22cm，device.heigh默认29.7cm,可传入其他值，以适应不同文档和打印尺寸
                byte[] _byte = RDLCReport.ExportPdf(ref err, device);
                if (!string.IsNullOrEmpty(err))
                {
                    return Json(err);
                }
                FileContentResult file = File(_byte, "application/pdf");
                return file;
            }
            else
            {
                return Json(device.Err);
            }
        }

        /// <summary>
        /// 下拉选择或者弹出选择后触发调用，完成数据读取功能
        /// 数据读取在录入表管理/数据读取中自定义
        /// </summary>
        /// <param name="controlslist">主表控件的list，包括id与value</param>
        /// <param name="gridlist">子表数据列表</param>
        /// <param name="id"></param>
        /// <param name="tbid">_main或子表编码</param>
        /// <param name="indexid">下拉或者弹出选择(触发控件)对应的指标编码</param>
        /// <param name="value">下拉或者弹出选择(触发控件)对应的控件Value</param>
        /// <returns>返回List<ControlEntity>前端再解析</returns>
        [HttpPost]
        public ActionResult AfterControlSelect(IEnumerable<ControlEntity> controlslist, IEnumerable<GridListEntity> gridlist, string id, string tbid, string indexid, string value, string listid)
        {
            string grid = "";//子表id，子表写入数据时会修改该值，前端根据该值刷新子表数据
            string newid = listid;
            try
            {
                List<ControlEntity> list = new List<ControlEntity>();
				if (tbid == "_main")
				{
					list = tbWarehousingOfGoods.ReadValue(ref newid, ref grid, CurrentUser, controlslist, indexid, value);
				}
				if (tbid == "tb_WarehousingDetails")
				{
					list = gridWarehousingDetails.ReadValue(ref newid, ref grid, CurrentUser, controlslist, gridlist, indexid, value);
				}
                //返回的list交由前端myJS.setValueByList(lists)为控件赋值
                return Json(SuccessTip("", list, newid, grid));
            }
            catch (Exception ex)
            {
                Record.AddErr(listid, _flowid, "WarehousingOfGoodsController:AfterControlSelect", ex);
                return Json(ErrorTip(ex.Message));
            }
        }

        /// <summary>
        /// 添加主表数据,listid=0时被调用
        /// </summary>
        /// <param name="err">错误信息</param>
        /// <param name="prcno">当前流程步骤编码</param>
        /// <param name="model">主表数据</param>
        /// <returns></returns>
        private long Add(ref string err, string prcno, WarehousingOfGoodsModel model)
        {
            long listid = 0;
            DataTable dtMain = DataTableHelp.ModelToDataTable<WarehousingOfGoodsModel>(model);//model转换DataTable
            //进行主键和唯一键检测，主键和唯一键可在录入表指标属性中设置
            err = CheckCom.CheckMainTbValueBKAndUnique(listid, _maintbid, model, dtMain);
            if (string.IsNullOrEmpty(err))
            {
                //进行主表自定义校验，自定义校验可在录入表管理/录入校验中设置
                err = CheckCom.CheckMainTbValidate(dtMain, _flowid, prcno);
                if (string.IsNullOrEmpty(err))
                {
					tbWarehousingOfGoods.GetModelDefault(model, CurrentUser);
					model.runName = BaseUtil.GetRunName(CurrentUser == null ? "!undefined" : CurrentUser.Account, _flowid, _tbname, dtMain);//得到名称
					
					listid = tbWarehousingOfGoods.InsertReturnID(model);
					
					err = listid > 0 ? "" : "添加失败";
					if (string.IsNullOrEmpty(err))
					{
						Record.Add(CurrentUser == null ? "!undefined" : CurrentUser.Account, listid.ToString(), _flowid, "#新增数据#");
					}
                }
            }
            return listid;
        }

        /// <summary>
        /// 编辑主子表数据listid不为0时被调用，可处理多个子表
        /// 同时调用子表AfterGridEdit或AfterGridFinish事件
        /// </summary>
        /// <param name="model">主表数据</param>
        /// <param name="gridlist">子表数据列表</param>
        /// <param name="listid">主表自增长id：基础信息表对应主表listid，一般录入表对应表flowrunlist中的listid</param>
        /// <param name="prcno">当前流程步骤编码</param>
        /// <param name="isFinish">是否完成，确定调用AfterGridEdit或AfterGridFinish</param>
        /// <returns></returns>
        private string Edit(WarehousingOfGoodsModel model, IEnumerable<GridListEntity> gridlist, long listid, string prcno, string isFinish = "")
        {
            string err = "";
            string updateFields;//可修改字段
			List<WarehousingDetailsModel> listWarehousingDetails = WarehousingDetailsService.CheckedAndGetList(gridlist, "", listid, ref err);

            if (string.IsNullOrEmpty(err))
            {
                model.ListId = listid;

                DataTable dtMain = DataTableHelp.ModelToDataTable<WarehousingOfGoodsModel>(model);
                //主键和唯一检测，可在录入表指标属性中设置
                err = CheckCom.CheckMainTbValueBKAndUnique(listid, _maintbid, model, dtMain);
                if (string.IsNullOrEmpty(err))
                {
                    //自定义校验，可在录入表管理录入校验中设置
                    err = CheckCom.CheckTbValidate(dtMain, gridlist, _flowid, prcno);
                    if (string.IsNullOrEmpty(err))
                    {
                        //子表数据编辑
						err += gridWarehousingDetails.SaveGrid(model, gridlist, listid, prcno, isFinish);
						if (!string.IsNullOrEmpty(err))
						{
							return err;
						}


                        updateFields = WarehousingOfGoodsService.GetUpdateFields(prcno);//可修改字段
                        if(!string.IsNullOrEmpty(updateFields))
                        {

                            //编辑主表
                            err = tbWarehousingOfGoods.UpdateByWhere("where listid=" + listid + "", updateFields, model) > 0 ? "" : "编辑失败";
                        }

                        Record.Add(CurrentUser == null ? "!undefined" : CurrentUser.Account, listid.ToString(), _flowid, "#编辑数据#");
                    }
                }
            }

            return err;
        }


        #endregion Form编辑页面

        #region 子表处理
        /// <summary>
        /// 子表获取数据，前端子表table.render调用此函数
        /// </summary>
        /// <param name="tbid">子表编码</param>
        /// <param name="listid">主表数据id</param>
        /// <param name="from">add或edit，用于控制子表指标编辑时锁定</param>
        /// <returns></returns>
        [HttpGet]
        public JsonResult GetGridList(string tbid, long listid, string from)
        {
            List<dynamic> list = null;
            try
            {
				if (tbid == "tb_WarehousingDetails")
				{
					list = gridWarehousingDetails.GetGridDataByListId(CurrentUser, listid, from);
				}
                var result = new { code = 0, msg = "", count = 999999, data = list };
                return Json(result);
            }
            catch (Exception ex)
            {
                Record.AddErr(listid.ToString(), _flowid, "WarehousingOfGoodsController:GetGridList", ex);
                return Json(new { msg = ex.Message, count = -1 });
            }
        }

        /// <summary>
        /// 子表添加一条数据，点击子表列表右侧添加按钮触发
        /// </summary>
        /// <param name="controlslist">主表控件list,循环后得到model</param>
        /// <param name="list">子表数据列表（只取首行）</param>
        /// <param name="tbid">子表编码</param>
        /// <param name="listid">主表id：基础信息表对应主表listid，一般录入表对应表flowrunlist中的listid</param>
        [HttpPost]
        public ActionResult AddGrid(long listid, string tbid, IEnumerable<ControlEntity> controlslist, IEnumerable<GridListEntity> list)
        {
            string err = "";
            long newid = 0;
            try
            {
                WarehousingOfGoodsModel model = tbWarehousingOfGoods.GetModelByControlsList(controlslist);
                newid = this.AddGridItem(ref err, listid, tbid, model, list);

            }
            catch (Exception ex)
            {
                Record.AddErr(listid.ToString(), _flowid, "WarehousingOfGoodsController:AddGrid", ex);
                err += ex.Message;
            }

            if (newid > 0 && string.IsNullOrEmpty(err))
            {
                return Json(SuccessTip("操作成功", newid.ToString()));
            }
            else
            {
                return Json(ErrorTip(err));
            }
        }

        /// <summary>
        /// 子表插入空数据，点击子表列表上部新增行按钮触发
        /// </summary>
        /// <param name="controlslist">主表控件list,循环后得到model</param>
        /// <param name="grid">子表id</param>
        /// <param name="listid">主表数据id</param>
        /// <returns></returns>
        [HttpPost]
        public ActionResult AddGridNull(IEnumerable<ControlEntity> controlslist, string grid, long listid)
        {
			string err = "";
            long newid = listid;
            WarehousingOfGoodsModel model = tbWarehousingOfGoods.GetModelByControlsList(controlslist);
            if (listid == 0)
            {
                newid = tbWarehousingOfGoods.InsertEmptyReturnID(ref err, CurrentUser);
            }
            if (!string.IsNullOrEmpty(err) || newid == 0)
            {
               return Json(ErrorTip(err));
            }

			if (grid == "tb_WarehousingDetails")
			{
				err = gridWarehousingDetails.AddGridNull(grid, newid, model);//子表插入空数据
			}

            if (!string.IsNullOrEmpty(err))
            {
                return Json(ErrorTip(err));
            }
            else
            {
                return Json(SuccessTip("操作成功", newid.ToString()));
            }
        }

        /// <summary>
        ///子表删除一条数据，点击子表列表右侧删除按钮触发
        /// </summary>
        /// <param name="controlslist">主表控件list,循环后得到model</param>
        /// <param name="flag">#子表编码#id#行号#</param>
        /// <param name="listid">主表id：基础信息表对应主表listid，一般录入表对应表flowrunlist中的listid</param>
        /// <returns></returns>
        [HttpPost]
        public ActionResult DelGrid(IEnumerable<ControlEntity> controlslist, string flag, string listid)
        {
            string tbid = "";
            string id = "";
            string err = "";
            WarehousingOfGoodsModel model = tbWarehousingOfGoods.GetModelByControlsList(controlslist);
            BasicHelp.GetTbAndIdByFlag(flag, ref tbid, ref id);//flag：#子表编码#id#行号#

            if (!string.IsNullOrEmpty(tbid) && !string.IsNullOrEmpty(id))
            {
				if(tbid == "tb_WarehousingDetails")
				{
					err += gridWarehousingDetails.DelGrid(listid, id, CurrentUser, model);
				}
                if (string.IsNullOrEmpty(err))
                {
                    return Json(SuccessTip("删除成功"));
                }
                else
                {
                    return Json(ErrorTip(err));
                }
            }
            else
            {
                return Json(ErrorTip("参数错误"));
            }
        }

        /// <summary>
        /// 批量删除子表数据，点击子表列表上部删除按钮触发
        /// </summary>
        /// <param name="controlslist">主表控件list,循环后得到model</param>
        /// <param name="listid">主表数据主键</param>
        /// <param name="tbid">子表id</param>
        /// <param name="idsStr"></param>
        /// <returns></returns>
        [HttpPost]
        public JsonResult BatchDelGrid(IEnumerable<ControlEntity> controlslist, string listid, string tbid, string idsStr)
        {
            string err = "";
            WarehousingOfGoodsModel model = tbWarehousingOfGoods.GetModelByControlsList(controlslist);
            string id = "";
            string[] arr = BaseUtil.GetStrArray(idsStr, ",");
            for (int i = 0; i < arr.GetLength(0); i++)
            {
                id = arr[i] == null ? "0" : arr[i].ToString();
				if(tbid == "tb_WarehousingDetails")
				{
					err += gridWarehousingDetails.DelGrid(listid, id, CurrentUser, model);
				}
            }
            if (string.IsNullOrEmpty(err))
            {
                return Json(SuccessTip("删除成功"));
            }
            else
            {
                return Json(ErrorTip(err));
            }
        }

        /// <summary>
        /// 编辑子表数据，点击子表列表上部保存按钮触发
        /// </summary>
        /// <param name="controlslist">主表控件list,循环后得到model</param>
        /// <param name="gridlist">子表数据</param>
        /// <param name="grid">子表id</param>
        /// <param name="listid">主表数据id</param>
        /// <param name="prcno">流程步骤编码</param>
        /// <returns></returns>
        [HttpPost]
        public ActionResult EditGrid(IEnumerable<ControlEntity> controlslist, IEnumerable<GridListEntity> gridlist, long listid, string grid, string prcno)
        {
            string err = "";
            WarehousingOfGoodsModel model = tbWarehousingOfGoods.GetModelByControlsList(controlslist);
			if (grid == "tb_WarehousingDetails")
			{
				List<WarehousingDetailsModel> objList = WarehousingDetailsService.CheckedAndGetList(gridlist, "", listid, ref err);
				if (!string.IsNullOrEmpty(err))
				{
					return Json(ErrorTip(err));
				}
				if (objList.Count < 1)
				{
					return Json(SuccessTip(""));//无数据直接返回
				}
				err = gridWarehousingDetails.SaveGrid(model, gridlist, listid, prcno, "");
			}
            if (!string.IsNullOrEmpty(err))
            {
                return Json(ErrorTip(err));
            }
            else
            {
                return Json(SuccessTip("操作成功", listid.ToString()));
            }
        }

        /// <summary>
        /// 子表添加一条数据
        /// </summary>
        /// <param name="err">错误信息</param>
        /// <param name="model">主表model</param>
        /// <param name="gridlist">子表数据列表</param>
        /// <param name="tbid">子表编码</param>
        /// <param name="listid">主表id：基础信息表对应主表listid，一般录入表对应表flowrunlist中的listid</param>
        /// <returns></returns>
        public long AddGridItem(ref string err, long listid, string tbid, WarehousingOfGoodsModel model, IEnumerable<GridListEntity> list, CurrentUserEntity user = null)
        {
            long newid = 0;
            user = user == null ? CurrentUser : user;

			if (tbid == "tb_WarehousingDetails")
			{
				List<WarehousingDetailsModel> objList = WarehousingDetailsService.CheckedAndGetList(list, "#tb_WarehousingDetails#0#0#", listid, ref err);
				if (string.IsNullOrEmpty(err))
				{
					if (listid == 0)
					{
						newid = tbWarehousingOfGoods.InsertEmptyReturnID(ref err, user);
					}
					else
					{
						newid = listid;
					}
					if (newid > 0)
					{
						err = gridWarehousingDetails.AddGrid(model, list, newid);
					}
					else
					{
						err = "主表插入数据错误";
					}
				}
			}

            return newid;
        }
        #endregion 子表处理

        #region 弹出处理--文本框设置了数据规范（单列、多列或树形选择），点击文本框将弹出页面
        /// <summary>
        /// 统一处理弹出数据选择页面,如果文本框设置了数据规范（单列、多列或树形选择），点击文本框将被触发
        /// </summary>
		/// <param name="tbid">_main或子表编码</param>
		/// <param name="indexid">触发弹出页面的指标编码</param>
        /// <param name="id">子表数据列表id或空</param>
        /// <param name="strv">子表哪一列触发如v1、v2</param>
        /// <param name="from">list或edit，list时会自动解除条件参数中包含的系统指标，如用户登录名等</param>
        /// <returns></returns>
        [HttpGet]
        public ActionResult PopUpPage(string tbid, string indexid, string id, string strv, string from)
        {
           object param = BasicHelp.GetParamObject(CurrentUser);

            ViewBag.PuTbId = tbid == null ? "" : tbid;
            ViewBag.PuIndexId = indexid == null ? "" : indexid;
            ViewBag.PuId = id == null ? "" : id;
            ViewBag.PuV = strv == null ? "" : strv.Replace("v","");
            ViewBag.PuFrom = from == null ? "" : from;
            //弹出页面的查询条件有下拉选择时，为其绑定动态数据源
            ViewBag.SelectList = tbWarehousingOfGoods.GetSelectList(tbid, indexid, from, param);
            return View("Grid_" + indexid);
        }

        /// <summary>
        /// 统一处理弹出页面获得数据列表
        /// </summary>
        /// <param name="pageInfo">页面信息，包括行数、排序等</param>
        /// <param name="indexid">主表触发时为指标编码，子表触发时为子表编码+指标编码</param>
        /// <param name="list">封装查询条件</param>
        /// <returns></returns>
        [HttpPost]
        public ActionResult GetPopUpPageList(PageInfoEntity pageInfo, string indexid, string from, IEnumerable<valueTextEntity> list)
        {
            long total = 0;

            try
            {
                IEnumerable<dynamic> _list = tbWarehousingOfGoods.GetPopUpListForPage(ref total, pageInfo, indexid, from, list, CurrentUser);
                if (_list == null)
                {
                    return Json(new { msg = "<span style='color: #FE7300;'>参数错误</span>", count = -1 });
                }
                else
                {
                    return Json(new { code = 0, msg = "", count = total, data = _list });
                }
            }
            catch (Exception ex)
            {
                Record.AddErr("", _flowid, "WarehousingOfGoodsController:GetPopUpPageList", ex);
                return Json(new { msg = "Err：<br>" + ex.Message, count = -1 });
            }
        }

        /// <summary>
        /// 弹出页面点击确定后统一调用，默认什么也不做
        /// </summary>
        /// <param name="tbid">_main或子表编码</param>
        /// <param name="indexid">触发弹出页面的指标编码，主表时为指标编码，子表时为子表编码+指标编码</param>
        /// <param name="id">子表数据列表id或空</param>
        /// <param name="value">选择的值</param>
        /// <param name="v">子表弹出时使用，第几列</param>
        /// <returns></returns>
        [HttpPost]
        public ActionResult AfterPopUpSelect(string tbid, string indexid, string id, string value, string v)
        {
            //默认什么也不做--可自定义
            if (tbid == "_main")//主表
            {
                 //自定义 如
                //if (indexid == "xxx")
                //{
                //}
            }
            else//子表
            {
                //自定义 如
                //if (indexid == "xxx")
                //{
                //}
            }
            return Json("");
        }
        #endregion 弹出处理--文本框设置了数据规范（单列、多列或树形选择），点击文本框将弹出页面
    }
}
```

```
/*******************************************************************************
 * Creator:admin 2023-08-01 11:22:45
 * Description: YoursLC有源低代码
*********************************************************************************/
using System;
using System.Data;
using System.Collections.Generic;
using Newtonsoft.Json;
using Think9.Models;
using System.IO;
using Think9.Services.Base;
using Think9.Services.Basic;
using Think9.Services.Com;
using System.Linq;
using Newtonsoft.Json.Linq;

namespace Think9.Services.CodeBuild
{
	/// <summary>
	/// 主表Service
	/// </summary>
	public class WarehousingOfGoodsService : BaseService<WarehousingOfGoodsModel>
	{
		private ComService comService = new ComService();
		private ExtraDbService extraDb = new ExtraDbService();//外部数据源
		private ExtraDbEntity extraDbModel;//外部数据源
		private readonly static string _maintbid = "tb_WarehousingOfGoods";//主表编码
		private readonly static string _flowid = "bi_WarehousingOfGoods";//流程编码 bi_基础信息 fw_一般录入表
		private readonly static string _tbname = "货品入库";//录入表名称
		private readonly string _split = Think9.Services.Base.BaseConfig.ComSplit;//多选项的字符分割
		private string sql;
		private string str;

		#region Before处理
		/// <summary>
		/// 添加前数据处理，默认处理自动编号及子表数据初始化
		/// </summary>
		/// <param name="err">错误信息</param>
		/// <param name="mPrcs">当前流程步骤，基础信息表为空</param>
		/// <param name="user">当前用户</param>
		/// <returns>基础信息表自增长，一般录入表对应flowrunlist中的listid</returns>
		public long BeforeAdd(ref string err, CurrentPrcsEntity mPrcs, CurrentUserEntity user)
		{
			long listid = 0;

			//处理自动编号--录入表指标设置了自动编号，则增加一条空数据,返回listid，没有设置返回0
			listid = AutoNo.SetAutoNumber(ref err, _flowid, _tbname, mPrcs, user);
			

			return listid;
		}

		/// <summary>
		/// 编辑前数据处理，默认标志接手办理
		/// </summary>
		/// <param name="listid">主表主键</param>
		/// <param name="mPrcs">当前流程步骤，基础信息表为空</param>
		/// <param name="user">当前用户信息</param>
		/// <returns></returns>
		public string BeforeEdit(string listid, CurrentPrcsEntity mPrcs, CurrentUserEntity user)
		{
			string err = "";
			if (_flowid.StartsWith("fw_"))
			{
				err = FlowCom.TakeOverPrcs(user, mPrcs);//标志接手办理
			}
			//可自定义
			return err;
		}

		/// <summary>
		/// 主表插入一条空数据,listid=0时子表添加数据前会被调用
		/// </summary>
		/// <param name="err">错误信息</param>
		/// <param name="user">当前用户</param>
		/// <returns>返回listid，基础信息表自增长，一般录入表对应flowrunlist中的listid</returns>
		public long InsertEmptyReturnID(ref string err, CurrentUserEntity user)
		{
			//FlowCom.GetFistStept(_flowid)流程第一步
			return PageCom.InsertEmptyReturnID(ref err, _flowid, _tbname, user, FlowCom.GetFistStept(_flowid));
		}

		/// <summary>
		/// 删除前数据处理，默认什么也不做
		/// </summary>
		/// <param name="mPrcs">当前流程步骤，基础信息表为空</param>
		/// <returns></returns>
		public string BeforeDelete(string listid, CurrentPrcsEntity mPrcs)
		{
			//可自定义
			return "";
		}
		#endregion Before处理

		#region After处理
		/// <summary>
        /// 添加后数据处理--【批量】，导入数据时被调用
        /// </summary>
        /// <param name="err">错误信息</param>
        /// <param name="idsStr">listid逗号间隔</param>
        /// <param name="user">当前用户</param>
        /// <returns></returns>
        public List<string> BatchAfterAdd(ref string err, string idsStr, CurrentUserEntity user)
        {
			return null;//未定义--通过录入表管理/自定义事件可自定义
        }

		/// <summary>
        /// 添加后数据处理，通过录入表管理/事件扩展可自定义
        /// </summary>
        /// <param name="err">错误信息</param>
        /// <param name="listid">主表主键</param>
        /// <param name="user">当前用户</param>
        /// <param name="model">当前数据对象</param>
        /// <returns></returns>
		public List<string> AfterAdd(ref string err, string listid, CurrentUserEntity user, WarehousingOfGoodsModel model = null)
		{
			return null;//未定义--通过录入表管理/自定义事件可自定义
		}

		/// <summary>
		/// 编辑后数据处理，默认调用通用函数实现数据回写，通过录入表管理/事件扩展可自定义
		/// </summary>
		/// <param name="err">错误信息</param>
		/// <param name="listid">主表主键</param>
		/// <param name="prcno">当前流程步骤编码，结束为_finish</param>
		/// <param name="user">当前用户</param>
		/// <param name="model">当前数据model</param>
		/// <returns></returns>
		public List<string> AfterEdit(ref string err, string listid, string prcno, CurrentUserEntity user, WarehousingOfGoodsModel model = null)
		{
			return null;//未定义--通过录入表管理/自定义事件可自定义
		}

		/// <summary>
		/// 完成后数据处理，默认调用通用函数实现数据回写，通过录入表管理/事件扩展可自定义
		/// </summary>
		/// <param name="err">错误信息</param>
		/// <param name="flowid">流程编码</param>
		/// <param name="listid">主表主键</param>
		/// <param name="prcno">当前流程步骤编码，结束为_finish</param>
		/// <param name="user">当前用户</param>
		/// <param name="model">当前数据model</param>
		/// <returns></returns>
		public List<string> AfterFinish(ref string err, string listid, string prcno, CurrentUserEntity user, WarehousingOfGoodsModel model = null)
		{
			FlowCom.FinishFlowPrcs(listid, _flowid, prcno, user);//结束并锁定数据
			return null;//未定义--通过录入表管理/自定义事件可自定义
		}

		/// <summary>
		/// 删除后数据处理，默认什么也不做，通过录入表管理/事件扩展可自定义
		/// </summary>
		/// <param name="err">错误信息</param>
		/// <param name="listid">主表主键</param>
		/// <param name="model">当前数据model</param>
		/// <returns></returns>
		public List<string> AfterDelete(ref string err, string listid, WarehousingOfGoodsModel model = null)
		{
			return null;//未定义--通过录入表管理/自定义事件可自定义
		}

		/// <summary>
        /// 数据回写，录入表管理中的数据回写中定义
        /// </summary>
        /// <param name="listid">主表主键</param>
        /// <param name="prcno">流程步骤编码，基础信息表</param>
        /// <param name="model">当前数据model</param>
		public List<string> WriteBackData(ref string err, string listid, string prcno, CurrentUserEntity user, WarehousingOfGoodsModel model)
        {
			return null;//未定义，数据回写在录入表管理/数据回写中设置
        }
		#endregion After处理

		#region 查询
		/// <summary>
		/// 数据查询列表
		/// </summary>
		/// <param name="total">结果集总数</param>
		/// <param name="model">主表数据model</param>
		/// <param name="pageInfo">页面信息，包括行数、排序等</param>
		/// <param name="user">当前用户信息</param>
		/// <param name="flowid">流程编码</param>
		/// <param name="isAll">为all则显示所有</param>
		/// <returns></returns>
		public List<dynamic> GetListForPage(ref long total, WarehousingOfGoodsModel model, PageInfoEntity pageInfo, CurrentUserEntity user, string isAll)
		{
			object param = BasicHelp.GetParamObject(user);
			WarehousingOfGoodsModel entity = new WarehousingOfGoodsModel();
			if (string.IsNullOrEmpty(isAll))
			{
				entity = model;
			}
			//主表查询返回数据列表，备注：查询条件可在录入表指标属性中设置
			List<dynamic> list = GetList(ref total, entity, pageInfo, user).ToList();
			IEnumerable<valueTextEntity> selectList = GetSelectList("list", param);//下拉选择、多选、单选准备动态数据源
			TransformValue(selectList, list, user);//处理Value与Text转化

			return list;
		}

		/// <summary>
		/// list转化为DataTable(rdlc报表接收DataTable数据)，同时处理图片及Value与Text转化
		/// </summary>
		/// <param name="model">当前页面数据，作为查询条件</param>
		/// <param name="user">当前用户</param>
		/// <returns></returns>
		public DataTable GetListForExport(WarehousingOfGoodsModel model, CurrentUserEntity user)
		{
			//主表查询返回数据列表，备注：查询条件可在录入表指标属性中设置
			List<dynamic> list = GetList(model, user).ToList();
			if (list == null || list.Count < 1)
			{
				list.Add(new WarehousingOfGoodsModel());//无数据时需加入一条空数据，否则报错
			}
			//为下拉选择、多选、单选准备动态数据源
			IEnumerable<valueTextEntity> selectList = GetSelectList("list", BasicHelp.GetParamObject(user));
			TransformValue(selectList, list, user);//处理Value与Text转化
			TransformImg(list);//处理图片

			DataTable dt= DataTableHelp.ListToDataTable<dynamic>(list);//转换DataTable
			GetSumRow(model, user, dt);//添加合计行
			return dt;
		}

		/// <summary>
		/// 为下拉选择、多选、单选准备动态数据源，只处理主表组件
		/// 处理列表显示时value与text转化，动态数据源来源于为指标指定的数据规范
		/// </summary>
		/// <param name="from">add、edit或list，list表明从列表页面查询条件跳转而来</param>
		/// <param name="param">条件参数</param>
		/// <returns></returns>
		public IEnumerable<valueTextEntity> GetSelectList(string from, object param)
		{
			DataTable dt = DataTableHelp.NewValueTextDt();

			//入库类型
			sql = "SELECT DetailCode as id,DetailName as name FROM sys_itemsdetail WHERE ItemCode = 'RKLX' ORDER BY OrderNo";
			foreach (DataRow dr in comService.GetDataTable(sql, param).Rows)
			{
				DataRow row = dt.NewRow();
				row["ClassID"] = "inRKLX";
				row["Value"] = dr["id"].ToString();
				row["Text"] = dr["name"].ToString();
				dt.Rows.Add(row);
			}
			//仓库
			sql = "SELECT inCoding as id,inName as name FROM tb_Warehouse ORDER BY state";
			foreach (DataRow dr in comService.GetDataTable(sql, param).Rows)
			{
				DataRow row = dt.NewRow();
				row["ClassID"] = "inCK";
				row["Value"] = dr["id"].ToString();
				row["Text"] = dr["name"].ToString();
				dt.Rows.Add(row);
			}
			//相关单位
			sql = "SELECT inGYSBH as id,inGYSMC as name FROM tb_Supplier ORDER BY listid";
			foreach (DataRow dr in comService.GetDataTable(sql, param).Rows)
			{
				DataRow row = dt.NewRow();
				row["ClassID"] = "inXGDW";
				row["Value"] = dr["id"].ToString();
				row["Text"] = dr["name"].ToString();
				dt.Rows.Add(row);
			}
			//审核状态
			sql = "SELECT DetailCode as id,DetailName as name FROM sys_itemsdetail WHERE ItemCode = 'SHZT' ORDER BY OrderNo";
			foreach (DataRow dr in comService.GetDataTable(sql, param).Rows)
			{
				DataRow row = dt.NewRow();
				row["ClassID"] = "inSHZT";
				row["Value"] = dr["id"].ToString();
				row["Text"] = dr["name"].ToString();
				dt.Rows.Add(row);
			}

			return DataTableHelp.ToEnumerable<valueTextEntity>(dt);//DataTable转换成IEnumerable
		}
		
		/// <summary>
		/// 获得分页数据 主表查询调用，返回列表，查询条件可在录入表指标属性中设置
		/// </summary>
		/// <param name="total">结果集总数</param>
		/// <param name="model">主表数据model</param>
		/// <param name="pageInfo">页面信息，包括行数、排序等</param>
		/// <param name="user">当前用户信息</param>
		/// <param name="flowid">流程编码</param>
		/// <returns></returns>
		private IEnumerable<dynamic> GetList(ref long total, WarehousingOfGoodsModel model, PageInfoEntity pageInfo, CurrentUserEntity user)
		{
			string tbid = _flowid.Replace("bi_", "tb_").Replace("fw_", "tb_");
			string where = this.GetWhere(model, user);

			return base.GetPageByFilter(ref total, model, pageInfo, where);

		}

		/// <summary>
		/// 主表查询调用，返回列表，查询条件可在录入表指标属性中设置
		/// </summary>
		/// <param name="model">主表数据model</param>
		/// <param name="user">当前用户信息</param>
		/// <returns></returns>
		private IEnumerable<dynamic> GetList(WarehousingOfGoodsModel model, CurrentUserEntity user)
		{
			string tbid = _flowid.Replace("bi_", "tb_").Replace("fw_", "tb_");
			string where = this.GetWhere(model, user);

			return base.GetByWhere(where, model, null, "ORDER BY listid DESC");

		}

		/// <summary>
		/// 得到查询where
		/// </summary>
		/// <param name="model">当前页面数据，作为查询条件</param>
		/// <param name="user">当前用户</param>
		/// <returns></returns>
		private string GetWhere(WarehousingOfGoodsModel model, CurrentUserEntity user)
		{
			string where = BasicHelp.GetWhereByFlowId(user, _flowid);
			//入库单号
			if (!string.IsNullOrEmpty(model.inRKDH))
			{
				where += " AND (tb_WarehousingOfGoods.inRKDH LIKE  @inRKDH)"; 
				model.inRKDH = string.Format("%{0}%", model.inRKDH); 
			}
			//入库日期
			if(model.inRKRQ != null)
			{
				where += " AND (tb_WarehousingOfGoods.inRKRQ >= @inRKRQ)"; 
			}
			if(model.inRKRQ_Exa  != null)
			{
				where += " AND (tb_WarehousingOfGoods.inRKRQ <= @inRKRQ_Exa)"; 
			}
			//入库类型
			if (!string.IsNullOrEmpty(model.inRKLX))
			{
				where += " AND (tb_WarehousingOfGoods.inRKLX = @inRKLX)"; 
			}
			//仓库
			if (!string.IsNullOrEmpty(model.inCK))
			{
				where += " AND (tb_WarehousingOfGoods.inCK = @inCK)"; 
			}
			//制单人
			if (!string.IsNullOrEmpty(model.inZDR))
			{
				where += " AND (tb_WarehousingOfGoods.inZDR LIKE  @inZDR)"; 
				model.inZDR = string.Format("%{0}%", model.inZDR); 
			}
			//相关单位
			if (!string.IsNullOrEmpty(model.inXGDW))
			{
				where += " AND (tb_WarehousingOfGoods.inXGDW = @inXGDW)"; 
			}
			//金额
			if(model.inJE != null)
			{
				where += " AND (tb_WarehousingOfGoods.inJE >= @inJE)"; 
			}
			if(model.inJE_Exa  != null)
			{
				where += " AND (tb_WarehousingOfGoods.inJE <= @inJE_Exa)"; 
			}
			//审核状态
			if (!string.IsNullOrEmpty(model.inSHZT))
			{
				where += " AND (tb_WarehousingOfGoods.inSHZT = @inSHZT)"; 
			}
			//采购单号
			if (!string.IsNullOrEmpty(model.inCGDH))
			{
				where += " AND (tb_WarehousingOfGoods.inCGDH LIKE  @inCGDH)"; 
				model.inCGDH = string.Format("%{0}%", model.inCGDH); 
			}
			//备注
			if (!string.IsNullOrEmpty(model.inBZ))
			{
				where += " AND (tb_WarehousingOfGoods.inBZ LIKE  @inBZ)"; 
				model.inBZ = string.Format("%{0}%", model.inBZ); 
			}
			return where;
		}

		/// <summary>
		/// 处理select、checkbox等组件Value与Text的转化，同时将禁用按钮字符传入用于按钮权限控制
		/// </summary>
		/// <param name="SelectList">Value与Text数据集</param>
		/// <param name="list">数据集list</param>
		/// <param name="user">当前用户</param>
		private void TransformValue(IEnumerable<valueTextEntity> SelectList, List<dynamic> list, CurrentUserEntity user)
		{
			if (list == null)
			{
				return;
			}
			//禁用按钮字符，格式[butid1][butid2]，用于按钮权限控制，录入表管理/页面按钮可设置
			str = GetDisableButStr("list", user);
			//处理列表数据select、checkbox、radio等Value与Text转化
			foreach (WarehousingOfGoodsModel obj in list)
			{
			    obj.DisableButStr = str; //传入禁用按钮字符,前端控制按钮状态
				//入库类型
				foreach (valueTextEntity sel in SelectList.Where(x => x.ClassID == "inRKLX"))
				{
					if (obj.inRKLX == sel.Value)
					{
						obj.inRKLX = sel.Text;
						break;
					}
				}
				//仓库
				foreach (valueTextEntity sel in SelectList.Where(x => x.ClassID == "inCK"))
				{
					if (obj.inCK == sel.Value)
					{
						obj.inCK = sel.Text;
						break;
					}
				}
				//相关单位
				foreach (valueTextEntity sel in SelectList.Where(x => x.ClassID == "inXGDW"))
				{
					if (obj.inXGDW == sel.Value)
					{
						obj.inXGDW = sel.Text;
						break;
					}
				}
				//审核状态
				foreach (valueTextEntity sel in SelectList.Where(x => x.ClassID == "inSHZT"))
				{
					if (obj.inSHZT == sel.Value)
					{
						obj.inSHZT = sel.Text;
						break;
					}
				}
			}
		}

		/// <summary>
		/// 图片列处理
		/// </summary>
		/// <param name="list">数据集list</param>
		private void TransformImg(List<dynamic> list)
		{
			return;
		}

		/// <summary>
		/// 列表合计，录入表指标设置为统计求和（需数值类型）就会求解
		/// </summary>
		/// <param name="model">当前数据</param>
		/// <param name="user">当前用户</param>
		/// <param name="dt">数据集</param>
		private void GetSumRow(WarehousingOfGoodsModel model, CurrentUserEntity user, DataTable dt)
		{
			return;
		}
		#endregion 查询

		#region 弹出页面处理
		/// <summary>
		/// 弹出页面的查询条件有下拉选择时，为其绑定动态数据源，动态数据源来源于为指标指定的数据规范
		/// </summary>
		/// <param name="tbid">_main或者空</param>
		/// <param name="indexid">触发弹出页面的指标编码</param>
		/// <param name="from">edit或list</param>
		/// <param name="param">条件参数</param>
		/// <returns></returns>
		public IEnumerable<valueTextEntity> GetSelectList(string tbid, string indexid, string from, object param)
		{
			DataTable dt = DataTableHelp.NewValueTextDt();
			//主表组件触发弹出页面
			if (tbid == "_main")
			{
				if (indexid == "inCGDH")
				{
					sql = "SELECT inGYSBH as id,inGYSMC as name FROM tb_Supplier ORDER BY listid";
					foreach (DataRow dr in comService.GetDataTable(sql).Rows)
					{
						DataRow row = dt.NewRow();
						row["ClassID"] = "inGYS";
						row["Value"] = dr["id"].ToString();
						row["Text"] = dr["name"].ToString();
						dt.Rows.Add(row);
					}
				}
			}
			else//子表组件触发弹出页面
			{
				if (indexid == "WarehousingDetailsv1")
				{
					sql = "SELECT inCoding as id,inName as name FROM tb_ProductClassification ORDER BY LENGTH(inCoding)  ,inCoding";
					foreach (DataRow dr in comService.GetDataTable(sql).Rows)
					{
						DataRow row = dt.NewRow();
						row["ClassID"] = "inSSLB";
						row["Value"] = dr["id"].ToString();
						row["Text"] = dr["name"].ToString();
						dt.Rows.Add(row);
					}
					sql = "SELECT DetailCode as id,DetailName as name FROM sys_itemsdetail WHERE ItemCode = 'UnitOfMeasure' ORDER BY OrderNo";
					foreach (DataRow dr in comService.GetDataTable(sql).Rows)
					{
						DataRow row = dt.NewRow();
						row["ClassID"] = "inJLDW";
						row["Value"] = dr["id"].ToString();
						row["Text"] = dr["name"].ToString();
						dt.Rows.Add(row);
					}
					sql = "SELECT DetailCode as id,DetailName as name FROM sys_itemsdetail WHERE ItemCode = 'State' ORDER BY OrderNo";
					foreach (DataRow dr in comService.GetDataTable(sql).Rows)
					{
						DataRow row = dt.NewRow();
						row["ClassID"] = "inQYTY";
						row["Value"] = dr["id"].ToString();
						row["Text"] = dr["name"].ToString();
						dt.Rows.Add(row);
					}
				}
			}

			return DataTableHelp.ToEnumerable<valueTextEntity>(dt);//DataTable转换成IEnumerable
		}

		/// <summary>
		/// 统一处理弹出页面获得数据列表
		/// </summary>
		/// <param name="total">结果集总数</param>
		/// <param name="indexid">主表触发时为指标编码，子表触发时为子表编码+指标编码</param>
		/// <param name="from">list或edit 为list时（即查询时）会解除条件参数中包含的系统指标，如用户登录名等</param>
		/// <param name="list">封装查询条件为list</param>
		public IEnumerable<dynamic> GetPopUpListForPage(ref long total, PageInfoEntity pageInfo, string indexid, string from, IEnumerable<valueTextEntity> list, CurrentUserEntity user = null)
		{
			string tbname;
			string some;
			string where;
			string order;
			PopUpTableListService tblist = new PopUpTableListService();

			IEnumerable<dynamic> _list = null;
				
			if (indexid == "inCGDH")
			{
				tbname = "tb_GoodsProcurement";
				some = "listid as Id,inCGDH as Value,inCGDH as info1,createTime as info2,inYFJE as info3,inSFJE as info4,inSHRQ as info5,inJBR as info6";
				where = " WHERE 1=1";
				order =" ORDER BY inSHRQ desc";
				
				//文本框 采购单号
				string _inCGDH = BasicHelp.GetTextFromList(list, indexid, "inCGDH").Trim();
				if (!string.IsNullOrEmpty(_inCGDH))
				{
					where += " AND inCGDH LIKE  @inCGDH"; 
				}
				
				//下拉选择或单选框 供应商
				string _inGYS = BasicHelp.GetTextFromList(list, indexid, "inGYS").Trim();
				if (!string.IsNullOrEmpty(_inGYS))
				{
					where += " AND inGYS = @inGYS"; 
				}
				
				//收货日期
				string _inSHRQ = BasicHelp.GetTextFromList(list, indexid, "inSHRQ").Trim();
				if (!string.IsNullOrEmpty(_inSHRQ))
				{
					where += " AND inSHRQ >= @inSHRQ"; 
				}
				
				//收货日期
				string _inSHRQ_Exa = BasicHelp.GetTextFromList(list, indexid, "inSHRQ_Exa").Trim();
				if (!string.IsNullOrEmpty(_inSHRQ_Exa))
				{
					where += " AND inSHRQ <= @inSHRQ_Exa"; 
				}
				
				//应付金额
				string _inYFJE = BasicHelp.GetTextFromList(list, indexid, "inYFJE").Trim();
				if (!string.IsNullOrEmpty(_inYFJE))
				{
					where += " AND inYFJE >= @inYFJE"; 
				}
				
				//应付金额
				string _inYFJE_Exa = BasicHelp.GetTextFromList(list, indexid, "inYFJE_Exa").Trim();
				if (!string.IsNullOrEmpty(_inYFJE_Exa))
				{
					where += " AND inYFJE <= @inYFJE_Exa"; 
				}
				
				//实付金额
				string _inSFJE = BasicHelp.GetTextFromList(list, indexid, "inSFJE").Trim();
				if (!string.IsNullOrEmpty(_inSFJE))
				{
					where += " AND inSFJE >= @inSFJE"; 
				}
				
				//实付金额
				string _inSFJE_Exa = BasicHelp.GetTextFromList(list, indexid, "inSFJE_Exa").Trim();
				if (!string.IsNullOrEmpty(_inSFJE_Exa))
				{
					where += " AND inSFJE <= @inSFJE_Exa"; 
				}
				
				//文本框 经办人
				string _inJBR = BasicHelp.GetTextFromList(list, indexid, "inJBR").Trim();
				if (!string.IsNullOrEmpty(_inJBR))
				{
					where += " AND inJBR LIKE  @inJBR"; 
				}
				
				//文本框 备注
				string _inBZ = BasicHelp.GetTextFromList(list, indexid, "inBZ").Trim();
				if (!string.IsNullOrEmpty(_inBZ))
				{
					where += " AND inBZ LIKE  @inBZ"; 
				}
				
				object param = new { inCGDH = string.Format("%{0}%", _inCGDH),inGYS = _inGYS,inSHRQ = ExtConvert.ToDateOrNull(_inSHRQ),inSHRQ_Exa = ExtConvert.ToDateOrNull(_inSHRQ_Exa),inYFJE = ExtConvert.ToDecimalOrNull(_inYFJE),inYFJE_Exa = ExtConvert.ToDecimalOrNull(_inYFJE_Exa),inSFJE = ExtConvert.ToDecimalOrNull(_inSFJE),inSFJE_Exa = ExtConvert.ToDecimalOrNull(_inSFJE_Exa),inJBR = string.Format("%{0}%", _inJBR),inBZ = string.Format("%{0}%", _inBZ) };
				
				 _list = tblist.GetPageList(ref total, pageInfo, some, tbname, where, order,  param);
			}
				
			if (indexid == "WarehousingDetailsv1")
			{
				tbname = "tb_ProductManagement";
				some = "listid as Id,inHPBM as Value,inHPBM as info1,inHPMC as info2,inGGXH as info3,inHPTP as info4,inXSJ as info5,inCBJ as info6";
				where = " WHERE 1=1";
				order =" ORDER BY listid desc";
				
				//文本框 货品名称
				string _inHPMC = BasicHelp.GetTextFromList(list, indexid, "inHPMC").Trim();
				if (!string.IsNullOrEmpty(_inHPMC))
				{
					where += " AND inHPMC LIKE  @inHPMC"; 
				}
				
				//下拉选择或单选框 所属类别
				string _inSSLB = BasicHelp.GetTextFromList(list, indexid, "inSSLB").Trim();
				if (!string.IsNullOrEmpty(_inSSLB))
				{
					where += " AND inSSLB = @inSSLB"; 
				}
				
				//下拉选择或单选框 计量单位
				string _inJLDW = BasicHelp.GetTextFromList(list, indexid, "inJLDW").Trim();
				if (!string.IsNullOrEmpty(_inJLDW))
				{
					where += " AND inJLDW = @inJLDW"; 
				}
				
				//最低库存
				string _inZDKC = BasicHelp.GetTextFromList(list, indexid, "inZDKC").Trim();
				if (!string.IsNullOrEmpty(_inZDKC))
				{
					where += " AND inZDKC >= @inZDKC"; 
				}
				
				//最低库存
				string _inZDKC_Exa = BasicHelp.GetTextFromList(list, indexid, "inZDKC_Exa").Trim();
				if (!string.IsNullOrEmpty(_inZDKC_Exa))
				{
					where += " AND inZDKC <= @inZDKC_Exa"; 
				}
				
				//最高库存
				string _inZGKC = BasicHelp.GetTextFromList(list, indexid, "inZGKC").Trim();
				if (!string.IsNullOrEmpty(_inZGKC))
				{
					where += " AND inZGKC >= @inZGKC"; 
				}
				
				//最高库存
				string _inZGKC_Exa = BasicHelp.GetTextFromList(list, indexid, "inZGKC_Exa").Trim();
				if (!string.IsNullOrEmpty(_inZGKC_Exa))
				{
					where += " AND inZGKC <= @inZGKC_Exa"; 
				}
				
				//下拉选择或单选框 启用|停用
				string _inQYTY = BasicHelp.GetTextFromList(list, indexid, "inQYTY").Trim();
				if (!string.IsNullOrEmpty(_inQYTY))
				{
					where += " AND inQYTY = @inQYTY"; 
				}
				
				object param = new { inHPMC = string.Format("%{0}%", _inHPMC),inSSLB = _inSSLB,inJLDW = _inJLDW,inZDKC = ExtConvert.ToDecimalOrNull(_inZDKC),inZDKC_Exa = ExtConvert.ToDecimalOrNull(_inZDKC_Exa),inZGKC = ExtConvert.ToDecimalOrNull(_inZGKC),inZGKC_Exa = ExtConvert.ToDecimalOrNull(_inZGKC_Exa),inQYTY = _inQYTY };
				
				 _list = tblist.GetPageList(ref total, pageInfo, some, tbname, where, order,  param);
			}


			return _list;
		}
		#endregion 弹出页面处理

		/// <summary>
        /// 根据当前用户返回已禁用页面按钮的字符，用于按钮的权限控制
        /// </summary>
        /// <param name="pageType">页面类别，list或form</param>
        /// <param name="user">当前用户</param>
        /// <returns></returns>
        public string GetDisableButStr(string pageType, CurrentUserEntity user)
        {
            return AuthorityService.GetDisableButStr(_maintbid, pageType, user);
        }

		/// <summary>
		/// 数据删除，可处理软删除
		/// </summary>
		/// <param name="listid">主表数据id</param>
		/// <returns></returns>
		public string DelByListId(string listid, CurrentUserEntity user)
		{
			string err = "";
			var model = base.GetByWhereFirst("where listid = " + listid + "");
			if (model == null)
				return "当前数据不存在";
			
			List<string> resultList = AfterDelete(ref err, listid, model);
			Record.AddResultList("system", listid.ToString(), _flowid, resultList, "#自定义事件AfterDelete#");
			if(!string.IsNullOrEmpty(err))
			{
				return err;
			}
			//删除子表数据
			WarehousingDetailsService gridWarehousingDetails = new WarehousingDetailsService();
			foreach (DataRow dr in comService.GetDataTable("Select id from  tb_WarehousingDetails where ListId=" + listid + "").Rows)
			{
				err += gridWarehousingDetails.DelGrid(listid, dr["id"].ToString(), user, model);
			}
			if(!string.IsNullOrEmpty(err))
			{
				return err;
			}
			
			//删除主表及相关数据
			AutoNo.DelAutoNo(listid, _flowid);//删除自动编号
			AttachmentService.DelAttachment(long.Parse(listid), _flowid);//删除附件
			if (_flowid.StartsWith("fw_"))//删除flowrunlist、flowrunprcslist中关联数据
			{
				comService.ExecuteSql("delete from flowrunlist where ListId = " + listid + "");
				comService.ExecuteSql("delete from flowrunprcslist where ListId = " + listid + "");
			}
			return base.DeleteByWhere("where ListId = " + listid + "") ? "" : "删除失败";//删除主表数据
		}

		/// <summary>
		/// 获得rdlc报表的相关数据,查看详细时被调用
		/// </summary>
		/// <param name="listid">数据主键</param>
		/// <param name="tbname">主表名称</param>
		/// <returns></returns>
		public static RdlcDeviceEntity GetRdlcDevice(string listid, string rdlcTemple = null, DataTable mainDt = null, DataTable gridDt = null)
		{
			string err = "";
			string directory = Directory.GetCurrentDirectory();

			RdlcDeviceEntity device = new RdlcDeviceEntity();
			device.ListId = listid;
			device.PathUserImg = Think9.Services.Base.BaseConfig.GetUserImgPath();//用户图片所在文件夹
			device.ImgNoExist = Think9.Services.Base.BaseConfig.GetImgNoExistPath();//图片不存在时的替代

			device.PathRdlc = Path.Combine(directory, "wwwroot\\Reports\\WarehousingOfGoods.rdlc");//rdlc模板文件
			if (rdlcTemple != null)
			{
				rdlcTemple = rdlcTemple.EndsWith(".rdlc") ? rdlcTemple : rdlcTemple + ".rdlc";
				device.PathRdlc = Path.Combine(directory, "wwwroot\\Reports\\" + rdlcTemple + "");//rdlc模板文件
			}
			if (mainDt != null)
			{
				device.MainDt = mainDt;//主表数据
			}
			else
			{
				device.MainDt = PageCom.GetMainTbDt(ref err, _flowid, listid, device.PathUserImg, device.ImgNoExist);//主表数据
			}
			if (gridDt != null)
			{
				device.GridDt = gridDt;//子表数据
			}
			else
			{
				device.GridDt = PageCom.GetGridTbDt(ref err, _flowid, listid, device.PathUserImg, device.ImgNoExist);//子表数据
			}

			if (!string.IsNullOrEmpty(err))
			{
				device.Err = err;
			}
			return device;
		}

		/// <summary>
		/// 获得rdlc报表相关数据,数据导出时被调用
		/// </summary>
		/// <param name="gridDt">列表数据</param>
		/// <param name="rdlcTemple">指定的rdlc模板，不指定则使用默认</param>
		/// <returns></returns>
		public static RdlcDeviceEntity GetRdlcDevice(DataTable gridDt, string rdlcTemple = null)
		{
			string directory = Directory.GetCurrentDirectory();

			RdlcDeviceEntity device = new RdlcDeviceEntity();
			device.PathUserImg = Think9.Services.Base.BaseConfig.GetUserImgPath();//用户图片所在文件夹
			device.ImgNoExist = Think9.Services.Base.BaseConfig.GetImgNoExistPath();//图片不存在时的替代
			device.GridDt = gridDt;//列表数据

			device.PathRdlc = Path.Combine(directory, "wwwroot\\Reports\\list_WarehousingOfGoods.rdlc");//rdlc默认模板
			if (rdlcTemple != null)
			{
				rdlcTemple = rdlcTemple.EndsWith(".rdlc") ? rdlcTemple : rdlcTemple + ".rdlc";
				device.PathRdlc = Path.Combine(directory, "wwwroot\\Reports\\" + rdlcTemple + "");//指定的rdlc模板
			}
			return device;
		}

		/// <summary>
		///返回可修改字段,自由流程排除了隐藏指标,固定流程排除了隐藏指标及不可写字段
		/// </summary>
		/// <param name="prcno">流程步骤编码</param>
		/// <returns></returns>
		public static string GetUpdateFields(string prcno)
		{
			//自由流程或无流程排除了隐藏指标
			 return "inRKDH,inRKRQ,inRKLX,inCK,inZDR,inXGDW,inJE,inCGDH,inBZ";
		}
		
		//主表数据读取
		public List<ControlEntity> ReadValue(ref string listid, ref string grid, CurrentUserEntity user, IEnumerable<ControlEntity> controlslist, string indexid, string value)
		{
			List<ControlEntity> list = new List<ControlEntity>();
			
			string tbname = "";
			string some = "";
			string where = "";
			string order = "";
			string err = "";
			DataTable dt;
			
			if (indexid == "inCGDH")
			{
				//读取单值 从货物采购中读取相关单位
				tbname = "tb_goodsprocurement";
				some = "tb_goodsprocurement.inGYS AS inXGDW";
				where = "WHERE tb_goodsprocurement.incgdh = @inCGDH";
				order = " order by listid";
				
				dt = comService.GetDataTable(tbname, some, where, order, new { inCGDH = value });
				if (dt.Rows.Count > 0)
				{
					//相关单位
					list.Add(new ControlEntity { ControlID = "inXGDW", ControlValue = dt.Rows[0]["inXGDW"].ToString(), ControlType = "2" });
					
				}
			}
			if (indexid == "inCGDH")
			{
				grid += "#tb_WarehousingDetails#";//前端调用tableRender刷新子表数据
				//如果list为0则主表插入一条空数据返回自增长listid
				listid = listid == "0" ? InsertEmptyReturnID(ref err, user).ToString() : listid;
				WarehousingDetailsService WarehousingDetailsService = new WarehousingDetailsService();
				//读取采购明细到入库明细
				sql = "SELECT tb_procurementdetails.v1 AS v1,tb_procurementdetails.v2 AS v2,tb_procurementdetails.v3 AS v3,tb_procurementdetails.v4 AS v4,tb_procurementdetails.v5 AS v6,tb_procurementdetails.v6 AS v5,tb_procurementdetails.v7 AS v7 FROM  tb_GoodsProcurement INNER JOIN tb_procurementdetails ON tb_GoodsProcurement.listid = tb_procurementdetails.listid WHERE tb_goodsprocurement.incgdh = @inCGDH";
				dt = comService.GetDataTable(sql, new { inCGDH = value });
				
				foreach (DataRow dr in dt.Rows)
				{
					WarehousingDetailsModel model = new WarehousingDetailsModel();
					model.ListId = int.Parse(listid);
					model.v1 = dr["v1"].ToString();
					model.v2 = dr["v2"].ToString();
					model.v3 = dr["v3"].ToString();
					model.v4 = dr["v4"].ToString();
					str = dr["v6"].ToString();
					if (ValidatorHelper.IsNumberic(str) && !string.IsNullOrEmpty(str))
					{
						model.v6 = ExtConvert.ToDecimalOrNull(str);
					}
					str = dr["v5"].ToString();
					if (ValidatorHelper.IsNumberic(str) && !string.IsNullOrEmpty(str))
					{
						model.v5 = ExtConvert.ToDecimalOrNull(str);
					}
					str = dr["v7"].ToString();
					if (ValidatorHelper.IsNumberic(str) && !string.IsNullOrEmpty(str))
					{
						model.v7 = ExtConvert.ToDecimalOrNull(str);
					}
					
					WarehousingDetailsService.Insert(model);
				}
			}
			return list;
		}


		#region GetObject 部分函数发布模式下会被调用
		public WarehousingOfGoodsModel NewModel( )
		{
			return new WarehousingOfGoodsModel();
		}

		public WarehousingOfGoodsModel ToModel(string json)
		{
			WarehousingOfGoodsModel model = new WarehousingOfGoodsModel();
			if (!string.IsNullOrEmpty(json))
			{
			   model = (WarehousingOfGoodsModel)JsonConvert.DeserializeObject<WarehousingOfGoodsModel>(json);
			}
			return model;
		}

		public WarehousingOfGoodsModel GetModelByControlsList(IEnumerable<ControlEntity> controlslist)
		{
			WarehousingOfGoodsModel model = new WarehousingOfGoodsModel();
			str = BasicHelp.GetTextFromList(controlslist, "listid");
			model.ListId = string.IsNullOrEmpty(str) ? 0 : long.Parse(str);
			model.inRKDH = BasicHelp.GetTextFromList(controlslist, "inRKDH");//入库单号
			str = BasicHelp.GetTextFromList(controlslist, "inRKRQ");//入库日期
			if (ValidatorHelper.IsDateTime(str))
			{
				model.inRKRQ = ExtConvert.ToDateOrNull(str);
			}
			model.inRKLX = BasicHelp.GetTextFromList(controlslist, "inRKLX");//入库类型
			model.inCK = BasicHelp.GetTextFromList(controlslist, "inCK");//仓库
			model.inZDR = BasicHelp.GetTextFromList(controlslist, "inZDR");//制单人
			model.inXGDW = BasicHelp.GetTextFromList(controlslist, "inXGDW");//相关单位
			str = BasicHelp.GetTextFromList(controlslist, "inJE");//金额
			if (ValidatorHelper.IsNumberic(str))
			{
				model.inJE = ExtConvert.ToDecimalOrNull(str);
			}
			model.inSHZT = BasicHelp.GetTextFromList(controlslist, "inSHZT");//审核状态
			model.inCGDH = BasicHelp.GetTextFromList(controlslist, "inCGDH");//采购单号
			model.inBZ = BasicHelp.GetTextFromList(controlslist, "inBZ");//备注
			return model;
		}

		//主表指标赋初始值
		public WarehousingOfGoodsModel GetModel(string type, long listid, CurrentUserEntity CurrentUser)
		{
			WarehousingOfGoodsModel model = new WarehousingOfGoodsModel();
			if (type == "add")
			{
				model.ListId = listid;
				if (listid != 0)
				{
					model = GetByWhereFirst("where listid=" + listid + "");
				}
				//赋初始值--系统指标或默认值
				model.inRKRQ = DateTime.Today;//系统指标当前日期
				model.inCK = "KF-001";//默认值
				model.inZDR = CurrentUser == null ? "!undefined" : CurrentUser.RealName;//系统指标当前用户真实姓名
				model.inXGDW = "KCTZ";//默认值
			}
			else
			{
				model = GetByWhereFirst("where listid=" + listid + "");
			}
			return model;
		}

		//同时处理复选框和图片指标
		public WarehousingOfGoodsModel GetModel(string json)
		{
			WarehousingOfGoodsModel model = new WarehousingOfGoodsModel();
			if (!string.IsNullOrEmpty(json))
			{
			   model = (WarehousingOfGoodsModel)JsonConvert.DeserializeObject<WarehousingOfGoodsModel>(json);
			   //处理主表复选框和图片

			}
			return model;
		}

		public void GetModel(string listid, ref WarehousingOfGoodsModel model)
		{
			if (model == null)
			{
				if (!string.IsNullOrEmpty(listid))
				{
					model = base.GetByWhereFirst("where listid=" + listid + "");
				}
                if (model == null)
                {
                    model = new WarehousingOfGoodsModel { ListId = long.Parse(listid) };//空值会报错
                }
			}
			else
			{
				if (!string.IsNullOrEmpty(listid))
				{
					model.ListId = long.Parse(listid);
				}
			}

			if(string.IsNullOrEmpty(model.createUser))
            {
				MainTBEntity entity = MainTBService.GetMainTBEntity(listid, _flowid);
				model.isLock = entity.isLock;
				model.createTime = entity.createTime;
				model.createUser = entity.createUser;
				model.createDept = entity.createDept;
				model.createDeptStr = entity.createDeptStr;
				model.runName = entity.runName;
				model.attachmentId = entity.attachmentId;
			}
		}

		public WarehousingOfGoodsModel GetModel(string listid, CurrentUserEntity user)
        {
            var model = base.GetByWhereFirst("where listid=" + listid + "");
            if (model == null)
                return null;

            model.createUser = user == null ? "!undefined" : user.Account;
            model.createDept = user == null ? "!undefined" : user.DeptNo;
            model.createDeptStr = user == null ? "!undefined" : user.DeptNoStr;
            model.isLock = "0";

            return model;
        }

		public void GetModelDefault(WarehousingOfGoodsModel model, CurrentUserEntity user)
		{
			model.createTime = DateTime.Now.ToString();
			model.state = 1;//1有效0无效-1已删除
			model.isLock = "0";
			model.createUser = user == null ? "!undefined" : user.Account;
			model.createDept = user == null ? "!undefined" : user.DeptNo;
			model.createDeptStr = user == null ? "!undefined" : user.DeptNoStr;
		}

		public DataTable ModelToDataTable(WarehousingOfGoodsModel model)
		{
			return DataTableHelp.ModelToDataTable <WarehousingOfGoodsModel> (model);
		}
		public long InsertModel(WarehousingOfGoodsModel model, DataTable dtMain, CurrentUserEntity user, string flowid, string tbname)
		{
			model.createTime = DateTime.Now.ToString();
			model.state = 1;
			model.isLock = "0";
			model.createUser = user == null ? "!undefined" : user.Account;
			model.createDept = user == null ? "!undefined" : user.DeptNo;
			model.createDeptStr = user == null ? "!undefined" : user.DeptNoStr;
			model.runName = BaseUtil.GetRunName(model.createUser, flowid, tbname, dtMain);
			
			return base.InsertReturnID(model);
		}
		#endregion GetObject 部分函数发布模式下会被调用
	}
}
```

```
@*YoursLC有源低代码 Create:admin 2023-08-01 11:22:45 添加或编辑-此文件放置于Views/WarehousingOfGoods /中*@

@using Think9.Models;
@*@model Think9.Models.WarehousingOfGoodsModel;*@
@{ ViewBag.Title = "Add";
	Layout = "~/Areas/Shared/_LayuiForm.cshtml"; }

@*货品入库 ---录入表样式按照默认方式一行两列生成，可能是因为未设计表单样式*@
<style>
	/* 防止table的下拉列表被隐藏*/
	.layui-table-cell {
		overflow: visible;
	}
	.layui-table-box {
		overflow: visible;
	}
	.layui-table-body {
		overflow: visible; /* 与手机端冲突 */
	}
	/* 设置下拉框的高度与表格单元相同 */
	td .layui-form-select {
		margin-top: -3px;
		margin-left: -7px;
		margin-right: -7px;
	}
	.layui-table-view .layui-table th {
		overflow: hidden;
	}
</style>
<form class="layui-form layui-form-pane" lay-filter="formUser">
<input style="display:none" id="_isDebug" value="debug">@*debug为调试；release为发布*@
<input style="display:none" id="_listid" value="@ViewBag.ListId">
<input style="display:none" id="_plit" value="@ViewBag.Split">@*多选框字符分割*@
<input style="display:none" id="_frm" value="@ViewBag.Frm">@*从哪里跳转来的?默认list*@
<input style="display:none" id="_type" value="@ViewBag.Type">@*add或edit*@
<input style="display:none" id="_userid" value="@ViewBag.UserId">@*用户id*@
<input style="display:none" id="_attachmentId">@*附件id*@
<input style="display:none" id="_fwid" value="@ViewBag.FId">@*当前流程编码*@
<input style="display:none" id="prc_id" value="@ViewBag.PrcId">@*当前流程步骤id*@
<input style="display:none" id="prc_no" value="@ViewBag.PrcNo">@*当前流程步骤编码*@
@*弹出选择时页面间传递数据*@
<input style="display:none" id="pu_value">@*弹出选择时使用-弹出页面选择的值*@
<input style="display:none" id="pu_tbid">@*弹出选择时使用-触发弹出页面的表id，_main或子表编码*@
<input style="display:none" id="pu_indexid">@*弹出选择时使用-触发弹出页面的指标编码*@
<input style="display:none" id="pu_rowid">@*弹出选择时使用-子表弹出，对应tableid 哪一行*@
<input style="display:none" id="pu_column">@*弹出选择时使用-子表弹出，第几列*@
<div class="layui-form">
 <div class="layui-form-item"  style="text-align: right;">
	<div class="layui-btn-container">
			@*<a href="" target="_blank" id="print" class="layui-btn">打印</a>*@
			<button type="button" class="layui-btn" id="att">附件</button>
			<button type="button" class="layui-btn" lay-submit lay-filter="edit" id="edit">保存</button>
			@*<button type="button" class="layui-btn" lay-submit lay-filter="next"  id="next">转交</button>*@
			@*<button type="button" class="layui-btn" lay-submit lay-filter="finish" id="finish">结束</button>*@
	 </div>
  </div>

	<div class="layui-row layui-col-space10">
		<div class="layui-col-xs12 layui-col-sm6 layui-col-md6">
			<label class="layui-form-label required">入库单号</label>
			<div class="layui-input-block">
				<input type='text' name='inRKDH' id='inRKDH' autocomplete='off' class='layui-input'  maxlength='30'    lay-verify='required'  placeholder='请输入入库单号'>
				</div>
			</div>
		<div class="layui-col-xs12 layui-col-sm6 layui-col-md6">
			<label class="layui-form-label required">日期</label>
			<div class="layui-input-block">
				<input  name='inRKRQ' id='inRKRQ'  class='layui-input' autocomplete='off'  onClick="WdatePicker({ el: this,dateFmt: 'yyyy-MM-dd'})" placeholder='yyyy-MM-dd'   lay-verify='required|date' >
			</div>
		</div>
	 </div>
	<div class="layui-row layui-col-space10">
		<div class="layui-col-xs12 layui-col-sm6 layui-col-md6">
			<label class="layui-form-label required">入库类型</label>
			<div class="layui-input-block">
				<select id="inRKLX" name="inRKLX"  lay-filter = "inRKLX"   lay-verify='required' >
					<option value="">==请选择==</option>
						@foreach (valueTextEntity item in ((IEnumerable<valueTextEntity>)ViewBag.SelectList).Where(x => x.ClassID == "inRKLX"))
						{
							 <option value="@item.Value">@item.Text</option>
						}
				</select>
				</div>
			</div>
		<div class="layui-col-xs12 layui-col-sm6 layui-col-md6">
			<label class="layui-form-label required">仓库</label>
			<div class="layui-input-block">
				<select id="inCK" name="inCK"  lay-filter = "inCK"   lay-verify='required' >
					<option value="">==请选择==</option>
						@foreach (valueTextEntity item in ((IEnumerable<valueTextEntity>)ViewBag.SelectList).Where(x => x.ClassID == "inCK"))
						{
							 <option value="@item.Value">@item.Text</option>
						}
				</select>
				</div>
			</div>
	 </div>
	<div class="layui-row layui-col-space10">
		<div class="layui-col-xs12 layui-col-sm6 layui-col-md6">
			<label class="layui-form-label required">制单人</label>
			<div class="layui-input-block">
				<input type='text' name='inZDR' id='inZDR' autocomplete='off' class='layui-input'  maxlength='30'    lay-verify='required'  placeholder='请输入制单人'>
				</div>
			</div>
		<div class="layui-col-xs12 layui-col-sm6 layui-col-md6">
			<label class="layui-form-label required">相关单位</label>
			<div class="layui-input-block">
				<select id="inXGDW" name="inXGDW"  lay-filter = "inXGDW"   lay-verify='required' >
					<option value="">==请选择==</option>
						@foreach (valueTextEntity item in ((IEnumerable<valueTextEntity>)ViewBag.SelectList).Where(x => x.ClassID == "inXGDW"))
						{
							 <option value="@item.Value">@item.Text</option>
						}
				</select>
				</div>
			</div>
	 </div>
	<div class="layui-row layui-col-space10">
		<div class="layui-col-xs12 layui-col-sm6 layui-col-md6">
			<label class="layui-form-label">金额</label>
			<div class="layui-input-block">
				<input type='text' name='inJE' id='inJE' autocomplete='off' class='layui-input'   maxlength='15'    lay-verify='number'   placeholder='自动计算'>
			</div>
		</div>
		<div class="layui-col-xs12 layui-col-sm6 layui-col-md6">
			<label class="layui-form-label">采购单号</label>
			<div class="layui-input-block">
				<input type='text' name='inCGDH' id='inCGDH' autocomplete='off' class='layui-input'  maxlength='30'     placeholder='选择采购单号后自动读取采购明细'>
				</div>
			</div>
	 </div>
	<div class="layui-row layui-col-space10">
		<div class="layui-col-xs12 layui-col-sm6 layui-col-md6">
			<label class="layui-form-label">备注</label>
			<div class="layui-input-block">
				<input type='text' name='inBZ' id='inBZ' autocomplete='off' class='layui-input'  maxlength='200'     placeholder='请输入备注'>
				</div>
			</div>
	 </div>
</div>
	<div class="layui-table-box" id="div_tb_WarehousingDetails">
		<table class="layui-hide" id="tb_WarehousingDetails" lay-filter="tableFilter"> </table></div>
</form>
<script>
	layui.config({
		base: '/self_js/'  /*自定义的js 在wwwroot/self_js文件夹中*/
	});
	layui.use(["form", "exLayer", "element", "exUtils",  "table", "WarehousingOfGoods"], function () {
		let form = layui.form;
		let layer = layui.layer;
		let table = layui.table;
		let exLayer = layui.exLayer;
		let exUtils = layui.exUtils;
		let element = layui.element;
		let myJS = layui.WarehousingOfGoods;
		let $ = layui.$;

		form.render();
		getFormVal();//控件赋值-复选框和图片

		//Tab选项
		element.on('tab(tabDemo)', function (data) {
        });
		//赋值--不包括多选框和图片
		form.val("formUser", {
			"inRKDH": "@Model.inRKDH"
			,"inRKRQ": showDate("@Model.inRKRQ")
			,"inRKLX": "@Model.inRKLX"
			,"inCK": "@Model.inCK"
			,"inZDR": "@Model.inZDR"
			,"inXGDW": "@Model.inXGDW"
			,"inJE": "@Model.inJE"
			,"inSHZT": "@Model.inSHZT"
			,"inCGDH": "@Model.inCGDH"
			,"inBZ": "@Model.inBZ"
		});
		//自定义控件赋值，用于多选框和图片的显示等
		function getFormVal() {

		}
		$('#inCGDH').on('click', function () {
			exLayer.open('选择采购单号', '/_TB/PopUpPage?tbid=_main&indexid=inCGDH&id=_n&from=add' + "&fwid=" + $("#_fwid").val(), '100%', '100%', '0px', '0px', null, null);
		});

		$('#att').on('click', function () {
			exLayer.open('附件上传', '/Com/FileManage/Attachment?fwid=' + $('#_fwid').val() + '&listid=' + $('#_listid').val() + '&prcid=' + $('#prc_id').val() + '&userid=' + $('#_userid').val() + '&attid=' + $('#_attachmentId').val(), '100%', '100%', '0px', '0px', null, null);
		});
		//点击保存按钮
		form.on("submit(edit)", function (data) {
			var _gridList = myJS.foreachGridTable();//遍历子表取数，在自定义js中定义
			exUtils.ajax('/_TB/SaveData', 'post', {
				model: data.field, 'gridlist': _gridList, listid: $('#_listid').val(), prcno: $('#prc_no').val(), type: $('#_type').val(), att: $('#_attachmentId').val(), fwid: $('#_fwid').val(), json: JSON.stringify(data.field, null, 4) }, true).done(function (response) {
				exLayer.greenTickMsg(response.message, function () {
				if ($('#_frm').val() == 'list') {
					//从list页面跳转需刷新列表
					$(window.parent.document).find('#search').click();
				}
				parent.layer.close(parent.layer.getFrameIndex(window.name));
			});
		}).fail(function (error) {
			console.log(error);
		});
			return false;
		});

		let tb_WarehousingDetails = table.render({
			elem: "#tb_WarehousingDetails",
			url: "/_TB/GetGridList?tbid=tb_WarehousingDetails"+"&listid=" + $('#_listid').val() + "&from=" + $('#_type').val() + "&fwid=" + $('#_fwid').val(),
			page: false,
			cols: [[
				@*flag与Vn(n为大于等于1的整数)之间不能手动插入或删除列，不能更改次序，否则会有错误*@
				{ field: "flag",  hide: true }
				,{ field: "v1", title: "编码", width: 130, templet: '#tb_WarehousingDetailsv1' }
				,{ field: "v2", title: "名称<span style='color: red'>*</span>", width: 130, templet: '#tb_WarehousingDetailsv2' }
				,{ field: "v3", title: "规格", width: 130, templet: '#tb_WarehousingDetailsv3' }
				,{ field: "v4", title: "单位", width: 130, templet: '#tb_WarehousingDetailsv4' }
				,{ field: "v5", title: "单价", width: 130, templet: '#tb_WarehousingDetailsv5' }
				,{ field: "v6", title: "数量", width: 130, templet: '#tb_WarehousingDetailsv6' }
				,{ field: "v7", title: "金额", width: 130, templet: '#tb_WarehousingDetailsv7' }
				,{ field: "v8", title: "备注", width: 180, templet: '#tb_WarehousingDetailsv8' }
				,{ title: "", align: "left", templet: "#addordelitem" }
			]],
			done: function (res, curr, count) {
				//手机给div设定宽度，要不表头显示不全
				if ($(window).width() < 768) {
					//$('th').hide();//表头隐藏
					$('#div_tb_WarehousingDetails').css({ 'width': '1270'});
				}
				$('.layui-table .layui-table-cell > span').css({ 'font-weight': 'bold' });

				if (count == -1) {
					layer.msg(res.msg, { icon: 5, time: 20000, btn: ['关闭'] });//显示错误
				}

			}

		});

	   table.on("tool(tableFilter)", function (obj) {
		let data = obj.data;
		switch (obj.event) {
			case "addGrid":
				addGrid(data);
				break;
			case "delGrid":
				delGrid(data);
				break;
		 }
		});

		//子表添加一条数据，点击右侧添加按钮调用
		function addGrid(data) {
			var _controlsList = myJS.getControlValueList();//主表所有控件
            var _gridList = myJS.getFirstGridTable();//只取子表数据首行
			exUtils.ajax("/_TB/AddGrid", "post", { model: data.field, "list": _gridList, tbid: data.TbId, listid: $('#_listid').val(), fwid: $("#_fwid").val(), controlslist: _controlsList }, true).done(function (response) {
				$("#_listid").val(response.extra);
				tableRender(data.TbId);//子表数据刷新
			}).fail(function (error) {
				console.log(error);
			});
		}

		//子表删除一条数据，点击右侧删除按钮调用
		function delGrid(data) {
		    var _controlsList = myJS.getControlValueList();//主表所有控件
			exLayer.confirm("确定要删除吗？", function () {
				exUtils.ajax("/_TB/DelGrid", "post", { flag: data.flag, listid: data.ListId, fwid: $("#_fwid").val(), controlslist: _controlsList }, true).done(function (response) {
					tableRender(data.TbId);//子表数据刷新
					 exUtils.tableSuccessMsg('删除成功！');
				}).fail(function (error) {
					console.log(error);
				});
			})
		}

		//子表刷新
		function tableRender(tbid) {
			if (tbid == 'tb_WarehousingDetails' || tbid.indexOf('#tb_WarehousingDetails#') > -1) {
				tb_WarehousingDetails.reload({
					url: "/_TB/GetGridList?tbid=tb_WarehousingDetails" + "&listid=" + $('#_listid').val() + "&from=" + $('#_type').val() + "&fwid=" + $('#_fwid').val()
				});
			}
		}

        table.on("toolbar(tableFilter)", function (obj) {
            switch (obj.event) {
                case "_event":
                    break;

            }
        });

		//弹出页面关闭后为控件赋值并执行数据读取 无弹出页面可删除
		$("#pu_value").click(function () {
			myJS.getValueFromPopUp();//弹出页面关闭后，将选择的Value赋值给触发弹出页面的input，在自定义js中定义
			readValue();//执行数据读取，每个弹出都触发--可手动优化
		});

		//数据读取
		function readValue() {
			var _gridList = myJS.getCurrentGridTable($('#pu_tbid').val(), $('#pu_rowid').val());
            var _controlsList = myJS.getControlValueList();//主表所有控件ID和Value，在自定义js中定义

			exUtils.ajax("/_TB/AfterControlSelect", "post", { controlslist: _controlsList, "gridlist": _gridList, id: $('#pu_rowid').val(), tbid: $('#pu_tbid').val(), indexid: $('#pu_indexid').val(), value: $('#pu_value').val(), fwid: $('#_fwid').val(), listid: $('#_listid').val() }, true).done(function (response) {
				var lists = response.list;
				var _listid = response.extra;
                var _grid = response.extra2;
				if (_listid != "") {
                    $('#_listid').val(_listid)
                }
                if (lists != null) {
                    //console.log(lists);
                    myJS.setValueByList(lists);//使用后台返回的lists，为控件赋值，在自定义js中定义
				}
				if (_grid != "") {
                    tableRender(_grid);//子表数据刷新
				}

				form.render();//一定要加
			}).fail(function (error) {
				console.log(error);
			});

			return false;
		}

		//打印
        function setPrint() {
            $("#print").attr("href", "/_TB/Print?listid=" + $('#_listid').val() + "&type=pdf&fwid=" + $('#_fwid').val());
        }

		//消息提示
        $(document).on("mouseenter", "*[lay-tips]", function () {
            var remind = $(this).attr("lay-tips");
            var tips = $(this).data("offset") || 4;
            var color = $(this).data("color") || '#88858e';
            layer.tips(remind, this, {
                time: -1,
                tips: [tips, color],
                area: ['auto', 'auto'],
            });
        }).on("mouseleave", "*[lay-tips]", function () {
            layer.closeAll("tips");
        });

		$(document).ready(function () {
		    setPrint();//打印

			myJS.setFormButDisable("@ViewBag.DisableBut");//控制页面按钮状态
		    myJS.setStateByFlow($('#prc_no').val());//根据步骤编码设置控件disabled属性
			form.render('select');//要加上，否则下拉选择disabled设置无效

			if (layui.device().mobile) {
				//手机端
				$(".layui-btn").attr("class", "layui-btn layui-btn-sm");
            }
        });
	});
</script>
<!-- 添加或删除 排除了统计行 -->
<script type='text/html' id='addordelitem'>
    {{#  if(d.Id >= 0){ }}
    {{#  if(d.Id == 0){ }}
    <button type="button" class='layui-btn layui-btn-xs' title='添加数据' lay-event='addGrid' id='addGrid'><i class='fa fa-plus'></i></button>
    {{#  } else{ }}
    <button type="button" class='layui-btn layui-btn-danger layui-btn-xs' title='删除数据' lay-event='delGrid' id='delGrid'><i class='fa fa-minus'></i></button>
    {{#  } }}
    {{#  } }}
</script>
<!-- 编码 -->
<script type="text/html" id="tb_WarehousingDetailsv1">
	<input type='text' name='tb_WarehousingDetailsv1' value = '{{d.v1_Exa}}' autocomplete='off' class='layui-input'  maxlength='30' style='height:30px;'  placeholder='编码' {{d.v1_JS}} {{d.v1_Lock}}>
</script>
<!-- 名称 -->
<script type="text/html" id="tb_WarehousingDetailsv2">
	<input type='text' name='tb_WarehousingDetailsv2' value = '{{d.v2_Exa}}' autocomplete='off' class='layui-input'  maxlength='30' style='height:30px;'  placeholder='名称'  {{d.v2_Lock}}>
</script>
<!-- 规格 -->
<script type="text/html" id="tb_WarehousingDetailsv3">
	<input type='text' name='tb_WarehousingDetailsv3' value = '{{d.v3_Exa}}' autocomplete='off' class='layui-input'  maxlength='30' style='height:30px;'  placeholder='规格'  {{d.v3_Lock}}>
</script>
<!-- 单位 -->
<script type='text/html' id='tb_WarehousingDetailsv4'>
	<div class='layui-input-inline' style='width:100px;'>
		<select name={{'id_'+d.Id}} data-value={{d.v4}} lay-filter='tb_WarehousingDetails_v4' {{d.v4_Lock}}>
		<option value="">==请选择==</option>
		{{d.v4_Exa}}
		</select>
	</div>
</script>
<!-- 单价 -->
<script type="text/html" id="tb_WarehousingDetailsv5">
	<input type='text' name='tb_WarehousingDetailsv5' value = '{{d.v5_Exa}}' autocomplete='off' class='layui-input'  maxlength='15' style='height:30px;'  placeholder='单价'  {{d.v5_Lock}}>
</script>
<!-- 数量 -->
<script type="text/html" id="tb_WarehousingDetailsv6">
	<input type='text' name='tb_WarehousingDetailsv6' value = '{{d.v6_Exa}}' autocomplete='off' class='layui-input'  maxlength='15' style='height:30px;'  placeholder='数量'  {{d.v6_Lock}}>
</script>
<!-- 金额 -->
<script type="text/html" id="tb_WarehousingDetailsv7">
	<input type='text' name='tb_WarehousingDetailsv7' value = '{{d.v7_Exa}}' autocomplete='off' class='layui-input'  maxlength='15' style='height:30px;'  placeholder='¥'  {{d.v7_Lock}}>
</script>
<!-- 备注 -->
<script type="text/html" id="tb_WarehousingDetailsv8">
	<input type='text' name='tb_WarehousingDetailsv8' value = '{{d.v8_Exa}}' autocomplete='off' class='layui-input'  maxlength='100' style='height:30px;'  placeholder='备注'  {{d.v8_Lock}}>
</script>
<!-- 子表onclick调用 -->
<script>
	function PopUpPage(tbid, indexid, id) {
		var url = '/_TB/PopUpPage?';
		PopSelectValue(tbid, indexid, id, url, document.getElementById("_fwid").value);
	}
	function PopUpImgUplaod(tbid, indexid, id, fname) {
		PopImgUplaod2(tbid, indexid, id, fname);
	}
</script>
```


```
/**
 * Create:admin 2023-08-01 11:22:46
 * description:YoursLC有源低代码 自定义扩展 此文件放置于wwwroot/self_js文件夹中
 */

layui.define(['jquery', 'table'], function (exports) {
    let table = layui.table;
    let $ = layui.$;

    var api = {
        //编辑时锁定
        lockForEditing: function (_type) {
        },
        searchShow: function () {
            var display = $('#searchfield').css('display');
            if (display == 'none') {
                $("#searchfield").show();
                document.body.scrollTop = document.documentElement.scrollTop = 0;
            }
            else {
                $("#searchfield").hide();
            }
        },
        //控制list页面按钮状态
        setListButDisable: function (strDisable) {
            layui.device().mobile ? $("#batchDel").html('<i class="fa fa-trash-o"></i>删除') : $("#batchDel").html('<i class="fa fa-trash-o"></i>批量删除');
            if (strDisable == 'all' || strDisable.indexOf("[batchDel]") > -1) {
                $("#batchDel").attr("class", "layui-btn layui-btn-disabled layui-btn-sm");//禁用批量删除
                $("#batchDel").removeAttr("lay-event");
            }

            layui.device().mobile ? $("#mergeExport").html('<i class="fa fa-file-pdf-o"></i>导出') : $("#mergeExport").html('<i class="fa fa-file-pdf-o"></i>合并导出');
            if (strDisable == 'all' || strDisable.indexOf("[mergeExport]") > -1) {
                $("#mergeExport").attr("class", "layui-btn layui-btn-disabled layui-btn-sm");//禁用批量导出
                $("#mergeExport").removeAttr("lay-event");
            }

            layui.device().mobile ? $("#importExcel").html('<i class="fa fa-file-excel-o"></i>导入') : $("#importExcel").html('<i class="fa fa-file-excel-o"></i>数据导入');
            if (strDisable == 'all' || strDisable.indexOf("[importExcel]") > -1) {
                $("#importExcel").attr("class", "layui-btn layui-btn-disabled layui-btn-sm");//禁用数据导入
                $("#importExcel").removeAttr("lay-event");
            }

            layui.device().mobile ? $("#add").html('<i class="fa fa-plus"></i>新增') : $("#add").html('<i class="fa fa-plus"></i>新增数据');
            if (strDisable == 'all' || strDisable.indexOf("[add]") > -1) {
                $("#add").attr("class", "layui-btn layui-btn-disabled layui-btn-sm");//禁用数据新增
                $("#add").removeAttr("lay-event");
            }
        },
        //控制form页面按钮状态
        setFormButDisable: function (strDisable) {
            if (strDisable == 'all' || strDisable.indexOf("[print]") > -1) {
                $("#print").attr("class", "layui-btn layui-btn-disabled");//禁用打印
                $("#print").removeAttr("href");
            }
            if (strDisable == 'all' || strDisable.indexOf("[att]") > -1) {
                $("#att").attr("class", "layui-btn layui-btn-disabled");//禁用附件
                $('#att').unbind('click');
            }
            if (strDisable == 'all' || strDisable.indexOf("[edit]") > -1) {
                $("#edit").attr("class", "layui-btn layui-btn-disabled");//禁用保存
                $("#edit").removeAttr("lay-filter");
            }
            if (strDisable == 'all' || strDisable.indexOf("[next]") > -1) {
                $("#next").attr("class", "layui-btn layui-btn-disabled");//禁用转交
                $("#next").removeAttr("lay-filter");
            }
            if (strDisable == 'all' || strDisable.indexOf("[finish]") > -1) {
                $("#finish").attr("class", "layui-btn layui-btn-disabled");//禁用结束
                $("#finish").removeAttr("lay-filter");
            }
        },

        //导出文件
        downFile: function (url, fileName) {
            var xhr = new XMLHttpRequest();
            xhr.open('post', url, true);
            xhr.responseType = "blob";// 返回类型blob
            xhr.onload = function () {
                if (this.status === 200) {
                    var blob = this.response;
                    var reader = new FileReader();
                    reader.readAsDataURL(blob);
                    reader.onload = function (e) {
                        var a = document.createElement('a');
                        a.download = fileName;
                        a.href = e.target.result;
                        $("body").append(a);  // 修复firefox中无法触发click
                        a.click();
                        $(a).remove();
                    }
                }
            };
            xhr.send()
        },

        //将所有主表控件（ID、Value和ControlType）Push到list中
        getControlValueList: function () {
            var _list = [];
            _list.push({ ControlID: 'listid', ControlValue: $('#_listid').val(), ControlType: '1' });//listid
            _list.push({ ControlID: 'inRKDH', ControlValue: $('#inRKDH').val(), ControlType: '1' });//入库单号
            _list.push({ ControlID: 'inRKRQ', ControlValue: $('#inRKRQ').val(), ControlType: '1' });//入库日期
            _list.push({ ControlID: 'inRKLX', ControlValue: $('#inRKLX').val(), ControlType: '2' });//入库类型
            _list.push({ ControlID: 'inCK', ControlValue: $('#inCK').val(), ControlType: '2' });//仓库
            _list.push({ ControlID: 'inZDR', ControlValue: $('#inZDR').val(), ControlType: '1' });//制单人
            _list.push({ ControlID: 'inXGDW', ControlValue: $('#inXGDW').val(), ControlType: '2' });//相关单位
            _list.push({ ControlID: 'inJE', ControlValue: $('#inJE').val(), ControlType: '1' });//金额
            _list.push({ ControlID: 'inSHZT', ControlValue: $('#inSHZT').val(), ControlType: '2' });//审核状态
            _list.push({ ControlID: 'inCGDH', ControlValue: $('#inCGDH').val(), ControlType: '1' });//采购单号
            _list.push({ ControlID: 'inBZ', ControlValue: $('#inBZ').val(), ControlType: '1' });//备注
            return _list;
        },

        //固定流程时根据流程编码设置控件读写状态
        setStateByFlow: function (prcno) {
            //无流程
        },

        //执行数据读取--使用后台返回的lists，为控件赋值
        setValueByList: function (lists) {
            //主表
            if ($('#pu_tbid').val() == '_main') {
                for (var item in lists) {
                    var _value = lists[item].ControlValue;
                    var _id = lists[item].ControlID;
                    var _type = lists[item].ControlType;
                    var _list = lists[item].ListValue;
                    if (_list == null) {
                        //读取单值
                        //text文本框
                        if (_type == "1") {
                            $("#" + _id).val(_value);
                        }
                        //select下拉选择
                        if (_type == "2") {
                            $("select[name=" + _id + "]").val(_value);
                            /* $("#" + _id).val(_value);*/
                        }
                        //checkbox复选框
                        if (_type == "3") {
                        }
                        //radio单选框
                        if (_type == "4") {
                            $("input[name=" + _id + "]" + "[value='" + _value + "']").prop('checked', 'checked');
                        }
                        //img图片
                        if (_type == "5") {
                        }
                    }
                    else {
                        //数据联动
                        var _controlid = "#" + _id;
                        $("" + _controlid + "").empty(); //清空控件
                        if (_type == "2") {
                            $("" + _controlid + "").append(new Option('==请选择==', ''));
                        }
                        $.each(_list, function (i, item) {
                            $("" + _controlid + "").append(new Option(item.Text, item.Value));
                        });
                    }
                }
            }
            else {//子表
                var _starts = "#" + $('#pu_tbid').val() + "#" + $('#pu_rowid').val() + "#";
                var trList = $(".layui-table").find("tr");
                for (var i = 0; i < trList.length; i++) {
                    var tdArr = trList.eq(i).find("td");
                    if (tdArr.eq(0).text().startsWith(_starts) && $('#pu_tbid').val() == 'tb_WarehousingDetails') {
                        for (var item in lists) {
                            var _list = lists[item].ListValue;
                            var _value = lists[item].ControlValue;
                            var _id = lists[item].ControlID.replace("v", "");//列序号如1、2、3...
                            if (_list == null) {
                                //读取单值
                                if (lists[item].ControlType == "2") {
                                    tdArr.eq(parseInt(_id)).find('select').val(_value);//下拉选择
                                }
                                else {
                                    tdArr.eq(parseInt(_id)).find('input').val(_value);
                                }
                            }
                            else {
                                //数据联动
                                if (lists[item].ControlType == "2") {
                                    tdArr.eq(parseInt(_id)).find('select').empty();
                                    $.each(_list, function (i, item) {
                                        tdArr.eq(parseInt(_id)).find('select').append(new Option(item.Text, item.Value));
                                    });
                                }
                            }
                        }
                    }
                }
            }
        },

        //弹出选择触发--弹出页面关闭后，将选择的Value赋值给触发弹出页面的input
        getValueFromPopUp: function (tbid, indexid, id) {
            var _tbid = $('#pu_tbid').val();//表id，主表为_main
            var _id = $('#pu_rowid').val();//子表数据主键
            var _indexid = $('#pu_indexid').val();//指标编码
            var _v = $('#pu_column').val();//第几列--子表弹出时有用
            var _value = $('#pu_value').val();//弹出页面选择的值
            var flag = '';

            if (_tbid == '_main') {
                $("#" + _indexid + "").val(_value);
            }
            else {
                var flag = '';
                var _starts = "#" + _tbid + "#" + _id + "#";
                var trList = $(".layui-table").find("tr");
                for (var i = 0; i < trList.length; i++) {
                    var tdArr = trList.eq(i).find("td");
                    flag = tdArr.eq(0).text();
                    if (flag.startsWith(_starts) && _tbid == 'tb_WarehousingDetails') {
                        tdArr.eq(parseInt(_v)).find('input').val(_value);
                    }
                }
            }
        },
        //某个子表table首行取数--增加行的Grid
        getFirstGridTable: function () {
            var _list = [];
            var trList = $(".layui-table").find("tr");  //获取table下的所有tr
            for (var i = 0; i < trList.length; i++) {  //遍历所有的tr
                var tdArr = trList.eq(i).find("td"); //获取该tr下的所有td
                var flag = tdArr.eq(0).text();
                if (flag.startsWith('#tb_WarehousingDetails#') && flag.substr(-3) == '#0#') {
                    var _row = {};
                    _row.flag = flag;
                    _row.v1 = tdArr.eq(1).find('input').val();//编码
                    _row.v2 = tdArr.eq(2).find('input').val();//名称
                    _row.v3 = tdArr.eq(3).find('input').val();//规格
                    _row.v4 = tdArr.eq(4).find('select').val();//单位
                    _row.v5 = tdArr.eq(5).find('input').val();//单价
                    _row.v6 = tdArr.eq(6).find('input').val();//数量
                    _row.v7 = tdArr.eq(7).find('input').val();//金额
                    _row.v8 = tdArr.eq(8).find('input').val();//备注
                    _list.push(_row);
                }
            }
            return _list;
        },
        //某个子表table取数
        getCurrentGridTable: function (tbid, id) {
            var _list = [];
            var trList = $(".layui-table").find("tr");  //获取table下的所有tr
            for (var i = 0; i < trList.length; i++) {  //遍历所有的tr
                var tdArr = trList.eq(i).find("td"); //获取该tr下的所有td
                var flag = tdArr.eq(0).text();
                if (flag.startsWith('#tb_WarehousingDetails#' + id + '#') && tbid == 'tb_WarehousingDetails') {
                    var _row = {};
                    _row.flag = flag;
                    _row.v1 = tdArr.eq(1).find('input').val();//编码
                    _row.v2 = tdArr.eq(2).find('input').val();//名称
                    _row.v3 = tdArr.eq(3).find('input').val();//规格
                    _row.v4 = tdArr.eq(4).find('select').val();//单位
                    _row.v5 = tdArr.eq(5).find('input').val();//单价
                    _row.v6 = tdArr.eq(6).find('input').val();//数量
                    _row.v7 = tdArr.eq(7).find('input').val();//金额
                    _row.v8 = tdArr.eq(8).find('input').val();//备注
                    _list.push(_row);
                }
            }
            return _list;
        },
        //遍历子表table取数--可从多个子表取值
        foreachGridTable: function () {
            var _list = [];
            var trList = $(".layui-table").find("tr");  //获取table下的所有tr
            for (var i = 0; i < trList.length; i++) {  //遍历所有的tr
                var tdArr = trList.eq(i).find("td"); //获取该tr下的所有td
                var flag = tdArr.eq(0).text();
                if (flag.startsWith('#tb_WarehousingDetails#')) {
                    var _row = {};
                    _row.flag = flag;
                    _row.v1 = tdArr.eq(1).find('input').val();//编码
                    _row.v2 = tdArr.eq(2).find('input').val();//名称
                    _row.v3 = tdArr.eq(3).find('input').val();//规格
                    _row.v4 = tdArr.eq(4).find('select').val();//单位
                    _row.v5 = tdArr.eq(5).find('input').val();//单价
                    _row.v6 = tdArr.eq(6).find('input').val();//数量
                    _row.v7 = tdArr.eq(7).find('input').val();//金额
                    _row.v8 = tdArr.eq(8).find('input').val();//备注
                    _list.push(_row);
                }
            }
            return _list;
        },
        //设置子表不可编辑
        setGridDisabled: function (grid) {
            var trList = $(".layui-table").find("tr");  //获取table下的所有tr
            for (var i = 0; i < trList.length; i++) {  //遍历所有的tr
                var tdArr = trList.eq(i).find("td"); //获取该tr下的所有td
                var flag = tdArr.eq(0).text();
                if (flag.startsWith('#tb_WarehousingDetails#') && grid == 'tb_WarehousingDetails') {
                    tdArr.eq(1).find('input').attr('disabled', 'disabled');//编码
                    tdArr.eq(2).find('input').attr('disabled', 'disabled');//名称
                    tdArr.eq(3).find('input').attr('disabled', 'disabled');//规格
                    tdArr.eq(4).find('select').attr('disabled', 'disabled');//单位
                    tdArr.eq(5).find('input').attr('disabled', 'disabled');//单价
                    tdArr.eq(6).find('input').attr('disabled', 'disabled');//数量
                    tdArr.eq(7).find('input').attr('disabled', 'disabled');//金额
                    tdArr.eq(8).find('input').attr('disabled', 'disabled');//备注
                    tdArr.eq(9).find('button').attr('disabled', 'disabled');//右侧添加删除按钮
                    tdArr.eq(9).find('button').attr('class', 'layui-btn layui-btn-disabled layui-btn-xs');
                    tdArr.eq(9).find('button').removeAttr('lay-event');
                }
            }
        }
    };

    //暴露接口
    exports('WarehousingOfGoods', api);
});
```



#### 说明
除Think9.CreatCode.dll和Think9.Settings.dll（这两个模块处理代码生成和自定义设置功能）其余代码全部开源
YoursLC有源低代码包括免费版和收费版，免费版会有部分功能限制，如需收费版，联系qq：576463026

讨论交流QQ群（937494747）