RMYY_CallCenter_Api/RMYY_CallCen.../Controllers/Adjust/DeviceContro...

using RMYY_CallCenter_Api.DB;
using RMYY_CallCenter_Api.Model;
using RMYY_CallCenter_Api.Utility;
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Web;
using System.Web.Mvc;

namespace RMYY_CallCenter_Api.Controllers.System
{
    public class DeviceController : BaseController
    {
        BLL.T_Adjust_Device deviceservice = new BLL.T_Adjust_Device();
        BLL.T_Adjust_DeviceType typeservice = new BLL.T_Adjust_DeviceType();

        BLL.T_Adjust_Log logBll = new BLL.T_Adjust_Log();
        private static InternalMessagesController msg = new InternalMessagesController();
        BLL.T_Adjust_TpInfo tpinfoBll = new BLL.T_Adjust_TpInfo();
        Bll.T_Sys_Department deptbll = new Bll.T_Sys_Department();
        /// <summary>
        /// 设备信息list Device/GetList
        /// </summary>
        /// <param name="typeName">设备名称</param>
        /// <param name="dicId">设备类型对应的字典的id</param>
        /// <param name="assetCode">资产编码</param>
        /// <param name="deviceShortCode">设备短码</param>
        /// <param name="deptId">所属科室</param>
        /// <param name="deviceStatus">int 设备状态 设备调配（1待上架，2闲置，3使用中） </param>
        /// <param name="orderBy">  排序 F_DicId或 F_UpdateTime</param>
        /// <param name="page"></param>
        /// <param name="pagesize"></param>
        /// <param name="orderByRule">倒序还是正序，desc或者 asc</param>
        /// <returns></returns>
        public ActionResult GetList(string typeName, string assetCode, string code, string deviceTypeId, string deviceShortCode, string orderBy, string deviceStatus, int orderByRule = 0, int page = 1, int pagesize = 10, int isdc = 0, int deptId = 0, int dicId = 0)
        {
            string sql = " and F_IsDelete=0 and F_Classify=1";
            if (!string.IsNullOrEmpty(deviceTypeId))
            {

                sql += " and F_DeviceTypeId in ( " + deviceTypeId + ")";

            }

            if (!string.IsNullOrEmpty(code))
            {

                sql += " and (F_AssetCode='" + code + "' or F_DeviceShortCode='" + code + "')";
            }
            DataTable dt = new DataTable();
            string strorderby = " order by ";
            if (string.IsNullOrEmpty(orderBy))
            {
                strorderby += " F_UpdateTime";
            }
            else
            {
                strorderby += orderBy;
            }
            if (orderByRule == 0)
            {
                strorderby += " desc";
            }
            else
            {
                strorderby += " asc";
            }



            if (!string.IsNullOrEmpty(typeName))
            {
                sql += " and F_TypeName like '%" + typeName + "%' ";
            }
            if (dicId > 0)
            {
                sql += " and F_DicId='" + dicId + "' ";
            }
            if (!string.IsNullOrEmpty(assetCode))
            {
                sql += " and F_AssetCode='" + assetCode + "' ";

            }
            if (!string.IsNullOrEmpty(deviceShortCode))
            {
                sql += " and F_DeviceShortCode='" + deviceShortCode + "' ";

            }
            if (deptId > 0)
            {
                sql += " and F_BelongDept='" + deptId + "' ";
            }
            if (!string.IsNullOrEmpty(deviceStatus))
            {
                //string[] strlist= deviceStatus.Split(',');
                //List<int> lis = new List<int>();
                //foreach (var item in strlist)
                //{
                //    lis.Add(Convert.ToInt32(item));
                //}
                sql += " and F_DeviceStatus  in (" + deviceStatus + ")  ";
            }

            if (isdc > 0)
            {
                string dcsql = " and a.F_IsDelete=0 and and a.F_Classify=1";

                string dcstrorderby = " order by ";
                if (string.IsNullOrEmpty(orderBy))
                {
                    dcstrorderby += " a.F_UpdateTime";
                }
                else
                {
                    dcstrorderby += orderBy;
                }
                if (orderByRule == 0)
                {
                    strorderby += " desc";
                }
                else
                {
                    strorderby += " asc";
                }
                //if (!string.IsNullOrEmpty(code))
                //{

                //    sql += " and (a.F_AssetCode='" + code + "' or a. F_DeviceShortCode='" + code + "')";
                //}

                if (!string.IsNullOrEmpty(typeName))
                {
                    dcsql += " and a.F_TypeName like '%" + typeName + "%' ";
                }
                if (dicId > 0)
                {
                    dcsql += " and a.F_DicId='" + dicId + "' ";
                }
                if (!string.IsNullOrEmpty(assetCode))
                {
                    dcsql += " and a.F_AssetCode='" + assetCode + "' ";

                }
                if (!string.IsNullOrEmpty(deviceShortCode))
                {
                    dcsql += " and a.F_DeviceShortCode='" + deviceShortCode + "' ";

                }
                if (deptId > 0)
                {
                    dcsql += " and a.F_BelongDept='" + deptId + "' ";
                }
                if (!string.IsNullOrEmpty(deviceStatus))
                {
                    sql += " and a.F_DeviceStatus  in (" + deviceStatus + ")  ";
                }
                //if (deviceTypeId > 0)
                //{

                //    dcsql += " and a.F_DeviceTypeId=" + deviceTypeId + "";

                //}
                if (!string.IsNullOrEmpty(deviceTypeId))
                {

                    dcsql += " and F_DeviceTypeId in (  " + deviceTypeId + " )";

                }
                var dtdc = DB.DbHelperSQL.Query("SELECT  a.F_BigTypeName 设备类型,a.F_TypeName 设备名称,F_AssetCode 资产编码 , F_DeviceShortCode 设备短码,F_Specification 规格型号, F_Code 出厂编码,F_BelongDeptName 归属科室, F_BelongPhone 归属科室电话, (CASE F_DeviceStatus    WHEN 1 THEN '待上架' WHEN 2 THEN '闲置' WHEN 3 THEN '使用中'    ELSE '' END) 设备状态,CAST(b.F_price AS VARCHAR) + '/' + b.F_ChargingStandard 计费标准    from T_Adjust_Device a LEFT join T_Adjust_DeviceType b on b.F_TypeId = a.F_DeviceTypeId    where 1=1 " + dcsql + dcstrorderby).Tables[0];
                var msg = new NPOIHelper().ExportToExcel("设备管理", dtdc);
                if (msg == "")
                {
                    return Success("导出成功");
                }
                else
                {
                    return Error("导出失败");
                }
            }


            int recordCount = 0;
            dt = Bll.PagerBll.GetListPager(
                "(SELECT T_Adjust_Device.*,b.F_Price,F_ChargingStandard from T_Adjust_Device LEFT join T_Adjust_DeviceType b on b.F_TypeId=T_Adjust_Device.F_DeviceTypeId ) T_Adjust_Device",
                "F_DeviceId",
                "*",
                sql,
               strorderby,
                pagesize,
                page,
                true,
                out recordCount);

            dt.Columns.Add("FileUrl", typeof(object));

            foreach (DataRow dr in dt.Rows)
            {
                if (!string.IsNullOrEmpty(fileurlpath) && !string.IsNullOrEmpty(dr["F_File"].ToString()))
                {
                    dr["FileUrl"] = GetFileData(dr["F_File"].ToString(), fileurlpath);
                }
            }

            var obj = new
            {
                state = "success",
                message = "成功",
                rows = dt,
                total = recordCount
            };

            return Content(obj.ToJson());


        }


        /// <summary>
        /// 添加或编辑设备信息 Device/AddOrEditDevice
        /// </summary>
        /// <param name="address">部门地址</param>
        /// <param name="deptId">部门id</param>
        /// <param name="deptName">部门名</param>
        /// <param name="phone">部门电话</param>
        /// <param name="assetCode">资产编码</param>
        /// <param name="deviceShortCode">设备断码</param>
        /// <param name="code">出厂编号</param>
        /// <param name="specification">规格型号</param>

        /// <param name="deviceTypeId">设备类型表的id</param>
        /// <param name="deviceId">设备id</param>
        /// <returns></returns>

        public ActionResult AddOrEditDevice(string address, int deptId, string deptName
             , string phone, string assetCode, string deviceShortCode, string file,

            string code, string specification, string bigTypeName, string typeName, int dicId = 0,
              int deviceTypeId = 0, int deviceId = 0)
        {
            int chuancan = deviceTypeId;

            if (deviceTypeId == 0)
            {
                if (string.IsNullOrEmpty(bigTypeName) && string.IsNullOrEmpty(typeName))
                {
                    return Error("请选择或者输入设备类型和设备名称");
                }

            }
            Model.T_Adjust_DeviceType typemodel = new T_Adjust_DeviceType();
            if (deviceTypeId > 0)
            {
                typemodel = typeservice.GetModel(deviceTypeId);
                if (typemodel == null)
                {
                    return Error(" 设备类型不存在");
                }

            }
            else
            {

                //找不到字典 判断字典表是否存在，不存在加一个字典值
                int dicaddid = 0;
                if (dicId > 0)
                {
                    Model.T_Sys_DictionaryValue dicmodel = new Bll.T_Sys_DictionaryValue().GetModel(dicId);
                    if (dicmodel != null)
                    {
                        dicaddid = dicmodel.F_DictionaryValueId;
                    }
                }
                else
                {
                    Model.T_Sys_DictionaryValue dicmodel = new Bll.T_Sys_DictionaryValue().GetModel(bigTypeName);
                    if (dicmodel != null)
                    {
                        dicaddid = dicmodel.F_DictionaryValueId;
                    }
                    else
                    {
                        dicaddid = new Bll.T_Sys_DictionaryValue().Add(bigTypeName);

                    }
                }



                //先添加字典的记录

                //添加设备类型记录
                //  int dicaddid = new Bll.T_Sys_DictionaryValue().Add(bigTypeName);
                Model.T_Adjust_DeviceType modeltype = typeservice.GetModel(bigTypeName, typeName, 1);
                if (modeltype == null)
                {

                    Model.T_Adjust_DeviceType model = new T_Adjust_DeviceType();
                    model.F_DeviceNum = 0;
                    model.F_IsDelete = 0;

                    model.F_Classification = 1;
                    model.F_CreateBy = User.F_UserCode;
                    model.F_BigTypeName = bigTypeName;
                    model.F_TypeName = typeName;

                    model.F_DicId = dicaddid;
                    model.F_CreateTime = DateTime.Now;
                    int res = typeservice.Add(model);


                    deviceTypeId = res;
                }
                else { deviceTypeId = modeltype.F_TypeId; }


            }
            if (string.IsNullOrEmpty(assetCode))
            {
                return Error("资产编码不能为空");
            }







            var existslist = deviceservice.GetModelList(" F_AssetCode ='" + assetCode + "'");
            if (deviceId > 0)
            {
                if (existslist.Count == 0)
                { }
                else if (existslist.Count == 1 && existslist.First().F_DeviceId == deviceId)
                { }
                else
                {
                    return Error("资产编码不能重复！");
                }
                ////设备类型的数量加1
                //var mm = typeservice.GetModel(deviceTypeId);
                //mm.F_DeviceNum = mm.F_DeviceNum == null ? 1 : mm.F_DeviceNum + 1;
                //mm.F_UpdateTime = DateTime.Now;
                //typeservice.Update(mm);




                if (deviceTypeId != existslist.First().F_DeviceId)
                {
                    //修改了类型说明
                    var mm = typeservice.GetModel(deviceTypeId);
                    mm.F_DeviceNum = mm.F_DeviceNum == null ? 1 : mm.F_DeviceNum + 1;
                    mm.F_UpdateTime = DateTime.Now;
                    typeservice.Update(mm);

                    var olddevice = deviceservice.GetModel(existslist.First().F_DeviceId);
                    var oldtype = typeservice.GetModel(olddevice.F_DeviceTypeId);
                    oldtype.F_DeviceNum = oldtype.F_DeviceNum - 1;
                    oldtype.F_UpdateTime = DateTime.Now;
                    typeservice.Update(oldtype);
                }







                Model.T_Adjust_Device model = deviceservice.GetModel(deviceId);
                //编辑
                model.F_BigTypeName = typemodel.F_BigTypeName;
                model.F_TypeName = typemodel.F_TypeName;
                model.F_DicId = typemodel.F_DicId;

                model.F_BelongPhone = phone;
                model.F_BelongAddress = address;
                model.F_BelongDept = deptId;
                model.F_BelongDeptName = deptName;
                model.F_DeviceTypeId = deviceTypeId;
                model.F_AssetCode = assetCode;
                model.F_DeviceShortCode = deviceShortCode;
                model.F_Specification = specification;
                model.F_Code = code;
                model.F_File = file;
                model.F_UpdateTime = DateTime.Now;



                if (deviceservice.Update(model))
                {

                    return Success("修改成功");
                }
                else
                {
                    return Error("修改失败");
                }

            }
            else
            {

                if (existslist.Count > 0)
                {
                    return Error("资产编码不能重复！");
                }

                Model.T_Adjust_Device model = new T_Adjust_Device();
                model.F_BigTypeName = typemodel.F_BigTypeName;
                model.F_TypeName = typemodel.F_TypeName;
                model.F_DicId = typemodel.F_DicId;


                model.F_BelongPhone = phone;
                model.F_BelongAddress = address;
                model.F_BelongDept = deptId;
                model.F_BelongDeptName = deptName;
                model.F_DeviceTypeId = deviceTypeId;
                model.F_AssetCode = assetCode;
                model.F_DeviceShortCode = deviceShortCode;
                model.F_Specification = specification;
                model.F_Code = code;
                model.F_Source = 1;
                model.F_CreateBy = User.F_UserCode;
                model.F_CreateTime = DateTime.Now;
                model.F_UpdateTime = DateTime.Now;
                model.F_DeviceStatus = 1;//待上架
                model.F_Classify = 1;
                model.F_IsDelete = 0;
                model.F_File = file;
                int res = deviceservice.Add(model);
                if (res > 0)
                {
                    //设备类型的数量加1
                    var mm = typeservice.GetModel(deviceTypeId);
                    mm.F_DeviceNum = mm.F_DeviceNum == null ? 1 : mm.F_DeviceNum + 1;
                    mm.F_UpdateTime = DateTime.Now;
                    typeservice.Update(mm);

                    return Success("添加成功");
                }
                else
                {
                    return Error("添加失败");
                }
            }







        }

        /// <summary>
        /// 删除设备 DelDeviceType
        /// </summary>
        /// <param name="deviceId"></param>
        /// <returns></returns>
        public ActionResult DelDevice(int deviceId)
        {
            if (deviceId <= 0)
            {
                return Error("请选中要删除的列");

            }
            string sql = " update T_Adjust_Device set F_IsDelete=1 where F_DeviceId=" + deviceId;
            if (DbHelperSQL.ExecuteSql(sql) > 0)
            {
                //把设备类型表的数量-1
                string updatenum = "  update T_Adjust_DeviceType set F_DeviceNum=(SELECT Count(1) from T_Adjust_Device WHERE F_IsDelete=0 and  F_DeviceTypeId   in (SELECT F_DeviceTypeId from T_Adjust_Device WHERE F_IsDelete=0 and   F_DeviceId=" + deviceId + ")) WHERE F_TypeId in (SELECT F_DeviceTypeId from T_Adjust_Device WHERE F_DeviceId=" + deviceId + ")";
                DbHelperSQL.ExecuteSql(updatenum);
                return Success("删除成功");
            }
            else
            {
                return Error("删除失败");
            }


        }


        /// <summary>
        /// GetTypeName 添加编辑时根据dicid获取设备名称下拉框 
        /// </summary>
        /// <param name="dicId"></param>
        /// <returns></returns>
        public ActionResult GetTypeName(string bigTypeName, string typeName, int dicId = 0, int classification = 0)
        {

            string sql = " F_IsDelete=0 ";
            if (dicId >= 0)
            {
                sql += " and  F_DicId=" + dicId + " ";
            }
            if (classification > 0)
            {
                sql += " and  F_Classification=" + classification + " ";
            }

            if (!string.IsNullOrEmpty(bigTypeName))
            {
                sql += " and  F_BigTypeName='" + bigTypeName + "' ";
            }
            if (!string.IsNullOrEmpty(typeName))
            {
                sql += " and  F_TypeName='" + typeName + "' ";
            }


            List<T_Adjust_DeviceType> devices = typeservice.GetModelList(sql);

            var obj = new
            {
                state = "success",
                message = "成功",
                rows = devices

            };

            return Content(obj.ToJson());
            //return deviceservice.GetModelList(" F_DicId='" + dicId + "' and F_IsDelete=0");

        }

        /// <summary>
        /// BatchUpdate
        /// </summary>
        /// <param name="ids"></param>
        /// <param name="operateType">下架1  上架2 </param>
        /// <returns></returns>
        public ActionResult BatchUpdate(int[] ids, int operateType)
        {
            int total = 0;
            if (ids != null && ids.Length > 0)
            {
                foreach (int item in ids)
                {
                    Model.T_Adjust_Device model = deviceservice.GetModel(item);

                    if (model.F_DeviceStatus == 3)
                    {
                        continue;
                    }
                    model.F_DeviceStatus = operateType;
                    if (operateType == 2)
                    {
                        model.F_ListingTime = DateTime.Now;
                    }
                    else
                    {
                        model.F_ListingTime = null;
                    }
                    model.F_UpdateTime = DateTime.Now;
                    bool insertlog = false;
                    if (model.F_Classify == 2)
                    {
                        insertlog = true;
                    }


                    if (deviceservice.Update(model))
                    {
                        if (insertlog)
                        {
                            string desc = "";
                            if (operateType == 1)
                            {
                                desc = "下架";
                            }
                            else
                            {
                                desc = "上架";
                            }
                            InsertLog(model.F_DeviceId, desc);
                        }
                        total++;
                    }
                }
                if (total > 0)
                {
                    return Success("批量修改成功");

                }
                else
                {
                    return Error("批量修改失败");
                }



            }
            else
            {
                return Error("获取参数失败");
            }
        }

        /// <summary>
        /// 我的设备列表  Device/GetMyDeviceList
        /// </summary>
        /// <param name="typeName">设备名称</param>
        /// <param name="startTime"></param>
        /// <param name="endTime"></param>
        /// <param name="dicId">设备类型</param>
        /// <param name="deviceStatus">设备状态传int 1 待上架 2 闲置 3 使用中</param>
        /// <param name="page"></param>
        /// <param name="pagesize"></param>
        /// <returns></returns>
        public ActionResult GetMyDeviceList(

            string typeName, string startTime, string endTime, int dicId = 0, int deviceStatus = 0, int page = 1, int pagesize = 10, int isdc = 0)
        {

            DataTable dt = new DataTable();
            string sql = " and F_IsDelete=0 and F_Classify=2";
            int mydeptid = User.F_DeptId;

            sql += " and  (F_BelongDept= " + mydeptid + " or F_UseDept=" + mydeptid + " )";
            if (dicId > 0)
            {
                sql += " and F_DicId='" + dicId + "' ";
            }
            if (!string.IsNullOrEmpty(startTime))
            {
                sql += " and F_ListingTime>='" + startTime + "'";
            }
            if (!string.IsNullOrEmpty(endTime))
            {
                sql += " and F_ListingTime<='" + endTime + "'";
            }
            if (!string.IsNullOrEmpty(typeName))
            {
                sql += " and F_TypeName like '%" + typeName + "%' ";
            }
            if (deviceStatus > 0)
            {
                sql += " and F_DeviceStatus='" + deviceStatus + "' ";
            }

            if (isdc > 0)
            {
                var dtdc = DB.DbHelperSQL.Query("	 SELECT  F_TypeName 设备名称, F_Desc 设备描述,F_AssetCode 资产编码 , F_DeviceShortCode 设备短码,F_Specification 规格型号, F_BelongDeptName 归属科室, F_BelongPhone 归属科室电话,(CASE F_DeviceStatus    WHEN 1 THEN '待上架' WHEN 2 THEN '可调拨' WHEN 3 THEN '调拨中'     ELSE ''END) 设备状态,F_ListingTime 上架时间 from T_Adjust_Device a WITH(NOLOCK) where 1=1 " + sql + "order by F_DeviceId desc").Tables[0];
                var msg = new NPOIHelper().ExportToExcel("我的设备", dtdc);
                if (msg == "")
                {
                    return Success("导出成功");
                }
                else
                {
                    return Error("导出失败");
                }
            }

            int recordCount = 0;
            dt = Bll.PagerBll.GetListPager(
              "T_Adjust_Device",
              "F_DeviceId",
              "*",
              sql,
             " order by F_DeviceId desc",
              pagesize,
              page,
              true,
              out recordCount);

            dt.Columns.Add("FileUrl", typeof(object));

            foreach (DataRow dr in dt.Rows)
            {
                if (!string.IsNullOrEmpty(fileurlpath) && !string.IsNullOrEmpty(dr["F_File"].ToString()))
                {
                    dr["FileUrl"] = GetFileData(dr["F_File"].ToString(), fileurlpath);
                }
            }


            var obj = new
            {
                state = "success",
                message = "成功",
                rows = dt,
                total = recordCount
            };

            return Content(obj.ToJson());

        }

        /// <summary>
        /// 我的设备列表中添加编辑设备  Device/AddOrEditMyDevice
        /// </summary>
        /// <param name="address">部门地址</param>
        /// <param name="phone">部门电话</param>
        /// <param name="assetCode">资产编码</param>
        /// <param name="file">文件 string</param>
        /// <param name="desc">描述</param>
        /// <param name="deviceTypeId">设备类型表的主键id，不是dicId</param>
        /// <param name="deviceId">设备id，编辑用</param>
        /// <returns></returns>
        public ActionResult AddOrEditMyDevice(string address
            , string phone, string assetCode, string file, string desc, string deviceShortCode, string bigTypeName, string typeName,

            string code, string specification, int dicId = 0,
            int deviceTypeId = 0, int deviceId = 0)
        {
            if (deviceTypeId == 0)
            {
                if (string.IsNullOrEmpty(bigTypeName) && string.IsNullOrEmpty(typeName))
                {
                    return Error("请选择或者输入设备类型和设备名称");
                }
                if (dicId == 0 && string.IsNullOrEmpty(typeName))
                {
                    return Error("请选择或者输入设备类型和设备名称");
                }
            }
            Model.T_Adjust_DeviceType typemodel = new T_Adjust_DeviceType();

            if (deviceTypeId > 0)
            {
                typemodel = typeservice.GetModel(deviceTypeId);
                if (typemodel == null)
                {
                    return Error(" 设备类型不存在");
                }

            }
            else
            {
                //先添加字典的记录
                //添加设备类型记录

                //T_Sys_DictionaryValue orderModel = new T_Sys_DictionaryValue();
                //orderModel.F_Name = bigTypeName;

                //orderModel.F_State = true;

                //orderModel.F_DictionaryFlag = "DBSBLX";


                //int dicaddid = new Bll.T_Sys_DictionaryValue().Add(bigTypeName);
                int dicaddid = 0;

                if (dicId > 0)
                {
                    Model.T_Sys_DictionaryValue dicmodel = new Bll.T_Sys_DictionaryValue().GetModel(dicId);
                    if (dicmodel != null)
                    {
                        dicaddid = dicmodel.F_DictionaryValueId;
                        bigTypeName = dicmodel.F_Name;
                    }
                }
                else
                {

                    Model.T_Sys_DictionaryValue dicmodel = new Bll.T_Sys_DictionaryValue().GetModel(bigTypeName);
                    if (dicmodel != null)
                    {
                        dicaddid = dicmodel.F_DictionaryValueId;

                    }
                    else
                    {
                        dicaddid = new Bll.T_Sys_DictionaryValue().Add(bigTypeName);

                    }
                }
                Model.T_Adjust_DeviceType modeltype = typeservice.GetModel(bigTypeName, typeName, 2);
                if (modeltype == null)
                {
                    // Model.T_Adjust_DeviceType model = new T_Adjust_DeviceType();
                    typemodel.F_DeviceNum = 0;
                    typemodel.F_IsDelete = 0;


                    typemodel.F_CreateBy = User.F_UserCode;
                    typemodel.F_BigTypeName = bigTypeName;
                    typemodel.F_TypeName = typeName;
                    typemodel.F_Classification = 2;
                    typemodel.F_DicId = dicaddid;
                    typemodel.F_CreateTime = DateTime.Now;
                    typemodel.F_UpdateTime = DateTime.Now;
                    int res = typeservice.Add(typemodel);


                    deviceTypeId = res;
                }
                else
                {
                    typemodel = modeltype;
                    deviceTypeId = modeltype.F_TypeId;
                }
            }


            var existslist = deviceservice.GetModelList(" F_AssetCode ='" + assetCode + "' and F_AssetCode is not null and F_AssetCode!='' ");
            if (deviceId > 0)
            {
                if (existslist.Count == 0)
                { }
                else if (existslist.Count == 1 && existslist.First().F_DeviceId == deviceId)
                {
                }
                else
                {
                    return Error("资产编码不能重复！");
                }
                Model.T_Adjust_Device model = deviceservice.GetModel(deviceId);
                int old = model.F_DeviceTypeId;
                bool needupdatecount = false;
                if (old != deviceTypeId)
                {
                    needupdatecount = true;
                }

                //编辑
                model.F_BigTypeName = typemodel.F_BigTypeName;
                model.F_TypeName = typemodel.F_TypeName;
                model.F_DicId = typemodel.F_DicId;
                model.F_DeviceTypeId = deviceTypeId;


                model.F_BelongPhone = phone;
                model.F_BelongAddress = address;
                model.F_AssetCode = assetCode;
                model.F_DeviceShortCode = deviceShortCode;
                model.F_Specification = specification;
                model.F_Code = code;
                model.F_File = file;

                model.F_UpdateTime = DateTime.Now;


                model.F_DeviceShortCode = deviceShortCode;
                model.F_Specification = specification;
                model.F_Code = code;
                model.F_Desc = desc;



                if (deviceservice.Update(model))
                {
                    if (needupdatecount)
                    {

                        string uda = " update T_Adjust_DeviceType set F_DeviceNum= isnull(F_DeviceNum,0)+1   where F_TypeId=" + deviceId + "";

                        string uda2 = " update T_Adjust_DeviceType set F_DeviceNum= isnull(F_DeviceNum,0)-1   where F_TypeId=" + old + "";
                        DbHelperSQL.ExecuteSql(uda);
                        DbHelperSQL.ExecuteSql(uda2);
                    }

                    return Success("修改成功");
                }
                else
                {
                    return Error("修改失败");
                }

            }
            else
            {

                if (!string.IsNullOrEmpty(assetCode) && existslist.Count > 0)
                {
                    return Error("资产编码不能重复！");
                }

                //  Model.T_Sys_Department dept = new Bll.T_Sys_Department().GetModel(User.F_DeptId);

                var dept = DbHelperSQL.Query(" SELECT * from T_AllDept WHERE F_deptid = " + User.F_DeptId + "").Tables[0];

                Model.T_Adjust_Device model = new T_Adjust_Device();
                model.F_BelongDept = User.F_DeptId;
                model.F_BelongDeptName = dept.Rows[0]["keyname"].ToString();
                model.F_Source = 1;
                model.F_DeviceStatus = 1;//待上架
                model.F_Classify = 2;
                model.F_IsDelete = 0;
                model.F_CreateBy = User.F_UserCode;
                model.F_CreateTime = DateTime.Now;
                model.F_UpdateTime = DateTime.Now;

                model.F_DeviceShortCode = deviceShortCode;
                model.F_Specification = specification;
                model.F_Code = code;

                model.F_DeviceTypeId = deviceTypeId;
                model.F_BigTypeName = typemodel.F_BigTypeName;
                model.F_TypeName = typemodel.F_TypeName;
                model.F_DicId = typemodel.F_DicId;

                model.F_BelongPhone = phone;
                model.F_BelongAddress = address;

                model.F_AssetCode = assetCode;
                model.F_Desc = desc;




                model.F_File = file;

                int res = deviceservice.Add(model);
                if (res > 0)
                {
                    string uda = " update T_Adjust_DeviceType set F_DeviceNum= isnull(F_DeviceNum,0)+1   where F_TypeId=" + deviceTypeId + "";

                    DbHelperSQL.ExecuteSql(uda);
                    InsertLog(res, "添加设备");

                    return Success("添加成功");
                }
                else
                {
                    return Error("添加失败");
                }
            }







        }

        /// <summary>
        ///  GetUnusedList 调拨管理中的闲置列表，状态都是闲置
        /// </summary>
        /// <param name="typeName">设备名称</param>
        /// <param name="startTime"></param>
        /// <param name="endTime"></param>
        /// <param name="dicId">设备类型</param>
        /// <param name="page"></param>
        /// <param name="pagesize"></param>
        /// <returns></returns>
        public ActionResult GetUnusedList(

           string typeName, string startTime, string endTime, int dicId = 0, int page = 1, int pagesize = 10, int listType = 1, int isdc = 0)
        {

            DataTable dt = new DataTable();
            string sql = " and F_IsDelete=0 and F_Classify=2 ";

            if (listType == 1)
            {

                sql += " and F_DeviceStatus in (2,3)";
                sql += " and F_BelongDept !=" + User.F_DeptId + "";
            }
            else
            {
                sql += " and F_DeviceStatus=3";
            }

            if (dicId > 0)
            {
                sql += " and F_DicId='" + dicId + "' ";
            }
            if (!string.IsNullOrEmpty(startTime))
            {
                sql += " and F_ListingTime>='" + startTime + "'";
            }
            if (!string.IsNullOrEmpty(endTime))
            {
                sql += " and F_ListingTime<='" + endTime + "'";
            }
            if (!string.IsNullOrEmpty(typeName))
            {
                sql += " and F_TypeName like '%" + typeName + "%' ";
            }
            //if (deviceStatus > 0)
            //{
            //    sql += " and F_DeviceStatus='" + deviceStatus + "' ";
            //}


            if (isdc > 0)
            {
                var dtdc = DB.DbHelperSQL.Query("	 SELECT  F_TypeName 设备名称, F_Desc 设备描述,F_AssetCode 资产编码 , F_DeviceShortCode 设备短码,F_Specification 规格型号, F_BelongDeptName 归属科室, F_BelongPhone 归属科室电话,(CASE F_DeviceStatus    WHEN 1 THEN '待上架' WHEN 2 THEN '可调拨' WHEN 3 THEN '调拨中'    ELSE ''END) 设备状态,F_ListingTime 上架时间 from T_Adjust_Device a WITH(NOLOCK) where 1=1 " + sql + "order by F_DeviceId desc").Tables[0];
                var msg = new NPOIHelper().ExportToExcel("空闲设备", dtdc);
                if (msg == "")
                {
                    return Success("导出成功");
                }
                else
                {
                    return Error("导出失败");
                }
            }


            int recordCount = 0;
            dt = Bll.PagerBll.GetListPager(
              "T_Adjust_Device",
              "F_DeviceId",
              "*",
              sql,
             " order by F_ListingTime desc",
              pagesize,
              page,
              true,
              out recordCount);

            dt.Columns.Add("FileUrl", typeof(object));

            foreach (DataRow dr in dt.Rows)
            {
                if (!string.IsNullOrEmpty(fileurlpath) && !string.IsNullOrEmpty(dr["F_File"].ToString()))
                {
                    dr["FileUrl"] = GetFileData(dr["F_File"].ToString(), fileurlpath);
                }
            }


            var obj = new
            {
                state = "success",
                message = "成功",
                rows = dt,
                total = recordCount
            };

            return Content(obj.ToJson());

        }
        private string fileurlpath = ConfigHelper.GetValue("fileurlpath");
        public DataTable GetFileData(string ids, string prefix)
        {
            DataTable dt = DbHelperSQL.Query("select * from T_Sys_Accessories WITH(NOLOCK) where F_FileId in (" + ids + ")").Tables[0];

            foreach (DataRow dr in dt.Rows)
            {
                if (FileHelper.Exists(FileHelper.GetPath() + dr["F_FileUrl"].ToString()))
                {
                    dr["F_FileUrl"] = prefix + dr["F_FileUrl"].ToString();
                }
                else
                {
                    string url = HomeController.Upload(dr["F_FileUrl"].ToString(), dr["F_FileName"].ToString(), "/" + dr["F_FileUrl"].ToString().Replace(dr["F_FileName"].ToString(), ""));
                    if (url == "1")
                        dr["F_FileUrl"] = prefix + dr["F_FileUrl"].ToString();
                    else
                        dr["F_FileUrl"] = url;
                }
            }

            return dt;
        }
        /// <summary>
        /// AuditDB
        /// </summary>
        /// <param name="reason">拒绝的时候原因</param>
        /// <param name="operate">0 拒绝 1 同意</param>
        /// <param name="deviceId"></param>
        /// <returns></returns>
        public ActionResult AuditDB(string reason, int operate, int deviceId = 0)
        {

            if (deviceId <= 0)
            {
                return Error("请选择设备");
            }
            Model.T_Adjust_Device model = deviceservice.GetModel(deviceId);
            string reusercode = model.F_UseCode;
            Model.T_Adjust_Device oldmodel = deviceservice.GetModel(deviceId);
            //            参考附件图片，同意、拒绝操作需要给对应人发消息（钉钉）
            //1.同意：设备状态变更为待上架，归属科室变更为申请科室
            //2.拒绝：设备状态变更为可调配，需要输入拒绝原因
            if (operate == 1)
            {


                model.F_DeviceStatus = 1;
                model.F_BelongAddress = model.F_UseAddress;
                model.F_BelongDept = model.F_UseDept;
                model.F_BelongDeptName = model.F_UseDeptName;
                model.F_BelongPhone = model.F_UsePhone;

                model.F_UseDept = null;
                model.F_UseAddress = "";
                model.F_UseDeptName = "";
                model.F_UsePhone = "";
                model.F_UseCode = "";

                model.F_ListingTime = null;
                model.F_UpdateTime = DateTime.Now;

                if (deviceservice.Update(model))
                {
                    //添加操作日志
                    InsertLog(deviceId, "同意申请，" + oldmodel.F_TypeName + "归属科室更改为" + oldmodel.F_UseDeptName);
                    msg.AddInternalMessagesInfo("调拨审核同意", model.F_TypeName + "同意调拨", reusercode, User.F_UserCode, EnumSmsType.comprehensive
      , 0);

                    return Success("审核成功");
                }
                else
                {
                    return Error("审核失败");
                }
            }
            if (operate == 0)
            {

                model.F_DeviceStatus = 2;
                model.F_UseDept = null;
                model.F_UseAddress = "";
                model.F_UseDeptName = "";
                model.F_UsePhone = "";
                model.F_UseCode = "";


                model.F_UpdateTime = DateTime.Now;
                if (deviceservice.Update(model))
                {
                    if (!string.IsNullOrEmpty(reason))
                    {
                        reason = ",原因：" + reason;
                    }

                    InsertLog(deviceId, "拒绝申请" + reason);
                    msg.AddInternalMessagesInfo("调拨审核拒绝", model.F_TypeName + "拒绝申请", reusercode, User.F_UserCode, EnumSmsType.comprehensive
   , 0);
                    return Success("审核成功");
                }
                else
                {
                    return Error("审核失败");
                }


            }
            return Error("审核失败");



        }

        /// <summary>
        /// 申请调拨 Adjust
        /// </summary>
        /// <param name="deviceId"></param>
        /// <returns></returns>
        public ActionResult Adjust(int deviceId)
        {
            if (deviceId <= 0)
            {
                return Error("请选择设备");
            }


            Model.T_Adjust_Device model = deviceservice.GetModel(deviceId);
            if (model.F_DeviceStatus == 3)
            {
                return Error("调拨中不允许申请");
            }
            if (model.F_BelongDept == User.F_DeptId)
            {
                return Error("此设备所属部门是登录人的部门");
            }
            Model.T_Sys_Department deptmodel = new Bll.T_Sys_Department().GetModel(User.F_DeptId);
            var dept = DbHelperSQL.Query(" SELECT * from T_AllDept WHERE F_deptid = " + User.F_DeptId + "").Tables[0];


            model.F_UseDept = User.F_DeptId;
            model.F_UseAddress = dept.Rows[0]["F_location"].ToString();// dept.F_Location;
            model.F_UseDeptName = dept.Rows[0]["keyname"].ToString();
            model.F_UsePhone = deptmodel.F_OfficeTelephone;
            model.F_UseCode = User.F_UserCode;

            model.F_DeviceStatus = 3;
            model.F_UpdateTime = DateTime.Now;

            if (deviceservice.Update(model))
            {
                InsertLog(deviceId, "申请设备调拨");
                return Success("申请成功");
            }
            else
            {
                return Error("申请失败");
            }
        }

        /// <summary>
        /// GetDetail
        /// </summary>
        /// <param name="deviceId"></param>
        /// <param name="classify">1 调配 2调拨</param>
        /// <returns></returns>
        public ActionResult GetDetail(int deviceId, int classify = 1)
        {
            var dt = deviceservice.GetList(" F_DeviceId=" + deviceId + "").Tables[0];


            dt.Columns.Add("FileUrl", typeof(object));

            foreach (DataRow dr in dt.Rows)
            {
                if (!string.IsNullOrEmpty(fileurlpath) && !string.IsNullOrEmpty(dr["F_File"].ToString()))
                {
                    dr["FileUrl"] = GetFileData(dr["F_File"].ToString(), fileurlpath);
                }
            }




            var tpinfo = tpinfoBll.GetModelList(" F_DeviceId=" + deviceId + " order by F_CreateTime desc");
            var obj = new
            {
                state = "success",
                message = "成功",
                data = dt,
                logs = tpinfo
            };

            return Content(obj.ToJson());



        }



        public ActionResult GetDBInfo(int deviceId = 0, int page = 1, int pagesize = 10)
        {

            if (deviceId == 0)
            {

                return Error("deviceId 不能为空");
            }

            DataTable dt = new DataTable();
            string sql = " and 1 = 1";



            if (deviceId > 0)
            {
                sql += " and F_DeviceId='" + deviceId + "' ";
            }

            int recordCount = 0;
            dt = Bll.PagerBll.GetListPager(
              "T_Adjust_Log",
              "F_LogId",
              "*",
              sql,
             " order by F_CreateTime desc",
              pagesize,
              page,
              true,
              out recordCount);



            var obj = new
            {
                state = "success",
                message = "成功",
                data = dt,
                total = recordCount

            };

            return Content(obj.ToJson());



        }


        public void InsertLog(int deviceId, string log)
        {
            Model.T_Adjust_Log logmodel = new T_Adjust_Log();
            logmodel.F_CreateBy = User.F_UserName + "(" + User.F_UserCode + ")";
            logmodel.F_CreateTime = DateTime.Now;
            logmodel.F_Log = log;
            logmodel.F_DeviceId = deviceId;
            logBll.Add(logmodel);
        }


        //工单相关的接口


        /// <summary>
        /// GetAllDPDevice创建工单时，获取所有的调配设备
        /// </summary>
        /// <returns></returns>
        public ActionResult GetAllDPDevice()
        {
            string sql = "select F_DeviceId,F_TypeName from T_Adjust_Device  where F_Classify=1 and F_IsDelete=0 ";
            var list = DbHelperSQL.Query(sql).Tables[0];
            var obj = new
            {
                state = "success",
                message = "成功",
                data = list
            };
            return Content(obj.ToJson());

        }



        //列表默认显示对应借用类型名称下的闲置设备，可使用资产编码或短码搜索；可选择对应设备点击出库进行出库；

        /// <summary>
        /// GetUnuseDevice根据工单编号查找 该工单借用的类型名称.下的闲置设备，可使用资产编码或短码搜索；可选择对应设备点击出库进行出库；
        /// </summary>
        /// <param name="workOrderCode"></param>
        /// <param name="assetCode"></param>
        /// <param name="deviceShortCode"></param>
        /// <param name="page"></param>
        /// <param name="pagesize"></param>
        /// <returns></returns>
        public ActionResult GetUnuseDevice(string assetCode, string deviceShortCode, int deviceTypeId = 0, int page = 1, int pagesize = 10)
        {



            DataTable dt = new DataTable();
            string sql = " and F_IsDelete=0 and F_Classify=1 and F_DeviceStatus=2  ";

            sql += " and F_DeviceTypeId=" + deviceTypeId + "";



            if (!string.IsNullOrEmpty(assetCode))
            {
                sql += " and F_AssetCode='" + assetCode + "' ";
            }


            if (!string.IsNullOrEmpty(deviceShortCode))
            {
                sql += " and F_DeviceShortCode='" + deviceShortCode + "' ";
            }
            int recordCount = 0;
            dt = Bll.PagerBll.GetListPager(
              "T_Adjust_Device",
              "F_DeviceId",
              "*",
              sql,
             " order by F_DeviceId desc",
              pagesize,
              page,
              true,
              out recordCount);




            var obj = new
            {
                state = "success",
                message = "成功",
                rows = dt,
                total = recordCount
            };

            return Content(obj.ToJson());


        }

        //列表默认显示当前用户所在的科室下所有使用中的设备，可使用资产编码或短码搜索其他设备；可选择对应设备点击入库进行入库；
        /// <summary>
        /// GetUseDevice
        /// </summary>
        /// <param name="assetCode">资产编码</param>
        /// <param name="deviceShortCode">短码</param>
        /// <param name="page"></param>
        /// <param name="pagesize"></param>
        /// <returns></returns>
        public ActionResult GetUseDevice(string assetCode, string deviceShortCode, int deviceTypeId = 0, int page = 1, int pagesize = 10)
        {
            DataTable dt = new DataTable();
            string sql = " and F_IsDelete=0 and F_Classify=1 and F_DeviceStatus=3 and F_UseDept='" + User.F_DeptId + "'";
            sql += " and F_DeviceTypeId=" + deviceTypeId + "";
            if (!string.IsNullOrEmpty(assetCode))
            {
                sql += " and F_AssetCode='" + assetCode + "' ";
            }


            if (!string.IsNullOrEmpty(deviceShortCode))
            {
                sql += " and F_DeviceShortCode='" + deviceShortCode + "' ";
            }
            int recordCount = 0;
            dt = Bll.PagerBll.GetListPager(
              "T_Adjust_Device",
              "F_DeviceId",
              "*",
              sql,
             " order by F_DeviceId desc",
              pagesize,
              page,
              true,
              out recordCount);




            var obj = new
            {
                state = "success",
                message = "成功",
                rows = dt,
                total = recordCount
            };

            return Content(obj.ToJson());


        }



        //string address
        //    , string phone, string assetCode,  string file,string desc, string deviceShortCode,

        //    string code, string specification,
        //    string bigname,string name ,

        //1 调配 2调拨
        public ActionResult ImportDevice()
        {
            HttpPostedFileBase _upfile = Request.Files["upFile"];
            int headrow = 0;
            string savepath = Server.MapPath("..") + "/Upload/import/" + DateTime.Now.ToString("yyyy") + "/" + DateTime.Now.ToString("MM") + "/" + DateTime.Now.ToString("dd");
            // 如果不存在就创建file文件夹
            if (!Directory.Exists(savepath))
            {
                if (savepath != null) Directory.CreateDirectory(savepath);
            }

            string realurl = Path.Combine(savepath, _upfile.FileName);
            // 指定保存文件的路径


            // 保存文件到服务器
            _upfile.SaveAs(realurl);


            NPOIHelper npoi = new NPOIHelper();
            DataTable dt = npoi.ExcelToTable(_upfile, headrow);
            try
            {
                bool isValid = true;
                if (dt != null && dt.Columns.Count >= 2)
                {
                    string firstColumnName = dt.Columns[7].ColumnName;
                    string secondColumnName = dt.Columns[2].ColumnName;

                    isValid = (firstColumnName == "出厂编号" && secondColumnName == "科室电话");
                }
                if (isValid == false)
                {
                    return Error("导入模版错误");
                }
            }
            catch (Exception)
            {
                return Error("导入模版错误");
            }

            int res = 0;
            string returnerror = "";
            foreach (DataRow dr in dt.Rows)
            {
                int deviceTypeId = 0;
                int dicaddid = 0;
                headrow = headrow + 1;




                if (dr[0].ToString() != "" && dr[1].ToString() != "" && dr[4].ToString() != "")
                {

                    var existslist = deviceservice.GetModelList(" F_AssetCode ='" + dr[4].ToString() + "'");
                    if (existslist.Count > 0)
                    {

                        Model.T_Adjust_Device model = existslist.First();

                        if (model.F_Classify != 1)
                        {

                            returnerror += "第" + headrow + "行资产编码已存在，属于调拨类型";
                            continue;
                        }

                        model.F_BigTypeName = dr[0].ToString();// typemodel.F_BigTypeName;
                        model.F_TypeName = dr[1].ToString();
                        //根据bigtypename去找dic
                        Model.T_Sys_DictionaryValue dic = new Bll.T_Sys_DictionaryValue().GetModel(dr[0].ToString());
                        if (dic == null)
                        {
                            //先添加字典的记录
                            dicaddid = new Bll.T_Sys_DictionaryValue().Add(dr[0].ToString());
                        }
                        model.F_DicId = dicaddid == 0 ? dic.F_DictionaryValueId : dicaddid;//.F_DicId;
                        Model.T_Adjust_DeviceType modeltype = typeservice.GetModel(dr[0].ToString(), dr[1].ToString(), 1);
                        if (modeltype == null)
                        {//添加设备类型记录
                            Model.T_Adjust_DeviceType addmodel = new T_Adjust_DeviceType();
                            addmodel.F_DeviceNum = 0;
                            addmodel.F_IsDelete = 0;

                            addmodel.F_Classification = 1;
                            addmodel.F_CreateBy = User.F_UserCode;
                            addmodel.F_BigTypeName = dr[0].ToString();
                            addmodel.F_TypeName = dr[1].ToString();

                            addmodel.F_DicId = dicaddid;
                            addmodel.F_CreateTime = DateTime.Now;
                            addmodel.F_UpdateTime = DateTime.Now;
                            int rees = typeservice.Add(addmodel);


                            deviceTypeId = rees;
                        }

                        var dept = DbHelperSQL.Query(" SELECT * from T_AllDept WHERE F_deptid = " + User.F_DeptId + "").Tables[0];
                        model.F_BelongPhone = dr[2].ToString();
                        model.F_BelongAddress = dr[3].ToString();
                        model.F_BelongDept = User.F_DeptId;
                        //  model.F_BelongDeptName = dept.F_DeptName;// eptName;
                        model.F_BelongDeptName = dept.Rows[0]["keyname"].ToString();
                        model.F_DeviceTypeId = deviceTypeId == 0 ? modeltype.F_TypeId : deviceTypeId;
                        model.F_AssetCode = dr[4].ToString();
                        model.F_DeviceShortCode = dr[5].ToString();
                        model.F_Specification = dr[6].ToString();
                        model.F_Code = dr[7].ToString();




                        model.F_UpdateTime = DateTime.Now;



                        deviceservice.Update(model);
                    }




                    else
                    {
                        Model.T_Adjust_Device model = new T_Adjust_Device();
                        model.F_BigTypeName = dr[0].ToString();// typemodel.F_BigTypeName;
                        model.F_TypeName = dr[1].ToString();
                        //根据bigtypename去找dic

                        Model.T_Sys_DictionaryValue dic = new Bll.T_Sys_DictionaryValue().GetModel(dr[0].ToString());
                        if (dic == null)
                        {
                            //先添加字典的记录
                            dicaddid = new Bll.T_Sys_DictionaryValue().Add(dr[0].ToString());
                        }
                        model.F_DicId = dicaddid == 0 ? dic.F_DictionaryValueId : dicaddid;//.F_DicId;
                        Model.T_Adjust_DeviceType modeltype = typeservice.GetModel(dr[0].ToString(), dr[1].ToString(), 1);
                        if (modeltype == null)
                        {//添加设备类型记录
                            Model.T_Adjust_DeviceType addmodel = new T_Adjust_DeviceType();
                            addmodel.F_DeviceNum = 0;
                            addmodel.F_IsDelete = 0;

                            addmodel.F_Classification = 1;
                            addmodel.F_CreateBy = User.F_UserCode;
                            addmodel.F_BigTypeName = dr[0].ToString();
                            addmodel.F_TypeName = dr[1].ToString();

                            addmodel.F_DicId = dicaddid;
                            addmodel.F_CreateTime = DateTime.Now;
                            addmodel.F_UpdateTime = DateTime.Now;
                            int rees = typeservice.Add(addmodel);


                            deviceTypeId = rees;
                        }
                        var dept = DbHelperSQL.Query(" SELECT * from T_AllDept WHERE F_deptid = " + User.F_DeptId + "").Tables[0];
                        //   Model.T_Sys_Department dept = new Bll.T_Sys_Department().GetModel(User.F_DeptId);
                        model.F_BelongPhone = dr[2].ToString();
                        model.F_BelongAddress = dr[3].ToString();
                        model.F_BelongDept = User.F_DeptId;
                        model.F_BelongDeptName = dept.Rows[0]["keyname"].ToString();
                        model.F_DeviceTypeId = modeltype.F_TypeId;
                        model.F_AssetCode = dr[4].ToString();
                        model.F_DeviceShortCode = dr[5].ToString();
                        model.F_Specification = dr[6].ToString();
                        model.F_Code = dr[7].ToString();
                        model.F_Source = 1;
                        model.F_CreateBy = User.F_UserCode;
                        model.F_CreateTime = DateTime.Now;
                        model.F_UpdateTime = DateTime.Now;
                        model.F_DeviceStatus = 1;//待上架
                        model.F_Classify = 1;
                        model.F_IsDelete = 0;

                        deviceservice.Add(model);
                        // 设备的数量重新算一遍
                        string updatesql = "update T_Adjust_DeviceType set F_DeviceNum = (SELECT Count(1) from T_Adjust_Device WHERE F_IsDelete = 0 and F_DeviceTypeId =" + modeltype.F_TypeId + " ) WHERE F_TypeId  =" + modeltype.F_TypeId;
                        DbHelperSQL.ExecuteSql(updatesql);
                    }
                }
                else
                {
                    return Error("第" + headrow + "行，第1，2,5 列信息不能为空，未导入");
                }
            }
            return Success("导入成功!" + returnerror);
        }

        public ActionResult ImportMyDevice()
        {
            HttpPostedFileBase _upfile = Request.Files["upFile"];
            int headrow = 0;
            NPOIHelper npoi = new NPOIHelper();
            DataTable dt = npoi.ExcelToTable(_upfile, headrow);

            try
            {
                bool isValid = true;
                if (dt != null && dt.Columns.Count >= 2)
                {
                    string firstColumnName = dt.Columns[8].ColumnName;
                    string secondColumnName = dt.Columns[2].ColumnName;

                    isValid = (firstColumnName == "描述" && secondColumnName == "科室电话");
                }
                if (isValid == false)
                {
                    return Error("导入模版错误");
                }
            }
            catch (Exception)
            {

                return Error("导入模版错误");
            }

            int exportnum = 0;

            string returnerror = "";
            var bll = new Bll.T_Cus_Customer();
            int res = 0;
            //  Model.T_Sys_Department dept = new Bll.T_Sys_Department().GetModel(User.F_DeptId);
            var dept = DbHelperSQL.Query(" SELECT * from T_AllDept WHERE F_deptid = " + User.F_DeptId + "").Tables[0];
            foreach (DataRow dr in dt.Rows)
            {
                int dicaddid = 0;
                int deviceTypeId = 0;
                headrow = headrow + 1;
                if (dr[0].ToString() != "" && dr[1].ToString() != "")
                {
                    //  Model.T_Adjust_DeviceType typemodel = typeservice.GetModel(dr[0].ToString(), dr[1].ToString(),2);

                    //根据bigtypename去找dic
                    Model.T_Sys_DictionaryValue dic = new Bll.T_Sys_DictionaryValue().GetModel(dr[0].ToString());
                    if (dic == null)
                    {
                        //先添加字典的记录
                        dicaddid = new Bll.T_Sys_DictionaryValue().Add(dr[0].ToString());
                    }

                    Model.T_Adjust_DeviceType modeltype = typeservice.GetModel(dr[0].ToString(), dr[1].ToString(), 1);
                    if (modeltype == null)
                    {
                        continue;
                        //添加设备类型记录
                        //Model.T_Adjust_DeviceType addmodel = new T_Adjust_DeviceType();
                        //addmodel.F_DeviceNum = 0;
                        //addmodel.F_IsDelete = 0;

                        //addmodel.F_Classification = 2;
                        //addmodel.F_CreateBy = User.F_UserCode;
                        //addmodel.F_BigTypeName = dr[0].ToString();
                        //addmodel.F_TypeName = dr[1].ToString();

                        //addmodel.F_DicId = dicaddid;
                        //addmodel.F_CreateTime = DateTime.Now;
                        //addmodel.F_UpdateTime = DateTime.Now;
                        //int rees = typeservice.Add(addmodel);


                        //deviceTypeId = rees;
                    }

                    var existslist = deviceservice.GetModelList(" F_AssetCode ='" + dr[4].ToString() + "'  ");
                    if (existslist.Count > 0)
                    {
                        Model.T_Adjust_Device model
                            = existslist.First();

                        if (model.F_Classify != 2)
                        {

                            returnerror += "第" + headrow + "行资产编码已存在，属于调配类型";
                            continue;
                        }

                        model.F_DeviceTypeId = deviceTypeId == 0 ? modeltype.F_TypeId : deviceTypeId;
                        model.F_BigTypeName = dr[0].ToString();
                        model.F_TypeName = dr[1].ToString();
                        model.F_DicId = dicaddid == 0 ? dic.F_DictionaryValueId : dicaddid;



                        model.F_BelongPhone = dr[2].ToString();
                        model.F_BelongAddress = dr[3].ToString();


                        model.F_AssetCode = dr[4].ToString();
                        model.F_DeviceShortCode = dr[5].ToString();
                        model.F_Specification = dr[6].ToString();
                        model.F_Code = dr[7].ToString();
                        model.F_Desc = dr[8].ToString();

                        model.F_UpdateTime = DateTime.Now;


                        deviceservice.Update(model);
                    }
                    else
                    {

                        Model.T_Adjust_Device model
                            = new T_Adjust_Device();
                        model.F_BelongDept = User.F_DeptId;
                        // model.F_BelongDeptName = dept.F_DeptName;
                        model.F_BelongDeptName = dept.Rows[0]["keyname"].ToString();
                        model.F_Source = 1;
                        model.F_DeviceStatus = 1;//待上架
                        model.F_Classify = 2;
                        model.F_IsDelete = 0;
                        model.F_CreateBy = User.F_UserCode;
                        model.F_CreateTime = DateTime.Now;
                        model.F_UpdateTime = DateTime.Now;


                        model.F_DeviceTypeId = deviceTypeId == 0 ? modeltype.F_TypeId : deviceTypeId;
                        model.F_BigTypeName = dr[0].ToString();
                        model.F_TypeName = dr[1].ToString();
                        model.F_DicId = dicaddid == 0 ? dic.F_DictionaryValueId : dicaddid;



                        model.F_BelongPhone = dr[2].ToString();
                        model.F_BelongAddress = dr[3].ToString();


                        model.F_AssetCode = dr[4].ToString();
                        model.F_DeviceShortCode = dr[5].ToString();
                        model.F_Specification = dr[6].ToString();
                        model.F_Code = dr[7].ToString();
                        model.F_Desc = dr[8].ToString();

                        int addre = deviceservice.Add(model);
                        if (addre > 0)
                        {
                            exportnum++;
                            // 设备的数量重新算一遍
                            string updatesql = "update T_Adjust_DeviceType set F_DeviceNum = (SELECT Count(1) from T_Adjust_Device WHERE F_IsDelete = 0 and F_DeviceTypeId =" + model.F_DeviceTypeId + " ) WHERE F_TypeId  =" + model.F_DeviceTypeId;
                            DbHelperSQL.ExecuteSql(updatesql);
                        }


                    }

                }
                else
                {
                    return Error("第" + headrow + "行，第1，2列信息不能为空，未导入");
                }
            }
            //if (exportnum == 0)
            //{
            //    return Success("0条数据被导入");
            //}
            //else {
            return Success("导入成功,导入" + exportnum + "数据");
            //}

        }

        /// <summary>
        /// ordertype 1 是调配 2 是调拨
        /// </summary>
        /// <param name="month">格式是yyyy-mm</param>
        /// <returns></returns>
        [AllowAnonymous]
        public ActionResult GetTotalReport(string month,int ordertype=1)
        {
            if (string.IsNullOrEmpty(month))
            {
                month = DateTime.Now.ToString("yyyy-MM");
            }
            DataTable jiechu = new DataTable();
            DataTable jieru = new DataTable();
            if (ordertype == 1)
            {
                jiechu = DbHelperSQL.Query("SELECT   F_BelongDept,F_BelongDeptName,SUM(F_Cost) jiechu FROM  [T_Adjust_TpOrder]  where F_IsDelete=0 and  F_BelongDept is  not null  and  F_OrderStatus=2 and F_ordertype=" + ordertype + " and   CONVERT(VARCHAR(7), F_OutTime, 120)='" + month + "'  GROUP BY F_BelongDept, F_BelongDeptName").Tables[0];

                jieru = DbHelperSQL.Query("SELECT   F_UseDept,F_UseDeptName,SUM(F_Cost) jieru  FROM  [T_Adjust_TpOrder] where F_IsDelete=0 and  F_UseDept is  not null  and  F_OrderStatus=2 and F_ordertype=" + ordertype + " and CONVERT(VARCHAR(7), F_OutTime, 120)='" + month + "' GROUP BY F_UseDept, F_UseDeptName ").Tables[0];

            }
            else {

                jiechu = DbHelperSQL.Query("SELECT   F_BelongDept,F_BelongDeptName,SUM(F_total) jiechu FROM  [T_Adjust_TpOrder]  where F_IsDelete=0 and  F_BelongDept is  not null  and  F_OrderStatus=2 and F_ordertype=" + ordertype + " and   CONVERT(VARCHAR(7), F_OutTime, 120)='" + month + "'  GROUP BY F_BelongDept, F_BelongDeptName").Tables[0];

                jieru = DbHelperSQL.Query("SELECT   F_UseDept,F_UseDeptName,SUM(F_total) jieru  FROM  [T_Adjust_TpOrder] where F_IsDelete=0 and  F_UseDept is  not null  and  F_OrderStatus=2 and F_ordertype=" + ordertype + " and CONVERT(VARCHAR(7), F_OutTime, 120)='" + month + "' GROUP BY F_UseDept, F_UseDeptName ").Tables[0];
            }

            var idList = new List<int>(jiechu.AsEnumerable().Select(x => x.Field<int>("F_BelongDept")));

            var idList2 = new List<int>(jieru.AsEnumerable().Select(x => x.Field<int>("F_UseDept")));

            var union = idList.Union(idList2);

            List<ReturnReport> lists = new List<ReturnReport>();
            foreach (int item in union)
            {
                ReturnReport re = new ReturnReport();
                DataRow[] rows = jiechu.Select("F_BelongDept=" + item + " ");

                if (rows != null && rows.Count() > 0)
                {
                    re.DeptName = rows[0]["F_BelongDeptName"].ToString();
                   // re.jiechu = Convert.ToDecimal(rows[0]["jiechu"].ToString());
                    re.jiechu = !string.IsNullOrEmpty(rows[0]["jiechu"].ToString()) ? Convert.ToDecimal(rows[0]["jiechu"].ToString()) : 0;
                }
                re.DeptId = item;
                DataRow[] rows2 = jieru.Select("F_UseDept=" + item + " ");

                if (rows2 != null && rows2.Count() > 0)
                {
                    re.DeptName = rows2[0]["F_UseDeptName"].ToString();

                    re.jieru = !string.IsNullOrEmpty(rows2[0]["jieru"].ToString())?Convert.ToDecimal(rows2[0]["jieru"].ToString()) :0;
                }
                   
                lists.Add(re);
            }
            var obj = new
            {
                state = "success",
                message = "成功",
                data = lists
            };
            return Content(obj.ToJson());
        }
        public class ReturnReport
        {
            public string DeptName { get; set; }
            public int DeptId { get; set; }
            public decimal jiechu { get; set; }
            public decimal jieru { get; set; }

        }
        /// <summary>
        /// 同步数据，过来是调配类型的
        /// </summary>
        [AllowAnonymous]
        public void tpdata()
        {

            string depsql = "select F_DeptId, keyname from  DeptNameName ";
            DataTable deptdt = DbHelperSQL.Query(depsql).Tables[0];


            List<Model.T_Sys_Department> deptlist = deptbll.GetModelList("F_State=1");

            // 转换为字典以加速查找
            var deptDict = deptdt.AsEnumerable()
                .ToDictionary(row => row.Field<int>("F_DeptId"), row => row.Field<string>("keyname"));

            //var departmentDict = deptlist.ToDictionary(d => d.F_DeptName, d => d);

            // 过滤掉重复的部门名称，保留第一个出现的
            var departmentDict = deptlist
                .GroupBy(d => d.F_DeptName)
                .Select(g => g.First())
                .ToDictionary(d => d.F_DeptName, d => d);
          
             int pageSize = 100; // 每页1000条
                                 //  int currentPage = 0; // 当前页码（从0开始）



            //一次同步1000条，避免卡死

            int rescount = (int)DbHelperSQL.GetSingle("SELECT  count(1)         FROM T_SyncEquip where tb_bz=1");
            // 预先计算总页数（避免在循环中计算）
            int totalPages = (rescount + pageSize - 1) / pageSize;
            int lastId = 0;  // 起始值（根据sb_Id类型调整）
            int processed = 0;
            List<Model.T_Adjust_Device> devicesToAdd = new List<Model.T_Adjust_Device>();
            List<Model.T_Adjust_Device> devicesToUpdate = new List<Model.T_Adjust_Device>();
            Dictionary<int,int> deviceTypeUpdates = new Dictionary<int, int>();

            while (processed < rescount)
            {
                // 使用参数化查询防止注入
                string sql = @"
        SELECT TOP (@take) * 
        FROM T_SyncEquip 
        WHERE tb_bz=1 and  sb_Id > @lastId 
        ORDER BY sb_Id";

                SqlParameter[] parameters = {
        new SqlParameter("@take", pageSize),
        new SqlParameter("@lastId", lastId)
    };

                DataTable dt = DbHelperSQL.Query(sql, parameters).Tables[0];
                if (dt.Rows.Count == 0) break;
                // 并行处理当前页数据（行级并行）
                Parallel.For(0, dt.Rows.Count, new ParallelOptions
                {
                    MaxDegreeOfParallelism = Environment.ProcessorCount
                }, i =>
                {


                    DataRow item = dt.Rows[i];
                    int deviceTypeId = 0;
                    int dicaddid = 0;
                    string bigTypeName = item["category_name"].ToString();//设备类别名称
                    string typeName = item["equip_name"].ToString();
                    string assetCode = item["equip_code"].ToString();//设备编码唯一

                    string specification = item["spec_model"].ToString();//规格型号
                    string code = item["precoding"].ToString();//出厂编码/SN
                    string mandept_name = item["mandept_name"].ToString();//管理部门
                    string usedept_name = item["usedept_name"].ToString();//使用部门


                    if (string.IsNullOrEmpty(bigTypeName) && string.IsNullOrEmpty(typeName))
                    {
                        return;
                        //continue;
                        // return Error("请选择或者输入设备类型和设备名称");
                    }
                    if (string.IsNullOrEmpty(assetCode))
                    {
                        return;
                        //continue;
                        //return Error("资产编码不能为空");
                    }

                    Model.T_Adjust_DeviceType typemodel = new T_Adjust_DeviceType();
                    //找不到这个设备类型，给它自动添加一个设备类型
                    // return Error(" 设备类型不存在");
                    //先看字典id
                    typemodel = typeservice.GetModel(bigTypeName, typeName, 1);
                    Model.T_Sys_DictionaryValue dicmodel = new Bll.T_Sys_DictionaryValue().GetModel(bigTypeName);
                    if (dicmodel != null)
                    {
                        dicaddid = dicmodel.F_DictionaryValueId;
                    }
                    else
                    {
                        //// 实时添加新字典值
                        //lock (this) // 防止并发添加相同记录
                        //{
                            // 再次检查，避免并发添加
                          //  dicmodel = new Bll.T_Sys_DictionaryValue().GetModel(bigTypeName);
                            //if (dicmodel == null)
                            //{
                                dicaddid = new Bll.T_Sys_DictionaryValue().Add(bigTypeName);
                            //}
                            //else
                            //{
                            //    dicaddid = dicmodel.F_DictionaryValueId;
                            //}
                      //  }

                    }

                    if (typemodel == null)
                    { // 实时添加新设备类型
                      //lock (this) // 防止并发添加相同记录
                      //{
                      //    // 再次检查，避免并发添加
                      //    typemodel = typeservice.GetModel(bigTypeName, typeName, 1);
                      //    if (typemodel == null)
                      //    {
                      //        Model.T_Adjust_DeviceType addtypemodel = new T_Adjust_DeviceType
                      //        {
                      //            F_DeviceNum = 0,
                      //            F_IsDelete = 0,
                      //            F_Classification = 1,
                      //            F_CreateBy = "8000",
                      //            F_BigTypeName = bigTypeName,
                      //            F_TypeName = typeName,
                      //            F_DicId = dicaddid,
                      //            F_CreateTime = DateTime.Now,
                      //            F_UpdateTime = DateTime.Now
                      //        };

                        //        int addres = typeservice.Add(addtypemodel);
                        //        deviceTypeId = addres;
                        //    }
                        //    else
                        //    {
                        //        deviceTypeId = typemodel.F_TypeId;
                        //    }
                        //}

                        Model.T_Adjust_DeviceType addtypemodel = new T_Adjust_DeviceType
                        {
                            F_DeviceNum = 0,
                            F_IsDelete = 0,
                            F_Classification = 1,
                            F_CreateBy = "8000",
                            F_BigTypeName = bigTypeName,
                            F_TypeName = typeName,
                            F_DicId = dicaddid,
                            F_CreateTime = DateTime.Now,
                            F_UpdateTime = DateTime.Now
                        };
                        int addres = typeservice.Add(addtypemodel);
                        deviceTypeId = addres;
                    }
                    else
                    {
                        deviceTypeId = typemodel.F_TypeId;
                    }


                    var existslist = deviceservice.GetModelList(" F_AssetCode ='" + assetCode + "'");

                    Model.T_Adjust_Device model = new T_Adjust_Device();

                    //检查设备是否已存在（实时查询）
                    if (existslist.Count > 0)
                    {
                        //存在这个资产编码，更新原来的值
                        Model.T_Adjust_Device devicemodel = existslist.First();

                        if (devicemodel.F_BigTypeName == bigTypeName && devicemodel.F_TypeName == typeName && devicemodel.F_DicId == dicaddid
                            && devicemodel.F_Specification == specification && devicemodel.F_Code == code
                            )
                        {
                            return;
                            //continue;
                        }

                        //devicemodel.F_BigTypeName = bigTypeName;
                        //    devicemodel.F_TypeName = typeName;
                        //    devicemodel.F_DicId = dicaddid;

                        //    devicemodel.F_Specification = specification;
                        //    devicemodel.F_Code = code;
                        //    devicemodel.F_UpdateTime = DateTime.Now;
                        //    deviceservice.Update(devicemodel);
                        //return;

                        devicemodel.F_BigTypeName = bigTypeName;
                        devicemodel.F_TypeName = typeName;
                        devicemodel.F_DicId = dicaddid;
                        devicemodel.F_Specification = specification;
                        devicemodel.F_Code = code;
                        devicemodel.F_UpdateTime = DateTime.Now;

                        lock (devicesToUpdate)
                        {
                            devicesToUpdate.Add(devicemodel);
                        }

                        return;



                        //continue;
                        // return Error("资产编码不能重复！");
                    }

                    // 10. 设置设备部门和状态信息（使用预加载的部门数据）
                    if (departmentDict.TryGetValue(mandept_name, out Model.T_Sys_Department targetDepartment))
                    {
                        model.F_BelongPhone = targetDepartment.F_OfficeTelephone;
                        model.F_BelongAddress = targetDepartment.F_Location;
                        model.F_BelongDept = targetDepartment.F_DeptId;

                        if (deptDict.TryGetValue(targetDepartment.F_DeptId, out string keyname))
                        {
                            model.F_BelongDeptName = keyname;
                        }

                        if (departmentDict.TryGetValue(usedept_name, out Model.T_Sys_Department useDepartment))
                        {
                            model.F_UseAddress = useDepartment.F_Location;
                            model.F_UseDept = useDepartment.F_DeptId;

                            if (deptDict.TryGetValue(useDepartment.F_DeptId, out string usekeyname))
                            {
                                model.F_UseDeptName = usekeyname;
                            }

                            model.F_UsePhone = useDepartment.F_OfficeTelephone;
                            model.F_DeviceStatus = 3; // 使用中
                        }
                        else
                        {
                            model.F_DeviceStatus = 1; // 待上架
                        }
                    }
                    else
                    {
                        model.F_DeviceStatus = 1; // 待上架
                    }

                    // 11. 设置设备基本信息
                    model.F_BigTypeName = bigTypeName;
                    model.F_TypeName = typeName;
                    model.F_DicId = dicaddid;
                    model.F_DeviceTypeId = deviceTypeId;
                    model.F_AssetCode = assetCode;
                    model.F_Specification = specification;
                    model.F_Code = code;
                    model.F_Source = 3;
                    model.F_CreateBy = "8000";
                    model.F_CreateTime = DateTime.Now;
                    model.F_UpdateTime = DateTime.Now;
                    model.F_Classify = 1;
                    model.F_IsDelete = 0;

                    // 12. 添加到待处理列表
                    lock (devicesToAdd)
                    {
                        // 关键字段判断：根据业务需求定义重复逻辑
                        bool exists = devicesToAdd.Any(x =>x.F_AssetCode == model.F_AssetCode);

                        // 仅当不存在重复时添加
                        if (!exists)
                        {
                            devicesToAdd.Add(model);
                        }
                        
                    }

                    // 13. 记录需要更新的设备类型计数
                    lock (deviceTypeUpdates)
                    {
                        if (deviceTypeUpdates.ContainsKey(deviceTypeId))
                        {
                            deviceTypeUpdates[deviceTypeId]++;
                        }
                        else
                        {
                            deviceTypeUpdates[deviceTypeId] = 1;
                        }
                    }
                    //  });

                  
                    #region

                    //有使用科室，并且能查到使用科室id ，就给状态是使用中，不然就待上架

                    //Model.T_Sys_Department targetDepartment = deptlist.FirstOrDefault(d => d.F_DeptName == mandept_name);
                    //    Model.T_Sys_Department useDepartment = deptlist.FirstOrDefault(d => d.F_DeptName == usedept_name);
                    //    if (targetDepartment != null)
                    //    {
                    //        // 找到后的操作
                    //        model.F_BelongPhone = targetDepartment.F_OfficeTelephone;
                    //        model.F_BelongAddress = targetDepartment.F_Location;
                    //        model.F_BelongDept = targetDepartment.F_DeptId;
                    //        var keyname = deptdt.AsEnumerable()
                    //       .Where(row => row.Field<int>("F_DeptId") == targetDepartment.F_DeptId)
                    //       .Select(row => row.Field<string>("keyname"))
                    //       .FirstOrDefault();

                    //        if (keyname != null)
                    //        {
                    //            model.F_BelongDeptName = keyname;
                    //        }

                    //        if (useDepartment != null)
                    //        {
                    //            model.F_UseAddress = useDepartment.F_Location;
                    //            model.F_UseDept = useDepartment.F_DeptId;
                    //            var usekeyname = deptdt.AsEnumerable()
                    //          .Where(row => row.Field<int>("F_DeptId") == useDepartment.F_DeptId)
                    //          .Select(row => row.Field<string>("keyname"))
                    //          .FirstOrDefault();

                    //            if (keyname != null)
                    //            {
                    //                model.F_UseDeptName = usekeyname;
                    //            }

                    //            model.F_UsePhone = useDepartment.F_OfficeTelephone;
                    //            model.F_DeviceStatus = 3;//使用中
                    //        }
                    //        else
                    //        {
                    //            model.F_DeviceStatus = 1;//待上架
                    //        }
                    //    }
                    //    else
                    //    {
                    //        model.F_DeviceStatus = 1;//待上架
                    //    }


                    //    model.F_BigTypeName = bigTypeName;
                    //    model.F_TypeName = typeName;
                    //    model.F_DicId = dicaddid;



                    //    model.F_DeviceTypeId = deviceTypeId;
                    //    model.F_AssetCode = assetCode;
                    //    // model.F_DeviceShortCode = deviceShortCode;
                    //    model.F_Specification = specification;
                    //    model.F_Code = code;
                    //    model.F_Source = 3;
                    //    model.F_CreateBy = "8000";
                    //    model.F_CreateTime = DateTime.Now;
                    //    model.F_UpdateTime = DateTime.Now;
                    //    model.F_DeviceStatus = 1;//待上架
                    //    model.F_Classify = 1;
                    //    model.F_IsDelete = 0;
                    //// model.F_File = file;
                    //try
                    //{
                    //    int res = deviceservice.Add(model);
                    //    if (res > 0)
                    //    {
                    //        //设备类型的数量加1
                    //        var mm = typeservice.GetModel(deviceTypeId);
                    //        mm.F_DeviceNum = mm.F_DeviceNum == null ? 1 : mm.F_DeviceNum + 1;
                    //        mm.F_UpdateTime = DateTime.Now;
                    //        typeservice.Update(mm);

                    //        // return Success("添加成功");
                    //    }
                    //    else
                    //    {
                    //        // return Error("添加失败");
                    //    }
                    //}
                    //catch (Exception)
                    //{


                    //}


                    ////}

                    //  }
                    #endregion
                });
                // 14. 批量处理当前页数据
                if (devicesToAdd.Count > 0)
                {
                    BatchAddDevices(devicesToAdd);
                    DbHelperSQL.ExecuteSql(" insert into T_Log(F_Type,F_Content) values('同步设备,添加','" + devicesToAdd.Count + "')");
                    devicesToAdd.Clear();
                }

                if (devicesToUpdate.Count > 0)
                {
                    BatchUpdateDevices(devicesToUpdate);
                    DbHelperSQL.ExecuteSql(" insert into T_Log(F_Type,F_Content) values('同步设备,修改','" + devicesToUpdate.Count + "')");
                    devicesToUpdate.Clear();
                }

                // 15. 更新设备类型计数
                if (deviceTypeUpdates.Count > 0)
                {
                    BatchUpdateDeviceTypeCounts(deviceTypeUpdates);
                    deviceTypeUpdates.Clear();
                }
                // 更新分页键
                lastId = Convert.ToInt32(dt.Rows[dt.Rows.Count - 1]["sb_Id"]);
                processed += dt.Rows.Count;
            }

            //把所有的tb_bz=1的更新成0
            DbHelperSQL.ExecuteSql("update T_SyncEquip set tb_bz=0 ");
        }
        // 批量添加设备的方法
        private void BatchAddDevices(List<Model.T_Adjust_Device> devices)
        {
            int batchSize = 70; // 根据实际情况调整
            for (int i = 0; i < devices.Count; i += batchSize)
            {
                int count = Math.Min(batchSize, devices.Count - i);
                List<Model.T_Adjust_Device> batch = devices.GetRange(i, count);
                deviceservice.BatchAddDevices(batch);
            }
        }

        // 批量更新设备的方法
        private void BatchUpdateDevices(List<Model.T_Adjust_Device> devices)
        {  
            
                deviceservice.BatchUpdateDevices(devices);
           
           
        }

        // 批量更新设备类型计数的方法
        private void BatchUpdateDeviceTypeCounts(Dictionary<int, int> typeCounts)
        {  
                deviceservice.BatchUpdateDeviceTypeCounts(typeCounts);
            
         }
    }
}