using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using VueWebCoreApi.DLL.BLL;
using VueWebCoreApi.Models;
using VueWebCoreApi.Models.RolePermission;
using VueWebCoreApi.Models.WorkData;
using VueWebCoreApi.Tools;
using static VueWebCoreApi.Models.RolePermission.RolePermissionSava;

namespace VueWebCoreApi.Controllers
{
    [ApiExplorerSettings(GroupName = "基础设置")]
    [ApiController]
    [Route("api/[controller]")]
    [ChannelActionFilter]
    public class BasicSettingController : Controller
    {
        //定义全局信息返回变量
        ToMessage mes = new ToMessage();
        RedisCommon redis = new RedisCommon();

        #region[组织架构,查询组织信息]
        /// <summary>
        /// 组织架构,查询组织信息
        /// </summary>
        /// <param name="storg_code">组织编码</param>
        /// <param name="storg_name">组织名称</param>
        /// <returns></returns>
        [Route(template: "STorgData")]
        [HttpGet]
        public JsonResult STorgData(string storg_code, string storg_name)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = BasicSettingBLL.STorgData(storg_code, storg_name);
            return Json(mes);
        }
        #endregion

        #region[组织架构新增编辑]
        /// <summary>
        /// 组织架构新增编辑
        /// </summary>
        /// <param name="obj">提交数据对象</param>
        /// <returns></returns>
        [Route(template: "AddUpdateOrganization")]
        [HttpPost]
        public JsonResult AddUpdateOrganization([FromBody] JObject obj)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            string OrganCode = obj["OrganCode"].ToString(); //组织编码
            string OrganName = obj["OrganName"].ToString(); //组织名称
            string leve = obj["leve"].ToString(); //层级编码
            string parent_id = obj["parent_id"].ToString(); //parent_id
            string storgcode = obj["storgcode"].ToString(); //所属组织编码
            string torg_seq = obj["torg_seq"].ToString(); //排序序号
            string status = obj["status"].ToString(); //状态
            string OperType = obj["OperType"].ToString();  //操作类型
            mes = BasicSettingBLL.AddUpdateOrganization(OrganCode, OrganName, leve, parent_id, storgcode, torg_seq, status, OperType, us);
            return Json(mes);
        }
        #endregion

        #region[组织架构删除]
        /// <summary>
        /// 组织架构删除
        /// </summary>
        /// <param name="orgcode">组织编码</param>
        /// <returns></returns>
        [Route(template: "DeleteOrganization")]
        [HttpPost]
        public JsonResult DeleteOrganization(string orgcode)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = BasicSettingBLL.DeleteOrganization(orgcode, us);
            return Json(mes);
        }
        #endregion


        #region[岗位信息列表查询]
        /// <summary>
        /// 岗位信息列表查询
        /// </summary>
        /// <param name="postcode">岗位编码</param>
        /// <param name="postname">岗位名称</param>
        /// <param name="page">页码</param>
        /// <param name="rows">每页显示条数</param>
        /// <param name="prop">排序字段</param>
        /// <param name="order">排序规则</param>
        /// <returns></returns>
        [Route(template: "PostData")]
        [HttpGet]
        public JsonResult PostData(string postcode, string postname, int page = 0, int rows = 0, string prop = null, string order = null)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            int startNum = rows * (page - 1) + 1;  //起始记录rowNum
            int endNum = rows * page;   //结束记录 rowNum
            mes = BasicSettingBLL.PostData(postcode, postname, startNum, endNum, prop, order);
            return Json(mes);
        }
        #endregion

        #region[岗位新增编辑]
        /// <summary>
        /// 岗位新增编辑
        /// </summary>
        /// <param name="obj">提交数据对象</param>
        /// <returns></returns>
        [Route(template: "AddUpdatePost")]
        [HttpPost]
        public JsonResult AddUpdatePost([FromBody] JObject obj)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            string postcode = obj["postcode"].ToString(); //岗位编码
            string postname = obj["postname"].ToString(); //岗位名称
            string description = obj["description"].ToString();//岗位描述
            string status = obj["status"].ToString(); //状态
            string OperType = obj["OperType"].ToString();  //操作类型
            mes = BasicSettingBLL.AddUpdatePost(postcode, postname, description, status, OperType, us);
            return Json(mes);
        }
        #endregion

        #region[岗位删除]
        /// <summary>
        /// 岗位删除
        /// </summary>
        /// <param name="postcode">岗位编码</param>
        /// <returns></returns>
        [Route(template: "DeletePost")]
        [HttpPost]
        public JsonResult DeletePost(string postcode)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = BasicSettingBLL.DeletePost(postcode, us);
            return Json(mes);
        }
        #endregion


        #region[用户信息列表查询]
        /// <summary>
        /// 用户信息列表查询
        /// </summary>
        /// <param name="storgcode">左侧组织编码</param>
        /// <param name="usercode">用户编码</param>
        /// <param name="username">用户名称</param>
        /// <param name="page">页码</param>
        /// <param name="rows">每页显示条数</param>
        /// <param name="prop">排序字段</param>
        /// <param name="order">排序规则</param>
        /// <returns></returns>
        [Route(template: "UserData")]
        [HttpGet]
        public JsonResult UserData(string storgcode, string usercode, string username, int page = 0, int rows = 0, string prop = null, string order = null)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            int startNum = rows * (page - 1) + 1;  //起始记录rowNum
            int endNum = rows * page;   //结束记录 rowNum
            mes = BasicSettingBLL.UserData(storgcode, usercode, username, startNum, endNum, prop, order);
            return Json(mes);
        }
        #endregion

        #region[用户信息新增编辑]
        /// <summary>
        /// 用户信息新增编辑
        /// </summary>
        /// <param name="obj">提交数据</param>
        /// <returns></returns>
        [Route(template: "AddUpdateUserSave")]
        [HttpPost]
        public JsonResult AddUpdateUserSave([FromBody] JObject obj)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            string usercode = obj["usercode"].ToString(); //用户编码
            string username = obj["username"].ToString(); //用户名称
            string password = obj["password"].ToString();//用户密码
            string payrate = obj["payrate"].ToString();//薪资属性
            string mobile = obj["mobile"].ToString();//手机号
            string email = obj["email"].ToString();//邮箱
            string storg_code = obj["storg_code"].ToString();//所属组织
            string status = obj["status"].ToString(); //状态
            string post_code = obj["post_code"].ToString();//岗位
            string role_code = obj["role_code"].ToString();//角色
            string group_code = obj["group_code"].ToString();//班组
            string opertype = obj["OperType"].ToString();  //操作类型
            mes = BasicSettingBLL.AddUpdateUserSave(usercode, username, password, payrate,mobile, email, storg_code, status, post_code, role_code, group_code, opertype, us);
            return Json(mes);
        }
        #endregion

        #region[用户信息删除]
        /// <summary>
        /// 用户信息删除
        /// </summary>
        /// <param name="usercode">用户编码</param>
        /// <returns></returns>
        [Route(template: "DeleteUserSave")]
        [HttpPost]
        public JsonResult DeleteUserSave(string usercode)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = BasicSettingBLL.DeleteUserSave(usercode, us);
            return Json(mes);
        }
        #endregion


        #region[班组信息列表查询]
        /// <summary>
        /// 班组信息列表查询
        /// </summary>
        /// <param name="groupcode">班组编码</param>
        /// <param name="groupname">班组名称</param>
        /// <param name="page">页码</param>
        /// <param name="rows">每页显示条数</param>
        /// <param name="prop">排序字段</param>
        /// <param name="order">排序规则</param>
        /// <returns></returns>
        [Route(template: "GroupData")]
        [HttpGet]
        public JsonResult GroupData(string groupcode, string groupname, int page = 0, int rows = 0, string prop = null, string order = null)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            int startNum = rows * (page - 1) + 1;  //起始记录rowNum
            int endNum = rows * page;   //结束记录 rowNum
            mes = BasicSettingBLL.GroupData(groupcode, groupname, startNum, endNum, prop, order);
            return Json(mes);
        }
        #endregion

        #region[班组新增编辑]
        /// <summary>
        /// 班组新增编辑
        /// </summary>
        /// <param name="obj">提交数据对象</param>
        /// <returns></returns>
        [Route(template: "AddUpdateGroup")]
        [HttpPost]
        public JsonResult AddUpdateGroup([FromBody] JObject obj)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            string groupcode = obj["groupcode"].ToString(); //班组编码
            string groupname = obj["groupname"].ToString(); //班组名称
            string description = obj["description"].ToString();//班组描述
            string status = obj["status"].ToString(); //状态
            string OperType = obj["OperType"].ToString();  //操作类型
            mes = BasicSettingBLL.AddUpdateGroup(groupcode, groupname, description, status, OperType, us);
            return Json(mes);
        }
        #endregion

        #region[班组删除]
        /// <summary>
        /// 班组删除
        /// </summary>
        /// <param name="groupcode">班组编码</param>
        /// <returns></returns>
        [Route(template: "DeleteGroup")]
        [HttpPost]
        public JsonResult DeleteGroup(string groupcode)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = BasicSettingBLL.DeleteGroup(groupcode, us);
            return Json(mes);
        }
        #endregion


        #region[角色管理列表查询]
        /// <summary>
        /// 角色管理列表查询
        /// </summary>
        /// <param name="role_code">角色编码</param>
        /// <param name="role_name">角色名称</param>
        /// <param name="page">页码</param>
        /// <param name="rows">每页显示条数</param>
        /// <param name="prop">排序字段</param>
        /// <param name="order">排序规则</param>
        /// <returns></returns>
        [Route(template: "RoleData")]
        [HttpGet]
        public JsonResult RoleData(string role_code, string role_name, int page = 0, int rows = 0, string prop = null, string order = null)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            int startNum = rows * (page - 1) + 1;  //起始记录rowNum
            int endNum = rows * page;   //结束记录 rowNum
            mes = BasicSettingBLL.RoleData(role_code, role_name, startNum, endNum, prop, order);
            return Json(mes);
        }
        #endregion

        #region[角色管理新增、编辑保存]
        /// <summary>
        /// 角色管理新增、编辑保存
        /// </summary>
        /// <param name="obj">提交数据对象</param>
        /// <returns></returns>
        [Route(template: "RoleAddUpdateSava")]
        [HttpPost]
        public JsonResult RoleAddUpdateSava([FromBody] JObject obj)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            var menucode = HttpContext.Request.Headers["Menucode"].ToString(); //菜单编码
            string rolecode = obj["rolecode"].ToString(); //角色编码
            string rolename = obj["rolename"].ToString(); //角色名称
            string status = obj["status"].ToString();//状态
            string datacode = obj["datacode"].ToString(); //数据范围
            string datapermissions = obj["datapermissions"].ToString(); //数据权限
            string description = obj["description"].ToString(); //描述
            string OperType = obj["OperType"].ToString();  //操作类型
            mes = BasicSettingBLL.RoleAddUpdateSava(menucode, rolecode, rolename, status, datacode, datapermissions, description, OperType, us);
            return Json(mes);
        }
        #endregion

        #region[角色管理删除]
        [Route(template: "RoleDeleteSava")]
        [HttpPost]
        public JsonResult RoleDeleteSava(string rolecode)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = BasicSettingBLL.RoleDeleteSava(rolecode, us);
            return Json(mes);
        }
        #endregion


        #region[角色管理分配用户,获取已分配用户列表]
        /// <summary>
        /// 角色管理分配用户,获取已分配用户列表
        /// </summary>
        /// <param name="flag">TRUE(已关联) FALSE(未关联)</param>
        /// <param name="role_code">角色编码</param>
        /// <param name="usercode">用户编码</param>
        /// <param name="username">用户名称</param>
        /// <param name="storg_code">组织编码</param>
        /// <param name="post_code">岗位编码</param>
        /// <param name="group_code">班组编码</param>
        /// <param name="page">页码</param>
        /// <param name="rows">每页显示条数</param>
        /// <param name="prop">排序字段</param>
        /// <param name="order">排序规则</param>
        /// <returns></returns>
        [Route(template: "RoleAssignedUserData")]
        [HttpGet]
        public JsonResult RoleAssignedUserData(string flag, string role_code, string usercode, string username, string storg_code, string post_code, string group_code, int page = 0, int rows = 0, string prop = null, string order = null)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            int startNum = rows * (page - 1) + 1;  //起始记录rowNum
            int endNum = rows * page;   //结束记录 rowNum
            mes = BasicSettingBLL.RoleAssignedUserData(flag, role_code, usercode, username, storg_code, post_code, group_code, startNum, endNum, prop, order);
            return Json(mes);
        }

        #endregion

        #region[角色管理分配用户,批量取消已分配的用户]
        /// <summary>
        /// 角色编码
        /// </summary>
        /// <param name="role_code">角色编码</param>
        /// <param name="user">用户编码数组</param>
        /// <returns></returns>
        [Route(template: "RoleAssignedUserBatchCancel")]
        [HttpPost]
        public JsonResult RoleAssignedUserBatchCancel(string role_code, string[] user)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = BasicSettingBLL.RoleAssignedUserBatchCancel(role_code, user, us);
            return Json(mes);
        }
        #endregion

        #region[角色管理分配用户,批量添加未分配的用户]
        /// <summary>
        /// 角色编码
        /// </summary>
        /// <param name="role_code">角色编码</param>
        /// <param name="user">用户编码数组</param>
        /// <returns></returns>
        [Route(template: "RoleAssignedUserBatchAdd")]
        [HttpPost]
        public JsonResult RoleAssignedUserBatchAdd(string role_code, string[] user)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = BasicSettingBLL.RoleAssignedUserBatchAdd(role_code, user, us);
            return Json(mes);
        }
        #endregion


        #region[角色权限查询角色]
        /// <summary>
        /// 角色权限查询角色
        /// </summary>
        /// <returns></returns>
        [Route(template: "RolePermissionSearchRole")]
        [HttpGet]
        public JsonResult RolePermissionSearchRole()
        {
            mes = BasicSettingBLL.RolePermissionSearchRole();
            return Json(mes);
        }
        #endregion

        #region[角色权限查询默认菜单按钮数据]
        /// <summary>
        /// 角色权限查询默认菜单按钮数据
        /// </summary>
        /// <param name="type">操作端类型(PC/APP)</param>
        /// <returns></returns>
        [Route(template: "RolePermissionSearchRoleMenu")]
        [HttpGet]
        public JsonResult RolePermissionSearchRoleMenu(string type)
        {
            mes = BasicSettingBLL.RolePermissionSearchRoleMenu(type);
            return Json(mes);
        }
        #endregion

        #region[角色权限,根据角色查找关联权限]
        /// <summary>
        /// 角色权限,根据角色查找关联权限
        /// </summary>
        /// <param name="rolecode">角色编码</param>
        /// <param name="type">菜单编码</param>
        /// <returns></returns>
        [Route(template: "RolePermissionSearchRoleMenuButton")]
        [HttpGet]
        public JsonResult RolePermissionSearchRoleMenuButton(string rolecode, string type)
        {
            mes = BasicSettingBLL.RolePermissionSearchRoleMenuButton(rolecode, type);
            return Json(mes);
        }
        #endregion

        #region[角色权限,提交]
        /// <summary>
        /// 角色权限,提交
        /// </summary>
        /// <param name="type">类型</param>
        /// <param name="rolecode">角色编码</param>
        /// <param name="json">提交数据</param>
        /// <returns></returns>
        [Route(template: "RolePermissionSava")]
        [HttpPost]
        public JsonResult RolePermissionSava([FromBody] object json, string rolecode, string type)
        {
            var jsonStr = JsonConvert.SerializeObject(json);
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = BasicSettingBLL.RolePermissionSava(jsonStr, rolecode, type, us);
            return Json(mes);
        }
        #endregion



        #region[往来单位分类信息]
        /// <summary>
        /// 往来单位分类信息
        /// </summary>
        /// <returns></returns>
        [Route(template: "TCunstomerClassTree")]
        [HttpGet]
        public JsonResult TCunstomerClassTree()
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = BasicSettingBLL.TCunstomerClassTree();
            return Json(mes);
        }
        #endregion

        #region[往来单位分类新增/编辑提交]
        /// <summary>
        /// 往来单位分类新增/编辑提交
        /// </summary>
        /// <param name="data_sources">数据来源:ERP/MES</param>
        /// <param name="customerclasscode">往来单位分类编码</param>
        /// <param name="customerclassname">往来单位分类名称</param>
        /// <param name="parentcode">上级分类编码</param>
        /// <param name="OperType">操作类型:Add/Update</param>
        /// <returns></returns>
        [Route(template: "TCunstomerClassTreeAddUpdate")]
        [HttpPost]
        public JsonResult TCunstomerClassTreeAddUpdate(string data_sources, string customerclasscode, string customerclassname, string parentcode, string OperType)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = BasicSettingBLL.TCunstomerClassTreeAddUpdate(data_sources, customerclasscode, customerclassname, parentcode, OperType, us);
            return Json(mes);
        }
        #endregion

        #region[往来单位分类删除]
        /// <summary>
        /// 往来单位分类删除
        /// </summary>
        /// <param name="customerclasscode">往来单位分类编码字串集</param>
        /// <returns></returns>
        [Route(template: "TCunstomerClassTreeDelete")]
        [HttpPost]
        public JsonResult TCunstomerClassTreeDelete(string customerclasscode)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = BasicSettingBLL.TCunstomerClassTreeDelete(customerclasscode, us);
            return Json(mes);
        }
        #endregion

        #region[往来单位信息列表]
        /// <summary>
        /// 往来单位信息列表
        /// </summary>
        /// <param name="customerclasscode">往来单位分类编码字符串集</param>
        /// <param name="customercode">往来单位编码</param>
        /// <param name="customername">往来单位名称</param>
        /// <param name="page">页码</param>
        /// <param name="rows">每页显示条数</param>
        /// <param name="prop">排序字段</param>
        /// <param name="order">排序规则</param>
        /// <returns></returns>
        [Route(template: "TCunstomerData")]
        [HttpGet]
        public JsonResult TCunstomerData(string customerclasscode, string customercode, string customername, int page = 0, int rows = 0, string prop = null, string order = null)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            int startNum = rows * (page - 1) + 1;  //起始记录rowNum
            int endNum = rows * page;   //结束记录 rowNum
            mes = BasicSettingBLL.TCunstomerData(customerclasscode, customercode, customername, startNum, endNum, prop, order);
            return Json(mes);
        }
        #endregion

        #region[往来单位新增/编辑保存]
        /// <summary>
        /// 往来单位新增/编辑保存
        /// </summary>
        /// <param name="obj">提交数据</param>
        /// <returns></returns>
        [Route(template: "TCunstomerAddUpdate")]
        [HttpPost]
        public JsonResult TCunstomerAddUpdate([FromBody] JObject obj)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            string data_sources = obj["data_sources"].ToString(); //数据来源:ERP/MES
            string customercode = obj["customercode"].ToString(); //往来单位编码
            string customername = obj["customername"].ToString(); //往来单位名称
            string customerclasscode = obj["customerclasscode"].ToString(); //往来单位类型编码
            string status = obj["status"].ToString(); //状态
            string conttacts = obj["conttacts"].ToString(); //联系人
            string conttphone = obj["conttphone"].ToString(); //联系方式
            string addr = obj["addr"].ToString(); //地址
            string OperType = obj["OperType"].ToString();  //操作类型
            mes = BasicSettingBLL.TCunstomerAddUpdate(data_sources, customercode, customername, customerclasscode, status, conttacts, conttphone, addr, OperType, us);
            return Json(mes);
        }
        #endregion

        #region[往来单位信息删除]
        /// <summary>
        /// 往来单位信息删除
        /// </summary>
        /// <param name="data_sources">数据来源:ERP/MES</param>
        /// <param name="customercode">往来单位编码</param>
        /// <returns></returns>
        [Route(template: "TCunstomerDelete")]
        [HttpPost]
        public JsonResult TCunstomerDelete(string data_sources, string customercode)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = BasicSettingBLL.TCunstomerDelete(data_sources, customercode, us);
            return Json(mes);
        }
        #endregion


        #region[仓库信息列表]
        /// <summary>
        /// 仓库信息列表
        /// </summary>
        /// <param name="code">仓库编码</param>
        /// <param name="name">仓库名称</param>
        /// <param name="status">状态</param>
        /// <param name="ishasPosition">货位管理</param>
        /// <param name="page">页码</param>
        /// <param name="rows">每页显示条数</param>
        /// <param name="prop">排序字段</param>
        /// <param name="order">排序规则</param>
        /// <returns></returns>
        [Route(template: "TSecStckData")]
        [HttpGet]
        public JsonResult TSecStckData(string code, string name, string status, string ishasPosition, int page = 0, int rows = 0, string prop = null, string order = null)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            int startNum = rows * (page - 1) + 1;  //起始记录rowNum
            int endNum = rows * page;   //结束记录 rowNum
            mes = BasicSettingBLL.TSecStckData(code, name, status, ishasPosition, startNum, endNum, prop, order);
            return Json(mes);
        }
        #endregion

        #region[仓库新增/编辑保存]
        /// <summary>
        /// 仓库新增/编辑保存
        /// </summary>
        /// <param name="obj">提交数据</param>
        /// <returns></returns>
        [Route(template: "TSecStckAddUpdate")]
        [HttpPost]
        public JsonResult TSecStckAddUpdate([FromBody] JObject obj)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            string data_sources = obj["data_sources"].ToString(); //数据来源:ERP/MES
            string stckcode = obj["stckcode"].ToString(); //仓库编码
            string stckname = obj["stckname"].ToString(); //仓库名称
            string ishaspostion = obj["ishaspostion"].ToString(); //是否货位管理
            string status = obj["status"].ToString(); //状态
            string description = obj["description"].ToString(); //备注
            string OperType = obj["OperType"].ToString();  //操作类型
            mes = BasicSettingBLL.TSecStckAddUpdate(data_sources, stckcode, stckname, ishaspostion, status, description, OperType, us);
            return Json(mes);
        }
        #endregion

        #region[仓库删除]
        /// <summary>
        /// 仓库删除
        /// </summary>
        /// <param name="data_sources">数据来源:ERP/MES</param>
        /// <param name="stckcode">仓库编码</param>
        /// <returns></returns>
        [Route(template: "TSecStckDelete")]
        [HttpPost]
        public JsonResult TSecStckDelete(string data_sources, string stckcode)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = BasicSettingBLL.TSecStckDelete(data_sources, stckcode, us);
            return Json(mes);
        }
        #endregion


        #region[仓位树型信息]
        /// <summary>
        /// 仓位树型信息
        /// </summary>
        /// <returns></returns>
        [Route(template: "TSecLocaTree")]
        [HttpGet]
        public JsonResult TSecLocaTree()
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = BasicSettingBLL.TSecLocaTree();
            return Json(mes);
        }
        #endregion

        #region[仓位信息列表]
        /// <summary>
        /// 仓位信息列表
        /// </summary>
        /// <param name="flag">选中左侧树型层级</param>
        /// <param name="stckcode">仓库编码字符串集</param>
        /// <param name="locacode">仓位编码</param>
        /// <param name="locaname">仓位名称</param>
        /// <param name="page">页码</param>
        /// <param name="rows">每页显示条数</param>
        /// <param name="prop">排序字段</param>
        /// <param name="order">排序规则</param>
        /// <returns></returns>
        [Route(template: "TSecLocaData")]
        [HttpGet]
        public JsonResult TSecLocaData(string flag, string stckcode, string locacode, string locaname, int page = 0, int rows = 0, string prop = null, string order = null)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            int startNum = rows * (page - 1) + 1;  //起始记录rowNum
            int endNum = rows * page;   //结束记录 rowNum
            mes = BasicSettingBLL.TSecLocaData(flag, stckcode, locacode, locaname, startNum, endNum, prop, order);
            return Json(mes);
        }
        #endregion

        #region[仓位信息新增/编辑保存]
        /// <summary>
        /// 仓位信息新增/编辑保存
        /// </summary>
        /// <param name="obj">提交数据</param>
        /// <returns></returns>
        [Route(template: "TSecLocaAddUpdate")]
        [HttpPost]
        public JsonResult TSecLocaAddUpdate([FromBody] JObject obj)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            string data_sources = obj["data_sources"].ToString(); //数据来源:ERP/MES
            string locacode = obj["locacode"].ToString(); //货位编码
            string locaname = obj["locaname"].ToString(); //货位名称
            string stckcode = obj["stckcode"].ToString(); //对应仓库编码
            string parentlocacode = obj["parentlocacode"].ToString(); //上级货位编码
            string depth = obj["depth"].ToString(); //级次
            string status = obj["status"].ToString(); //状态
            string description = obj["description"].ToString(); //备注
            string OperType = obj["OperType"].ToString();  //操作类型
            mes = BasicSettingBLL.TSecLocaAddUpdate(data_sources, locacode, locaname, stckcode, parentlocacode, depth, status, description, OperType, us);
            return Json(mes);
        }
        #endregion

        #region[仓位信息删除]
        /// <summary>
        /// 
        /// </summary>
        /// <param name="data_sources">数据来源:ERP/MES</param>
        /// <param name="locacode">仓库编码</param>
        /// <returns></returns>
        [Route(template: "TSecLocaDelete")]
        [HttpPost]
        public JsonResult TSecLocaDelete(string data_sources, string locacode)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = BasicSettingBLL.TSecLocaDelete(data_sources, locacode, us);
            return Json(mes);
        }
        #endregion


        #region[工艺路线工序下拉查询接口]
        /// <summary>
        /// 工艺路线工序下拉查询接口
        /// </summary>
        /// <returns></returns>
        [Route(template: "StepSelect")]
        [HttpGet]
        public JsonResult StepSelect()
        {
            mes = BasicSettingBLL.StepSelect();
            return Json(mes);
        }
        #endregion

        #region[工艺路线查询]
        /// <summary>
        /// 工艺路线查询
        /// </summary>
        /// <param name="routecode">工艺路线编码</param>
        /// <param name="routename">工艺路线名称</param>
        /// <param name="description">工艺路线描述</param>
        /// <param name="createuser">创建人员</param>
        /// <param name="page">页码</param>
        /// <param name="rows">每页显示条数</param>
        /// <param name="prop">排序字段</param>
        /// <param name="order">排序规则</param>
        /// <returns></returns>
        [Route(template: "RouteSearch")]
        [HttpGet]
        public JsonResult RouteSearch(string routecode = null, string routename = null, string description = null, string createuser = null, int page = 0, int rows = 0, string prop = null, string order = null)
        {
            int startNum = rows * (page - 1) + 1;  //起始记录rowNum
            int endNum = rows * page;   //结束记录 rowNum
            mes = BasicSettingBLL.RouteSearch(routecode, routename, description, createuser, startNum, endNum, prop, order);
            return Json(mes);
        }
        #endregion

        #region[工艺路线预览]
        /// <summary>
        /// 工艺路线预览
        /// </summary>
        /// <param name="routecode">工艺路线编码</param>
        /// <returns></returns>
        [Route(template: "ViewRoute")]
        [HttpGet]
        public JsonResult ViewRoute(string routecode)
        {
            mes = BasicSettingBLL.ViewRoute(routecode);
            return Json(mes);
        }
        #endregion

        #region[工艺路线新增]
        /// <summary>
        /// 工艺路线新增
        /// </summary>
        /// <param name="id">工艺路线id</param>
        /// <param name="opertype">操作类型(新增)</param>
        /// <param name="json">提交数据</param>
        /// <returns></returns>
        [Route(template: "AddUpdateRoute")]
        [HttpPost]
        public JsonResult AddUpdateRoute(string opertype, RoutEdit json, string id = null)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = BasicSettingBLL.AddUpdateRoute(id, opertype, us, json);
            return Json(mes);
        }
        #endregion

        #region[工艺路线删除]
        /// <summary>
        /// 工艺路线删除
        /// </summary>
        /// <param name="routecode">工艺路线编码</param>
        /// <returns></returns>
        [Route(template: "DeleteRoute")]
        [HttpPost]
        public JsonResult DeleteRoute(string routecode)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = BasicSettingBLL.DeleteRoute(routecode, us);
            return Json(mes);
        }
        #endregion


        #region[工序查询]
        /// <summary>
        /// 工序查询
        /// </summary>
        /// <param name="stepcode">工序编码</param>
        /// <param name="stepname">工序名称</param>
        /// <param name="enable">启用状态</param>
        /// <param name="steptypecode">工序类型编码</param>
        /// <param name="page">页码</param>
        /// <param name="rows">每页显示条数</param>
        /// <param name="prop">排序字段</param>
        /// <param name="order">排序规则</param>
        /// <returns></returns>
        [Route(template: "StepSearch")]
        [HttpGet]
        public JsonResult StepSearch(string stepcode = null, string stepname = null, string enable = null, string steptypecode = null, int page = 0, int rows = 0, string prop = null, string order = null)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            int startNum = rows * (page - 1) + 1;  //起始记录rowNum
            int endNum = rows * page;   //结束记录 rowNum
            mes = BasicSettingBLL.StepSearch(stepcode, stepname, enable, steptypecode, startNum, endNum, prop, order);
            return Json(mes);
        }
        #endregion

        #region[工序新增编辑]
        /// <summary>
        /// 工序新增编辑
        /// </summary>
        /// <param name="obj">提交数据对象</param>
        /// <returns></returns>
        [Route(template: "AddUpdateStep")]
        [HttpPost]
        public JsonResult AddUpdateStep([FromBody] JObject obj)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            string stepid = obj["id"].ToString();    //工序id(主键)
            string stepcode = obj["stepcode"].ToString(); //工序编码
            string stepname = obj["stepname"].ToString(); //工序名称
            string steptypecode = obj["steptypecode"].ToString(); //工序类型编码
            string enable = obj["enable"].ToString();           //启用状态
            string description = obj["description"].ToString(); //工序描述
            string OperType = obj["OperType"].ToString();  //操作类型
            mes = BasicSettingBLL.AddUpdateStep(stepid, stepcode, stepname, steptypecode, enable, description, us, OperType);
            return Json(mes);
        }
        #endregion

        #region[工序删除]
        /// <summary>
        /// 工序删除
        /// </summary>
        /// <param name="stepcode">工序编码</param>
        /// <returns></returns>
        [Route(template: "DeleteStep")]
        [HttpPost]
        public JsonResult DeleteStep(string stepcode)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = BasicSettingBLL.DeleteStep(stepcode, us);
            return Json(mes);
        }
        #endregion


        #region[节拍工价,产品信息查询]
        /// <summary>
        /// 节拍工价,产品信息查询
        /// </summary>
        /// <returns></returns>
        [Route(template: "PartSelect")]
        [HttpGet]
        public JsonResult PartSelect()
        {
            mes = BasicSettingBLL.PartSelect();
            return Json(mes);
        }
        #endregion

        #region[产品编码查找关联的工艺信息]
        /// <summary>
        /// 产品编码查找关联的工艺信息
        /// </summary>
        /// <param name="partcode">产品编码</param>
        /// <returns></returns>
        [Route(template: "PartSelectRpute")]
        [HttpGet]
        public JsonResult PartSelectRpute(string partcode)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = BasicSettingBLL.PartSelectRpute(partcode, us);
            return Json(mes);
        }
        #endregion

        #region[根据工艺信息(工艺路线编码)查找关联工序集合]
        /// <summary>
        /// 根据工艺信息(工艺路线编码)查找关联工序集合
        /// </summary>
        /// <param name="partcode">产品编码</param>
        /// <param name="routecode">工艺路线编码</param>
        /// <returns></returns>
        [Route(template: "RouteSelectStep")]
        [HttpGet]
        public JsonResult RouteSelectStep(string partcode,string routecode)
        {

            mes = BasicSettingBLL.RouteSelectStep(partcode, routecode);
            return Json(mes);
        }
        #endregion

        #region[产品编码批量查找关联的工艺信息]
        /// <summary>
        /// 产品编码批量查找关联的工艺信息
        /// </summary>
        /// <param name="list">产品编码集合</param>
        /// <returns></returns>
        [Route(template: "PartSelectRputeList")]
        [HttpPost]
        public JsonResult PartSelectRputeList(List<PartRouteList> list)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = BasicSettingBLL.PartSelectRputeList(list, us);
            return Json(mes);
        }
        #endregion

        #region[根据工艺信息(工艺路线编码)批量查找关联工序集合]
        /// <summary>
        /// 根据工艺信息(工艺路线编码)批量查找关联工序集合
        /// </summary>
        /// <param name="list">产品编码,工艺路线编码集合</param>
        /// <returns></returns>
        [Route(template: "RouteSelectStepList")]
        [HttpPost]
        public JsonResult RouteSelectStepList(List<PartRouteStepList> list)
        {

            mes = BasicSettingBLL.RouteSelectStepList(list);
            return Json(mes);
        }
        #endregion


        #region[节拍工价查询]
        /// <summary>
        /// 节拍工价查询
        /// </summary>
        /// <param name="partcode">产品编码</param>
        /// <param name="routecode">工艺路线编码</param>
        /// <param name="stepcode">工序编码</param> 
        /// <param name="page">页码</param>
        /// <param name="rows">每页显示条数</param>
        /// <param name="prop">排序字段</param>
        /// <param name="order">排序规则</param>
        /// <returns></returns>
        [Route(template: "BeatRateSearch")]
        [HttpGet]
        public JsonResult BeatRateSearch(string partcode = null, string routecode = null, string stepcode = null,int page = 0, int rows = 0, string prop = null, string order = null)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            int startNum = rows * (page - 1) + 1;  //起始记录rowNum
            int endNum = rows * page;   //结束记录 rowNum
            mes = BasicSettingBLL.BeatRateSearch(partcode, routecode, stepcode, us, startNum, endNum, prop, order);
            return Json(mes);
        }
        #endregion

        #region[节拍工价提交]
        /// <summary>
        /// 节拍工价提交
        /// </summary>
        /// <param name="json">提交数据</param>
        /// <returns></returns>
        [Route(template: "SaveBeatRate")]
        [HttpPost]
        public JsonResult SaveBeatRate(List<MaterialCraftsSave> json)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = BasicSettingBLL.SaveBeatRate(json,us);
            return Json(mes);
        }
        #endregion

        #region[节拍工价删除]
        /// <summary>
        /// 节拍工价删除
        /// </summary>
        /// <param name="id">数据列id</param>
        /// <returns></returns>
        [Route(template: "DeleteBeatRate")]
        [HttpPost]
        public JsonResult DeleteBeatRate(string id)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = BasicSettingBLL.DeleteBeatRate(id,us);
            return Json(mes);
        }
        #endregion

        




        #region[安灯系统/自定义安灯呼叫类型查询]
        /// <summary>
        /// 安灯系统/自定义安灯呼叫类型查询
        /// </summary>
        /// <returns></returns>
        [Route(template: "AnDengTypeSearch")]
        [HttpGet]
        public JsonResult AnDengTypeSearch()
        {
            mes = BasicSettingBLL.AnDengTypeSearch();
            return Json(mes);
        }
        #endregion

        #region[安灯系统/自定义安灯呼叫类型新增]
        /// <summary>
        /// 安灯系统/自定义安灯呼叫类型新增
        /// </summary>
        /// <param name="json">提交数据对象</param>
        /// <returns></returns>
        [Route(template: "AddUpdateAnDengType")]
        [HttpPost]
        public JsonResult AddUpdateAnDengType(List<ObjectData> json)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = BasicSettingBLL.AddUpdateAnDengType(json, us);
            return Json(mes);
        }
        #endregion

        #region[安灯系统/自定义安灯呼叫类型删除]
        /// <summary>
        /// 安灯系统/自定义安灯呼叫类型删除
        /// </summary>
        /// <param name="andengtypecode">安灯呼叫类型编码</param>
        /// <returns></returns>
        [Route(template: "DeleteAnDengType")]
        [HttpPost]
        public JsonResult DeleteAnDengType(string andengtypecode)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = BasicSettingBLL.DeleteAnDengType(andengtypecode, us);
            return Json(mes);
        }
        #endregion

        #region[安灯系统/查询绑定的响应人员]
        /// <summary>
        /// 安灯系统/查询绑定的响应人员
        /// </summary>
        /// <param name="wkshopcode">选中的车间编码</param>
        /// <param name="calltypecode">选中的呼叫类型编码</param>
        /// <returns></returns>
        [Route(template: "AnDengResponUserSearch")]
        [HttpGet]
        public JsonResult AnDengResponUserSearch(string wkshopcode, string calltypecode)
        {
            mes = BasicSettingBLL.AnDengResponUserSearch(wkshopcode, calltypecode);
            return Json(mes);
        }
        #endregion

        #region[安灯系统/新增响应人员查询已绑定的响应人员]
        /// <summary>
        /// 安灯系统/新增响应人员查询已绑定的响应人员
        /// </summary>
        /// <param name="wkshopcode">选中的车间编码</param>
        /// <param name="calltypecode">选中的呼叫类型编码</param>
        /// <returns></returns>
        [Route(template: "AnDengDigoResponUserSearch")]
        [HttpGet]
        public JsonResult AnDengDialogResponUserSearch(string wkshopcode, string calltypecode)
        {
            mes = BasicSettingBLL.AnDengDialogResponUserSearch(wkshopcode, calltypecode);
            return Json(mes);
        }
        #endregion

        #region[安灯系统/新增响应人员提交]
        /// <summary>
        /// 安灯系统/新增响应人员提交
        /// </summary>
        /// <param name="wkshopcode">选中的车间编码</param>
        /// <param name="calltypecode">选中的呼叫类型编码</param>
        /// <param name="enable">允许关闭</param>
        /// <param name="json">响应人员数据</param>
        /// <returns></returns>
        [Route(template: "AnDengDigoResponUserSeave")]
        [HttpPost]
        public JsonResult AnDengDigoResponUserSeave(string wkshopcode, string calltypecode, string enable, DataTable json)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = BasicSettingBLL.AnDengDigoResponUserSeave(wkshopcode, calltypecode, enable, us, json);
            return Json(mes);
        }
        #endregion

        #region[安灯系统/响应人员允许关闭]
        /// <summary>
        /// 安灯系统/响应人员允许关闭
        /// </summary>
        /// <param name="wkshopcode">选中的车间编码</param>
        /// <param name="calltypecode">选中的呼叫类型编码</param>
        /// <param name="enable">允许关闭</param>
        /// <returns></returns>
        [Route(template: "AnDengResponUserCloseSeave")]
        [HttpPost]
        public JsonResult AnDengResponUserCloseSeave(string wkshopcode, string calltypecode, string enable)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = BasicSettingBLL.AnDengResponUserCloseSeave(wkshopcode, calltypecode, enable, us);
            return Json(mes);
        }
        #endregion

        #region[安灯系统/响应人员删除]
        /// <summary>
        /// 安灯系统/响应人员删除
        /// </summary>
        /// <param name="id">子id</param>
        /// <param name="ando_cogfigid">主id</param>
        /// <returns></returns>
        [Route(template: "AnDengResponUserDeleteSeave")]
        [HttpPost]
        public JsonResult AnDengResponUserDeleteSeave(string id, string ando_cogfigid)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = BasicSettingBLL.AnDengResponUserDeleteSeave(id, ando_cogfigid, us);
            return Json(mes);
        }
        #endregion
    }
}