# YoursLC有源低代码

**Repository Path**: adaiauto/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-11-25
- **Last Updated**: 2023-11-25

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# YoursLC有源低代码

#### V1.10更新 20231014

- 移动端增强功能，自动生成适配移动端的H5页面
- 代码模板功能，解决重新生成时代码覆盖的问题
- ......
- 修复了已知bug，部分功能做了优化

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

#### 在线体验
 http://203.189.7.11:9009  admin 123456

#### 软件架构
基于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应用、修改源码和调试代码；
-  **开发版使用发布模式无需替换代码也能按照最新设置运行程序，可查看运行效果，最后一键生成源码，然后再启用调式模式进行代码调试和修改** ，如此可大大提高开发效率


#### 功能截图
移动端增强功能，自动生成适配移动端的页面
![输入图片说明](%E5%BE%AE%E4%BF%A1%E5%9B%BE%E7%89%87_20231014104344.jpg)![输入图片说明](%E5%BE%AE%E4%BF%A1%E5%9B%BE%E7%89%87_20231014104528.jpg)![输入图片说明](%E5%BE%AE%E4%BF%A1%E5%9B%BE%E7%89%87_20231014104611.jpg)

【数据规范】为录入表指标指定数据规范，可实现自动填写（为文本框赋值）、选择输入（为下拉框、弹出选择设置数据源），包括自动编号、单列选择、多列选择、树形选择
![输入图片说明](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 弹出处理--文本框设置了数据规范（单列、多列或树形选择），点击文本框将弹出页面
    }
}
```


```
@*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）