添加器具零件、器具库位

be/Modules/BaseData/src/Win_in.Sfs.Basedata.Application.Contracts/Equipments/DTOs/EquipmentLocDTO.cs

@@ -0,0 +1,31 @@
+using System.ComponentModel.DataAnnotations;
+using Win_in.Sfs.Shared.Domain;
+using Win_in.Sfs.Shared.Domain.Shared;
+
+namespace Win_in.Sfs.Basedata.Application.Contracts;
+
+using System;
+using System.Collections.Generic;
+
+[Display(Name = "器具库位关系")]
+
+public class EquipmentLocDTO : SfsBaseDataDTOBase, IHasCode
+{
+   
+    /// <summary>
+    /// 器具编号
+    /// </summary>
+    [Display(Name = "器具代码")]
+    [Required(ErrorMessage = "{0}是必填项")]
+    public string Code { get; set; }
+
+    /// <summary>
+    /// 库位编号
+    /// </summary>
+    [Display(Name = "库位代码")]
+    [Required(ErrorMessage = "{0}是必填项")]
+    public string LocCode { get; set; } 
+
+
+  
+}

be/Modules/BaseData/src/Win_in.Sfs.Basedata.Application.Contracts/Equipments/DTOs/EquipmentPartCodeDTO.cs

@@ -0,0 +1,73 @@
+using System.ComponentModel.DataAnnotations;
+using Win_in.Sfs.Shared.Domain;
+using Win_in.Sfs.Shared.Domain.Shared;
+
+namespace Win_in.Sfs.Basedata.Application.Contracts;
+
+using System;
+using System.Collections.Generic;
+
+[Display(Name = "器具基本信息")]
+
+public class EquipmentPartCodeDTO : SfsBaseDataDTOBase, IHasCode
+{
+  
+    /// <summary>
+    /// 器具代号
+    /// </summary>
+    [Display(Name = "器具代码")]
+    [Required(ErrorMessage = "{0}是必填项")]
+    public string Code { get; set; }
+
+
+    ///// <summary>
+    ///// 型号
+    ///// </summary>
+    //[Display(Name = "型号")]
+    //public string Model { get; set; } = string.Empty;
+    /// <summary>
+    /// 库位编号
+    /// </summary>
+    [Display(Name = "零件代码")]
+    [Required(ErrorMessage = "{0}是必填项")]
+    public string PartCode { get; set; } 
+
+
+
+    /// <summary>
+    ///  标包数量
+    /// </summary>
+    [Display(Name = "标包数")]
+    [Required(ErrorMessage = "{0}是必填项")]
+    public decimal StdQty { get; set; }
+
+
+
+    /// <summary>
+    /// 单位
+    /// </summary>
+    [Display(Name = "单位")]
+    public string Unit { get; set; }
+
+
+
+
+    /// <summary>
+    /// 状态
+    /// </summary>
+
+    //[Display(Name = "状态")]
+    //public int State { get; set; } = 0;
+
+    ///// <summary>
+    /////  创建人
+    ///// </summary>
+    //[Display(Name = "创建人")]
+    //public string Creator { get; set; }
+
+    ///// <summary>
+    /////  创建时间
+    ///// </summary>
+    //[Display(Name = "创建时间")]
+    //public DateTime CreatTime { get; set; } = DateTime.Now;
+}

be/Modules/BaseData/src/Win_in.Sfs.Basedata.Application.Contracts/Equipments/DTOs/EquipmentRecordErrorDTO.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Win_in.Sfs.Basedata.Equipments.DTOs;
+[Display(Name = "器具校验信息")]
+public class EquipmentRecordErrorDTO
+{
+    [Display(Name = "器具代码")]
+    public string EqptCode { set; get; }
+    [Display(Name = "零件代码")]
+    public string PartCode { set; get; }
+    [Display(Name = "错误信息")]
+    public string Error { set; get; }
+
+}

be/Modules/BaseData/src/Win_in.Sfs.Basedata.Application.Contracts/Equipments/IEquipmentLocAppService.cs

@@ -0,0 +1,33 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using Win_in.Sfs.Shared.Application.Contracts;
+using Win_in.Sfs.Shared.Domain.Shared;
+
+namespace Win_in.Sfs.Basedata.Application.Contracts;
+
+public interface IEquipmentLocAppService
+    : ISfsBaseDataAppServiceBase<EquipmentLocDTO, SfsBaseDataRequestInputBase, EquipmentLocEditInput>
+    , ISfsGetByCodeAppService<EquipmentLocDTO>
+    , ISfsCheckAppService<EquipmentLocCheckInput>
+    , ISfsUpsertAppService<EquipmentLocEditInput>
+{
+
+
+    Task<List<EquipmentLocDTO>> GetEquipmentLocAsync(List<string> p_ls);
+  
+
+    //Task<bool> CheckItemIsAvailable(string itemCode);
+    //[HttpGet("check-item-is-available-no-select-sql")]
+    //void CheckItemIsAvailable(EquipmentLocDTO EquipmentLocDTO);
+
+    //Task<List<EquipmentLocDTO>> GetListByNameAsync(string name);
+
+    //Task<EquipmentLocDTO> GetOrAddAsync(EquipmentLocEditInput input);
+
+    //Task<EnumItemManageType> GetManageTypeAsync(string itemCode);
+    //Task<Dictionary<string, EnumItemManageType>> GetManageTypesAsync(List<string> itemCodes);
+
+    //Task UpsertAsyncByInterface(EquipmentLocEditInput input);
+    //Task UpsertStdPackQtyAsync(string itemCode, decimal stdpackqty);
+}

be/Modules/BaseData/src/Win_in.Sfs.Basedata.Application.Contracts/Equipments/IEquipmentPartCodeAppService.cs

@@ -0,0 +1,31 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using Win_in.Sfs.Shared.Application.Contracts;
+using Win_in.Sfs.Shared.Domain.Shared;
+
+namespace Win_in.Sfs.Basedata.Application.Contracts;
+
+public interface IEquipmentPartCodeAppService
+    : ISfsBaseDataAppServiceBase<EquipmentPartCodeDTO, SfsBaseDataRequestInputBase, EquipmentPartCodeEditInput>
+    , ISfsGetByCodeAppService<EquipmentPartCodeDTO>
+
+    , ISfsUpsertAppService<EquipmentPartCodeEditInput>
+{
+
+
+    Task<List<EquipmentPartCodeDTO>> GetEquipmentPartCodesAsync(List<string> p_ls);
+    //Task<bool> CheckItemIsAvailable(string itemCode);
+    //[HttpGet("check-item-is-available-no-select-sql")]
+    //void CheckItemIsAvailable(EquipmentPartCodeDTO EquipmentPartCodeDTO);
+
+    //Task<List<EquipmentPartCodeDTO>> GetListByNameAsync(string name);
+
+    //Task<EquipmentPartCodeDTO> GetOrAddAsync(EquipmentPartCodeEditInput input);
+
+    //Task<EnumItemManageType> GetManageTypeAsync(string itemCode);
+    //Task<Dictionary<string, EnumItemManageType>> GetManageTypesAsync(List<string> itemCodes);
+
+    //Task UpsertAsyncByInterface(EquipmentPartCodeEditInput input);
+    //Task UpsertStdPackQtyAsync(string itemCode, decimal stdpackqty);
+}

be/Modules/BaseData/src/Win_in.Sfs.Basedata.Application.Contracts/Equipments/Inputs/EquipmentLocCheckInput .cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using Win_in.Sfs.Shared.Domain.Shared;
+
+namespace Win_in.Sfs.Basedata.Application.Contracts;
+
+public class EquipmentLocCheckInput
+{
+
+    /// <summary>
+    /// 器具编号
+    /// </summary>
+    [Display(Name = "器具代码")]
+    [Required(ErrorMessage = "{0}是必填项")]
+    public string Code { get; set; }
+
+    /// <summary>
+    /// 库位编号
+    /// </summary>
+    [Display(Name = "库位代码")]
+    [Required(ErrorMessage = "{0}是必填项")]
+    public string LocCode { get; set; }
+
+
+
+}

be/Modules/BaseData/src/Win_in.Sfs.Basedata.Application.Contracts/Equipments/Inputs/EquipmentLocEditInput.cs

@@ -0,0 +1,28 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+using Win_in.Sfs.Shared.Domain;
+using Win_in.Sfs.Shared.Domain.Shared;
+
+namespace Win_in.Sfs.Basedata.Application.Contracts;
+
+public class EquipmentLocEditInput : SfsBaseDataCreateOrUpdateInputBase
+{
+    /// <summary>
+    /// 器具编号
+    /// </summary>
+    [Display(Name = "器具代码")]
+    [Required(ErrorMessage = "{0}是必填项")]
+    public string Code { get; set; }
+
+    /// <summary>
+    /// 库位编号
+    /// </summary>
+    [Display(Name = "库位代码")]
+    [Required(ErrorMessage = "{0}是必填项")]
+    public string LocCode { get; set; }
+
+    [Display(Name = "状态")]
+    public int State { get; set; } = 0;
+
+
+}

be/Modules/BaseData/src/Win_in.Sfs.Basedata.Application.Contracts/Equipments/Inputs/EquipmentLocImportInput.cs

@@ -0,0 +1,33 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+using Win_in.Sfs.Shared.Application.Contracts;
+using Win_in.Sfs.Shared.Domain;
+using Win_in.Sfs.Shared.Domain.Shared;
+
+namespace Win_in.Sfs.Basedata.Application.Contracts;
+
+[Display(Name = "器具")]
+public class EquipmentLocImportInput : SfsBaseDataImportInputBase
+{
+    /// <summary>
+    /// 器具编号
+    /// </summary>
+    [Display(Name = "器具代码")]
+    [Required(ErrorMessage = "{0}是必填项")]
+    public string Code { get; set; }
+
+    /// <summary>
+    /// 库位编号
+    /// </summary>
+    [Display(Name = "库位代码")]
+    [Required(ErrorMessage = "{0}是必填项")]
+    public string LocCode { get; set; }
+
+
+    [Display(Name = "状态")]
+    public int State { get; set; } = 0;
+
+
+
+
+}

be/Modules/BaseData/src/Win_in.Sfs.Basedata.Application.Contracts/Equipments/Inputs/EquipmentPartCodeCheckInput.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using Win_in.Sfs.Shared.Domain.Shared;
+
+namespace Win_in.Sfs.Basedata.Application.Contracts;
+
+public class EquipmentPartCodeCheckInput
+{
+
+    /// <summary>
+    /// 器具代号
+    /// </summary>
+    [Display(Name = "器具代码")]
+    [Required(ErrorMessage = "{0}是必填项")]
+    public string Code { get; set; }
+
+
+
+
+    ///// <summary>
+    ///// 型号
+    ///// </summary>
+    //[Display(Name = "型号")]
+    //public string Model { get; set; } = string.Empty;
+    /// <summary>
+    /// 库位编号
+    /// </summary>
+    [Display(Name = "零件代码")]
+    [Required(ErrorMessage = "{0}是必填项")]
+    public string PartCode { get; set; }
+
+
+
+    /// <summary>
+    ///  标包数量
+    /// </summary>
+    [Display(Name = "标包数")]
+    [Required(ErrorMessage = "{0}是必填项")]
+    public decimal StdQty { get; set; }
+
+
+}

be/Modules/BaseData/src/Win_in.Sfs.Basedata.Application.Contracts/Equipments/Inputs/EquipmentPartCodeEditInput.cs

@@ -0,0 +1,53 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+using Win_in.Sfs.Shared.Domain;
+using Win_in.Sfs.Shared.Domain.Shared;
+
+namespace Win_in.Sfs.Basedata.Application.Contracts;
+
+public class EquipmentPartCodeEditInput : SfsBaseDataCreateOrUpdateInputBase
+{
+    /// <summary>
+    /// 器具代号
+    /// </summary>
+    [Display(Name = "器具代码")]
+    [Required(ErrorMessage = "{0}是必填项")]
+    public string Code { get; set; }
+
+
+
+
+    ///// <summary>
+    ///// 型号
+    ///// </summary>
+    //[Display(Name = "型号")]
+    //public string Model { get; set; } = string.Empty;
+    /// <summary>
+    /// 库位编号
+    /// </summary>
+    [Display(Name = "零件代码")]
+    [Required(ErrorMessage = "{0}是必填项")]
+    public string PartCode { get; set; }
+
+
+
+    /// <summary>
+    ///  标包数量
+    /// </summary>
+    [Display(Name = "标包数")]
+    [Required(ErrorMessage = "{0}是必填项")]
+    public decimal StdQty { get; set; }
+
+
+
+    /// <summary>
+    ///  标包数量
+    /// </summary>
+    [Display(Name = "单位")]
+    [Required(ErrorMessage = "{0}是必填项")]
+    public string Unit { get; set; }
+
+    [Display(Name = "状态")]
+    public int State { get; set; } = 0;
+
+}

be/Modules/BaseData/src/Win_in.Sfs.Basedata.Application.Contracts/Equipments/Inputs/EquipmentPartCodeImportInput.cs

@@ -0,0 +1,60 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+using Win_in.Sfs.Shared.Application.Contracts;
+using Win_in.Sfs.Shared.Domain;
+using Win_in.Sfs.Shared.Domain.Shared;
+
+namespace Win_in.Sfs.Basedata.Application.Contracts;
+
+[Display(Name = "器具")]
+public class EquipmentPartCodeImportInput : SfsBaseDataImportInputBase
+{
+    /// <summary>
+    /// 器具代号
+    /// </summary>
+    [Display(Name = "器具代码")]
+    [Required(ErrorMessage = "{0}是必填项")]
+    public string Code { get; set; }
+
+
+
+
+    ///// <summary>
+    ///// 型号
+    ///// </summary>
+    //[Display(Name = "型号")]
+    //public string Model { get; set; } = string.Empty;
+    /// <summary>
+    /// 库位编号
+    /// </summary>
+    [Display(Name = "零件代码")]
+    [Required(ErrorMessage = "{0}是必填项")]
+    public string PartCode { get; set; }
+
+
+
+    /// <summary>
+    ///  标包数量
+    /// </summary>
+    [Display(Name = "标包数")]
+    [Required(ErrorMessage = "{0}是必填项")]
+    public decimal StdQty { get; set; }
+
+
+    /// <summary>
+    ///  标包数量
+    /// </summary>
+    [Display(Name = "单位")]
+    [Required(ErrorMessage = "{0}是必填项")]
+    public string Unit { get; set; }
+
+
+    [Display(Name = "状态")]
+    public int State { get; set; } = 0;
+
+
+
+
+
+
+}

be/Modules/BaseData/src/Win_in.Sfs.Basedata.Application/BasedataApplicationAutoMapperProfile.cs

@@ -52,6 +52,8 @@ public partial class BasedataApplicationAutoMapperProfile : Profile
         EquipmentAutoMapperProfile();
         SplitPackingRecAutoMapperProfile();
         KittingAutoMapperProfile();
+        EquipmentLocAutoMapperProfile();
+        EquipmentPartCodeAutoMapperProfile();
         
     }
 }

be/Modules/BaseData/src/Win_in.Sfs.Basedata.Application/Equipments/EquipmentAppService.cs

@@ -292,7 +292,7 @@ public class EquipmentAppService
         {
             var entity = ObjectMapper.Map<EquipmentEditInput, Equipment>(input);
             entity.Code = string.Format("{0}{1}", "Q", entity.Code);
-            entity.Model = "Q";
+     
 
             await _repository.UpsertAsync(entity).ConfigureAwait(false);
             var entity1=_repository.WithDetails().FirstOrDefault(p => p.Code == input.Code);

be/Modules/BaseData/src/Win_in.Sfs.Basedata.Application/Equipments/EquipmentAreaAutoMapperProfile.cs

@@ -18,9 +18,8 @@ public partial class BasedataApplicationAutoMapperProfile : Profile
             .Ignore(x => x.TenantId)
             .Ignore(x => x.Remark)
             .Ignore(x => x.ExtraProperties)
-            .Ignore(x => x.ConcurrencyStamp)
-         
-            ;
+            .Ignore(x => x.ConcurrencyStamp);
+
 
         //CreateMap<Equipment, EquipmentImportInput>()
          

be/Modules/BaseData/src/Win_in.Sfs.Basedata.Application/Equipments/EquipmentAutoMapperProfile.cs

@@ -19,9 +19,7 @@ public partial class BasedataApplicationAutoMapperProfile : Profile
             .Ignore(x => x.Remark)
             .Ignore(x => x.ExtraProperties)
             .Ignore(x => x.ConcurrencyStamp)
-            .ForMember(p =>p.Code, p => p.MapFrom(q =>"Q" +q.Code))
-
-            ;
+            .ForMember(p => p.Code, p => p.MapFrom(q => "Q" + q.Code));
 
         //CreateMap<Equipment, EquipmentImportInput>()
          

be/Modules/BaseData/src/Win_in.Sfs.Basedata.Application/Equipments/EquipmentLocAppService.cs

@@ -0,0 +1,316 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.IO;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Volo.Abp;
+using Volo.Abp.Application.Dtos;
+using Volo.Abp.Caching;
+using Volo.Abp.Domain.Repositories;
+using Volo.Abp.Validation;
+using Win_in.Sfs.Basedata.Application.Contracts;
+using Win_in.Sfs.Basedata.Domain;
+using Win_in.Sfs.Basedata.Domain.Shared;
+using Win_in.Sfs.Shared.Application.Contracts;
+using Win_in.Sfs.Shared.Application.Contracts.ExportAndImport;
+using Win_in.Sfs.Shared.Domain;
+using Win_in.Sfs.Shared.Domain.Shared;
+
+namespace Win_in.Sfs.Basedata.Application;
+
+[Authorize]
+[Route($"{BasedataConsts.RootPath}EquipmentLoc")]
+public class EquipmentLocAppService
+    : SfsBaseDataWithCodeAppServiceBase<EquipmentLoc, EquipmentLocDTO, SfsBaseDataRequestInputBase, EquipmentLocEditInput, EquipmentLocImportInput>
+        , IEquipmentLocAppService
+{
+    //private readonly ItemValidator _itemValidator;
+    private readonly IEquipmentLocManager _manager;
+    private new readonly IEquipmentLocRepository _repository;
+    private readonly IExportImportService _importService;
+
+    public EquipmentLocAppService(
+        IEquipmentLocRepository repository,
+        IDistributedCache<EquipmentLocDTO> cache,
+        IExportImportService importService,
+       // ItemValidator itemValidator,
+        IEquipmentLocManager manager)
+        : base(repository, cache)
+    {
+        _importService=importService;
+        _repository = repository;
+        //_itemValidator = itemValidator;
+        _manager = manager;
+        base.CreatePolicyName = EquipmentPermissions.Create;
+        base.UpdatePolicyName = EquipmentPermissions.Update;
+        base.DeletePolicyName = EquipmentPermissions.Delete;
+    }
+   
+    [HttpPost("check")]
+    //[Authorize(ErpLocationPermissions.Default)]
+
+    public virtual async Task CheckAsync(string code, EquipmentLocCheckInput input)
+    {
+        await Task.CompletedTask.ConfigureAwait(false);
+    }
+    //public override async Task<IActionResult> ImportAsync([FromForm] SfsImportRequestInput requestInput, [Required] IFormFile file)
+    //{
+    //    List<EquipmentLocErrorDTO> errors = new List<EquipmentLocErrorDTO>();
+    //    using var ms = new MemoryStream();
+    //    await file.OpenReadStream().CopyToAsync(ms).ConfigureAwait(false);
+    //    var inputFileBytes = ms.GetAllBytes();
+    //    var dtos=_importService.Import<EquipmentLocEditInput>(inputFileBytes).ToList();
+    //    var list=ObjectMapper.Map<List<EquipmentLocEditInput>, List<EquipmentLoc>>(dtos);
+
+        
+
+
+
+    //    foreach (var itm in list)
+    //    {
+    //        itm.SetId(GuidGenerator.Create());
+    //        itm.Code = string.Format("{0}{1}", "Q", itm.Code);
+
+    //    }
+        
+
+
+
+    //    ////var bytes = result.FileContents;
+    //    ////result.FileContents = null;
+
+    //    ////HttpContextAccessor.HttpContext.Response.Headers.AccessControlExposeHeaders = "X-Response";
+    //    ////HttpContextAccessor.HttpContext.Response.Headers.Add("X-Response",
+    //    ////    JsonSerializer.Serialize(new { result.ExceptionMessage, result.FileName, result.FileCode, result }));
+
+    //    ////Console.WriteLine(@"导入错误信息：" + result.ExceptionMessage);
+
+    //    ////var resultAction = new TestResult(bytes, ExportImportService.ContentType) { FileDownloadName = result.FileName };
+    //    ////resultAction.errorNum = result.ErrorNum;
+    //    ////resultAction.successNum = resultAction.successNum;
+    //    //return resultAction;
+
+
+
+
+
+
+
+
+    //   // return base.ImportAsync(requestInput, file);
+    //}
+
+    //protected ICategoryAppService _categoryApp => LazyServiceProvider.LazyGetRequiredService<ICategoryAppService>();
+    //protected IItemCategoryAppService _itemCategoryApp => LazyServiceProvider.LazyGetRequiredService<IItemCategoryAppService>();
+
+    //[HttpPost("check")]
+    //public virtual async Task CheckAsync(string code, EquipmentLocCheckInput input)
+    //{
+    //    var result = new AbpValidationResult();
+    //    _itemValidator.CheckFormat(code);
+    //    var dto = await GetByCodeAsync(code).ConfigureAwait(false);
+    //    var entity = ObjectMapper.Map<EquipmentLocDTO, EquipmentLoc>(dto);
+    //    //_itemValidator.CheckCanBuy(entity, input.CanBuy, result);
+    //    //_itemValidator.CheckCanMake(entity, input.CanMake, result);
+    //    //_itemValidator.CheckStatus(entity, input.Statuses, result);
+    //    //_itemValidator.CheckProject(entity, input.Projects, result);
+    //    //await _itemValidator.CheckCategoryAsync(entity, input.Categories, result).ConfigureAwait(false);
+    //    if (result.Errors.Count > 0)
+    //    {
+    //        throw new AbpValidationException(result.Errors);
+    //    }
+    //}
+
+    ///// <summary>
+    ///// 检物品状态 是否可用
+    ///// </summary>
+    ///// <param name="itemCode"></param>
+    ///// <returns></returns>
+    ///// <exception cref="NotImplementedException"></exception>
+    //[HttpGet("check-item-is-available")]
+    //public virtual async Task<bool> CheckItemIsAvailable(string itemCode)
+    //{
+    //    var entity = await _repository.FindAsync(c => c.Code == itemCode).ConfigureAwait(false);
+
+    //    if (entity == null)
+    //    {
+    //        throw new UserFriendlyException($"未找到代码为 {itemCode} 的物品");
+    //    }
+
+    //    return entity.Status == EnumItemStatus.Active;
+    //}
+
+    /// <summary>
+    ///  检物品状态 是否可用(不查询数据库 直接根据对象判断)
+    /// </summary>
+    /// <param name="EquipmentLocDTO"></param>
+    /// <returns></returns>
+    //[HttpGet("check-item-is-available-no-select-sql")]
+    //public void CheckItemIsAvailable(EquipmentLocDTO EquipmentLocDTO)
+    //{
+    //    if (EquipmentLocDTO != null && EquipmentLocDTO.Status != EnumItemStatus.Active)
+    //    {
+    //        throw new UserFriendlyException($"物料 {EquipmentLocDTO.Code} 状态为 {EquipmentLocDTO.Status} ，不是可用状态");
+    //    }
+    //}
+
+    //[HttpGet("{id}")]
+    //public override async Task<EquipmentLocDTO> GetAsync(Guid id)
+    //{
+    //    var dto = await base.GetAsync(id).ConfigureAwait(false);
+
+    //    dto.ItemCategoryDictionary = await GetItemCategory(dto.Code).ConfigureAwait(false);
+
+    //    return dto;
+    //}
+
+    /// <summary>
+    ///
+    /// </summary>
+    /// <param name="name"></param>
+    /// <returns></returns>
+    /// <exception cref="NotImplementedException"></exception>
+    //[HttpGet("list-by-name")]
+    //public virtual async Task<List<EquipmentLocDTO>> GetListByNameAsync(string name)
+    //{
+    //    var entities = await _repository.GetListAsync(c => c.Name == name).ConfigureAwait(false);
+    //    var dtos = ObjectMapper.Map<List<EquipmentLoc>, List<EquipmentLocDTO>>(entities);
+    //    return dtos;
+    //}
+
+    //[HttpGet("get-manage-type")]
+    //public virtual async Task<EnumItemManageType> GetManageTypeAsync(string itemCode)
+    //{
+    //    var entity = await GetByCodeAsync(itemCode).ConfigureAwait(false);
+    //    Check.NotNull(entity, "物品代码", $"物品 {itemCode} 不存在");
+    //    return entity.ManageType;
+    //}
+
+    //[HttpGet("get-manage-types")]
+    //public virtual async Task<Dictionary<string, EnumItemManageType>> GetManageTypesAsync(List<string> itemCodes)
+    //{
+    //    var dtos = await GetByCodesAsync(itemCodes).ConfigureAwait(false);
+    //    var itemManageTypes = dtos.ToDictionary(dto => dto.Code, dto => dto.ManageType);
+    //    return itemManageTypes;
+    //}
+
+    //[HttpPost("get-or-add")]
+    //public virtual async Task<EquipmentLocDTO> GetOrAddAsync(EquipmentLocEditInput input)
+    //{
+    //    var result = await _repository.FirstOrDefaultAsync(p => p.Code == input.Code).ConfigureAwait(false);
+    //    if (result == null)
+    //    {
+    //        var entity = ObjectMapper.Map<EquipmentLocEditInput, EquipmentLoc>(input);
+    //        result = await _repository.InsertAsync(entity, true).ConfigureAwait(false);
+    //    }
+
+    //    var dto = ObjectMapper.Map<EquipmentLoc, EquipmentLocDTO>(result);
+    //    return dto;
+    //}
+
+    //[HttpPost("list")]
+    //public override async Task<PagedResultDto<EquipmentLocDTO>> GetPagedListByFilterAsync(
+    //    SfsBaseDataRequestInputBase sfsRequestInput,
+    //    bool includeDetails = false,
+    //    CancellationToken cancellationToken = default)
+    //{
+    //    Expression<Func<EquipmentLoc, bool>> expression = sfsRequestInput.Condition.Filters?.Count > 0
+    //                                                       ? sfsRequestInput.Condition.Filters.ToLambda<EquipmentLoc>()
+    //                                                       : p => true;
+    //    var pageResult = await GetPagedListAsync(
+    //        expression,
+    //        sfsRequestInput.SkipCount,
+    //        sfsRequestInput.MaxResultCount,
+    //        sfsRequestInput.Sorting,
+    //        includeDetails,
+    //        cancellationToken).ConfigureAwait(false);
+
+    //    foreach (var item in pageResult.Items)
+    //    {
+    //        item.ItemCategoryDictionary = await GetItemCategory(item.Code).ConfigureAwait(false);
+    //    }
+
+    //    return pageResult;
+    //}
+
+    //[HttpPost("upsert")]
+    //public virtual async Task UpsertAsync(EquipmentLocEditInput input)
+    //{
+    //    var entity = ObjectMapper.Map<EquipmentLocEditInput, EquipmentLoc>(input);
+    //    await _repository.UpsertAsync(entity).ConfigureAwait(false);
+    //}
+    //[HttpPost("upsert-interface")]
+    //public virtual async Task UpsertAsyncByInterface(EquipmentLocEditInput input)
+    //{
+    //    var entity = ObjectMapper.Map<EquipmentLocEditInput, EquipmentLoc>(input);
+    //    await _repository.UpsertAsyncByInterface(entity).ConfigureAwait(false);
+    //}
+
+    //protected override Expression<Func<EquipmentLoc, bool>> BuildSearchExpression(string keyWord)
+    //{
+    //    Expression<Func<EquipmentLoc, bool>> expression = p =>
+    //        p.Code.Contains(keyWord)
+    //        || p.Name.Contains(keyWord)
+    //        || p.Desc1.Contains(keyWord)
+    //        || p.Desc2.Contains(keyWord)
+    //        || p.AbcClass.Contains(keyWord)
+    //        || p.BasicUom.Contains(keyWord)
+    //        || p.Elevel.Contains(keyWord)
+    //        || p.Project.Contains(keyWord)
+    //        || p.Version.Contains(keyWord);
+    //    return expression;
+    //}
+
+    //private async Task<Dictionary<string, string>> GetItemCategory(string itemCode)
+    //{
+    //   // var itemCategorys = await this._itemCategoryApp.GetListByItemCode(itemCode).ConfigureAwait(false);
+
+    //   // return itemCategorys.ToDictionary(x => x.CategoryCode, y => y.Value);
+    //}
+
+    [HttpPost("upsert")]
+
+    public virtual async Task UpsertAsync(EquipmentLocEditInput input)
+    {
+        var entity = ObjectMapper.Map<EquipmentLocEditInput, EquipmentLoc>(input);
+
+        await _repository.UpsertAsync(entity).ConfigureAwait(false);
+    }
+
+    [HttpPost]
+    [Route("")]
+    public override async Task<EquipmentLocDTO> CreateAsync(EquipmentLocEditInput input)
+    {
+        var first= _repository.WithDetails().FirstOrDefault(p => p.Code == input.Code);
+        if (first == null)
+        {
+            var entity = ObjectMapper.Map<EquipmentLocEditInput, EquipmentLoc>(input);
+            //entity.Code = string.Format("{0}{1}",entity.Code);
+
+
+            await _repository.UpsertAsync(entity).ConfigureAwait(false);
+            var entity1=_repository.WithDetails().FirstOrDefault(p => p.Code == input.Code);
+            return ObjectMapper.Map<EquipmentLoc,EquipmentLocDTO>(entity1);
+        }
+        else
+        {
+            throw new UserFriendlyException($"已存在器具编号{input.Code}!");
+        }
+
+    }
+    [HttpPost]
+    [Route("GetEquipmentLocs")]
+    public async Task<List<EquipmentLocDTO>> GetEquipmentLocAsync(List<string> p_ls)
+    {
+       var query=await  _repository.GetQueryableAsync().ConfigureAwait(false);
+       var list =query.Where(p => p_ls.Contains(p.Code));
+       return  ObjectMapper.Map< List<EquipmentLoc> ,List<EquipmentLocDTO>>(list.ToList());
+
+    }
+}

be/Modules/BaseData/src/Win_in.Sfs.Basedata.Application/Equipments/EquipmentLocAutoMapperProfile.cs

@@ -0,0 +1,34 @@
+using AutoMapper;
+using Volo.Abp.AutoMapper;
+using Win_in.Sfs.Basedata.Application.Contracts;
+using Win_in.Sfs.Basedata.Domain;
+
+namespace Win_in.Sfs.Basedata.Application;
+
+public partial class BasedataApplicationAutoMapperProfile : Profile
+{
+    private void EquipmentLocAutoMapperProfile()
+    {
+        CreateMap<EquipmentLoc, EquipmentLocDTO>()
+          
+            .ReverseMap();
+
+        CreateMap<EquipmentLocImportInput, EquipmentLoc>()
+            .IgnoreAuditedObjectProperties()
+            .Ignore(x => x.TenantId)
+            .Ignore(x => x.Remark)
+            .Ignore(x => x.ExtraProperties)
+            .Ignore(x => x.ConcurrencyStamp)
+            .Ignore(x=>x.State)
+            .ForMember(p =>p.Code, p => p.MapFrom(q =>q.Code)) ;
+
+        //CreateMap<EquipmentLoc, EquipmentLocImportInput>()
+         
+        //CreateMap<EquipmentLoc, EquipmentLocForDongyangExportDTO>()
+        //    .Ignore(x => x.ItemCategory)
+        //    .Ignore(x => x.Color);
+        CreateMap<EquipmentLocEditInput, EquipmentLoc>()
+             .IgnoreAuditedObjectProperties()
+             .Ignore(x => x.ConcurrencyStamp).Ignore(x => x.Id);
+    }
+}

be/Modules/BaseData/src/Win_in.Sfs.Basedata.Application/Equipments/EquipmentPartCodeAppService.cs

@@ -0,0 +1,319 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.IO;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Volo.Abp;
+using Volo.Abp.Application.Dtos;
+using Volo.Abp.Caching;
+using Volo.Abp.Domain.Repositories;
+using Volo.Abp.ObjectMapping;
+using Volo.Abp.Validation;
+using Win_in.Sfs.Basedata.Application.Contracts;
+using Win_in.Sfs.Basedata.Domain;
+using Win_in.Sfs.Basedata.Domain.Shared;
+using Win_in.Sfs.Shared.Application.Contracts;
+using Win_in.Sfs.Shared.Application.Contracts.ExportAndImport;
+using Win_in.Sfs.Shared.Domain;
+using Win_in.Sfs.Shared.Domain.Shared;
+
+namespace Win_in.Sfs.Basedata.Application;
+
+[Authorize]
+[Route($"{BasedataConsts.RootPath}EquipmentPartCode")]
+public class EquipmentPartCodeAppService
+    : SfsBaseDataWithCodeAppServiceBase<EquipmentPartCode, EquipmentPartCodeDTO, SfsBaseDataRequestInputBase, EquipmentPartCodeEditInput, EquipmentPartCodeImportInput>
+        , IEquipmentPartCodeAppService
+{
+    //private readonly ItemValidator _itemValidator;
+    private readonly IEquipmentPartCodeManager _manager;
+    private new readonly IEquipmentPartCodeRepository _repository;
+    private readonly IExportImportService _importService;
+
+    public EquipmentPartCodeAppService(
+        IEquipmentPartCodeRepository repository,
+        IDistributedCache<EquipmentPartCodeDTO> cache,
+        IExportImportService importService,
+     
+        IEquipmentPartCodeManager manager)
+        : base(repository, cache)
+    {
+        _importService=importService;
+        _repository = repository;
+        _manager = manager;
+        base.CreatePolicyName = EquipmentPermissions.Create;
+        base.UpdatePolicyName = EquipmentPermissions.Update;
+        base.DeletePolicyName = EquipmentPermissions.Delete;
+    }
+   
+    [HttpPost("check")]
+    //[Authorize(ErpLocationPermissions.Default)]
+
+    public virtual async Task CheckAsync(string code, EquipmentPartCodeCheckInput input)
+    {
+        await Task.CompletedTask.ConfigureAwait(false);
+    }
+    //public override async Task<IActionResult> ImportAsync([FromForm] SfsImportRequestInput requestInput, [Required] IFormFile file)
+    //{
+    //    List<EquipmentPartCodeErrorDTO> errors = new List<EquipmentPartCodeErrorDTO>();
+    //    using var ms = new MemoryStream();
+    //    await file.OpenReadStream().CopyToAsync(ms).ConfigureAwait(false);
+    //    var inputFileBytes = ms.GetAllBytes();
+    //    var dtos=_importService.Import<EquipmentPartCodeEditInput>(inputFileBytes).ToList();
+    //    var list=ObjectMapper.Map<List<EquipmentPartCodeEditInput>, List<EquipmentPartCode>>(dtos);
+
+        
+
+
+
+    //    foreach (var itm in list)
+    //    {
+    //        itm.SetId(GuidGenerator.Create());
+    //        itm.Code = string.Format("{0}{1}", "Q", itm.Code);
+
+    //    }
+        
+
+
+
+    //    ////var bytes = result.FileContents;
+    //    ////result.FileContents = null;
+
+    //    ////HttpContextAccessor.HttpContext.Response.Headers.AccessControlExposeHeaders = "X-Response";
+    //    ////HttpContextAccessor.HttpContext.Response.Headers.Add("X-Response",
+    //    ////    JsonSerializer.Serialize(new { result.ExceptionMessage, result.FileName, result.FileCode, result }));
+
+    //    ////Console.WriteLine(@"导入错误信息：" + result.ExceptionMessage);
+
+    //    ////var resultAction = new TestResult(bytes, ExportImportService.ContentType) { FileDownloadName = result.FileName };
+    //    ////resultAction.errorNum = result.ErrorNum;
+    //    ////resultAction.successNum = resultAction.successNum;
+    //    //return resultAction;
+
+
+
+
+
+
+
+
+    //   // return base.ImportAsync(requestInput, file);
+    //}
+
+    //protected ICategoryAppService _categoryApp => LazyServiceProvider.LazyGetRequiredService<ICategoryAppService>();
+    //protected IItemCategoryAppService _itemCategoryApp => LazyServiceProvider.LazyGetRequiredService<IItemCategoryAppService>();
+
+    //[HttpPost("check")]
+    //public virtual async Task CheckAsync(string code, EquipmentPartCodeCheckInput input)
+    //{
+    //    var result = new AbpValidationResult();
+    //    _itemValidator.CheckFormat(code);
+    //    var dto = await GetByCodeAsync(code).ConfigureAwait(false);
+    //    var entity = ObjectMapper.Map<EquipmentPartCodeDTO, EquipmentPartCode>(dto);
+    //    //_itemValidator.CheckCanBuy(entity, input.CanBuy, result);
+    //    //_itemValidator.CheckCanMake(entity, input.CanMake, result);
+    //    //_itemValidator.CheckStatus(entity, input.Statuses, result);
+    //    //_itemValidator.CheckProject(entity, input.Projects, result);
+    //    //await _itemValidator.CheckCategoryAsync(entity, input.Categories, result).ConfigureAwait(false);
+    //    if (result.Errors.Count > 0)
+    //    {
+    //        throw new AbpValidationException(result.Errors);
+    //    }
+    //}
+
+    ///// <summary>
+    ///// 检物品状态 是否可用
+    ///// </summary>
+    ///// <param name="itemCode"></param>
+    ///// <returns></returns>
+    ///// <exception cref="NotImplementedException"></exception>
+    //[HttpGet("check-item-is-available")]
+    //public virtual async Task<bool> CheckItemIsAvailable(string itemCode)
+    //{
+    //    var entity = await _repository.FindAsync(c => c.Code == itemCode).ConfigureAwait(false);
+
+    //    if (entity == null)
+    //    {
+    //        throw new UserFriendlyException($"未找到代码为 {itemCode} 的物品");
+    //    }
+
+    //    return entity.Status == EnumItemStatus.Active;
+    //}
+
+    /// <summary>
+    ///  检物品状态 是否可用(不查询数据库 直接根据对象判断)
+    /// </summary>
+    /// <param name="EquipmentPartCodeDTO"></param>
+    /// <returns></returns>
+    //[HttpGet("check-item-is-available-no-select-sql")]
+    //public void CheckItemIsAvailable(EquipmentPartCodeDTO EquipmentPartCodeDTO)
+    //{
+    //    if (EquipmentPartCodeDTO != null && EquipmentPartCodeDTO.Status != EnumItemStatus.Active)
+    //    {
+    //        throw new UserFriendlyException($"物料 {EquipmentPartCodeDTO.Code} 状态为 {EquipmentPartCodeDTO.Status} ，不是可用状态");
+    //    }
+    //}
+
+    //[HttpGet("{id}")]
+    //public override async Task<EquipmentPartCodeDTO> GetAsync(Guid id)
+    //{
+    //    var dto = await base.GetAsync(id).ConfigureAwait(false);
+
+    //    dto.ItemCategoryDictionary = await GetItemCategory(dto.Code).ConfigureAwait(false);
+
+    //    return dto;
+    //}
+
+    /// <summary>
+    ///
+    /// </summary>
+    /// <param name="name"></param>
+    /// <returns></returns>
+    /// <exception cref="NotImplementedException"></exception>
+    //[HttpGet("list-by-name")]
+    //public virtual async Task<List<EquipmentPartCodeDTO>> GetListByNameAsync(string name)
+    //{
+    //    var entities = await _repository.GetListAsync(c => c.Name == name).ConfigureAwait(false);
+    //    var dtos = ObjectMapper.Map<List<EquipmentPartCode>, List<EquipmentPartCodeDTO>>(entities);
+    //    return dtos;
+    //}
+
+    //[HttpGet("get-manage-type")]
+    //public virtual async Task<EnumItemManageType> GetManageTypeAsync(string itemCode)
+    //{
+    //    var entity = await GetByCodeAsync(itemCode).ConfigureAwait(false);
+    //    Check.NotNull(entity, "物品代码", $"物品 {itemCode} 不存在");
+    //    return entity.ManageType;
+    //}
+
+    //[HttpGet("get-manage-types")]
+    //public virtual async Task<Dictionary<string, EnumItemManageType>> GetManageTypesAsync(List<string> itemCodes)
+    //{
+    //    var dtos = await GetByCodesAsync(itemCodes).ConfigureAwait(false);
+    //    var itemManageTypes = dtos.ToDictionary(dto => dto.Code, dto => dto.ManageType);
+    //    return itemManageTypes;
+    //}
+
+    //[HttpPost("get-or-add")]
+    //public virtual async Task<EquipmentPartCodeDTO> GetOrAddAsync(EquipmentPartCodeEditInput input)
+    //{
+    //    var result = await _repository.FirstOrDefaultAsync(p => p.Code == input.Code).ConfigureAwait(false);
+    //    if (result == null)
+    //    {
+    //        var entity = ObjectMapper.Map<EquipmentPartCodeEditInput, EquipmentPartCode>(input);
+    //        result = await _repository.InsertAsync(entity, true).ConfigureAwait(false);
+    //    }
+
+    //    var dto = ObjectMapper.Map<EquipmentPartCode, EquipmentPartCodeDTO>(result);
+    //    return dto;
+    //}
+
+    //[HttpPost("list")]
+    //public override async Task<PagedResultDto<EquipmentPartCodeDTO>> GetPagedListByFilterAsync(
+    //    SfsBaseDataRequestInputBase sfsRequestInput,
+    //    bool includeDetails = false,
+    //    CancellationToken cancellationToken = default)
+    //{
+    //    Expression<Func<EquipmentPartCode, bool>> expression = sfsRequestInput.Condition.Filters?.Count > 0
+    //                                                       ? sfsRequestInput.Condition.Filters.ToLambda<EquipmentPartCode>()
+    //                                                       : p => true;
+    //    var pageResult = await GetPagedListAsync(
+    //        expression,
+    //        sfsRequestInput.SkipCount,
+    //        sfsRequestInput.MaxResultCount,
+    //        sfsRequestInput.Sorting,
+    //        includeDetails,
+    //        cancellationToken).ConfigureAwait(false);
+
+    //    foreach (var item in pageResult.Items)
+    //    {
+    //        item.ItemCategoryDictionary = await GetItemCategory(item.Code).ConfigureAwait(false);
+    //    }
+
+    //    return pageResult;
+    //}
+
+    //[HttpPost("upsert")]
+    //public virtual async Task UpsertAsync(EquipmentPartCodeEditInput input)
+    //{
+    //    var entity = ObjectMapper.Map<EquipmentPartCodeEditInput, EquipmentPartCode>(input);
+    //    await _repository.UpsertAsync(entity).ConfigureAwait(false);
+    //}
+    //[HttpPost("upsert-interface")]
+    //public virtual async Task UpsertAsyncByInterface(EquipmentPartCodeEditInput input)
+    //{
+    //    var entity = ObjectMapper.Map<EquipmentPartCodeEditInput, EquipmentPartCode>(input);
+    //    await _repository.UpsertAsyncByInterface(entity).ConfigureAwait(false);
+    //}
+
+    //protected override Expression<Func<EquipmentPartCode, bool>> BuildSearchExpression(string keyWord)
+    //{
+    //    Expression<Func<EquipmentPartCode, bool>> expression = p =>
+    //        p.Code.Contains(keyWord)
+    //        || p.Name.Contains(keyWord)
+    //        || p.Desc1.Contains(keyWord)
+    //        || p.Desc2.Contains(keyWord)
+    //        || p.AbcClass.Contains(keyWord)
+    //        || p.BasicUom.Contains(keyWord)
+    //        || p.Elevel.Contains(keyWord)
+    //        || p.Project.Contains(keyWord)
+    //        || p.Version.Contains(keyWord);
+    //    return expression;
+    //}
+
+    //private async Task<Dictionary<string, string>> GetItemCategory(string itemCode)
+    //{
+    //   // var itemCategorys = await this._itemCategoryApp.GetListByItemCode(itemCode).ConfigureAwait(false);
+
+    //   // return itemCategorys.ToDictionary(x => x.CategoryCode, y => y.Value);
+    //}
+
+    [HttpPost("upsert")]
+
+    public virtual async Task UpsertAsync(EquipmentPartCodeEditInput input)
+    {
+        var entity = ObjectMapper.Map<EquipmentPartCodeEditInput, EquipmentPartCode>(input);
+
+        await _repository.UpsertAsync(entity).ConfigureAwait(false);
+    }
+
+    [HttpPost]
+    [Route("")]
+    public override async Task<EquipmentPartCodeDTO> CreateAsync(EquipmentPartCodeEditInput input)
+    {
+        var first= _repository.WithDetails().FirstOrDefault(p => p.Code == input.Code);
+        if (first == null)
+        {
+            var entity = ObjectMapper.Map<EquipmentPartCodeEditInput, EquipmentPartCode>(input);
+          
+            await _repository.UpsertAsync(entity).ConfigureAwait(false);
+            var entity1=_repository.WithDetails().FirstOrDefault(p => p.Code == input.Code);
+            return ObjectMapper.Map<EquipmentPartCode,EquipmentPartCodeDTO>(entity1);
+        }
+        else
+        {
+            throw new UserFriendlyException($"已存在器具编号{input.Code}!");
+        }
+
+    }
+    [HttpPost]
+    [Route("GetEquipmentPartCodes")]
+    public async Task<List<EquipmentPartCodeDTO>> GetEquipmentPartCodesAsync(List<string> p_ls)
+    {
+        var query = await _repository.GetQueryableAsync().ConfigureAwait(false);
+        var list = query.Where(p => p_ls.Contains(p.Code));
+
+        return ObjectMapper.Map<List<EquipmentPartCode>, List<EquipmentPartCodeDTO>>(list.ToList());
+
+    }
+
+
+
+
+}

be/Modules/BaseData/src/Win_in.Sfs.Basedata.Application/Equipments/EquipmentPartCodeAutoMapperProfile.cs

@@ -0,0 +1,35 @@
+using AutoMapper;
+using Volo.Abp.AutoMapper;
+using Win_in.Sfs.Basedata.Application.Contracts;
+using Win_in.Sfs.Basedata.Domain;
+
+namespace Win_in.Sfs.Basedata.Application;
+
+public partial class BasedataApplicationAutoMapperProfile : Profile
+{
+    private void EquipmentPartCodeAutoMapperProfile()
+    {
+        CreateMap<EquipmentPartCode, EquipmentPartCodeDTO>()
+          
+            .ReverseMap();
+
+        CreateMap<EquipmentPartCodeImportInput, EquipmentPartCode>()
+            .IgnoreAuditedObjectProperties()
+            .Ignore(x => x.TenantId)
+            .Ignore(x => x.Remark)
+            .Ignore(x => x.ExtraProperties)
+            .Ignore(x => x.ConcurrencyStamp)
+            .ForMember(p =>p.Code, p => p.MapFrom(q =>q.Code))
+
+            ;
+
+        //CreateMap<EquipmentPartCode, EquipmentPartCodeImportInput>()
+         
+        //CreateMap<EquipmentPartCode, EquipmentPartCodeForDongyangExportDTO>()
+        //    .Ignore(x => x.ItemCategory)
+        //    .Ignore(x => x.Color);
+        CreateMap<EquipmentPartCodeEditInput, EquipmentPartCode>()
+             .IgnoreAuditedObjectProperties()
+             .Ignore(x => x.ConcurrencyStamp).Ignore(x => x.Id);
+    }
+}

be/Modules/BaseData/src/Win_in.Sfs.Basedata.Application/Kittings/KittingAppService.cs

@@ -151,10 +151,7 @@ public class KittingAppService : SfsBaseDataWithCodeAppServiceBase<Kitting, Kitt
         await file.OpenReadStream().CopyToAsync(ms).ConfigureAwait(false);
         var inputFileBytes = ms.GetAllBytes();
         var importList= _excelService.Import<KittingImportInput>(inputFileBytes).ToList();
-        var checklist=importList.GroupBy(p => new { p.Code, p.PartCode }).Where(g => g.Count() > 1).Select(p => new { Code = p.Key.Code, PartCode = p.Key.PartCode });//导入重复报错
-                                                                                                                                                                      //检测是否导入重复
-
-
+        var checklist=importList.GroupBy(p => new { p.Code, p.PartCode }).Where(g => g.Count() > 1).Select(p => new { Code = p.Key.Code, PartCode = p.Key.PartCode });//导入重复报错                                                                                                                                                              //检测是否导入重复
         List<KittingErrorDto> errors = new List<KittingErrorDto>();
         if (checklist.Any())
         {
@@ -163,14 +160,7 @@ public class KittingAppService : SfsBaseDataWithCodeAppServiceBase<Kitting, Kitt
 
                 errors.Add(new KittingErrorDto() { Code=error.Code,PartCode=error.PartCode, Content="记录有重复!" });
             }
-           
-
-            
         }
-
-
-
-
         var codeList=importList.Select(p=>p.Code).Distinct().ToList();
         var includeList = query.Where(p => codeList.Contains(p.Code)).ToList();
         var existCodeList = includeList.Select(p => p.Code).ToList();
@@ -246,25 +236,23 @@ public class KittingAppService : SfsBaseDataWithCodeAppServiceBase<Kitting, Kitt
                         //existKittingDetailList.Add(itm);
                     }
                 }
-                //var leftExist = from itm in newDetail
-                //                join itm1 in include.Details on itm.PartCode equals itm1.PartCode
-                //                into temp
-                //                from tm in temp.DefaultIfEmpty()
-                //                where tm == null
-                //                select itm;
-                //if (leftExist.Any())
-                //{
-                //    var list = leftExist.ToList();
-                //    foreach (var itm in list)
-                //    {
-                //        var detail = new KittingDetail();
-                //        detail.InjectFrom(itm);
-                //        detail.SetId(Guid.NewGuid());
-                //        detail.MasterId = include.Id;
-                //        //newKittingDetailList.Add(detail);
-
-                //    }
-                //}
+                var leftExist = from itm in newDetail
+                                join itm1 in include.Details on itm.PartCode equals itm1.PartCode
+                                into temp
+                                from tm in temp.DefaultIfEmpty()
+                                where tm == null
+                                select itm;
+                if (leftExist.Any())
+                {
+                    var list = leftExist.ToList();
+                    foreach (var itm in list)
+                    {
+                        var detail = new KittingDetail();
+                        detail.InjectFrom(itm);
+                        detail.SetId(Guid.NewGuid());
+                        detail.MasterId = include.Id;
+                    }
+                }
 
                 //var entity = new KittingEditInput();
                 //entity.InjectFrom(include);
@@ -309,12 +297,10 @@ public class KittingAppService : SfsBaseDataWithCodeAppServiceBase<Kitting, Kitt
                 //        detail.Id = Guid.NewGuid();
                 //        detail.MasterId = entity.Id;
                 //        entity.Details.Add(detail);
-
                 //    }
                 //}
                 //existKittingInputList.Add(entity);
             }
-
             // List<Kitting> list1 = new List<Kitting>();
             // foreach (var itm in existKittingInputList)
             // {
@@ -329,24 +315,13 @@ public class KittingAppService : SfsBaseDataWithCodeAppServiceBase<Kitting, Kitt
             //         kitting.AddDetails(kittingDetail);
             //     }
             //     list1.Add(kitting);
-
             // }
             //var details= list1.Select(p => p.Details).ToList();
-
-
             //    //await _repository.GetDbContext().BulkInsertAsync(newKittingDetailList).ConfigureAwait(continueOnCapturedContext: false);
             //    //await _repository.GetDbContext().BulkUpdateAsync(existKittingDetailList).ConfigureAwait(continueOnCapturedContext: false);
             //    // var ls= ObjectMapper.Map< List<KittingEditInput> ,List <Kitting>>(existKittingInputList);
-
-
             //    //await _repository.UpdateManyAsync(list1,true).ConfigureAwait(continueOnCapturedContext: false);
-
-
             //    await _manager.ImportDataAsync(includeList).ConfigureAwait(false);
-
-
-
-
         }
 
         if (errors.Count > 0)

be/Modules/BaseData/src/Win_in.Sfs.Basedata.Domain/Equipments/Equipment.cs

@@ -3,6 +3,7 @@ using System.ComponentModel.DataAnnotations;
 using Win_in.Sfs.Shared.Domain;
 using Win_in.Sfs.Shared.Domain.Entities;
 using Win_in.Sfs.Shared.Domain.Shared;
+using Win_in.Sfs.Shared.Domain.Shared.Enums.Basedata;
 
 namespace Win_in.Sfs.Basedata.Domain;
 
@@ -20,11 +21,11 @@ public class Equipment : SfsBaseDataAggregateRootBase, IHasCode
     /// <summary>
     /// 类型
     /// </summary>
-    public string Type { get; set; }
+    public EnumEquipmentType Type { get; set; }
     /// <summary>
     /// 型号
     /// </summary>
-    public string Model { get; set; }
+    public EnumEquipmentModel  Model { get; set; }
     /// <summary>
     /// 库位编号
     /// </summary>
@@ -50,113 +51,4 @@ public class Equipment : SfsBaseDataAggregateRootBase, IHasCode
     public decimal StdQty { get; set; }
 
 
-
-
-
-
-
-
-    ///// <summary>
-    ///// 代码
-    ///// </summary>
-    //[IgnoreUpdate]
-    //public string Code { get; set; }
-    ///// <summary>
-    ///// 名称
-    ///// </summary>
-    //public string Name { get; set; }
-    ///// <summary>
-    ///// 描述
-    ///// </summary>
-    //public string Desc1 { get; set; }
-    ///// <summary>
-    ///// 描述2
-    ///// </summary>
-    //public string Desc2 { get; set; }
-    ///// <summary>
-    ///// 状态
-    ///// </summary>
-    //public EnumItemStatus Status { get; set; }
-    ///// <summary>
-    ///// 制造件
-    ///// </summary>
-    //public bool CanMake { get; set; }
-    ///// <summary>
-    ///// 采购件
-    ///// </summary>
-    //[IgnoreUpdate]
-    //public bool CanBuy { get; set; }
-    ///// <summary>
-    ///// 外包件
-    ///// </summary>
-    //public bool CanOutsourcing { get; set; }
-    ///// <summary>
-    ///// 回收件
-    ///// </summary>
-    //public bool IsRecycled { get; set; }
-
-    //[Display(Name = "类型")]
-    //public string Type { get; set; }
-
-    //[Display(Name = "种类")]
-    //public string Category { get; set; }
-
-    //[Display(Name = "分组")]
-    //public string Group { get; set; }
-
-    //[Display(Name = "颜色")]
-    //public string Color { get; set; }
-
-    //[Display(Name = "配置")]
-    //public string Configuration { get; set; }
-    ///// <summary>
-    ///// 基本计量单位
-    ///// </summary>
-    //public string BasicUom { get; set; }
-
-    ///// <summary>
-    ///// 标包数
-    ///// </summary>
-    //public decimal StdPackQty { get; set; }
-
-    ///// <summary>
-    ///// ABC类,默认为C
-    ///// </summary>
-    //public string AbcClass { get; set; }
-    ///// <summary>
-    ///// 项目
-    ///// </summary>
-    //public string Project { get; set; }
-    ///// <summary>
-    ///// 版本
-    ///// </summary>
-    //public string Version { get; set; }
-    ///// <summary>
-    ///// 工程变革
-    ///// </summary>
-    //public string Eco { get; set; }
-    ///// <summary>
-    ///// 有效期
-    ///// </summary>
-    //public int Validity { get; set; }
-    ///// <summary>
-    ///// 有效期单位
-    ///// </summary>
-    //public EnumValidityUnit ValidityUnit { get; set; }
-
-    ///// <summary>
-    ///// 管理类型
-    ///// </summary>
-    //public EnumItemManageType ManageType { get; set; }
-
-    ///// <summary>
-    ///// 打印标签用的一个等级
-    ///// </summary>
-    //public string Elevel { get; set; }
-
-    ///// <summary>
-    ///// 虚零件
-    ///// </summary>
-    //public virtual bool IsPhantom { get; set; }
-
 }

be/Modules/BaseData/src/Win_in.Sfs.Basedata.Domain/Equipments/EquipmentLoc.cs

@@ -0,0 +1,36 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+using Win_in.Sfs.Shared.Domain;
+using Win_in.Sfs.Shared.Domain.Entities;
+using Win_in.Sfs.Shared.Domain.Shared;
+using Win_in.Sfs.Shared.Domain.Shared.Enums.Basedata;
+
+namespace Win_in.Sfs.Basedata.Domain;
+
+/// <summary>
+/// 物品基本信息
+/// </summary>
+public class EquipmentLoc : SfsBaseDataAggregateRootBase, IHasCode
+{
+    /// <summary>
+    /// 器具代码
+    /// </summary>
+    public string Code { get; set; }
+    ///// <summary>
+    ///// 类型
+    ///// </summary>
+    //public EquipmentType Type { get; set; }
+    ///// <summary>
+    ///// 型号
+    ///// </summary>
+    //public EquipmentModel  Model { get; set; }
+    /// <summary>
+    /// 库位代码
+    /// </summary>
+    public string LocCode { get; set; }
+    /// <summary>
+    /// 状态
+    /// </summary>
+    public int State { get; set; }
+
+}

be/Modules/BaseData/src/Win_in.Sfs.Basedata.Domain/Equipments/EquipmentLocManager.cs

@@ -0,0 +1,29 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Volo.Abp.Domain.Services;
+
+namespace Win_in.Sfs.Basedata.Domain;
+
+public class EquipmentLocManager : DomainService, IEquipmentLocManager
+{
+    private readonly IEquipmentLocRepository _repository;
+
+    public EquipmentLocManager(IEquipmentLocRepository repository)
+    {
+        _repository = repository;
+    }
+
+    /// <summary>
+    /// 执行导入
+    /// </summary>
+    public virtual async Task ImportDataAsync(List<EquipmentLoc> mergeEntities, List<EquipmentLoc> deleteEntities = null)
+    {
+        if (deleteEntities != null && deleteEntities.Count > 0)
+        {
+            await _repository.BulkDeleteAsync(deleteEntities).ConfigureAwait(false);
+        }
+
+        await _repository.BulkMergeAsync(mergeEntities).ConfigureAwait(false);
+    }
+}
+

be/Modules/BaseData/src/Win_in.Sfs.Basedata.Domain/Equipments/EquipmentPartCode.cs

@@ -0,0 +1,44 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+using Win_in.Sfs.Shared.Domain;
+using Win_in.Sfs.Shared.Domain.Entities;
+using Win_in.Sfs.Shared.Domain.Shared;
+using Win_in.Sfs.Shared.Domain.Shared.Enums.Basedata;
+
+namespace Win_in.Sfs.Basedata.Domain;
+
+/// <summary>
+/// 器具基本信息
+/// </summary>
+public class EquipmentPartCode : SfsBaseDataAggregateRootBase, IHasCode
+{
+   
+    /// <summary>
+    /// 器具编号
+    /// </summary>
+    public string Code { get; set; }
+    ///// <summary>
+    ///// 类型
+    ///// </summary>
+    //public EquipmentType Type { get; set; }
+    ///// <summary>
+    ///// 型号
+    ///// </summary>
+    //public EquipmentModel Model { get; set; }
+    /// <summary>
+    /// 库位编号
+    /// </summary>
+    public string  PartCode { get; set; }
+    /// <summary>
+    /// 数量
+    /// </summary>
+    public decimal StdQty { get; set; }
+    /// <summary>
+    /// 状态
+    /// </summary>
+    public int State { get; set; }
+    /// <summary>
+    /// 单位
+    /// </summary>
+    public string Unit { get; set; }
+}

be/Modules/BaseData/src/Win_in.Sfs.Basedata.Domain/Equipments/EquipmentPartCodeManager.cs

@@ -0,0 +1,29 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Volo.Abp.Domain.Services;
+
+namespace Win_in.Sfs.Basedata.Domain;
+
+public class EquipmentPartCodeManager : DomainService, IEquipmentPartCodeManager
+{
+    private readonly IEquipmentPartCodeRepository _repository;
+
+    public EquipmentPartCodeManager(IEquipmentPartCodeRepository repository)
+    {
+        _repository = repository;
+    }
+
+    /// <summary>
+    /// 执行导入
+    /// </summary>
+    public virtual async Task ImportDataAsync(List<EquipmentPartCode> mergeEntities, List<EquipmentPartCode> deleteEntities = null)
+    {
+        if (deleteEntities != null && deleteEntities.Count > 0)
+        {
+            await _repository.BulkDeleteAsync(deleteEntities).ConfigureAwait(false);
+        }
+
+        await _repository.BulkMergeAsync(mergeEntities).ConfigureAwait(false);
+    }
+}
+

be/Modules/BaseData/src/Win_in.Sfs.Basedata.Domain/Equipments/IEquipmentLocManager.cs

@@ -0,0 +1,8 @@
+using Volo.Abp.Domain.Services;
+using Win_in.Sfs.Shared.Domain;
+
+namespace Win_in.Sfs.Basedata.Domain;
+
+public interface IEquipmentLocManager : IDomainService, IBulkImportService<EquipmentLoc>
+{
+}

be/Modules/BaseData/src/Win_in.Sfs.Basedata.Domain/Equipments/IEquipmentLocRepository.cs

@@ -0,0 +1,13 @@
+using System.Threading.Tasks;
+using Win_in.Sfs.Shared.Domain;
+
+namespace Win_in.Sfs.Basedata.Domain;
+
+public interface IEquipmentLocRepository : ISfsBaseDataRepositoryBase<EquipmentLoc>, ISfsBulkRepositoryBase<EquipmentLoc>
+{
+    public Task UpsertAsync(EquipmentLoc entity);
+
+    public Task InsertAutoSaveAsync(EquipmentLoc entity);
+
+    public Task UpsertAsyncByInterface(EquipmentLoc entity);
+}

be/Modules/BaseData/src/Win_in.Sfs.Basedata.Domain/Equipments/IEquipmentPartCodeManager.cs

@@ -0,0 +1,8 @@
+using Volo.Abp.Domain.Services;
+using Win_in.Sfs.Shared.Domain;
+
+namespace Win_in.Sfs.Basedata.Domain;
+
+public interface IEquipmentPartCodeManager : IDomainService, IBulkImportService<EquipmentPartCode>
+{
+}

be/Modules/BaseData/src/Win_in.Sfs.Basedata.Domain/Equipments/IEquipmentPartCodeRepository.cs

@@ -0,0 +1,13 @@
+using System.Threading.Tasks;
+using Win_in.Sfs.Shared.Domain;
+
+namespace Win_in.Sfs.Basedata.Domain;
+
+public interface IEquipmentPartCodeRepository : ISfsBaseDataRepositoryBase<EquipmentPartCode>, ISfsBulkRepositoryBase<EquipmentPartCode>
+{
+    public Task UpsertAsync(EquipmentPartCode entity);
+
+    public Task InsertAutoSaveAsync(EquipmentPartCode entity);
+
+    public Task UpsertAsyncByInterface(EquipmentPartCode entity);
+}

be/Modules/BaseData/src/Win_in.Sfs.Basedata.EntityFrameworkCore/BasedataDbContextModelCreatingExtensions.cs

@@ -69,6 +69,8 @@ public static class BasedataDbContextModelCreatingExtensions
         builder.ConfigurePositionCode(options);
         builder.ConfigureSplitPackingRec(options);
         builder.ConfigureKitting(options);
+        builder.ConfigureEquipmentLoc(options);
+        builder.ConfigureEquipmentPartCode(options);
 
     }
 

be/Modules/BaseData/src/Win_in.Sfs.Basedata.EntityFrameworkCore/BasedataEntityFrameworkCoreModule.cs

@@ -69,9 +69,11 @@ public class BasedataEntityFrameworkCoreModule : AbpModule
         context.Services.AddTransient<IItemGuideBookRepository, ItemGuideBookEfCoreRepository>();
         context.Services.AddTransient<IDocumentSettingRepository, DocumentSettingEfCoreRepository>();
         context.Services.AddTransient<IEquipmentRepository, EquipmentEfCoreRepository>();
-context.Services.AddTransient<IEquipmentAreaRepository, EquipmentAreaEfCoreRepository>();
+        context.Services.AddTransient<IEquipmentAreaRepository, EquipmentAreaEfCoreRepository>();
         context.Services.AddTransient<ISplitPackingRecRepository, SplitPackingRecEfCoreRepository>();
         context.Services.AddTransient<IKittingRepository, KittingEfCoreRepository>();
+        context.Services.AddTransient<IEquipmentPartCodeRepository, EquipmentPartCodeEfCoreRepository>();
+        context.Services.AddTransient<IEquipmentLocRepository, EquipmentLocEfCoreRepository>();
         ConfigureEntity();
     }
 

be/Modules/BaseData/src/Win_in.Sfs.Basedata.EntityFrameworkCore/Equipments/EquipmentLocDbContextModelCreatingExtensions.cs

@@ -0,0 +1,40 @@
+using Microsoft.EntityFrameworkCore;
+using Volo.Abp.EntityFrameworkCore.Modeling;
+using Win_in.Sfs.Basedata.Domain;
+using Win_in.Sfs.Shared.Domain.Shared;
+using Win_in.Sfs.Shared.EntityFrameworkCore;
+
+namespace Win_in.Sfs.Basedata.EntityFrameworkCore;
+
+public static class EquipmentLocDbContextModelCreatingExtensions
+{
+    public static void ConfigureEquipmentLoc(this ModelBuilder builder, BasedataModelBuilderConfigurationOptions options)
+    {
+        builder.Entity<EquipmentLoc>(b =>
+        {
+            //Configure table & schema name
+            b.ToTable(options.TablePrefix + nameof(EquipmentLoc), options.Schema);
+            //Configure ABP properties
+            b.ConfigureByConvention();
+            //Configure Sfs base properties
+            b.ConfigureSfsBase();
+
+            //Properties
+            b.Property(q => q.Code).IsRequired().HasMaxLength(SfsPropertyConst.CodeLength).IsRequired(true);
+            b.Property(q => q.LocCode).IsRequired().HasMaxLength(SfsPropertyConst.CodeLength).IsRequired(true);
+            
+
+
+            //Relations
+            //None
+
+            //Indexes
+            b.HasIndex(q => new { q.Code ,q.LocCode}).IsUnique();
+        });
+    }
+}
+
+
+/// <summary>
+/// 器具编号
+/// </summary>

be/Modules/BaseData/src/Win_in.Sfs.Basedata.EntityFrameworkCore/Equipments/EquipmentLocEfCoreRepository.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore;
+using Volo.Abp.EntityFrameworkCore;
+using Win_in.Sfs.Basedata.Domain;
+using Win_in.Sfs.Shared.Domain;
+
+namespace Win_in.Sfs.Basedata.EntityFrameworkCore;
+
+public class EquipmentLocEfCoreRepository : SfsBaseDataEfCoreRepositoryBase<BasedataDbContext, EquipmentLoc>, IEquipmentLocRepository, ISfsBulkRepositoryBase<EquipmentLoc>
+{
+    public EquipmentLocEfCoreRepository(IDbContextProvider<BasedataDbContext> dbContextProvider) : base(dbContextProvider)
+    {
+    }
+    public virtual async Task UpsertAsyncByInterface(EquipmentLoc entity)
+    {
+        var dbSet = await GetDbSetAsync().ConfigureAwait(false);
+        var exist = await dbSet.FirstOrDefaultAsync(p => p.Code == entity.Code).ConfigureAwait(false);
+        if (exist == null)
+        {
+            var insRet = await InsertAsync(entity).ConfigureAwait(false);
+        }
+        else
+        {
+            exist.State = entity.State;
+          
+            exist.LastModificationTime = DateTimeOffset.Now.DateTime;
+
+        }
+    }
+    public virtual async Task UpsertAsync(EquipmentLoc entity)
+    {
+        var dbSet = await GetDbSetAsync().ConfigureAwait(false);
+        var exist = await dbSet.FirstOrDefaultAsync(p => p.Code == entity.Code).ConfigureAwait(false);
+        if (exist == null)
+        {
+            var insRet = await InsertAsync(entity).ConfigureAwait(false);
+        }
+        else
+        {
+            exist.State = entity.State;
+         
+            exist.LastModificationTime = DateTimeOffset.Now.DateTime;
+
+        }
+
+      
+    }
+
+    public virtual async Task InsertAutoSaveAsync(EquipmentLoc entity)
+    {
+        _ = await InsertAsync(entity, true, GetCancellationToken()).ConfigureAwait(false);
+    }
+}

be/Modules/BaseData/src/Win_in.Sfs.Basedata.EntityFrameworkCore/Equipments/EquipmentPartCodeDbContextModelCreatingExtensions.cs

@@ -0,0 +1,40 @@
+using Microsoft.EntityFrameworkCore;
+using Volo.Abp.EntityFrameworkCore.Modeling;
+using Win_in.Sfs.Basedata.Domain;
+using Win_in.Sfs.Shared.Domain.Shared;
+using Win_in.Sfs.Shared.EntityFrameworkCore;
+
+namespace Win_in.Sfs.Basedata.EntityFrameworkCore;
+
+public static class EquipmentPartCodeDbContextModelCreatingExtensions
+{
+    public static void ConfigureEquipmentPartCode(this ModelBuilder builder, BasedataModelBuilderConfigurationOptions options)
+    {
+        builder.Entity<EquipmentPartCode>(b =>
+        {
+            //Configure table & schema name
+            b.ToTable(options.TablePrefix + nameof(EquipmentPartCode), options.Schema);
+            //Configure ABP properties
+            b.ConfigureByConvention();
+            //Configure Sfs base properties
+            b.ConfigureSfsBase();
+
+            //Properties
+            b.Property(q => q.Code).IsRequired().HasMaxLength(SfsPropertyConst.CodeLength).IsRequired(true);
+            b.Property(q => q.PartCode).HasMaxLength(SfsPropertyConst.CodeLength).IsRequired(true);
+           
+            
+           
+            //Relations
+            //None
+
+            //Indexes
+            b.HasIndex(q => new { q.Code,q.PartCode }).IsUnique();
+        });
+    }
+}
+
+
+/// <summary>
+/// 器具编号
+/// </summary>

be/Modules/BaseData/src/Win_in.Sfs.Basedata.EntityFrameworkCore/Equipments/EquipmentPartCodeEfCoreRepository.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore;
+using Volo.Abp.EntityFrameworkCore;
+using Win_in.Sfs.Basedata.Domain;
+using Win_in.Sfs.Shared.Domain;
+
+namespace Win_in.Sfs.Basedata.EntityFrameworkCore;
+
+public class EquipmentPartCodeEfCoreRepository : SfsBaseDataEfCoreRepositoryBase<BasedataDbContext, EquipmentPartCode>, IEquipmentPartCodeRepository, ISfsBulkRepositoryBase<EquipmentPartCode>
+{
+    public EquipmentPartCodeEfCoreRepository(IDbContextProvider<BasedataDbContext> dbContextProvider) : base(dbContextProvider)
+    {
+    }
+    public virtual async Task UpsertAsyncByInterface(EquipmentPartCode entity)
+    {
+        var dbSet = await GetDbSetAsync().ConfigureAwait(false);
+        var exist = await dbSet.FirstOrDefaultAsync(p => p.Code== entity.Code).ConfigureAwait(false);
+        if (exist == null)
+        {
+            var insRet = await InsertAsync(entity).ConfigureAwait(false);
+        }
+        else
+        {
+            exist.State = entity.State;
+         
+            exist.LastModificationTime = DateTimeOffset.Now.DateTime;
+
+        }
+    }
+    public virtual async Task UpsertAsync(EquipmentPartCode entity)
+    {
+        var dbSet = await GetDbSetAsync().ConfigureAwait(false);
+        var exist = await dbSet.FirstOrDefaultAsync(p => p.Code == entity.Code).ConfigureAwait(false);
+        if (exist == null)
+        {
+            var insRet = await InsertAsync(entity).ConfigureAwait(false);
+        }
+        else
+        {
+            exist.State = entity.State;
+         
+            exist.LastModificationTime = DateTimeOffset.Now.DateTime;
+
+        }
+
+        // var context = await GetDbContextAsync();
+        // await context.SingleMergeAsync(entity, options =>
+        // {
+        //     //业务主键,可以是联合主键
+        //     options.ColumnPrimaryKeyExpression = c => new
+        //     {
+        //         c.Code
+        //     };
+        //     //需要在更新时忽略的属性
+        //     options.IgnoreOnMergeUpdateExpression = c => new
+        //     {
+        //         c.Id,
+        //         c.ManageType,
+        //     };
+        // });
+    }
+
+    public virtual async Task InsertAutoSaveAsync(EquipmentPartCode entity)
+    {
+        _ = await InsertAsync(entity, true, GetCancellationToken()).ConfigureAwait(false);
+    }
+}

be/Modules/Shared/src/Win_in.Sfs.Shared.Domain.Shared/Enums/Basedata/EnumEquipmentModel.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Win_in.Sfs.Shared.Domain.Shared.Enums.Basedata;
+public enum EnumEquipmentType
+{
+    [Display(Name = "小")]
+    Small =0,
+    [Display(Name = "大")]
+    Large =1,
+    [Display(Name = "超大")]
+    Oversized =2
+}
+
+public enum EnumEquipmentModel
+{
+    
+    /// <summary>
+    /// 内部
+    /// </summary>
+    [Display(Name = "内部")]
+    Internal = 0,
+
+    /// <summary>
+    /// 外部
+    /// </summary>
+    [Display(Name = "外部")]
+    External = 1,
+
+
+
+
+}

be/Modules/Shared/src/Win_in.Sfs.Shared.Domain.Shared/Enums/Store/Statuses/EnumEquipmentRecordType.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Win_in.Sfs.Shared.Domain.Shared.Enums.Store.Statuses;
+public enum EnumEquipmentRecordType
+{
+    Bind=0,
+    UnBind=1
+
+}

be/Modules/Store/src/Win_in.Sfs.Wms.Store.Application.Contracts/Equipments/IEquipmentRecordAppService.cs

@@ -1,7 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
+using Win_in.Sfs.Basedata.Equipments.DTOs;
 using Win_in.Sfs.Shared.Application.Contracts;
+using Win_in.Sfs.Wms.Store.Equipments;
 
 namespace Win_in.Sfs.Wms.Store.Application.Contracts;
 
@@ -12,34 +14,10 @@ public interface IEquipmentRecordAppService
         , ISfsUpsertAppService<EquipmentRecordEditInput>
 {
 
-    ///// <summary>
-    ///// 打开订单明细
-    ///// </summary>
-    ///// <returns></returns>
-    //Task OpenDetailAsync(Guid id, Guid detailId);
 
-    ///// <summary>
-    ///// 关闭订单明细
-    ///// </summary>
-    ///// <returns></returns>
-    //Task CloseDetailAsync(Guid id, Guid detailId);
+    Task<List<EquipmentRecordErrorDTO>> Bind(List<EquipmentRecord> p_ls);
+    Task<List<EquipmentRecordErrorDTO>> UnBind(List<EquipmentRecord> p_ls);
 
-    ///// <summary>
-    ///// 更新订单明细
-    ///// </summary>
-    ///// <param name="number"></param>
-    ///// <param name="input"></param>
-    ///// <returns></returns>
-    //Task UpdateDetailsAsync(string number,List<PurchaseOrderDetailUpdateInput> input);
 
-    ///// <summary>
-    ///// 【批量创建】到货通知 （收货单）
-    ///// </summary>
-    ///// <param name="inputs"></param>
-    ///// <returns></returns>
-    //Task<List<PurchaseOrderDTO>> CreateManyAsync(List<PurchaseOrderEditInput> inputs);
 
-    //Task<List<PurchaseOrderDTO>> GetListBySupplierCodeAsync(string supplierCode, string itemCode);
-    //Task<List<string>> GetNoPoBillList(List<string> poBillNo);
-    //Task<PurchaseOrderDTO> CreateOrUpdateAsync(PurchaseOrderEditInput input);
 }

be/Modules/Store/src/Win_in.Sfs.Wms.Store.Application/Equipments/EquipmentRecordAppService.cs

@@ -10,6 +10,7 @@ using Volo.Abp;
 using Volo.Abp.Domain.Entities;
 using Volo.Abp.Domain.Repositories;
 using Volo.Abp.ObjectMapping;
+using Win_in.Sfs.Basedata.Equipments.DTOs;
 using Win_in.Sfs.Shared.Application;
 using Win_in.Sfs.Shared.Application.Contracts;
 using Win_in.Sfs.Store.Application.Contracts;
@@ -42,6 +43,28 @@ public class EquipmentRecordAppService
         _manager = manager;
         _repository = repository;
     }
+    /// <summary>
+    /// 绑定器具记录
+    /// </summary>
+    /// <param name="p_ls"></param>
+    /// <returns></returns>
+    /// <exception cref="NotImplementedException"></exception>
+    public Task<List<EquipmentRecordErrorDTO>> Bind(List<EquipmentRecord> p_ls)
+    {
+       return _manager.Bind(p_ls); 
+    }
+
+    /// <summary>
+    /// 解绑器具记录
+    /// </summary>
+    /// <param name="p_ls"></param>
+    /// <returns></returns>
+    /// <exception cref="NotImplementedException"></exception>
+    public Task<List<EquipmentRecordErrorDTO>> UnBind(List<EquipmentRecord> p_ls)
+    {
+        return _manager.UnBind(p_ls);
+    }
+
     /// <summary>
     /// 没用
     /// </summary>
@@ -54,6 +77,9 @@ public class EquipmentRecordAppService
     {
         throw new NotImplementedException();
     }
+
+  
+
     /// <summary>
     /// 没用
     /// </summary>
@@ -70,6 +96,8 @@ public class EquipmentRecordAppService
     {
         throw new NotImplementedException();
     }
+
+
     /// <summary>
     /// 没用
     /// </summary>
@@ -96,109 +124,4 @@ public class EquipmentRecordAppService
     }
 
 
-
-    //[HttpGet("by-batchsize")]
-    //public virtual async Task<List<EquipmentRecordDTO>> GetToBeProcessedListAsync(int batchSize)
-    //{
-    //    var entities = await _manager.GetToBeProcessedListAsync(batchSize).ConfigureAwait(false);
-    //    var dtos = ObjectMapper.Map<List<EquipmentRecord>, List<EquipmentRecordDTO>>(entities);
-    //    return dtos;
-    //}
-
-    //[HttpPost("re-send-by-id/{id}")]
-    //public virtual async Task<EquipmentRecordDTO> ReSendByNumberAsync(Guid id)
-    //{
-    //    var EquipmentRecordOld = await _repository.GetAsync(id).ConfigureAwait(false);
-    //    if (EquipmentRecordOld == null)
-    //    {
-    //        throw new UserFriendlyException($"未找到ID为【{id.ToString()}】的数据");
-    //    }
-
-    //    EquipmentRecordOld.Status = EnumEquipmentRecordStatus.Error;
-
-    //    var EquipmentRecordNew = new ExchangeData()
-    //    {
-    //        DataAction = exchangeDataOld.DataAction,
-    //        DataContent = exchangeDataOld.DataContent,
-    //        DataIdentityCode = exchangeDataOld.DataIdentityCode,
-    //        DataType = exchangeDataOld.DataType,
-    //        DestinationSystem = exchangeDataOld.DestinationSystem,
-    //        EffectiveDate = exchangeDataOld.EffectiveDate,
-    //        Remark = exchangeDataOld.Remark,
-    //        SourceSystem = exchangeDataOld.SourceSystem,
-    //        WriteTime = DateTime.Now,
-    //        Writer = null,
-    //    };
-    //    var entityNew= await _repository.InsertAsync(exchangeDataNew).ConfigureAwait(false);
-
-    //    exchangeDataOld.Remark = $"在【{DateTime.Now}】时，重新生成了新的接口数据:ID为【{entityNew.Id}】";
-    //    await _repository.UpdateAsync(exchangeDataOld).ConfigureAwait(false);
-
-    //    return new ExchangeDataDTO() { Id = entityNew.Id };
-    //}
-
-    //[HttpPost("by-batchsize-post")]
-    //public virtual async Task<List<ExchangeDataDTO>> GetToBeProcessedListPostAsync(int batchSize)
-    //{
-    //    var resultList=new List<ExchangeData>();
-
-    //    var entities = await
-    //        (await _repository.GetDbSetAsync().ConfigureAwait(false))
-    //        .Where(p => p.Status == EnumExchangeDataStatus.Unread)
-    //        .OrderBy(p => p.TyrpNumber)
-    //        .Take(batchSize)
-    //        .ToListAsync().ConfigureAwait(false);
-
-    //    foreach (var entity in entities)
-    //    {
-    //        entity.Status = EnumExchangeDataStatus.Success;
-    //        entity.ReadTime = Clock.Now;
-    //        entity.Reader = "DataExchange.Agent";
-    //        resultList.Add(await _repository.UpdateAsync(entity).ConfigureAwait(false));
-    //    }
-
-    //    var dtos = ObjectMapper.Map<List<ExchangeData>, List<ExchangeDataDTO>>(resultList);
-    //    return dtos;
-    //}
-
-    //[HttpPost("by-batchsize-only-read")]
-    //public virtual async Task<List<ExchangeDataDTO>> GetToBeProcessedListOnlyReadAsync(int batchSize)
-    //{
-    //    var entities = await
-    //        (await _repository.GetDbSetAsync().ConfigureAwait(false))
-    //        .Where(p => p.Status == EnumExchangeDataStatus.Unread)
-    //        .OrderBy(p => p.TyrpNumber)
-    //        .Take(batchSize)
-    //        .ToListAsync().ConfigureAwait(false);
-
-    //    var dtos = ObjectMapper.Map<List<ExchangeData>, List<ExchangeDataDTO>>(entities);
-    //    return dtos;
-    //}
-
-    //[HttpPost("update-status-by-id-list")]
-    //public virtual async Task<List<ExchangeDataDTO>> UpdateStatusByIdListAsync(List<Guid> list)
-    //{
-    //    List<ExchangeData> listExchangeDatas = new EditableList<ExchangeData>();
-    //    var resultList = new List<ExchangeData>();
-
-    //    foreach (var id in list)
-    //    {
-    //        listExchangeDatas.Add(await _repository.GetAsync(id).ConfigureAwait(false));
-    //    }
-
-    //    listExchangeDatas.ForEach(p =>
-    //    {
-    //        p.Status = EnumExchangeDataStatus.Success;
-    //        p.ReadTime = Clock.Now;
-    //        p.Reader = "DataExchange.Agent";
-    //    });
-
-    //    foreach (var entity in listExchangeDatas)
-    //    {
-    //        resultList.Add(await _repository.UpdateAsync(entity).ConfigureAwait(false));
-    //    }
-
-    //    var dtos = ObjectMapper.Map<List<ExchangeData>, List<ExchangeDataDTO>>(resultList);
-    //    return dtos;
-    //}
 }

be/Modules/Store/src/Win_in.Sfs.Wms.Store.Domain/Equipments/EquipmentLocCap.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Win_in.Sfs.Shared.Domain;
+
+namespace Win_in.Sfs.Wms.Store.Equipments;
+
+
+public class EquipmentLocCap:SfsAggregateRootBase
+{
+    /// <summary>
+    /// 器具编码
+    /// </summary>
+    public string EqptCode { get; set; }
+    /// <summary>
+    /// 零件号
+    /// </summary>
+    public string PartCode { get; set; }
+    /// <summary>
+    /// 占用百分比
+    /// </summary>
+    public decimal Percent { get; set; }
+
+    /// <summary>
+    /// 录入数量
+    /// </summary>
+    public decimal Qty { get; set; }
+
+    /// <summary>
+    /// 标包数量
+    /// </summary>
+    public decimal StdQty { get; set; }
+
+}

be/Modules/Store/src/Win_in.Sfs.Wms.Store.Domain/Equipments/EquipmentLocCapManager.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Volo.Abp;
+using Volo.Abp.Domain.Services;
+using Win_in.Sfs.Basedata.Application.Contracts;
+using Win_in.Sfs.Shared.Domain.Shared;
+using Win_in.Sfs.Wms.Store.Equipments;
+
+namespace Win_in.Sfs.Wms.Store.Domain;
+
+public class EquipmentLocCapManager : DomainService, IEquipmentLocCapManager
+{
+    private readonly IEquipmentRecordRepository _repository;
+  
+
+    public EquipmentLocCapManager(IEquipmentRecordRepository repository
+     
+        ) 
+    {
+        _repository = repository;
+   
+    }
+  
+
+    public Task ImportDataAsync(List<EquipmentRecord> entities, List<EquipmentRecord> deleteEntities = null)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task ImportDataAsync(List<EquipmentLocCap> entities, List<EquipmentLocCap> deleteEntities = null)
+    {
+        throw new NotImplementedException();
+    }
+
+    private async Task SetDetailAsync(List<PurchaseOrderDetail> details)
+    {
+       
+    }
+}

be/Modules/Store/src/Win_in.Sfs.Wms.Store.Domain/Equipments/EquipmentRecord.cs

@@ -4,10 +4,13 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using Win_in.Sfs.Shared.Domain;
+using Win_in.Sfs.Shared.Domain.Shared.Enums.Store.Statuses;
 
 namespace Win_in.Sfs.Wms.Store.Equipments;
 
-
+/// <summary>
+/// 器具绑定解绑记录
+/// </summary>
 public class EquipmentRecord:SfsAggregateRootBase
 {
     /// <summary>
@@ -27,9 +30,15 @@ public class EquipmentRecord:SfsAggregateRootBase
     /// </summary>
     public string Batch { get; set; }
     /// <summary>
-    /// 库位
+    /// 来源库位
     /// </summary>
-    public string LocCode { get; set; }
+    public string FromLocCode { get; set; }
+
+    /// <summary>
+    /// 目标库位
+    /// </summary>
+    public string ToLocCode { get; set; }
+
     /// <summary>
     /// 数量
     /// </summary>
@@ -41,7 +50,7 @@ public class EquipmentRecord:SfsAggregateRootBase
     /// <summary>
     /// 记录类型
     /// </summary>
-    public int Type { get; set;}
+    public EnumEquipmentRecordType Type { get; set;}
 
 
   

be/Modules/Store/src/Win_in.Sfs.Wms.Store.Domain/Equipments/EquipmentRecordManager.cs

@@ -1,108 +1,219 @@
 using System;
 using System.Collections.Generic;
+
 using System.Linq;
 using System.Threading.Tasks;
-using Volo.Abp;
+using DocumentFormat.OpenXml.Packaging;
 using Volo.Abp.Domain.Services;
 using Win_in.Sfs.Basedata.Application.Contracts;
-using Win_in.Sfs.Shared.Domain.Shared;
+using Win_in.Sfs.Basedata.Domain.Shared;
+using Win_in.Sfs.Basedata.Equipments.DTOs;
+using Win_in.Sfs.Shared.Domain.Shared.Enums.Store.Statuses;
 using Win_in.Sfs.Wms.Store.Equipments;
 
 namespace Win_in.Sfs.Wms.Store.Domain;
 
+
+
+
 public class EquipmentRecordManager : DomainService, IEquipmentRecordManager
 {
     private readonly IEquipmentRecordRepository _repository;
-    //private readonly IPurchaseReceiptNoteManager _purchaseReceiptNoteManager;
-    //private readonly ISupplierAppService _supplierApp;
-    //private readonly IWarehouseAppService _warehouseApp;
-
-    public EquipmentRecordManager(IEquipmentRecordRepository repository
-        //, IPurchaseReceiptNoteManager purchaseReceiptNoteManager
-        //, ISupplierAppService supplierApp
-       // , IWarehouseAppService warehouseApp
+    private readonly IEquipmentLocCapRepository _repositoryCap;
+
+    private readonly IEquipmentLocAppService _locService;
+    private readonly IEquipmentPartCodeAppService _partService;
+
+    public EquipmentRecordManager(
+           IEquipmentRecordRepository repository,
+           IEquipmentLocCapRepository repositoryCap,
+           IEquipmentLocAppService locService,
+           IEquipmentPartCodeAppService partService
         ) 
     {
+        _locService=locService;
         _repository = repository;
-        //_purchaseReceiptNoteManager = purchaseReceiptNoteManager;
-       // _supplierApp = supplierApp;
-       // _warehouseApp = warehouseApp;
+        _repositoryCap = repositoryCap;
+        _partService= partService;
     }
-    /// <summary>
-    ///// 打开订单明细
-    ///// </summary>
-    ///// <returns></returns>
-    //public virtual async Task<bool> CheckIsCloseAsync(string number,string supplierCode, string itemCode)
-    //{
-    //    bool result = false;
-    //    var entitys = await _repository.GetListAsync(p =>p.Number==number && p.Details.Any(y => y.ItemCode == itemCode&&y.LineStatus== EnumOrderStatus.Close) && p.SupplierCode == supplierCode, true).ConfigureAwait(false);
-    //    if (entitys.Count!=0) result = true;
-    //    return result;
-    //}
-    ///// <summary>
-    ///// 打开订单明细
-    ///// </summary>
-    ///// <returns></returns>
-    //public virtual async Task OpenDetailAsync(Guid id, Guid detailId)
-    //{
-    //    var entity = await Repository.GetAsync(id).ConfigureAwait(false);
-    //    Check.NotNull(entity, EntityClassName);
-    //    await entity.OpenDetailAsync(detailId).ConfigureAwait(false);
-    //}
-
-    ///// <summary>
-    ///// 关闭订单明细
-    ///// </summary>
-    ///// <returns></returns>
-    //public virtual async Task CloseDetailAsync(Guid id, Guid detailId)
-    //{
-    //    var entity = await Repository.GetAsync(id).ConfigureAwait(false);
-    //    Check.NotNull(entity, EntityClassName);
-    //    await entity.CloseDetailAsync(detailId).ConfigureAwait(false);
-    //}
-
-    //public override async Task<PurchaseOrder> CreateAsync(PurchaseOrder purchaseOrder)
-    //{
-    //    //接收到新的采购订单时，更新无PO收货单的PoNumber
-    //    //await _purchaseReceiptNoteManager.AppendPoNumberAsync(purchaseOrder).ConfigureAwait(false);
-    //    purchaseOrder.SetIdAndNumberWithDetails(GuidGenerator, purchaseOrder.Number);
-    //    //不要用base.create 要不会把number覆盖
-    //    purchaseOrder = await Repository.InsertAsync(purchaseOrder).ConfigureAwait(false);
-    //    await PublishCreatedAsync(purchaseOrder).ConfigureAwait(false);
-    //    return purchaseOrder;
-
-    //}
-
-    ///// <summary>
-    ///// 执行导入
-    ///// </summary>
-    //public virtual async Task ImportDataAsync(List<EquipmentRecord> mergeEntities, List<EquipmentRecord> deleteEntities = null)
-    //{
-    //    //if (deleteEntities != null && deleteEntities.Count > 0)
-    //    //{
-    //    //    await _repository.BulkDeleteAsync(deleteEntities).ConfigureAwait(false);
-    //    //}
-
-    //    //foreach (var entity in mergeEntities)
-    //    //{
-    //    //    entity.SetIdAndNumberWithDetails(GuidGenerator, await GenerateNumberAsync(nameof(PurchaseOrder), entity.OrderDate).ConfigureAwait(false));
-    //    //}
-
-    //    //await _repository.BulkMergeAsync(mergeEntities).ConfigureAwait(false);
-
-    //    //var insertDetails = new List<PurchaseOrderDetail>();
-
-    //    //foreach (var item in mergeEntities)
-    //    //{
-    //    //    await SetDetailAsync(item.Details).ConfigureAwait(false);
-
-    //    //    insertDetails.AddRange(item.Details);
-    //    //}
-
-    //   // await _repository.BulkInsertAsync(insertDetails).ConfigureAwait(false);
-
-    //}
 
+    public async Task<List<EquipmentRecordErrorDTO>>  Bind(List<EquipmentRecord> p_ls)
+    {
+        List<EquipmentRecordErrorDTO> errors=new List<EquipmentRecordErrorDTO>();
+        var list=  p_ls.GroupBy(p => new { p.EqptCode, p.PartCode }).Select(p=>new { EqptCode=  p.Key.EqptCode, PartCode= p.Key.PartCode,SumQty=p.Sum(p=>p.Qty)});//导入零件
+        var partialErrors1=list.GroupBy(p => p.EqptCode).Where(g =>g.Count()>1).Select(p => new EquipmentRecordErrorDTO() { EqptCode=  p.Key,PartCode=string.Empty,Error=$"同器具代码有{p.Count().ToString()}种零件!"  });
+        errors.AddRange(partialErrors1.ToList());//同容器放不同零件校验
+        var ls=p_ls.Select(p => p.EqptCode).Distinct().ToList();//录入的器具记录代码列表
+        var Locs=_locService.GetEquipmentLocAsync(ls).Result;//获取器具库位关系
+        var parts =_partService.GetEquipmentPartCodesAsync(ls).Result;//获取器具零件关系
+        //零件和器具关系校验
+        var partErrorQery = from itm in list
+                     join itm1 in parts on
+                     new { itm.EqptCode, PartCode = itm.PartCode } equals new { EqptCode = itm1.Code, PartCode = itm1.PartCode }
+                     into temp
+                     from tm in temp.DefaultIfEmpty()
+                     where tm == null
+                     select new EquipmentRecordErrorDTO()
+                     {
+                         EqptCode = itm.EqptCode,
+                         PartCode = itm.PartCode,
+                         Error = $"器具零件关系不存在！"
+                     };
+        errors.AddRange(partErrorQery.ToList());
+        var query= await _repositoryCap.GetQueryableAsync().ConfigureAwait(false);
+        var capExistList= query.Where(p => ls.Contains(p.EqptCode)).ToList();//器具容量
+
+        var partialErrors2 = from itm in capExistList
+                    join itm1 in list.ToList() on itm.EqptCode equals itm1.EqptCode
+                    where itm.PartCode != itm.PartCode
+                    select new EquipmentRecordErrorDTO() {
+                        EqptCode = itm.EqptCode,PartCode=itm.PartCode ,Error=$"录入器具代码{itm.EqptCode}零件代码{itm.PartCode}与器具容量{itm1.EqptCode}零件代码{itm1.PartCode}不符！"
+                    };
+        errors.AddRange(partialErrors2.ToList());//导入记录和容量记录零件不是同一零件
+        var existList = from itm in list
+                        join itm1 in capExistList
+                        on new { itm.EqptCode, itm.PartCode } equals new { itm1.EqptCode, itm1.PartCode }
+                        select itm;
+        foreach (var itm in existList)
+        {
+            var cap = capExistList.FirstOrDefault(p => p.EqptCode == itm.EqptCode && p.PartCode == itm.PartCode);//读取当前器具容量
+            cap.Qty += itm.SumQty;//当前数量
+
+            if (cap.Qty > cap.StdQty)
+            {
+                errors.Add(new EquipmentRecordErrorDTO() { EqptCode=itm.EqptCode,PartCode=itm.PartCode,Error=$"超出容量限制!" });
+            }
+        }
+
+        if (errors.Count > 0)
+        {
+            return errors;
+        }
+        //新建器具容量 
+       var newList =from itm in list
+        join itm1 in capExistList
+        on new { itm.EqptCode, itm.PartCode } equals new { itm1.EqptCode, itm1.PartCode }
+        into temp1
+        from tm1 in temp1.DefaultIfEmpty()
+        where tm1 == null
+        select itm;
+        List<EquipmentLocCap> newlocList=new List<EquipmentLocCap>();
+        foreach (var itm in newList)
+        {
+            var gpart = parts.FirstOrDefault(p => p.Code == itm.EqptCode && p.PartCode == itm.PartCode);
+            var stdQty = gpart.StdQty;//标包
+            var qty = itm.SumQty;
+            var cap = new EquipmentLocCap()
+
+            {
+                 EqptCode=itm.EqptCode,
+                 PartCode=itm.PartCode,
+                 Percent=qty/stdQty,
+                 Qty=qty,
+                 StdQty=stdQty,
+            };
+            cap.SetId(GuidGenerator.Create());
+            newlocList.Add(cap);
+        }
+        //已存在器具容量变更
+      
+        foreach (var itm in existList)
+        {
+            var cap = capExistList.FirstOrDefault(p => p.EqptCode == itm.EqptCode && p.PartCode == itm.PartCode);//读取当前器具容量
+            cap.Qty = cap.Qty+itm.SumQty;//当前数量
+            cap.Percent = cap.Qty / cap.StdQty;
+        }
+
+        foreach (var itm in p_ls)
+        {
+            itm.Type = EnumEquipmentRecordType.Bind;
+            itm.SetId(GuidGenerator.Create());
+        }
+        await _repositoryCap.InsertManyAsync(newlocList).ConfigureAwait(false);   
+        await _repository.InsertManyAsync(p_ls).ConfigureAwait(false);
+
+
+        return errors;
+
+    }
+
+  
+
+
+    public async Task<List<EquipmentRecordErrorDTO>> UnBind(List<EquipmentRecord> p_ls)
+    {
+        List<EquipmentRecordErrorDTO> errors = new List<EquipmentRecordErrorDTO>();
+        var list = p_ls.GroupBy(p => new { p.EqptCode, p.PartCode }).Select(p => new { EqptCode = p.Key.EqptCode, PartCode = p.Key.PartCode, SumQty = p.Sum(p => p.Qty) });//导入零件
+        var partialErrors1 = list.GroupBy(p => p.EqptCode).Where(g => g.Count() > 1).Select(p => new EquipmentRecordErrorDTO() { EqptCode = p.Key, PartCode = string.Empty, Error = $"同器具代码有{p.Count().ToString()}种零件!" });
+        errors.AddRange(partialErrors1.ToList());//同容器放不同零件校验
+        var ls = p_ls.Select(p => p.EqptCode).Distinct().ToList();//录入的器具记录代码列表
+        var Locs = _locService.GetEquipmentLocAsync(ls).Result;//获取器具库位关系
+        var parts = _partService.GetEquipmentPartCodesAsync(ls).Result;//获取器具零件关系
+        //零件和器具关系校验
+        var partErrorQery = from itm in list
+                            join itm1 in parts on
+                            new { itm.EqptCode, PartCode = itm.PartCode } equals new { EqptCode = itm1.Code, PartCode = itm1.PartCode }
+                            into temp
+                            from tm in temp.DefaultIfEmpty()
+                            where tm == null
+                            select new EquipmentRecordErrorDTO()
+                            {
+                                EqptCode = itm.EqptCode,
+                                PartCode = itm.PartCode,
+                                Error = $"器具零件关系不存在！"
+                            };
+        errors.AddRange(partErrorQery.ToList());
+        var query = await _repositoryCap.GetQueryableAsync().ConfigureAwait(false);
+        var capExistList = query.Where(p => ls.Contains(p.EqptCode)).ToList();//器具容量
+
+        var partialErrors2 = from itm in capExistList
+                             join itm1 in list.ToList() on itm.EqptCode equals itm1.EqptCode
+                             where itm.PartCode != itm.PartCode
+                             select new EquipmentRecordErrorDTO()
+                             {
+                                 EqptCode = itm.EqptCode,
+                                 PartCode = itm.PartCode,
+                                 Error = $"录入器具代码{itm.EqptCode}零件代码{itm.PartCode}与器具容量{itm1.EqptCode}零件代码{itm1.PartCode}不符！"
+                             };
+        errors.AddRange(partialErrors2.ToList());//导入记录和器具容量记录零件不是同一零件
+        var existList = from itm in list
+                        join itm1 in capExistList
+                        on new { itm.EqptCode, itm.PartCode } equals new { itm1.EqptCode, itm1.PartCode }
+                        select itm;
+        foreach (var itm in existList)
+        {
+            var cap = capExistList.FirstOrDefault(p => p.EqptCode == itm.EqptCode && p.PartCode == itm.PartCode);//读取当前器具容量
+            cap.Qty =cap.Qty- itm.SumQty;//当前数量
+
+            if (cap.Qty <0)
+            {
+                errors.Add(new EquipmentRecordErrorDTO() { EqptCode = itm.EqptCode, PartCode = itm.PartCode, Error = $"解绑数量小0!" });
+            }
+        }
+
+        foreach (var itm in existList)
+        {
+            var cap = capExistList.FirstOrDefault(p => p.EqptCode == itm.EqptCode && p.PartCode == itm.PartCode);//读取当前器具容量
+            cap.Qty = cap.Qty - itm.SumQty;//当前数量
+            cap.Percent = cap.Qty / cap.StdQty;
+        }
+
+        foreach (var itm in p_ls)
+        {
+            itm.Type = EnumEquipmentRecordType.UnBind;
+            itm.SetId(GuidGenerator.Create());
+        }
+       
+        await _repository.InsertManyAsync(p_ls).ConfigureAwait(false);
+
+
+
+
+
+
+        return errors;
+
+    }
     public Task ImportDataAsync(List<EquipmentRecord> entities, List<EquipmentRecord> deleteEntities = null)
     {
         throw new NotImplementedException();
@@ -110,17 +221,6 @@ public class EquipmentRecordManager : DomainService, IEquipmentRecordManager
 
     private async Task SetDetailAsync(List<PurchaseOrderDetail> details)
     {
-        //foreach (var detail in details)
-        //{
-        //    var item = await ItemBasicAppService.GetByCodeAsync(detail.ItemCode).ConfigureAwait(false);
-        //    Check.NotNull(item, "物品代码", $"物品 {detail.ItemCode} 不存在");
-
-        //    if (item != null)
-        //    {
-        //        detail.ItemName = item.Name;
-        //        detail.ItemDesc1 = item.Desc1;
-        //        detail.ItemDesc2 = item.Desc2;
-        //    }
-        //}
+       
     }
 }

be/Modules/Store/src/Win_in.Sfs.Wms.Store.Domain/Equipments/IEquipmentLocCapManager.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Threading.Tasks;
+using Win_in.Sfs.Shared.Domain;
+using Win_in.Sfs.Wms.Store.Equipments;
+
+namespace Win_in.Sfs.Wms.Store.Domain;
+
+public interface IEquipmentLocCapManager : IBulkImportService<EquipmentLocCap>
+{
+    //Task OpenDetailAsync(Guid id, Guid detailId);
+    //Task CloseDetailAsync(Guid id, Guid detailId);
+    //Task<bool> CheckIsCloseAsync(string number, string supplierCode, string itemCode);
+}

be/Modules/Store/src/Win_in.Sfs.Wms.Store.Domain/Equipments/IEquipmentLocCapRepository.cs

@@ -0,0 +1,10 @@
+using System.Threading.Tasks;
+using Win_in.Sfs.Shared.Domain;
+using Win_in.Sfs.Wms.Store.Equipments;
+
+namespace Win_in.Sfs.Wms.Store.Domain;
+
+public interface IEquipmentLocCapRepository : ISfsStoreRepositoryBase<EquipmentLocCap>, ISfsBulkRepositoryBase<EquipmentLocCap>
+{
+    Task UpsertAsync(EquipmentLocCap newData);
+}

be/Modules/Store/src/Win_in.Sfs.Wms.Store.Domain/Equipments/IEquipmentRecordManager.cs

@@ -1,13 +1,16 @@
 using System;
+using System.Collections.Generic;
 using System.Threading.Tasks;
+using Win_in.Sfs.Basedata.Equipments.DTOs;
 using Win_in.Sfs.Shared.Domain;
 using Win_in.Sfs.Wms.Store.Equipments;
 
 namespace Win_in.Sfs.Wms.Store.Domain;
 
-public interface IEquipmentRecordManager :IBulkImportService<EquipmentRecord>
+public interface IEquipmentRecordManager : IBulkImportService<EquipmentRecord>
 {
-    //Task OpenDetailAsync(Guid id, Guid detailId);
-    //Task CloseDetailAsync(Guid id, Guid detailId);
-    //Task<bool> CheckIsCloseAsync(string number, string supplierCode, string itemCode);
+    Task<List<EquipmentRecordErrorDTO>> Bind(List<EquipmentRecord> p_ls);
+    Task<List<EquipmentRecordErrorDTO>> UnBind(List<EquipmentRecord> p_ls);
+
+
 }

be/Modules/Store/src/Win_in.Sfs.Wms.Store.EntityFrameworkCore/Equipments/EquipmentLocCapDbContextModelCreatingExtensions.cs

@@ -0,0 +1,32 @@
+using Microsoft.EntityFrameworkCore;
+using Volo.Abp.EntityFrameworkCore.Modeling;
+using Win_in.Sfs.Shared.Domain.Shared;
+using Win_in.Sfs.Wms.Store.Domain;
+using Win_in.Sfs.Wms.Store.Equipments;
+
+namespace Win_in.Sfs.Wms.Store.EntityFrameworkCore;
+
+public static class EquipmentLocCapDbContextModelCreatingExtensions
+{
+    public static void ConfigureEquipmentLocCap(this ModelBuilder builder, StoreModelBuilderConfigurationOptions options)
+    {
+        builder.Entity<EquipmentLocCap>(b =>
+        {
+            //Configure table & schema name
+            b.ToTable(options.TablePrefix + nameof(EquipmentLocCap), options.Schema);
+            //Configure ABP properties
+            b.ConfigureByConvention();
+            //Configure Sfs base properties
+            b.ConfigureSfsStoreBase();
+
+            b.Property(q => q.EqptCode).HasMaxLength(SfsPropertyConst.CodeLength);
+         
+            b.Property(q => q.PartCode).HasMaxLength(SfsPropertyConst.CodeLength);
+   
+            b.HasIndex(q => new { q.EqptCode });
+
+        });
+
+      
+    }
+}

be/Modules/Store/src/Win_in.Sfs.Wms.Store.EntityFrameworkCore/Equipments/EquipmentLocCapEfCoreRepository.cs

@@ -0,0 +1,23 @@
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore;
+using Volo.Abp.EntityFrameworkCore;
+using Win_in.Sfs.Shared.Domain;
+using Win_in.Sfs.Wms.Store.Domain;
+using Win_in.Sfs.Wms.Store.Equipments;
+
+namespace Win_in.Sfs.Wms.Store.EntityFrameworkCore;
+
+public class EquipmentLocCapEfCoreRepository : SfsStoreEfCoreRepositoryBase<StoreDbContext, EquipmentLocCap>, IEquipmentLocCapRepository, ISfsBulkRepositoryBase<EquipmentLocCap>
+{
+    public EquipmentLocCapEfCoreRepository(IDbContextProvider<StoreDbContext> dbContextProvider) : base(dbContextProvider)
+    {
+    }
+
+ 
+
+    public Task UpsertAsync(EquipmentLocCap newData)
+    {
+        throw new System.NotImplementedException();
+    }
+}

be/Modules/Store/src/Win_in.Sfs.Wms.Store.EntityFrameworkCore/Equipments/EquipmentRecordDbContextModelCreatingExtensions.cs

@@ -22,11 +22,15 @@ public static class EquipmentRecordDbContextModelCreatingExtensions
             b.Property(q => q.BarCode).HasMaxLength(SfsPropertyConst.CodeLength);
             b.Property(q => q.Batch).HasMaxLength(SfsPropertyConst.CodeLength);
             b.Property(q => q.EqptCode).HasMaxLength(SfsPropertyConst.CodeLength);
-            b.Property(q => q.LocCode).HasMaxLength(SfsPropertyConst.CodeLength);
+            b.Property(q => q.ToLocCode).HasMaxLength(SfsPropertyConst.CodeLength);
+            b.Property(q => q.FromLocCode).HasMaxLength(SfsPropertyConst.CodeLength);
             b.Property(q => q.PartCode).HasMaxLength(SfsPropertyConst.CodeLength);
             b.Property(q => q.Batch).HasMaxLength(SfsPropertyConst.CodeLength);
             b.Property(q => q.Type).HasMaxLength(SfsPropertyConst.CodeLength);
-          
+
+
+
+            b.HasIndex(q => new { q.EqptCode });
 
 
 

be/Modules/Store/src/Win_in.Sfs.Wms.Store.EntityFrameworkCore/StoreDbContextModelCreatingExtensions.cs

@@ -30,7 +30,7 @@ public static class StoreDbContextModelCreatingExtensions
         builder.ConfigureWorkOrder(options);
 
         builder.ConfigureEquipmentRecord(options);
-
+        builder.ConfigureEquipmentLocCap(options);