111

啊鑫

5 天以前 e159c28b6d090dc875c878e462ceb45a809315d7

111

 MES.Service/Modes/MesCustomer.cs

@@ -16,7 +16,7 @@
    /// <summary>
    /// ID 
    ///</summary>
    [SugarColumn(ColumnName = "id", IsIdentity = true)]
    [SugarColumn(ColumnName = "id")]
    public decimal Id { get; set; }

    /// <summary>

 MES.Service/Modes/MesDepots.cs

@@ -17,7 +17,7 @@
    /// <summary>
    /// 仓库ID
    /// </summary>
    [SugarColumn(ColumnName = "depot_id", IsIdentity = true)]
    [SugarColumn(ColumnName = "depot_id")]
    public decimal DepotId { get; set; }

    /// <summary>

 MES.Service/Modes/MesItemType.cs

@@ -18,7 +18,7 @@
    /// <summary>
    /// ID 
    ///</summary>
    [SugarColumn(ColumnName = "id", IsIdentity = true)]
    [SugarColumn(ColumnName = "id")]
    public decimal? Id { get; set; }

    /// <summary>

 MES.Service/Modes/MesItems.cs

@@ -18,8 +18,14 @@
    /// <summary>
    /// 物料ID 
    ///</summary>
    [SugarColumn(ColumnName = "id", IsIdentity = true)]
    [SugarColumn(ColumnName = "id")]
    public decimal Id { get; set; }
    
    /// <summary>
    /// 物料ID 
    ///</summary>
    [SugarColumn(ColumnName = "ITEM_ID")]
    public decimal? ItemId { get; set; }

    /// <summary>
    /// 工厂 

 MES.Service/Modes/MesStaff.cs

@@ -18,7 +18,7 @@
    /// <summary>
    /// ID 
    ///</summary>
    [SugarColumn(ColumnName = "id", IsIdentity = true)]
    [SugarColumn(ColumnName = "id")]
    public decimal? Id { get; set; }

    /// <summary>

 MES.Service/Modes/MesSupplier.cs

@@ -18,7 +18,7 @@
    /// <summary>
    /// ID 
    ///</summary>
    [SugarColumn(ColumnName = "id", IsIdentity = true)]
    [SugarColumn(ColumnName = "id")]
    public decimal Id { get; set; }

    /// <summary>

 MES.Service/Modes/MesUnit.cs

@@ -18,7 +18,7 @@
    /// <summary>
    /// BASEINFO 
    ///</summary>
    [SugarColumn(ColumnName = "id", IsIdentity = true)]
    [SugarColumn(ColumnName = "id")]
    public decimal Id { get; set; }

    /// <summary>

 MES.Service/Modes/SysDepartment.cs

@@ -125,7 +125,7 @@
    /// <summary>
    /// 部门id 
    ///</summary>
    [SugarColumn(ColumnName = "id", IsIdentity = true)]
    [SugarColumn(ColumnName = "id")]
    public decimal Id { get; set; }

    /// <summary>

 MES.Service/service/BasicData/MesCustomerManager.cs

@@ -101,10 +101,6 @@

        var entity = new MesCustomer
        {
            // Id = string.IsNullOrEmpty(customer.Id)
            //     ? DateTimeOffset.UtcNow.ToUnixTimeSeconds()
            //     : Convert.ToDecimal(customer.Id),
            
            CustNo = customer.FNumber,
            CustSname = customer.FShortName,
            CustName = customer.FName,
@@ -126,16 +122,41 @@
            Type = customer.Type,
        };

        var mesCustomer = Db.Queryable<MesCustomer>()
        // 查找是否已存在相同客户编码的记录
        var existingCustomer = Db.Queryable<MesCustomer>()
            .Where(s => s.CustNo == entity.CustNo)
            .First();

        if (mesCustomer != null)
        if (existingCustomer != null)
        {
            entity.Id = mesCustomer.Id;
            // 如果存在，使用现有的ID，后续将删除后重新插入
            entity.Id = existingCustomer.Id;
        }
        else
        {
            // 如果不存在，设为0，InsertOrUpdate方法将生成新ID
            entity.Id = 0;
        }

        return entity;
    }

    /// <summary>
    /// 生成新的ID，确保不重复
    /// </summary>
    private decimal GenerateNewId()
    {
        // 处理空表的情况，从1开始
        var maxId = Db.Queryable<MesCustomer>().Max(x => (decimal?)x.Id) ?? 0;
        var newId = maxId + 1;
        
        // 双重检查，确保生成的ID不存在
        while (Db.Queryable<MesCustomer>().Where(x => x.Id == newId).Any())
        {
            newId++;
        }
        
        return newId;
    }

    private bool UpdateCustomerStatusBatch(SqlSugarScope db,
@@ -176,12 +197,25 @@

    private bool InsertOrUpdate(SqlSugarScope db, MesCustomer entity)
    {
        db.Deleteable<MesCustomer>().Where(s => s.Id == entity.Id)
            .ExecuteCommand();

        var insert = db.Insertable(entity).ExecuteCommand();

        return insert > 0;
        if (entity.Id == 0)
        {
            // 新增情况：生成新ID并插入
            var newId = GenerateNewId();
            entity.Id = newId;
            return db.Insertable(entity).IgnoreColumns(ignoreNullColumn:true).ExecuteCommand() > 0;
        }
        else
        {
            // 更新情况：删除后重新插入，保持原有ID
            var originalId = entity.Id;
            
            // 先删除原记录（如果存在）
            db.Deleteable<MesCustomer>().Where(s => s.Id == originalId).ExecuteCommand();
            
            // 重新插入，保持原有ID
            entity.Id = originalId;
            return db.Insertable(entity).IgnoreColumns(ignoreNullColumn:true).ExecuteCommand() > 0;
        }
    }

    private bool InsertOrUpdateBatch(SqlSugarScope db,

 MES.Service/service/BasicData/MesDepotsManager.cs

@@ -76,14 +76,46 @@
        throw new NotImplementedException("反审核失败");
    }

    /// <summary>
    /// 生成新的DepotId，确保不重复
    /// </summary>
    private decimal GenerateNewId()
    {
        // 处理空表的情况，从1开始
        var maxId = Db.Queryable<MesDepots>().Max(x => (decimal?)x.DepotId) ?? 0;
        var newId = maxId + 1;
        
        // 双重检查，确保生成的DepotId不存在
        while (Db.Queryable<MesDepots>().Where(x => x.DepotId == newId).Any())
        {
            newId++;
        }
        
        return newId;
    }

    // 插入或更新仓库的方法
    private bool InsertOrUpdate(SqlSugarScope db, MesDepots entity)
    {
        db.Deleteable<MesDepots>()
            .Where(s => s.DepotId == entity.DepotId)
            .ExecuteCommand();
        var insert = db.Insertable(entity).ExecuteCommand();
        return insert > 0;
        if (entity.DepotId == 0)
        {
            // 新增情况：生成新DepotId并插入
            var newId = GenerateNewId();
            entity.DepotId = newId;
            return db.Insertable(entity).IgnoreColumns(ignoreNullColumn:true).ExecuteCommand() > 0;
        }
        else
        {
            // 更新情况：删除后重新插入，保持原有DepotId
            var originalId = entity.DepotId;
            
            // 先删除原记录（如果存在）
            db.Deleteable<MesDepots>().Where(s => s.DepotId == originalId).ExecuteCommand();
            
            // 重新插入，保持原有DepotId
            entity.DepotId = originalId;
            return db.Insertable(entity).IgnoreColumns(ignoreNullColumn:true).ExecuteCommand() > 0;
        }
    }

    // 将 ErpDepots 对象转换为 MesDepots 对象的方法
@@ -93,9 +125,6 @@
        {
            DepotCode = depots.FNumber,
            DepotName = depots.FName,
            // DepotId = string.IsNullOrEmpty(depots.Id)
            //     ? DateTimeOffset.UtcNow.ToUnixTimeSeconds()
            //     : Convert.ToInt32(depots.Id),
            IsFkc = depots.FAllowMinusQty,
            CreateBy = depots.FPrincipal,
            Depottype = depots.FStockProperty,
@@ -115,13 +144,20 @@
            Factory = "1000"
        };

        var mesDepots = Db.Queryable<MesDepots>()
        // 查找是否已存在相同仓库编码的记录
        var existingDepot = Db.Queryable<MesDepots>()
            .Where(s => s.DepotCode == entity.DepotCode)
            .First();

        if (mesDepots != null)
        if (existingDepot != null)
        {
            entity.DepotId = mesDepots.DepotId;
            // 如果存在，使用现有的DepotId，后续将删除后重新插入
            entity.DepotId = existingDepot.DepotId;
        }
        else
        {
            // 如果不存在，设为0，InsertOrUpdate方法将生成新DepotId
            entity.DepotId = 0;
        }

        return entity;

 MES.Service/service/BasicData/MesItemTypeManager.cs

@@ -31,24 +31,53 @@
        }
    }

    /// <summary>
    /// 生成新的ID，确保不重复
    /// </summary>
    private decimal GenerateNewId()
    {
        // 处理空表的情况，从1开始
        var maxId = Db.Queryable<MesItemType>().Max(x => (decimal?)x.Id) ?? 0;
        var newId = maxId + 1;
        
        // 双重检查，确保生成的ID不存在
        while (Db.Queryable<MesItemType>().Where(x => x.Id == newId).Any())
        {
            newId++;
        }
        
        return newId;
    }

    private bool InsertItemType(MesItemType entity)
    {
        // 先根据ID删除现有记录
        try
        if (entity.Id == 0)
        {
            Db.Deleteable<MesItemType>()
                .Where(it => it.Id == entity.Id).ExecuteCommand();
            // 新增情况：生成新ID并插入
            var newId = GenerateNewId();
            entity.Id = newId;
            return base.Insert(entity);
        }
        catch (Exception)
        else
        {
            // 删除失败可能是因为记录不存在，继续执行插入操作
            // 更新情况：删除后重新插入，保持原有ID
            var originalId = entity.Id;
            
            // 先删除原记录（如果存在）
            try
            {
                Db.Deleteable<MesItemType>()
                    .Where(it => it.Id == originalId).ExecuteCommand();
            }
            catch (Exception)
            {
                // 删除失败可能是因为记录不存在，继续执行插入操作
            }
            
            // 重新插入，保持原有ID
            entity.Id = originalId;
            return base.Insert(entity);
        }

        var insert = base.Insert(entity);
        if (insert)
            return true;

        throw new NotImplementedException("插入失败");
    }

    private bool DeleteItemType(decimal? id)
@@ -65,9 +94,6 @@
    {
        var entity = new MesItemType
        {
            // Id = string.IsNullOrEmpty(department.Id)
            //     ? DateTimeOffset.UtcNow.ToUnixTimeSeconds()
            //     : long.Parse(department.Id),
            Pgroup = department.FParentId,
            Tcode = department.FNumber,
            Tname = department.FName,
@@ -78,13 +104,20 @@
            Factory = "1000"
        };

        var mesItemType = Db.Queryable<MesItemType>()
        // 查找是否已存在相同类型编码的记录
        var existingItemType = Db.Queryable<MesItemType>()
            .Where(it => it.Tcode == entity.Tcode)
            .First();

        if (mesItemType != null)
        if (existingItemType != null)
        {
            entity.Id = mesItemType.Id;
            // 如果存在，使用现有的ID，后续将删除后重新插入
            entity.Id = existingItemType.Id;
        }
        else
        {
            // 如果不存在，设为0，InsertOrUpdate方法将生成新ID
            entity.Id = 0;
        }

        return entity;

 MES.Service/service/BasicData/MesItemsManager.cs

@@ -49,7 +49,7 @@
            Console.WriteLine("警告: 传入的物料列表为空");
            return false;
        }
        

        // 逐条处理，全部成功才返回true（事务内批量处理更优，此处保持原有逻辑）
        var result = items.Select(Save).ToList();
        return result.All(b => b);
@@ -89,37 +89,18 @@

    private MesItems GetMesItems(ErpItems item)
    {
        // var id = string.IsNullOrEmpty(item.Id)
        //     ? DateTimeOffset.UtcNow.ToUnixTimeSeconds()
        //     : long.Parse(item.Id);
        var entity = new MesItems
        {
            // Id = id,
            Guid = Guid.NewGuid(),
            Type = item.Type,
            ItemNo = item.FNumber,
            ItemName = item.FName,
            ItemModel = item.FSpecification,
            ItemUnit = item.FBaseUnitId,
            // Lowlimit = !string.IsNullOrEmpty(item.FSafeStock)
            //     ? Convert.ToDecimal(item.FSafeStock)
            //     : null,
            // Highlimit = !string.IsNullOrEmpty(item.FMaxStock)
            //     ? Convert.ToDecimal(item.FMaxStock)
            //     : null,
            // PrdPack = !string.IsNullOrEmpty(item.FMinPackCount)
            //     ? Convert.ToDecimal(item.FMinPackCount)
            //     : null,
            DepotCode = item.FStockId,
            Fmaterialgroup = item.FMaterialGroup,
            Remarks = item.FDescription,
            // Ffinishreceiptoverrate =
            //     !string.IsNullOrEmpty(item.FFinishReceiptOverRate)
            //         ? Convert.ToInt32(item.FFinishReceiptOverRate)
            //         : null,
            Fissuetype = item.FIssueType,
            // Fisbatchmanage = !string.IsNullOrEmpty(item.FIsBatchManage)
            //     ? Convert.ToInt32(item.FIsBatchManage)
            //     : null,
            Fpurchaserid = item.FPurchaserId,
            Fpurchaseunitid = item.FPurchaseUnitId,
            Storeunit = item.FStoreUnitID,
@@ -129,33 +110,54 @@
            ProductionWorkshop = item.FWorkShopId,
            ProduceUnit = item.FPRODUCEUNITID,
            SubconUnit = item.FSUBCONUNITID,
            FSubsidiary = string.IsNullOrEmpty(item.FUseOrgId)
                ? "1"
                : item.FUseOrgId,
            Fumbrella = string.IsNullOrEmpty(item.FCreateOrgId)
                ? "1"
                : item.FCreateOrgId,
            FSubsidiary = string.IsNullOrEmpty(item.FUseOrgId) ? "1" : item.FUseOrgId,
            Fumbrella = string.IsNullOrEmpty(item.FCreateOrgId) ? "1" : item.FCreateOrgId,
            LossPercent = item.FLOSSPERCENT,
            MnemonicCode = item.FMnemonicCode,
            ExpPeriod = item.FExpPeriod,
            // EItemId = id,
            // ItemId = id,
            LastupdateDate = DateTime.Now,
            CreateDate = DateTime.Now,
            Company = "1000",
            Factory = "1000"
        };

        var mesItems = Db.Queryable<MesItems>()
        // 查找是否已存在相同物料编码的记录
        var existingItem = Db.Queryable<MesItems>()
            .Where(s => s.ItemNo == entity.ItemNo)
            .First();

        if (mesItems != null)
        if (existingItem != null)
        {
            entity.Id = mesItems.Id;
            // 如果存在，使用现有的ID，后续将删除后重新插入
            entity.Id = existingItem.Id;
            entity.ItemId = existingItem.Id;
        }
        else
        {
            // 如果不存在，设为0，InsertOrUpdate方法将生成新ID
            entity.Id = 0;
            entity.ItemId = 0;
        }

        return entity;
    }

    /// <summary>
    /// 生成新的ID，确保不重复
    /// </summary>
    private decimal GenerateNewId()
    {
        // 处理空表的情况，从1开始
        var maxId = Db.Queryable<MesItems>().Max(x => (decimal?)x.Id) ?? 0;
        var newId = maxId + 1;
        
        // 双重检查，确保生成的ID不存在
        while (Db.Queryable<MesItems>().Where(x => x.Id == newId).Any())
        {
            newId++;
        }
        
        return newId;
    }

    private bool UpdateItemStatusBatch(SqlSugarScope db,
@@ -194,11 +196,30 @@

    private bool InsertOrUpdate(SqlSugarScope db, MesItems entity)
    {
        db.Deleteable<MesItems>().Where(s => s.Id == entity.Id)
            .ExecuteCommand();

        var insert = db.Insertable(entity).ExecuteCommand();
        return insert > 0;
        // 确保ItemId与Id保持一致
        entity.ItemId = entity.Id;
        
        if (entity.Id == 0)
        {
            // 新增情况：生成新ID并插入
            var newId = GenerateNewId();
            entity.Id = newId;
            entity.ItemId = newId;
            return db.Insertable(entity).IgnoreColumns(ignoreNullColumn:true).ExecuteCommand() > 0;
        }
        else
        {
            // 更新情况：删除后重新插入，保持原有ID
            var originalId = entity.Id;
            
            // 先删除原记录（如果存在）
            db.Deleteable<MesItems>().Where(s => s.Id == originalId).ExecuteCommand();
            
            // 重新插入，保持原有ID
            entity.Id = originalId;
            entity.ItemId = originalId;
            return db.Insertable(entity).IgnoreColumns(ignoreNullColumn:true).ExecuteCommand() > 0;
        }
    }

    private bool InsertOrUpdateBatch(SqlSugarScope db, List<MesItems> itemList)

 MES.Service/service/BasicData/MesStaffManager.cs

@@ -1,334 +1,4 @@
/*
namespace MES.Service.service.BasicData;

using MES.Service.DB;
using MES.Service.Dto.webApi;
using MES.Service.Modes;
using SqlSugar;

public class MesStaffManager : Repository<MesStaff>
{
    // Save 方法用于保存单个员工记录，根据类型执行不同的操作
    public bool Save(ErpStaff unit)
    {
        var entity = GetMesStaff(unit); // 将 ErpStaff 转换为 MesStaff
        var sysUser = GetUser(unit); // 获取 SysUser 实例
        var mesStaffPositionLink =  GetMesStaffPositionLink(unit); // 获取 MesStaffPositionLink 实例
        return UseTransaction(db =>
        {
            switch (unit.Type)
            {
                case "0":
                    if (UpdateStaffStatus(db, entity.Id, "A")) // 启用员工
                        return 1;
                    break;
                case "1":
                    if (UpdateStaffStatus(db, entity.Id, "B")) // 禁用员工
                        return 1;
                    break;
                case "2":
                case "4":
                    if (InsertOrUpdateStaff(db, sysUser, entity,mesStaffPositionLink)) // 插入或更新员工
                        return 1;
                    break;
                case "3":
                    if (DeleteStaff(db, sysUser, entity)) // 删除员工
                        return 1;
                    break;
                default:
                    throw new ArgumentNullException(
                        $"type没有{unit.Type}这个类型的参数");
            }

            throw new NotImplementedException("操作失败");
        }) > 0;
    }

    // 更新员工状态的方法
    private bool UpdateStaffStatus(SqlSugarScope db, decimal staffId,
        string status)
    {
        var result = db.Updateable<MesStaff>()
            .SetColumns(s => s.FforbidStatus == status)
            .Where(s => s.Id == staffId).ExecuteCommand();

        if (result > 0)
            return true;

        throw new NotImplementedException(status == "A" ? "启用失败" : "禁用失败");
    }

    // 插入或更新员工的方法
    private bool InsertOrUpdateStaff(SqlSugarScope db, SysUser sysUser,
        MesStaff entity, List<MesStaffPositionLink> mesStaffPositionLink)
    {
        var exists = db.Queryable<SysUser>().Any(u => u.Sid == sysUser.Sid);
        if (!exists)
        {
            var insertUser = db.Insertable(sysUser).ExecuteCommand();
        }
        db.Deleteable<MesStaff>()
            .Where(s => s.Id == entity.Id)
            .ExecuteCommand();

        var insertStaff =
            db.Insertable(entity).IgnoreColumns(true).ExecuteCommand();

        var insertPosition = 1;
        if (mesStaffPositionLink != null && mesStaffPositionLink.Count > 0)
        {
            //先删除，再新增
            db.Deleteable<MesStaffPositionLink>()
                .Where(s =>
                    mesStaffPositionLink.Any(m => m.StaffId == s.StaffId))
                .ExecuteCommand();

            //批量插入时，忽略空字段
            insertPosition = db.Insertable(mesStaffPositionLink).PageSize(1)
                .IgnoreColumnsNull().ExecuteCommand();
        }


        return insertStaff > 0 && insertPosition > 0;
    }

    // 删除员工的方法


    private bool DeleteStaff(SqlSugarScope db, SysUser sysUser, MesStaff entity)
    {
        var deleteUser = db.Deleteable<SysUser>()
            .Where(s => s.Sid == sysUser.Sid).ExecuteCommand();
        if (deleteUser > 0)
        {
            var deleteStaff =
                db.Deleteable<MesStaff>()
                    .Where(s =>
                        s.Id == entity.Id &&
                        s.PositionCode == entity.PositionCode)
                    .ExecuteCommand();

            //删除对应员工岗位信息关联表 池南骏 2025-01-02
            var insertPosition = db.Deleteable<MesStaffPositionLink>()
                .Where(s => s.StaffId == entity.Id)
                .ExecuteCommand();

            if (deleteStaff > 0)
                return true;
        }

        throw new NotImplementedException("反审核失败");
    }
    // 将 ErpStaff 对象转换为 MesStaff 对象的方法
    private MesStaff GetMesStaff(ErpStaff staff)
    {
        var entity = new MesStaff
        {
            Id = Convert.ToDecimal(staff.Id),
            StaffNo = staff.FStaffNumber,
            StaffName = staff.FName,
            DepartmentName = staff.FPostDept,
            PositionCode = staff.FPostId,
            PhoneNumber = staff.FMobile,
            Remark = staff.FDescription,
            FforbidStatus = staff.FForbidStatus,
            FSubsidiary = staff.FUseOrgId,
            Fumbrella = staff.FCreateOrgId,
            CreateDate = DateTime.Now,
            LastupdateDate = DateTime.Now,
            Type = staff.Type
        };

        if (staff.FStaffStartDate != null)
            entity.StartDate = DateTime.ParseExact(staff.FStaffStartDate,
                "yyyy-MM-dd HH:mm:ss", null);

        return entity;
    }

    // 将 ErpStaff 对象转换为 SysUser 对象的方法
    private SysUser GetUser(ErpStaff staff)
    {
        return new SysUser
        {
            IsStatus = true,
            Account = staff.FStaffNumber,
            UserName = staff.FName,
            Password = "E1ADC3949BA59ABBE56E057F2F883E", // 初始密码
            DepartNo = staff.FPostDept,
            Type = staff.Type,
            CreateTime = DateTime.Now
        };
    }

    /// <summary>
    ///     接口字段调整：根据json格式，在MesStaffPositionLink<List>中存入数据。
    /// </summary>
    /// <remarks>
    ///     修改人：池南骏
    ///     修改日期：2025-01-02 ——》 2025-01-05 二次修改
    ///     修改说明：
    ///     - 新增代码
    /// </remarks>
    private List<MesStaffPositionLink> GetMesStaffPositionLink(ErpStaff staff)
    {
        // 初始化返回的职位关联列表
        List<MesStaffPositionLink> staffDetails = new List<MesStaffPositionLink>();

        // 检查ErpStaff是否包含职位详情数据
        if (staff.ErpStaffDetails != null && staff.ErpStaffDetails.Count > 0)
        {
            // 使用LINQ将ErpStaffDetails转换为MesStaffPositionLink对象
            staffDetails = staff.ErpStaffDetails.Select(staffDetail =>
                new MesStaffPositionLink
                {
                    // 员工ID：从ErpStaff的Id属性转换为decimal类型
                    StaffId = Convert.ToDecimal(staff.Id),

                    // 职位ID：
                    // 1. 检查fPostId是否为空或null
                    // 2. 非空时转换为decimal，否则设为null
                    PositionId = string.IsNullOrEmpty(staffDetail.fPostId.ToString())
                        ? null
                        : Convert.ToDecimal(staffDetail.fPostId),

                    // 职位部门ID：逻辑与职位ID类似
                    FPostDeptId = string.IsNullOrEmpty(staffDetail.fPostDeptid.ToString())
                        ? null
                        : Convert.ToDecimal(staffDetail.fPostDeptid),

                    // 员工入职日期：
                    // 1. 检查fStaffStartDate是否为空或null
                    // 2. 非空时按"yyyy-MM-dd HH:mm:ss"格式解析为DateTime，否则设为null
                    FStaffStartDate = string.IsNullOrEmpty(staffDetail.fStaffStartDate.ToString())
                        ? null
                        : DateTime.ParseExact(staffDetail.fStaffStartDate, "yyyy-MM-dd HH:mm:ss", null)
                }).ToList();
        }
        // 返回转换后的职位关联列表
        return staffDetails;
    }
    // SaveList 方法用于保存多个员工记录，根据类型批量执行不同的操作
    public bool SaveList(List<ErpStaff> departments)
    {
        var list = new List<MesStaff>();
        var userList = new List<SysUser>();
        var mesStaffPositionLinkList = new List<MesStaffPositionLink>();
        departments.ForEach(s =>
        {
            var entity = GetMesStaff(s);
            entity.Type = s.Type;
            list.Add(entity);

            var sysUser = GetUser(s);
            sysUser.Type = s.Type;
            userList.Add(sysUser);
            var mesStaffPositionLink =
                GetMesStaffPositionLink(s); // 获取 SysUser 实例
            mesStaffPositionLinkList.AddRange(mesStaffPositionLink);
        });

        var groupBy = list.GroupBy(s => s.Type)
            .ToDictionary(g => g.Key, g => g.ToList());
        return UseTransaction(db =>
        {
            foreach (var staffGroup in groupBy)
                switch (staffGroup.Key)
                {
                    case "0":
                        if (!UpdateStaffStatusBatch(db, staffGroup.Value,
                                "A")) // 批量启用员工
                            throw new NotImplementedException("启用失败");
                        break;
                    case "1":
                        if (!UpdateStaffStatusBatch(db, staffGroup.Value,
                                "B")) // 批量禁用员工
                            throw new NotImplementedException("禁用失败");
                        break;
                    case "3":
                        if (!DeleteStaffBatch(db, userList,
                                staffGroup.Value)) // 批量删除员工
                            throw new NotImplementedException("删除失败");
                        break;
                    case "2":
                    case "4":
                        if (!InsertOrUpdateBatch(db, userList,
                                staffGroup.Value,mesStaffPositionLinkList)) // 批量插入或更新员工
                            throw new NotImplementedException("同步失败");
                        break;
                    default:
                        throw new ArgumentNullException(
                            $"type没有{staffGroup.Key}这个类型的参数");
                }

            return 1;
        }) > 0;
    }

    // 批量更新员工状态的方法
    private bool UpdateStaffStatusBatch(SqlSugarScope db,
        List<MesStaff> staffList, string status)
    {
        var ids = staffList.Select(it => it.Id).ToArray();
        var result = db.Updateable<MesStaff>()
            .SetColumns(s => s.FforbidStatus == status)
            .Where(s => ids.Contains(s.Id)).ExecuteCommand();

        if (result > 0)
            return true;

        throw new NotImplementedException(status == "A" ? "启用失败" : "禁用失败");
    }

    // 批量插入员工的方法
    private bool InsertStaffBatch(SqlSugarScope db, List<SysUser> userList,
        List<MesStaff> staffList)
    {
        var userInsert = userList.FindAll(s => s.Type == "2");
        var executeCommand = db.Insertable(userInsert).ExecuteCommand();
        if (executeCommand <= 0) throw new ArgumentNullException("审核失败");
        if (db.Insertable(staffList).ExecuteCommand() > 0)
            return true;

        throw new ArgumentNullException("审核失败");
    }

    // 批量删除员工的方法
    private bool DeleteStaffBatch(SqlSugarScope db, List<SysUser> userList,
        List<MesStaff> staffList)
    {
        var sid = userList.FindAll(s => s.Type == "3").Select(s => s.Account)
            .ToArray();
        var result = db.Deleteable<SysUser>()
            .Where(s => sid.Contains(s.Account)).ExecuteCommand();

        if (result <= 0) throw new ArgumentNullException("反审核失败");
        var ids = staffList.Select(it => it.Id).ToArray();
        if (db.Deleteable<MesStaff>()
                .Where(s => ids.Contains(s.Id)).ExecuteCommand() > 0)
            return true;

        throw new ArgumentNullException("反审核失败");
    }

    // 批量插入或更新员工的方法
    private bool InsertOrUpdateBatch(SqlSugarScope db, List<SysUser> userList,
        List<MesStaff> staffList,
        List<MesStaffPositionLink> mesStaffPositionLink)
    {
        foreach (var sysUser in userList)
        {
            var entity = staffList.First(s => s.Id == sysUser.Sid);
            if (!InsertOrUpdateStaff(db, sysUser, entity, mesStaffPositionLink))
                return false;
        }

        return true;
    }
}
 */

namespace MES.Service.service.BasicData;
namespace MES.Service.service.BasicData;

using MES.Service.DB;
using MES.Service.Dto.webApi;
@@ -374,24 +44,62 @@
        }) > 0;
    }

    /// <summary>
    /// 生成新的ID，确保不重复
    /// </summary>
    private decimal GenerateNewId()
    {
        // 处理空表的情况，从1开始
        var maxId = Db.Queryable<MesStaff>().Max(x => (decimal?)x.Id) ?? 0;
        var newId = maxId + 1;
        
        // 双重检查，确保生成的ID不存在
        while (Db.Queryable<MesStaff>().Where(x => x.Id == newId).Any())
        {
            newId++;
        }
        
        return newId;
    }

    private bool InsertUser(SqlSugarScope db, MesStaff entity)
    {
        db.Deleteable<MesStaff>()
            .Where(s => s.Id == entity.Id)
            .ExecuteCommand();

        db.Deleteable<SysUser>()
            .Where(s => s.StaffId == entity.Id.ToString())
            .ExecuteCommand();

        var sysUser = GetUser(entity);
        if (entity.Id == null)
        if (entity.Id == 0)
        {
            var id = db.Insertable<MesStaff>(entity).ExecuteReturnIdentity();
            sysUser.StaffId = id.ToString();
            // 新增情况：生成新ID并插入
            var newId = GenerateNewId();
            entity.Id = newId;
            
            var sysUser = GetUser(entity);
            var staffInsertId = db.Insertable(entity).ExecuteReturnIdentity();
            
            if (staffInsertId > 0)
            {
                sysUser.StaffId = staffInsertId.ToString();
                return db.Insertable(sysUser).ExecuteCommand() > 0;
            }
            return false;
        }

        return db.Insertable(sysUser).ExecuteCommand() > 0;
        else
        {
            // 更新情况：删除后重新插入，保持原有ID
            var originalId = entity.Id;
            
            // 先删除原记录（如果存在）
            db.Deleteable<MesStaff>().Where(s => s.Id == originalId).ExecuteCommand();
            db.Deleteable<SysUser>().Where(s => s.StaffId == originalId.ToString()).ExecuteCommand();
            
            // 重新插入，保持原有ID
            entity.Id = originalId;
            var sysUser = GetUser(entity);
            
            var staffInsert = db.Insertable(entity).ExecuteCommand();
            if (staffInsert > 0)
            {
                return db.Insertable(sysUser).ExecuteCommand() > 0;
            }
            return false;
        }
    }

    private bool DeleteStaff(SqlSugarScope db, MesStaff entity)
@@ -611,9 +319,6 @@
        {
            var entity = new MesStaff
            {
                // Id = string.IsNullOrEmpty(staff.Id)
                //     ? DateTimeOffset.UtcNow.ToUnixTimeSeconds()
                //     : Convert.ToDecimal(staff.Id),
                Guid = Guid.NewGuid(),
                StaffNo = staff.FStaffNumber,
                StaffName = staff.FName,
@@ -639,13 +344,20 @@
                    "yyyy-MM-dd HH:mm:ss", null);
            }

            var mesStaff = Db.Queryable<MesStaff>()
            // 查找是否已存在相同员工编码的记录
            var existingStaff = Db.Queryable<MesStaff>()
                .Where(s => s.StaffNo == entity.StaffNo)
                .First();

            if (mesStaff != null)
            if (existingStaff != null)
            {
                entity.Id = mesStaff.Id;
                // 如果存在，使用现有的ID，后续将删除后重新插入
                entity.Id = existingStaff.Id;
            }
            else
            {
                // 如果不存在，设为0，InsertUser方法将生成新ID
                entity.Id = 0;
            }

            return entity;

 MES.Service/service/BasicData/MesSupplierManager.cs

@@ -90,9 +90,6 @@
    {
        var entity = new MesSupplier
        {
            // Id = string.IsNullOrEmpty(supplier.Id)
            //     ? DateTimeOffset.UtcNow.ToUnixTimeSeconds()
            //     : Convert.ToDecimal(supplier.Id),
            Type = supplier.Type,
            SuppNo = supplier.FNumber,
            SuppSname = supplier.FShortName,
@@ -114,13 +111,20 @@
            Factory = "1000",
        };

        var mesSupplier = Db.Queryable<MesSupplier>()
        // 查找是否已存在相同供应商编码的记录
        var existingSupplier = Db.Queryable<MesSupplier>()
            .Where(s => s.SuppNo == entity.SuppNo)
            .First();

        if (mesSupplier != null)
        if (existingSupplier != null)
        {
            entity.Id = mesSupplier.Id;
            // 如果存在，使用现有的ID，后续将删除后重新插入
            entity.Id = existingSupplier.Id;
        }
        else
        {
            // 如果不存在，设为0，InsertOrUpdate方法将生成新ID
            entity.Id = 0;
        }

        return entity;
@@ -162,16 +166,45 @@
        throw new NotImplementedException("删除失败");
    }

    /// <summary>
    /// 生成新的ID，确保不重复
    /// </summary>
    private decimal GenerateNewId()
    {
        // 处理空表的情况，从1开始
        var maxId = Db.Queryable<MesSupplier>().Max(x => (decimal?)x.Id) ?? 0;
        var newId = maxId + 1;
        
        // 双重检查，确保生成的ID不存在
        while (Db.Queryable<MesSupplier>().Where(x => x.Id == newId).Any())
        {
            newId++;
        }
        
        return newId;
    }

    private bool InsertOrUpdate(SqlSugarScope db, MesSupplier entity)
    {
        db.Deleteable<MesSupplier>().Where(s => s.Id == entity.Id)
            .ExecuteCommand();

        var insert = db.Insertable(entity).ExecuteCommand();
        if (insert > 0)
            return true;

        return false;
        if (entity.Id == 0)
        {
            // 新增情况：生成新ID并插入
            var newId = GenerateNewId();
            entity.Id = newId;
            return db.Insertable(entity).IgnoreColumns(ignoreNullColumn:true).ExecuteCommand() > 0;
        }
        else
        {
            // 更新情况：删除后重新插入，保持原有ID
            var originalId = entity.Id;
            
            // 先删除原记录（如果存在）
            db.Deleteable<MesSupplier>().Where(s => s.Id == originalId).ExecuteCommand();
            
            // 重新插入，保持原有ID
            entity.Id = originalId;
            return db.Insertable(entity).IgnoreColumns(ignoreNullColumn:true).ExecuteCommand() > 0;
        }
    }

    private bool InsertOrUpdateBatch(SqlSugarScope db,

 MES.Service/service/BasicData/MesUnitManager.cs

@@ -100,9 +100,6 @@

        var entity = new MesUnit
        {
            // Id = string.IsNullOrEmpty(unit.Id)
            //     ? DateTimeOffset.UtcNow.ToUnixTimeSeconds()
            //     : Convert.ToDecimal(unit.Id),
            Fnumber = unit.FNumber,
            Fname = unit.FName,
            Funitgroupid = unit.FUnitGroupId,
@@ -121,13 +118,20 @@
            Type = unit.Type
        };

        var mesUnit = Db.Queryable<MesUnit>()
        // 查找是否已存在相同单位编码的记录
        var existingUnit = Db.Queryable<MesUnit>()
            .Where(s => s.Fnumber == entity.Fnumber)
            .First();

        if (mesUnit != null)
        if (existingUnit != null)
        {
            entity.Id = mesUnit.Id;
            // 如果存在，使用现有的ID，后续将删除后重新插入
            entity.Id = existingUnit.Id;
        }
        else
        {
            // 如果不存在，设为0，InsertOrUpdate方法将生成新ID
            entity.Id = 0;
        }

        return entity;
@@ -164,12 +168,45 @@
        return deleteByIds > 0;
    }

    /// <summary>
    /// 生成新的ID，确保不重复
    /// </summary>
    private decimal GenerateNewId()
    {
        // 处理空表的情况，从1开始
        var maxId = Db.Queryable<MesUnit>().Max(x => (decimal?)x.Id) ?? 0;
        var newId = maxId + 1;
        
        // 双重检查，确保生成的ID不存在
        while (Db.Queryable<MesUnit>().Where(x => x.Id == newId).Any())
        {
            newId++;
        }
        
        return newId;
    }

    private bool InsertOrUpdate(SqlSugarScope db, MesUnit entity)
    {
        db.Deleteable<MesUnit>()
            .Where(s => s.Id == entity.Id).ExecuteCommand();
        var insert = db.Insertable(entity).ExecuteCommand();
        return insert > 0;
        if (entity.Id == 0)
        {
            // 新增情况：生成新ID并插入
            var newId = GenerateNewId();
            entity.Id = newId;
            return db.Insertable(entity).IgnoreColumns(ignoreNullColumn:true).ExecuteCommand() > 0;
        }
        else
        {
            // 更新情况：删除后重新插入，保持原有ID
            var originalId = entity.Id;
            
            // 先删除原记录（如果存在）
            db.Deleteable<MesUnit>().Where(s => s.Id == originalId).ExecuteCommand();
            
            // 重新插入，保持原有ID
            entity.Id = originalId;
            return db.Insertable(entity).IgnoreColumns(ignoreNullColumn:true).ExecuteCommand() > 0;
        }
    }

    private bool InsertOrUpdateBatch(SqlSugarScope db, List<MesUnit> unitList)

 MES.Service/service/BasicData/SysDepartmentManager.cs

@@ -80,24 +80,52 @@
        throw new NotImplementedException("删除失败");
    }

    /// <summary>
    /// 生成新的ID，确保不重复
    /// </summary>
    private decimal GenerateNewId()
    {
        // 处理空表的情况，从1开始
        var maxId = Db.Queryable<SysDepartment>().Max(x => (decimal?)x.Id) ?? 0;
        var newId = maxId + 1;
        
        // 双重检查，确保生成的ID不存在
        while (Db.Queryable<SysDepartment>().Where(x => x.Id == newId).Any())
        {
            newId++;
        }
        
        return newId;
    }

    // 插入或更新部门的方法
    private bool InsertOrUpdateDepartment(SqlSugarScope db,
        SysDepartment entity)
    {
        db.Deleteable<SysDepartment>()
            .Where(s => s.Id == entity.Id).ExecuteCommand();

        var insert = db.Insertable(entity).ExecuteCommand();
        return insert > 0;
        if (entity.Id == 0)
        {
            // 新增情况：生成新ID并插入
            var newId = GenerateNewId();
            entity.Id = newId;
            return db.Insertable(entity).IgnoreColumns(ignoreNullColumn:true).ExecuteCommand() > 0;
        }
        else
        {
            // 更新情况：删除后重新插入，保持原有ID
            var originalId = entity.Id;
            
            // 先删除原记录（如果存在）
            db.Deleteable<SysDepartment>().Where(s => s.Id == originalId).ExecuteCommand();
            
            // 重新插入，保持原有ID
            entity.Id = originalId;
            return db.Insertable(entity).IgnoreColumns(ignoreNullColumn:true).ExecuteCommand() > 0;
        }
    }

    // 将 ErpDepartment 对象转换为 SysDepartment 对象的方法
    private SysDepartment GetSysDepartment(ErpDepartment department)
    {
        // var unixTimeSeconds = string.IsNullOrEmpty(department.Id)
        //     ? DateTimeOffset.UtcNow.ToUnixTimeSeconds()
        //     : Convert.ToDecimal(department.Id);

        var fForbidStatus = department.FForbidStatus;
        if (department.FForbidStatus == "0")
        {
@@ -112,8 +140,6 @@
        {
            Departmentcode = department.FNumber,
            Departmentname = department.FName,
            // Departmentid = unixTimeSeconds,
            // Id = unixTimeSeconds,
            Depextr1 = department.FDeptProperty,
            Depextr2 = department.FGroup,
            Depextr3 = department.FWIPStockID,
@@ -131,13 +157,20 @@
            Factory = "1000"
        };

        var sysDepartment = Db.Queryable<SysDepartment>()
        // 查找是否已存在相同部门编码的记录
        var existingDepartment = Db.Queryable<SysDepartment>()
            .Where(s => s.Departmentcode == entity.Departmentcode)
            .First();

        if (sysDepartment != null)
        if (existingDepartment != null)
        {
            entity.Id = sysDepartment.Id;
            // 如果存在，使用现有的ID，后续将删除后重新插入
            entity.Id = existingDepartment.Id;
        }
        else
        {
            // 如果不存在，设为0，InsertOrUpdate方法将生成新ID
            entity.Id = 0;
        }

        return entity;