修复引用报错

duheng

2024-07-18 049e28f3f6bfce2012fa7c34b2ad15c9ae3cf06b

修复引用报错

 BLL/HStation.BLL.Xhs.Core/01-interface/IPumpProject/IXhsProject.cs

ÎļþÒÑɾ³ý

 BLL/HStation.BLL.Xhs.Core/01-interface/IPumpProject/IXhsProjectItem.cs

ÎļþÒÑɾ³ý

 BLL/HStation.BLL.Xhs.Core/01-interface/IPumpProject/IXhsProjectItemModel.cs

ÎļþÒÑɾ³ý

 BLL/HStation.BLL.Xhs.Core/01-interface/IPumpProject/IXhsProjectItemModelMap.cs

ÎļþÒÑɾ³ý

 BLL/HStation.BLL.Xhs.Core/HStation.BLL.Xhs.Core.csproj

@@ -10,13 +10,30 @@
    <ItemGroup>
      <Compile Remove="03-localclient\PumpProduct\**" />
      <Compile Remove="03-localclient\PumpProject\**" />
      <Compile Remove="03-localclient\Pump\**" />
      <Compile Remove="04-bll\01-ProjectItem\**" />
      <Compile Remove="04-bll\02-PumpProdcuct\**" />
      <EmbeddedResource Remove="03-localclient\PumpProduct\**" />
      <EmbeddedResource Remove="03-localclient\PumpProject\**" />
      <EmbeddedResource Remove="03-localclient\Pump\**" />
      <EmbeddedResource Remove="04-bll\01-ProjectItem\**" />
      <EmbeddedResource Remove="04-bll\02-PumpProdcuct\**" />
      <None Remove="03-localclient\PumpProduct\**" />
      <None Remove="03-localclient\PumpProject\**" />
      <None Remove="03-localclient\Pump\**" />
      <None Remove="04-bll\01-ProjectItem\**" />
      <None Remove="04-bll\02-PumpProdcuct\**" />
    </ItemGroup>

    <ItemGroup>
      <Compile Remove="02-httpclient\XhsProject.cs" />
      <Compile Remove="02-httpclient\XhsProjectItem.cs" />
      <Compile Remove="02-httpclient\XhsProjectItemModel.cs" />
      <Compile Remove="02-httpclient\XhsProjectItemModelMap.cs" />
      <Compile Remove="03-localclient\XhsProject.cs" />
      <Compile Remove="03-localclient\XhsProjectItem.cs" />
      <Compile Remove="03-localclient\XhsProjectItemModel.cs" />
      <Compile Remove="03-localclient\XhsProjectItemModelMap.cs" />
    </ItemGroup>

    <ItemGroup>

 HStation.BLL.Assets.Core/00-core/ConfigHelper.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,13 @@
namespace HStation.BLL.Xhs
{
    internal class ConfigHelper
    {
        /// <summary>
        /// 
        /// </summary>
        public static string HttpUrl
        {
            get { return Settings.XhsParasHelper.Xhs.CAL.HttpClient.HttpUrl; }
        }
    }
}

 HStation.BLL.Assets.Core/00-core/Mapper.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,46 @@
using Mapster;

namespace HStation.BLL.Xhs
{
    /// <summary>
    ///
    /// </summary>
    public class Mapper : IRegister
    {
        /// <summary>
        ///
        /// </summary>
        /// <param name="config"></param>
        public void Register(TypeAdapterConfig config)
        {
            #region project

            config.ForType<AddXhsProjectItemInput, Model.XhsProject>()
              .Map(dest => dest.Paras, src => src.Paras)
              .Map(dest => dest.Flags, src => src.Flags)
              .Map(dest => dest.UseStatus, src => Yw.Model.eUseStatus.Enable);

            config.ForType<UpdateXhsProjectInput, Model.XhsProject>()
              .Map(dest => dest.Paras, src => src.Paras)
              .Map(dest => dest.Flags, src => src.Flags);

            config.ForType<Model.XhsProject, XhsProjectItemDto>()
              .Map(dest => dest.Paras, src => src.Paras)
              .Map(dest => dest.Flags, src => src.Flags);

            config.ForType<AddPumpSeriesDto, Model.PumpSeries>()
               .Map(dest => dest.Paras, src => src.Paras)
               .Map(dest => dest.Flags, src => src.Flags);

            config.ForType<UpdatePumpSeriesDto, Model.PumpSeries>()
              .Map(dest => dest.Paras, src => src.Paras)
              .Map(dest => dest.Flags, src => src.Flags);

            config.ForType<Model.PumpSeries, PumpSeriesDto>()
              .Map(dest => dest.Paras, src => src.Paras)
              .Map(dest => dest.Flags, src => src.Flags);

            #endregion project
        }
    }
}

 HStation.BLL.Assets.Core/01-interface/IPumpProduct/IPumpGroup.cs

 HStation.BLL.Assets.Core/01-interface/IPumpProduct/IPumpGroupAndMainMap.cs

 HStation.BLL.Assets.Core/01-interface/IPumpProduct/IPumpMain.cs

 HStation.BLL.Assets.Core/01-interface/IPumpProduct/IPumpMainAndPartMap.cs

 HStation.BLL.Assets.Core/01-interface/IPumpProduct/IPumpPartMain.cs

 HStation.BLL.Assets.Core/01-interface/IPumpProduct/IPumpPartPropContent.cs

 HStation.BLL.Assets.Core/01-interface/IPumpProduct/IPumpSeries.cs

 HStation.BLL.Assets.Core/03-localclient/PumpProduct/PumpGroup.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,283 @@
using HStation.Xhs;
using Yw.Dto;

namespace HStation.CAL.LocalClient
{
    /// <summary>
    /// æŠ¥è­¦ç­‰çº§
    /// </summary>
    public class PumpGroup : IPumpGroup
    {
        private readonly HStation.Service.PumpGroup _service = new();

        #region Query

        /// <summary>
        /// èŽ·å–所有
        /// </summary>
        public async Task<List<PumpGroupDto>> GetAll()
        {
            return await Task.Factory.StartNew(() =>
            {
                var list = _service.GetAll();
                var vm_list = list?.Select(x => new PumpGroupDto(x)).ToList();
                return vm_list;
            });
        }

        /// <summary>
        /// é€šè¿‡ ID èŽ·å–
        /// </summary>
        public async Task<PumpGroupDto> GetByID(long ID)
        {
            return await Task.Factory.StartNew(() =>
            {
                var model = _service.GetByID(ID);
                return model == null ? null : new PumpGroupDto(model);
            });
        }

        /// <summary>
        /// é€šè¿‡ Ids èŽ·å–
        /// </summary>
        public async Task<List<PumpGroupDto>> GetByIds(List<long> Ids)
        {
            return await Task.Factory.StartNew(() =>
            {
                var list = _service.GetByIds(Ids);
                var vm_list = list?.Select(x => new PumpGroupDto(x)).ToList();
                return vm_list;
            });
        }

        #endregion Query

        #region Insert

        /// <summary>
        /// æ’入一条
        /// </summary>
        public async Task<long> Insert(AddPumpGroupDto input)
        {
            return await Task.Factory.StartNew(() =>
            {
                var model = input.Adapt<AddPumpGroupDto, Model.PumpGroup>();
                model.SortCode = _service.GetMaxSortCode() + 1;
                var id = _service.Insert(model);
                return id;
            });
        }

        /// <summary>
        /// æ‰¹é‡æ’å…¥
        /// </summary>
        public async Task<bool> Inserts(List<AddPumpGroupDto> inputList)
        {
            return await Task.Factory.StartNew(() =>
            {
                var list = inputList.Select(x => x.Adapt<AddPumpGroupDto, Model.PumpGroup>()).ToList();
                list.ForEach(x =>
                {
                    x.SortCode = _service.GetMaxSortCode() + 1 + list.IndexOf(x);
                });
                var bol = _service.Inserts(list);
                return bol;
            });
        }

        /// <summary>
        /// å¤§æ‰¹é‡æ’å…¥
        /// </summary>
        public async Task<bool> BulkInserts(List<AddPumpGroupDto> list)
        {
            return await Task.Factory.StartNew(() =>
            {
                return false;
            });
        }

        #endregion Insert

        #region Update

        /// <summary>
        /// æ›´æ–°ä¸€æ¡
        /// </summary>
        public async Task<bool> Update(UpdatePumpGroupDto input)
        {
            return await Task.Factory.StartNew(() =>
            {
                var model = _service.GetByID(input.ID);
                if (model == null)
                {
                    throw YOops.Oh(eResultCode.Alert, InternalErrorCodes.D001, $"ID:{input.ID} æ•°æ®ä¸å­˜åœ¨");
                }

                var rhs = new Model.PumpGroup(model);
                input.Adapt(rhs);
                var bol = _service.Update(rhs);
                return bol;
            });
        }

        /// <summary>
        /// æ‰¹é‡æ›´æ–°
        /// </summary>
        public async Task<bool> Updates(List<UpdatePumpGroupDto> inputList)
        {
            return await Task.Factory.StartNew(() =>
            {
                if (inputList == null || inputList.Count < 1)
                {
                    return false;
                }
                var list = inputList.Select(x => x.Adapt<UpdatePumpGroupDto, Model.PumpGroup>()).ToList();
                var bol = _service.Updates(list);
                return bol;
            });
        }

        /// <summary>
        /// å¤§æ‰¹é‡æ›´æ–°
        /// </summary>
        public async Task<bool> BulkUpdates(List<UpdatePumpGroupDto> list)
        {
            return await Task.Factory.StartNew(() =>
            {
                return false;
            });
        }

        /// <summary>
        /// æ›´æ–°ç¼–码
        /// </summary>
        public async Task<bool> UpdateCode(long ID, string Code)
        {
            return await Task.Factory.StartNew(() =>
            {
                return false;
            });
        }

        /// <summary>
        /// æ›´æ–°æŽ’序码
        /// </summary>
        public async Task<bool> UpdateSortCode(long ID, int SortCode)
        {
            return await Task.Factory.StartNew(() =>
            {
                var bol = _service.UpdateSortCode(ID, SortCode);
                return bol;
            });
        }

        /// <summary>
        /// æ›´æ–°æŽ’序
        /// </summary>
        public async Task<bool> UpdateSorter(List<UpdateSortCodeInput> inputList)
        {
            return await Task.Factory.StartNew(() =>
            {
                var list = inputList.Select(x => x.Adapt<Yw.Model.Sorter>()).ToList();
                var bol = _service.UpdateSorter(list);
                return bol;
            });
        }

        /// <summary>
        /// æ›´æ–° Paras
        /// </summary>
        public async Task<bool> UpdateParas(long ID, Dictionary<string, string> Paras)
        {
            return await Task.Factory.StartNew(() =>
            {
                var bol = _service.UpdateParas(ID, Paras);
                return bol;
            });
        }

        /// <summary>
        /// æ›´æ–° Flags
        /// </summary>
        public async Task<bool> UpdateFlags(long ID, List<string> Flags)
        {
            return await Task.Factory.StartNew(() =>
            {
                var bol = _service.UpdateFlags(ID, Flags);
                return bol;
            });
        }

        /// <summary>
        /// æ›´æ–° TagName
        /// </summary>
        public async Task<bool> UpdateTagName(long ID, string TagName)
        {
            return await Task.Factory.StartNew(() =>
            {
                var bol = _service.UpdateTagName(ID, TagName);
                return bol;
            });
        }

        #endregion Update

        #region Delete

        /// <summary>
        /// é€šè¿‡ ID åˆ é™¤
        /// </summary>
        public async Task<bool> DeleteByID(long ID)
        {
            return await Task.Factory.StartNew(() =>
            {
                var bol = _service.DeleteByID(ID, out string msg);
                if (!bol)
                {
                    throw YOops.Oh(eResultCode.Alert, InternalErrorCodes.D999, msg);
                }
                return true;
            });
        }

        /// <summary>
        /// é€šè¿‡ Ids åˆ é™¤
        /// </summary>
        public async Task<bool> DeleteByIds(List<long> Ids)
        {
            return await Task.Factory.StartNew(() =>
            {
                return false;
            });
        }

        /// <summary>
        /// åˆ é™¤å…¨éƒ¨
        /// </summary>
        /// <returns></returns>
        public async Task<bool> DeleteAll()
        {
            return await Task.Factory.StartNew(() =>
            {
                return false;
            });
        }

        /// <summary>
        /// åˆ é™¤æ‹“展
        /// </summary>
        /// <param name="ID"></param>
        /// <returns></returns>
        public bool DeleteEx(long ID)
        {
            if (ID > 0)
            {
                var bol = _service.DeleteEx(ID);
                return bol;
            }
            return false;
        }

        #endregion Delete
    }
}

 HStation.BLL.Assets.Core/03-localclient/PumpProduct/PumpGroupAndMainMap.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,247 @@
using HStation.Xhs;
using Yw.Dto;

namespace HStation.CAL.LocalClient
{
    /// <summary>
    /// æŠ¥è­¦ç­‰çº§
    /// </summary>
    public class PumpGroupAndMainMap : IPumpGroupAndMainMap
    {
        private readonly HStation.Service.PumpGroupAndMainMap _service = new();

        #region Query

        /// <summary>
        /// èŽ·å–所有
        /// </summary>
        public async Task<List<PumpGroupAndMainMapDto>> GetAll()
        {
            return await Task.Factory.StartNew(() =>
            {
                var list = _service.GetAll();
                var vm_list = list?.Select(x => new PumpGroupAndMainMapDto(x)).ToList();
                return vm_list;
            });
        }

        /// <summary>
        /// é€šè¿‡ ID èŽ·å–
        /// </summary>
        public async Task<PumpGroupAndMainMapDto> GetByID(long ID)
        {
            return await Task.Factory.StartNew(() =>
            {
                var model = _service.GetByID(ID);
                return model == null ? null : new PumpGroupAndMainMapDto(model);
            });
        }

        /// <summary>
        /// é€šè¿‡ ID èŽ·å–
        /// </summary>
        public List<long> GetByGroupID(long ID)
        {
            var model = Service.PumpGroupAndMainMap.GetMainIDByGroupID(ID);
            return model;
        }

        /// <summary>
        /// é€šè¿‡ Ids èŽ·å–
        /// </summary>
        public async Task<List<PumpGroupAndMainMapDto>> GetByIds(List<long> Ids)
        {
            return await Task.Factory.StartNew(() =>
            {
                var list = _service.GetByIds(Ids);
                var vm_list = list?.Select(x => new PumpGroupAndMainMapDto(x)).ToList();
                return vm_list;
            });
        }

        #endregion Query

        #region Insert

        /// <summary>
        /// æ’入一条
        /// </summary>
        public async Task<long> Insert(AddPumpGroupAndMainMapDto input)
        {
            return await Task.Factory.StartNew(() =>
            {
                var model = input.Adapt<AddPumpGroupAndMainMapDto, Model.PumpGroupAndMainMap>();
                var id = _service.Insert(model);
                return id;
            });
        }

        /// <summary>
        /// æ‰¹é‡æ’å…¥
        /// </summary>
        public async Task<bool> Inserts(List<AddPumpGroupAndMainMapDto> inputList)
        {
            return await Task.Factory.StartNew(() =>
            {
                var list = inputList.Select(x => x.Adapt<AddPumpGroupAndMainMapDto, Model.PumpGroupAndMainMap>()).ToList();
                var bol = _service.Inserts(list);
                return bol;
            });
        }

        /// <summary>
        /// å¤§æ‰¹é‡æ’å…¥
        /// </summary>
        public async Task<bool> BulkInserts(List<AddPumpGroupAndMainMapDto> list)
        {
            return await Task.Factory.StartNew(() =>
            {
                return false;
            });
        }

        #endregion Insert

        #region Update

        /// <summary>
        /// æ›´æ–°ä¸€æ¡
        /// </summary>
        public async Task<bool> Update(UpdatePumpGroupAndMainMapDto input)
        {
            return await Task.Factory.StartNew(() =>
            {
                var model = _service.GetByID(input.ID);
                if (model == null)
                {
                    throw YOops.Oh(eResultCode.Alert, InternalErrorCodes.D001, $"ID:{input.ID} æ•°æ®ä¸å­˜åœ¨");
                }

                var rhs = new Model.PumpGroupAndMainMap(model);
                input.Adapt(rhs);
                var bol = _service.Update(rhs);
                return bol;
            });
        }

        /// <summary>
        /// æ‰¹é‡æ›´æ–°
        /// </summary>
        public async Task<bool> Updates(List<UpdatePumpGroupAndMainMapDto> inputList)
        {
            return await Task.Factory.StartNew(() =>
            {
                if (inputList == null || inputList.Count < 1)
                {
                    return false;
                }
                var list = inputList.Select(x => x.Adapt<UpdatePumpGroupAndMainMapDto, Model.PumpGroupAndMainMap>()).ToList();
                var bol = _service.Updates(list);
                return bol;
            });
        }

        /// <summary>
        /// å¤§æ‰¹é‡æ›´æ–°
        /// </summary>
        public async Task<bool> BulkUpdates(List<UpdatePumpGroupAndMainMapDto> list)
        {
            return await Task.Factory.StartNew(() =>
            {
                return false;
            });
        }

        /// <summary>
        /// æ›´æ–°ç¼–码
        /// </summary>
        public async Task<bool> UpdateCode(long ID, string Code)
        {
            return await Task.Factory.StartNew(() =>
            {
                return false;
            });
        }

        /// <summary>
        /// æ›´æ–° Paras
        /// </summary>
        public async Task<bool> UpdateParas(long ID, Dictionary<string, string> Paras)
        {
            return await Task.Factory.StartNew(() =>
            {
                var bol = _service.UpdateParas(ID, Paras);
                return bol;
            });
        }

        /// <summary>
        /// æ›´æ–° Flags
        /// </summary>
        public async Task<bool> UpdateFlags(long ID, List<string> Flags)
        {
            return await Task.Factory.StartNew(() =>
            {
                var bol = _service.UpdateFlags(ID, Flags);
                return bol;
            });
        }

        /// <summary>
        /// æ›´æ–° TagName
        /// </summary>
        public async Task<bool> UpdateTagName(long ID, string TagName)
        {
            return await Task.Factory.StartNew(() =>
            {
                var bol = _service.UpdateTagName(ID, TagName);
                return bol;
            });
        }

        #endregion Update

        #region Delete

        /// <summary>
        /// é€šè¿‡ ID åˆ é™¤
        /// </summary>
        public async Task<bool> DeleteByID(long ID)
        {
            return await Task.Factory.StartNew(() =>
            {
                var bol = _service.DeleteByID(ID, out string msg);
                if (!bol)
                {
                    throw YOops.Oh(eResultCode.Alert, InternalErrorCodes.D999, msg);
                }
                return true;
            });
        }

        /// <summary>
        /// é€šè¿‡ Ids åˆ é™¤
        /// </summary>
        public async Task<bool> DeleteByIds(List<long> Ids)
        {
            return await Task.Factory.StartNew(() =>
            {
                return false;
            });
        }

        /// <summary>
        /// åˆ é™¤å…¨éƒ¨
        /// </summary>
        /// <returns></returns>
        public async Task<bool> DeleteAll()
        {
            return await Task.Factory.StartNew(() =>
            {
                return false;
            });
        }

        #endregion Delete
    }
}

 HStation.BLL.Assets.Core/03-localclient/PumpProduct/PumpMain.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,316 @@
using HStation.Xhs;
using Mapster;
using Yw.Dto;

namespace HStation.CAL.LocalClient
{
    /// <summary>
    /// æŠ¥è­¦ç­‰çº§
    /// </summary>
    public class PumpMain : IPumpMain
    {
        private readonly HStation.Service.PumpMain _service = new();

        #region Query

        /// <summary>
        /// èŽ·å–所有
        /// </summary>
        public async Task<List<PumpMainDto>> GetAll()
        {
            return await Task.Factory.StartNew(() =>
            {
                var list = _service.GetAll();
                var vm_list = list?.Select(x => new PumpMainDto(x)).ToList();
                return vm_list;
            });
        }

        /// <summary>
        /// é€šè¿‡ ID èŽ·å–
        /// </summary>
        public async Task<PumpMainDto> GetByID(long ID)
        {
            return await Task.Factory.StartNew(() =>
            {
                var model = _service.GetByID(ID);
                return model == null ? null : new PumpMainDto(model);
            });
        }

        /// <summary>
        /// é€šè¿‡ Ids èŽ·å–
        /// </summary>
        public async Task<List<PumpMainDto>> GetByIds(List<long> Ids)
        {
            return await Task.Factory.StartNew(() =>
            {
                var list = _service.GetByIds(Ids);
                var vm_list = list?.Select(x => new PumpMainDto(x)).ToList();
                return vm_list;
            });
        }

        /// <summary>
        /// é€šè¿‡ ç³»åˆ—ID èŽ·å–
        /// </summary>
        public async Task<List<PumpMainDto>> GetByPumpSeriesID(long ID)
        {
            return await Task.Factory.StartNew(() =>
            {
                var list = _service.GetByPumpSeriesID(ID);
                var vm_list = list?.Select(x => new PumpMainDto(x)).ToList();
                return vm_list;
            });
        }

        #endregion Query

        #region Insert

        /// <summary>
        /// æ’入一条
        /// </summary>
        public async Task<long> Insert(AddPumpMainDto input)
        {
            return await Task.Factory.StartNew(() =>
            {
                var model = input.Adapt<AddPumpMainDto, Model.PumpMain>();
                model.SortCode = _service.GetMaxSortCode() + 1;
                var id = _service.Insert(model);
                return id;
            });
        }

        /// <summary>
        /// æ’入拓展(插入型号和映射表)
        /// </summary>
        public async Task<long> InsertEx(AddPumpMainDto input, AddPumpGroupAndMainMapDto mainmap, AddPumpPartMainDto part, List<AddPumpPropContentDto> content, AddPumpMainAndPartMapDto partmap)
        {
            return await Task.Factory.StartNew(() =>
            {
                var mainmodel = input.Adapt<AddPumpMainDto, Model.PumpMain>();
                var mainmapmodel = mainmap.Adapt<AddPumpGroupAndMainMapDto, Model.PumpGroupAndMainMap>();
                mainmodel.SortCode = _service.GetMaxSortCode() + 1;
                var partmodel = part.Adapt<AddPumpPartMainDto, Model.PumpPartMain>();
                var contentlist = content.Select(x => x.Adapt<AddPumpPropContentDto, Model.PumpPropContent>()).ToList();
                var partmapmodel = partmap.Adapt<AddPumpMainAndPartMapDto, Model.PumpMainAndPartMap>();
                var id = _service.InsertEx(mainmodel, mainmapmodel, partmodel, contentlist, partmapmodel);
                return id;
            });
        }

        /// <summary>
        /// æ‰¹é‡æ’å…¥
        /// </summary>
        public async Task<bool> Inserts(List<AddPumpMainDto> inputList)
        {
            return await Task.Factory.StartNew(() =>
            {
                var list = inputList.Select(x => x.Adapt<AddPumpMainDto, Model.PumpMain>()).ToList();
                list.ForEach(x =>
                {
                    x.SortCode = _service.GetMaxSortCode() + 1 + list.IndexOf(x);
                });
                var bol = _service.Inserts(list);
                return bol;
            });
        }

        /// <summary>
        /// å¤§æ‰¹é‡æ’å…¥
        /// </summary>
        public async Task<bool> BulkInserts(List<AddPumpMainDto> list)
        {
            return await Task.Factory.StartNew(() =>
            {
                return false;
            });
        }

        #endregion Insert

        #region Update

        /// <summary>
        /// æ›´æ–°ä¸€æ¡
        /// </summary>
        public async Task<bool> Update(UpdatePumpMainDto input)
        {
            return await Task.Factory.StartNew(() =>
            {
                var model = _service.GetByID(input.ID);
                if (model == null)
                {
                    throw YOops.Oh(eResultCode.Alert, InternalErrorCodes.D001, $"ID:{input.ID} æ•°æ®ä¸å­˜åœ¨");
                }

                var rhs = new Model.PumpMain(model);
                input.Adapt(rhs);
                var bol = _service.Update(rhs);
                return bol;
            });
        }

        /// <summary>
        /// æ‰¹é‡æ›´æ–°
        /// </summary>
        public async Task<bool> Updates(List<UpdatePumpMainDto> inputList)
        {
            return await Task.Factory.StartNew(() =>
            {
                if (inputList == null || inputList.Count < 1)
                {
                    return false;
                }
                var list = inputList.Select(x => x.Adapt<UpdatePumpMainDto, Model.PumpMain>()).ToList();
                var bol = _service.Updates(list);
                return bol;
            });
        }

        /// <summary>
        /// å¤§æ‰¹é‡æ›´æ–°
        /// </summary>
        public async Task<bool> BulkUpdates(List<UpdatePumpMainDto> list)
        {
            return await Task.Factory.StartNew(() =>
            {
                return false;
            });
        }

        /// <summary>
        /// æ›´æ–°ç¼–码
        /// </summary>
        public async Task<bool> UpdateCode(long ID, string Code)
        {
            return await Task.Factory.StartNew(() =>
            {
                return false;
            });
        }

        /// <summary>
        /// æ›´æ–°æŽ’序码
        /// </summary>
        public async Task<bool> UpdateSortCode(long ID, int SortCode)
        {
            return await Task.Factory.StartNew(() =>
            {
                var bol = _service.UpdateSortCode(ID, SortCode);
                return bol;
            });
        }

        /// <summary>
        /// æ›´æ–°æŽ’序
        /// </summary>
        public async Task<bool> UpdateSorter(List<UpdateSortCodeInput> inputList)
        {
            return await Task.Factory.StartNew(() =>
            {
                var list = inputList.Select(x => x.Adapt<Yw.Model.Sorter>()).ToList();
                var bol = _service.UpdateSorter(list);
                return bol;
            });
        }

        /// <summary>
        /// æ›´æ–° Paras
        /// </summary>
        public async Task<bool> UpdateParas(long ID, Dictionary<string, string> Paras)
        {
            return await Task.Factory.StartNew(() =>
            {
                var bol = _service.UpdateParas(ID, Paras);
                return bol;
            });
        }

        /// <summary>
        /// æ›´æ–° Flags
        /// </summary>
        public async Task<bool> UpdateFlags(long ID, List<string> Flags)
        {
            return await Task.Factory.StartNew(() =>
            {
                var bol = _service.UpdateFlags(ID, Flags);
                return bol;
            });
        }

        /// <summary>
        /// æ›´æ–° TagName
        /// </summary>
        public async Task<bool> UpdateTagName(long ID, string TagName)
        {
            return await Task.Factory.StartNew(() =>
            {
                var bol = _service.UpdateTagName(ID, TagName);
                return bol;
            });
        }

        #endregion Update

        #region Delete

        /// <summary>
        /// é€šè¿‡ ID åˆ é™¤
        /// </summary>
        public async Task<bool> DeleteByID(long ID)
        {
            return await Task.Factory.StartNew(() =>
            {
                var bol = _service.DeleteByID(ID, out string msg);
                if (!bol)
                {
                    throw YOops.Oh(eResultCode.Alert, InternalErrorCodes.D999, msg);
                }
                return true;
            });
        }

        /// <summary>
        /// é€šè¿‡ç³»åˆ— ID åˆ é™¤ è‡ªèº«åŠmap映射表中ID
        /// </summary>
        public async Task<bool> DeleteMapByMainID(long ID)
        {
            return await Task.Factory.StartNew(() =>
            {
                var bol = _service.DeleteByMainIDEx(ID);
                if (!bol)
                {
                    return false;
                }
                return true;
            });
        }

        /// <summary>
        /// é€šè¿‡ Ids åˆ é™¤
        /// </summary>
        public async Task<bool> DeleteByIds(List<long> Ids)
        {
            return await Task.Factory.StartNew(() =>
            {
                return false;
            });
        }

        /// <summary>
        /// åˆ é™¤å…¨éƒ¨
        /// </summary>
        /// <returns></returns>
        public async Task<bool> DeleteAll()
        {
            return await Task.Factory.StartNew(() =>
            {
                return false;
            });
        }

        #endregion Delete
    }
}

 HStation.BLL.Assets.Core/03-localclient/PumpProduct/PumpSeries.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,291 @@
using HStation.Xhs;
using Yw.Dto;

namespace HStation.CAL.LocalClient
{
    /// <summary>
    /// æŠ¥è­¦ç­‰çº§
    /// </summary>
    public class PumpSeries : IPumpSeries
    {
        private readonly HStation.Service.PumpSeries _service = new();

        #region Query

        /// <summary>
        /// èŽ·å–所有
        /// </summary>
        public async Task<List<PumpSeriesDto>> GetAll()
        {
            return await Task.Factory.StartNew(() =>
            {
                var list = _service.GetAll();
                var vm_list = list?.Select(x => new PumpSeriesDto(x)).ToList();
                return vm_list;
            });
        }

        /// <summary>
        /// é€šè¿‡ ID èŽ·å–
        /// </summary>
        public async Task<PumpSeriesDto> GetByID(long ID)
        {
            return await Task.Factory.StartNew(() =>
            {
                var model = _service.GetByID(ID);
                return model == null ? null : new PumpSeriesDto(model);
            });
        }

        /// <summary>
        /// é€šè¿‡ Ids èŽ·å–
        /// </summary>
        public async Task<List<PumpSeriesDto>> GetByIds(List<long> Ids)
        {
            return await Task.Factory.StartNew(() =>
            {
                var list = _service.GetByIds(Ids);
                var vm_list = list?.Select(x => new PumpSeriesDto(x)).ToList();
                return vm_list;
            });
        }

        #endregion Query

        #region Insert

        /// <summary>
        /// æ’入一条
        /// </summary>
        public async Task<long> Insert(AddPumpSeriesDto input)
        {
            return await Task.Factory.StartNew(() =>
            {
                var model = input.Adapt<AddPumpSeriesDto, Model.PumpSeries>();
                model.SortCode = _service.GetMaxSortCode() + 1;
                var id = _service.Insert(model);
                return id;
            });
        }

        /// <summary>
        /// æ‰¹é‡æ’å…¥
        /// </summary>
        public async Task<bool> Inserts(List<AddPumpSeriesDto> inputList)
        {
            return await Task.Factory.StartNew(() =>
            {
                var list = inputList.Select(x => x.Adapt<AddPumpSeriesDto, Model.PumpSeries>()).ToList();
                list.ForEach(x =>
                {
                    x.SortCode = _service.GetMaxSortCode() + 1 + list.IndexOf(x);
                });
                var bol = _service.Inserts(list);
                return bol;
            });
        }

        /// <summary>
        /// å¤§æ‰¹é‡æ’å…¥
        /// </summary>
        public async Task<bool> BulkInserts(List<AddPumpSeriesDto> list)
        {
            return await Task.Factory.StartNew(() =>
            {
                return false;
            });
        }

        #endregion Insert

        #region Update

        /// <summary>
        /// æ›´æ–°ä¸€æ¡
        /// </summary>
        public async Task<bool> Update(UpdatePumpSeriesDto input)
        {
            return await Task.Factory.StartNew(() =>
            {
                var model = _service.GetByID(input.ID);
                if (model == null)
                {
                    throw YOops.Oh(eResultCode.Alert, InternalErrorCodes.D001, $"ID:{input.ID} æ•°æ®ä¸å­˜åœ¨");
                }

                var rhs = new Model.PumpSeries(model);
                input.Adapt(rhs);
                var bol = _service.Update(rhs);
                return bol;
            });
        }

        /// <summary>
        /// æ‰¹é‡æ›´æ–°
        /// </summary>
        public async Task<bool> Updates(List<UpdatePumpSeriesDto> inputList)
        {
            return await Task.Factory.StartNew(() =>
            {
                if (inputList == null || inputList.Count < 1)
                {
                    return false;
                }
                var list = inputList.Select(x => x.Adapt<UpdatePumpSeriesDto, Model.PumpSeries>()).ToList();
                var bol = _service.Updates(list);
                return bol;
            });
        }

        /// <summary>
        /// å¤§æ‰¹é‡æ›´æ–°
        /// </summary>
        public async Task<bool> BulkUpdates(List<UpdatePumpSeriesDto> list)
        {
            return await Task.Factory.StartNew(() =>
            {
                return false;
            });
        }

        /// <summary>
        /// æ›´æ–°ç¼–码
        /// </summary>
        public async Task<bool> UpdateCode(long ID, string Code)
        {
            return await Task.Factory.StartNew(() =>
            {
                return false;
            });
        }

        /// <summary>
        /// æ›´æ–°æŽ’序码
        /// </summary>
        public async Task<bool> UpdateSortCode(long ID, int SortCode)
        {
            return await Task.Factory.StartNew(() =>
            {
                var bol = _service.UpdateSortCode(ID, SortCode);
                return bol;
            });
        }

        /// <summary>
        /// æ›´æ–°æŽ’序
        /// </summary>
        public async Task<bool> UpdateSorter(List<UpdateSortCodeInput> inputList)
        {
            return await Task.Factory.StartNew(() =>
            {
                var list = inputList.Select(x => x.Adapt<Yw.Model.Sorter>()).ToList();
                var bol = _service.UpdateSorter(list);
                return bol;
            });
        }

        /// <summary>
        /// æ›´æ–° Paras
        /// </summary>
        public async Task<bool> UpdateParas(long ID, Dictionary<string, string> Paras)
        {
            return await Task.Factory.StartNew(() =>
            {
                var bol = _service.UpdateParas(ID, Paras);
                return bol;
            });
        }

        /// <summary>
        /// æ›´æ–° Flags
        /// </summary>
        public async Task<bool> UpdateFlags(long ID, List<string> Flags)
        {
            return await Task.Factory.StartNew(() =>
            {
                var bol = _service.UpdateFlags(ID, Flags);
                return bol;
            });
        }

        /// <summary>
        /// æ›´æ–° TagName
        /// </summary>
        public async Task<bool> UpdateTagName(long ID, string TagName)
        {
            return await Task.Factory.StartNew(() =>
            {
                var bol = _service.UpdateTagName(ID, TagName);
                return bol;
            });
        }

        /// <summary>
        /// æ›´æ–° UseStatus
        /// </summary>
        public async Task<bool> UpdateUseStatus(long ID, int UseStatus)
        {
            return await Task.Factory.StartNew(() =>
            {
                var bol = _service.UpdateUseStatus(ID, (Yw.Model.eUseStatus)UseStatus);
                return bol;
            });
        }

        #endregion Update

        #region Delete

        /// <summary>
        /// é€šè¿‡ ID åˆ é™¤
        /// </summary>
        public async Task<bool> DeleteByID(long ID)
        {
            return await Task.Factory.StartNew(() =>
            {
                var bol = _service.DeleteByID(ID, out string msg);
                if (!bol)
                {
                    throw YOops.Oh(eResultCode.Alert, InternalErrorCodes.D999, msg);
                }
                return true;
            });
        }

        /// <summary>
        /// é€šè¿‡ Ids åˆ é™¤
        /// </summary>
        public async Task<bool> DeleteByIds(List<long> Ids)
        {
            return await Task.Factory.StartNew(() =>
            {
                return false;
            });
        }

        /// <summary>
        /// åˆ é™¤å…¨éƒ¨
        /// </summary>
        /// <returns></returns>
        public async Task<bool> DeleteAll()
        {
            return await Task.Factory.StartNew(() =>
            {
                return false;
            });
        }

        //删除拓展(删除系列下所有内容)
        public bool DeleteEx(long ID)
        {
            if (ID > 0)
            {
                var bol = _service.DeleteEx(ID);
                return bol;
            }
            return false;
        }

        #endregion Delete
    }
}

 HStation.BLL.Assets.Core/04-bll/00-core/CALCreateHelper.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,19 @@
namespace HStation.BLL.Xhs
{
    /// <summary>
    /// CAL辅助类
    /// </summary>
    internal class CALCreateHelper
    {
        /// <summary>
        /// åˆ›å»ºDAL
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public static T CreateCAL<T>()
        {
            var type = Settings.XhsParasHelper.Xhs.CAL.CALType;
            return Yw.CALFactory.CreateCAL<T>(type);
        }
    }
}

 HStation.BLL.Assets.Core/04-bll/01-PumpProdcuct/01-PumpSeries/PumpSeries.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,183 @@
using HStation.CAL;
using HStation.DAL;
using Yw.CAL;
using Yw.DAL.Basic;

namespace HStation.BLL
{
    /// <summary>
    ///
    /// </summary>
    public class PumpSeries : CAL.IPumpSeries
    {
        private readonly HStation.CAL.IPumpSeries _cal = CALCreateHelper.CreateCAL<HStation.CAL.IPumpSeries>();

        #region Query

        /// <summary>
        ///
        /// </summary>
        public async Task<List<PumpSeriesDto>> GetAll()
        {
            return await _cal.GetAll();
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<PumpSeriesDto> GetByID(long ID)
        {
            return await _cal.GetByID(ID);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<List<PumpSeriesDto>> GetByIds(List<long> Ids)
        {
            return await _cal.GetByIds(Ids);
        }

        #endregion Query

        #region Insert

        /// <summary>
        ///
        /// </summary>
        public async Task<long> Insert(AddPumpSeriesDto model)
        {
            return await _cal.Insert(model);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> Inserts(List<AddPumpSeriesDto> list)
        {
            return await _cal.Inserts(list);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> BulkInserts(List<AddPumpSeriesDto> list)
        {
            return await _cal.BulkInserts(list);
        }

        #endregion Insert

        #region Update

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> Update(UpdatePumpSeriesDto model)
        {
            return await _cal.Update(model);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> Updates(List<UpdatePumpSeriesDto> list)
        {
            return await _cal.Updates(list);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> BulkUpdates(List<UpdatePumpSeriesDto> list)
        {
            return await _cal.BulkUpdates(list);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> UpdateSortCode(long ID, int SortCode)
        {
            return await _cal.UpdateSortCode(ID, SortCode);
        }

        public async Task<bool> UpdateSorter(List<UpdateSortCodeInput> Sorters)
        {
            return await _cal.UpdateSorter(Sorters);
        }

        /// <summary>
        ///
        /// </summary>
        public Task<bool> UpdateParas(long ID, Dictionary<string, string> Paras)
        {
            return _cal.UpdateParas(ID, Paras);
        }

        /// <summary>
        ///
        /// </summary>
        public Task<bool> UpdateFlags(long ID, List<string> Flags)
        {
            return _cal.UpdateFlags(ID, Flags);
        }

        /// <summary>
        ///
        /// </summary>
        public Task<bool> UpdateTagName(long ID, string TagName)
        {
            return _cal.UpdateTagName(ID, TagName);
        }

        #endregion Update

        #region Delete

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> DeleteByID(long ID)
        {
            return await _cal.DeleteByID(ID);
        }

        /// <summary>
        /// åˆ é™¤æ‹“展
        /// </summary>
        /// <param name="ID"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public bool DeleteEx(long ID)
        {
            return _cal.DeleteEx(ID);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> DeleteByIds(List<long> Ids)
        {
            return await _cal.DeleteByIds(Ids);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> DeleteAll()
        {
            return await _cal.DeleteAll();
        }

        /// <summary>
        ///
        /// </summary>
        public Task<bool> UpdateUseStatus(long ID, int UseStatus)
        {
            return _cal.UpdateUseStatus(ID, UseStatus);
        }

        #endregion Delete
    }
}

 HStation.BLL.Assets.Core/04-bll/01-PumpProdcuct/02-PumpGroup/PumpGroup.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,164 @@
namespace HStation.BLL
{
    /// <summary>
    ///
    /// </summary>
    public class PumpGroup : CAL.IPumpGroup
    {
        private readonly HStation.CAL.IPumpGroup _cal = CALCreateHelper.CreateCAL<HStation.CAL.IPumpGroup>();

        #region Query

        /// <summary>
        ///
        /// </summary>
        public async Task<List<PumpGroupDto>> GetAll()
        {
            return await _cal.GetAll();
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<PumpGroupDto> GetByID(long ID)
        {
            return await _cal.GetByID(ID);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<List<PumpGroupDto>> GetByIds(List<long> Ids)
        {
            return await _cal.GetByIds(Ids);
        }

        #endregion Query

        #region Insert

        /// <summary>
        ///
        /// </summary>
        public async Task<long> Insert(AddPumpGroupDto model)
        {
            return await _cal.Insert(model);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> Inserts(List<AddPumpGroupDto> list)
        {
            return await _cal.Inserts(list);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> BulkInserts(List<AddPumpGroupDto> list)
        {
            return await _cal.BulkInserts(list);
        }

        #endregion Insert

        #region Update

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> Update(UpdatePumpGroupDto model)
        {
            return await _cal.Update(model);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> Updates(List<UpdatePumpGroupDto> list)
        {
            return await _cal.Updates(list);
        }

        public bool DeleteEx(long ID)
        {
            return _cal.DeleteEx(ID);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> BulkUpdates(List<UpdatePumpGroupDto> list)
        {
            return await _cal.BulkUpdates(list);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> UpdateSortCode(long ID, int SortCode)
        {
            return await _cal.UpdateSortCode(ID, SortCode);
        }

        public async Task<bool> UpdateSorter(List<UpdateSortCodeInput> Sorters)
        {
            return await _cal.UpdateSorter(Sorters);
        }

        /// <summary>
        ///
        /// </summary>
        public Task<bool> UpdateParas(long ID, Dictionary<string, string> Paras)
        {
            return _cal.UpdateParas(ID, Paras);
        }

        /// <summary>
        ///
        /// </summary>
        public Task<bool> UpdateFlags(long ID, List<string> Flags)
        {
            return _cal.UpdateFlags(ID, Flags);
        }

        /// <summary>
        ///
        /// </summary>
        public Task<bool> UpdateTagName(long ID, string TagName)
        {
            return _cal.UpdateTagName(ID, TagName);
        }

        #endregion Update

        #region Delete

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> DeleteByID(long ID)
        {
            return await _cal.DeleteByID(ID);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> DeleteByIds(List<long> Ids)
        {
            return await _cal.DeleteByIds(Ids);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> DeleteAll()
        {
            return await _cal.DeleteAll();
        }

        #endregion Delete
    }
}

 HStation.BLL.Assets.Core/04-bll/01-PumpProdcuct/03-PumpMain/PumpMain.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,184 @@
namespace HStation.BLL
{
    /// <summary>
    ///
    /// </summary>
    public class PumpMain : CAL.IPumpMain
    {
        private readonly HStation.CAL.IPumpMain _cal = CALCreateHelper.CreateCAL<HStation.CAL.IPumpMain>();

        #region Query

        /// <summary>
        ///
        /// </summary>
        public async Task<List<PumpMainDto>> GetAll()
        {
            return await _cal.GetAll();
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<PumpMainDto> GetByID(long ID)
        {
            return await _cal.GetByID(ID);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<List<PumpMainDto>> GetByIds(List<long> Ids)
        {
            return await _cal.GetByIds(Ids);
        }

        #endregion Query

        #region Insert

        /// <summary>
        ///
        /// </summary>
        public async Task<long> Insert(AddPumpMainDto model)
        {
            return await _cal.Insert(model);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> Inserts(List<AddPumpMainDto> list)
        {
            return await _cal.Inserts(list);
        }

        /// <summary>
        /// æ’入拓展
        /// </summary>
        /// <param name="input"></param>
        /// <param name="map"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public async Task<long> InsertEx(AddPumpMainDto input, AddPumpGroupAndMainMapDto map)
        {
            return await _cal.InsertEx(input, map);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> BulkInserts(List<AddPumpMainDto> list)
        {
            return await _cal.BulkInserts(list);
        }

        #endregion Insert

        #region Update

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> Update(UpdatePumpMainDto model)
        {
            return await _cal.Update(model);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> Updates(List<UpdatePumpMainDto> list)
        {
            return await _cal.Updates(list);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> BulkUpdates(List<UpdatePumpMainDto> list)
        {
            return await _cal.BulkUpdates(list);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> UpdateSortCode(long ID, int SortCode)
        {
            return await _cal.UpdateSortCode(ID, SortCode);
        }

        public async Task<bool> UpdateSorter(List<UpdateSortCodeInput> Sorters)
        {
            return await _cal.UpdateSorter(Sorters);
        }

        /// <summary>
        ///
        /// </summary>
        public Task<bool> UpdateParas(long ID, Dictionary<string, string> Paras)
        {
            return _cal.UpdateParas(ID, Paras);
        }

        /// <summary>
        ///
        /// </summary>
        public Task<bool> UpdateFlags(long ID, List<string> Flags)
        {
            return _cal.UpdateFlags(ID, Flags);
        }

        /// <summary>
        ///
        /// </summary>
        public Task<bool> UpdateTagName(long ID, string TagName)
        {
            return _cal.UpdateTagName(ID, TagName);
        }

        #endregion Update

        #region Delete

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> DeleteByID(long ID)
        {
            return await _cal.DeleteByID(ID);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> DeleteByIds(List<long> Ids)
        {
            return await _cal.DeleteByIds(Ids);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> DeleteAll()
        {
            return await _cal.DeleteAll();
        }

        public async Task<List<PumpMainDto>> GetByPumpSeriesID(long ID)
        {
            return await _cal.GetByPumpSeriesID(ID);
        }

        /// <summary>
        ///通过型号ID删除Map中对应数据
        /// </summary>
        public async Task<bool> DeleteMapByMainID(long ID)
        {
            return await _cal.DeleteMapByMainID(ID);
        }

        #endregion Delete
    }
}

 HStation.BLL.Assets.Core/04-bll/01-PumpProdcuct/04-PumpGroupAndMainMap/PumpGroupAndMainMap.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,152 @@
namespace HStation.BLL
{
    /// <summary>
    ///
    /// </summary>
    public class PumpGroupAndMainMap : CAL.IPumpGroupAndMainMap
    {
        private readonly HStation.CAL.IPumpGroupAndMainMap _cal = CALCreateHelper.CreateCAL<HStation.CAL.IPumpGroupAndMainMap>();

        #region Query

        /// <summary>
        ///
        /// </summary>
        public async Task<List<PumpGroupAndMainMapDto>> GetAll()
        {
            return await _cal.GetAll();
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<PumpGroupAndMainMapDto> GetByID(long ID)
        {
            return await _cal.GetByID(ID);
        }

        //通过组Id查找返回型号 ID
        public List<long> GetByGroupID(long ID)
        {
            return _cal.GetByGroupID(ID);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<List<PumpGroupAndMainMapDto>> GetByIds(List<long> Ids)
        {
            return await _cal.GetByIds(Ids);
        }

        #endregion Query

        #region Insert

        /// <summary>
        ///
        /// </summary>
        public async Task<long> Insert(AddPumpGroupAndMainMapDto model)
        {
            return await _cal.Insert(model);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> Inserts(List<AddPumpGroupAndMainMapDto> list)
        {
            return await _cal.Inserts(list);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> BulkInserts(List<AddPumpGroupAndMainMapDto> list)
        {
            return await _cal.BulkInserts(list);
        }

        #endregion Insert

        #region Update

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> Update(UpdatePumpGroupAndMainMapDto model)
        {
            return await _cal.Update(model);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> Updates(List<UpdatePumpGroupAndMainMapDto> list)
        {
            return await _cal.Updates(list);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> BulkUpdates(List<UpdatePumpGroupAndMainMapDto> list)
        {
            return await _cal.BulkUpdates(list);
        }

        /// <summary>
        ///
        /// </summary>
        public Task<bool> UpdateParas(long ID, Dictionary<string, string> Paras)
        {
            return _cal.UpdateParas(ID, Paras);
        }

        /// <summary>
        ///
        /// </summary>
        public Task<bool> UpdateFlags(long ID, List<string> Flags)
        {
            return _cal.UpdateFlags(ID, Flags);
        }

        /// <summary>
        ///
        /// </summary>
        public Task<bool> UpdateTagName(long ID, string TagName)
        {
            return _cal.UpdateTagName(ID, TagName);
        }

        #endregion Update

        #region Delete

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> DeleteByID(long ID)
        {
            return await _cal.DeleteByID(ID);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> DeleteByIds(List<long> Ids)
        {
            return await _cal.DeleteByIds(Ids);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> DeleteAll()
        {
            return await _cal.DeleteAll();
        }

        #endregion Delete
    }
}

 HStation.BLL.Assets.Core/04-bll/01-PumpProdcuct/05-PumpPartMain/PumpPartMain.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,122 @@
namespace HStation.BLL
{
    /// <summary>
    ///
    /// </summary>
    public class PumpPartMain : CAL.IPumpPartMain
    {
        private readonly HStation.CAL.IPumpPartMain _cal = CALCreateHelper.CreateCAL<HStation.CAL.IPumpPartMain>();

        #region Query

        /// <summary>
        ///
        /// </summary>
        public async Task<List<PumpPartMainDto>> GetAll()
        {
            return await _cal.GetAll();
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<PumpPartMainDto> GetByID(long ID)
        {
            return await _cal.GetByID(ID);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<List<PumpPartMainDto>> GetByIds(List<long> Ids)
        {
            return await _cal.GetByIds(Ids);
        }

        #endregion Query

        #region Insert

        /// <summary>
        ///
        /// </summary>
        public async Task<long> Insert(AddPumpPartMainDto model)
        {
            return await _cal.Insert(model);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> Inserts(List<AddPumpPartMainDto> list)
        {
            return await _cal.Inserts(list);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> BulkInserts(List<AddPumpPartMainDto> list)
        {
            return await _cal.BulkInserts(list);
        }

        #endregion Insert

        #region Update

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> Update(UpdatePumpPartMainDto model)
        {
            return await _cal.Update(model);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> Updates(List<UpdatePumpPartMainDto> list)
        {
            return await _cal.Updates(list);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> BulkUpdates(List<UpdatePumpPartMainDto> list)
        {
            return await _cal.BulkUpdates(list);
        }

        #endregion Update

        #region Delete

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> DeleteByID(long ID)
        {
            return await _cal.DeleteByID(ID);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> DeleteByIds(List<long> Ids)
        {
            return await _cal.DeleteByIds(Ids);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> DeleteAll()
        {
            return await _cal.DeleteAll();
        }

        #endregion Delete
    }
}

 HStation.BLL.Assets.Core/04-bll/01-PumpProdcuct/06-PumpPropContent/PumpPartPropContent.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,122 @@
namespace HStation.BLL
{
    /// <summary>
    ///
    /// </summary>
    public class PumpPartPropContent : CAL.IPumpPartPropContent
    {
        private readonly HStation.CAL.IPumpPartPropContent _cal = CALCreateHelper.CreateCAL<HStation.CAL.IPumpPartPropContent>();

        #region Query

        /// <summary>
        ///
        /// </summary>
        public async Task<List<PumpPropContentDto>> GetAll()
        {
            return await _cal.GetAll();
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<PumpPropContentDto> GetByID(long ID)
        {
            return await _cal.GetByID(ID);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<List<PumpPropContentDto>> GetByIds(List<long> Ids)
        {
            return await _cal.GetByIds(Ids);
        }

        #endregion Query

        #region Insert

        /// <summary>
        ///
        /// </summary>
        public async Task<long> Insert(AddPumpPropContentDto model)
        {
            return await _cal.Insert(model);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> Inserts(List<AddPumpPropContentDto> list)
        {
            return await _cal.Inserts(list);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> BulkInserts(List<AddPumpPropContentDto> list)
        {
            return await _cal.BulkInserts(list);
        }

        #endregion Insert

        #region Update

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> Update(UpdatePumpPropContentDto model)
        {
            return await _cal.Update(model);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> Updates(List<UpdatePumpPropContentDto> list)
        {
            return await _cal.Updates(list);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> BulkUpdates(List<UpdatePumpPropContentDto> list)
        {
            return await _cal.BulkUpdates(list);
        }

        #endregion Update

        #region Delete

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> DeleteByID(long ID)
        {
            return await _cal.DeleteByID(ID);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> DeleteByIds(List<long> Ids)
        {
            return await _cal.DeleteByIds(Ids);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> DeleteAll()
        {
            return await _cal.DeleteAll();
        }

        #endregion Delete
    }
}

 HStation.BLL.Assets.Core/04-bll/01-PumpProdcuct/07-PumpMainAndPartMap/PumpPartPropContent.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,122 @@
namespace HStation.BLL
{
    /// <summary>
    ///
    /// </summary>
    public class PumpMainAndPartMap : CAL.IPumpMainAndPartMap
    {
        private readonly HStation.CAL.IPumpMainAndPartMap _cal = CALCreateHelper.CreateCAL<HStation.CAL.IPumpMainAndPartMap>();

        #region Query

        /// <summary>
        ///
        /// </summary>
        public async Task<List<PumpMainAndPartMapDto>> GetAll()
        {
            return await _cal.GetAll();
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<PumpMainAndPartMapDto> GetByID(long ID)
        {
            return await _cal.GetByID(ID);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<List<PumpMainAndPartMapDto>> GetByIds(List<long> Ids)
        {
            return await _cal.GetByIds(Ids);
        }

        #endregion Query

        #region Insert

        /// <summary>
        ///
        /// </summary>
        public async Task<long> Insert(AddPumpMainAndPartMapDto model)
        {
            return await _cal.Insert(model);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> Inserts(List<AddPumpMainAndPartMapDto> list)
        {
            return await _cal.Inserts(list);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> BulkInserts(List<AddPumpMainAndPartMapDto> list)
        {
            return await _cal.BulkInserts(list);
        }

        #endregion Insert

        #region Update

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> Update(UpdatePumpMainAndPartMapDto model)
        {
            return await _cal.Update(model);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> Updates(List<UpdatePumpMainAndPartMapDto> list)
        {
            return await _cal.Updates(list);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> BulkUpdates(List<UpdatePumpMainAndPartMapDto> list)
        {
            return await _cal.BulkUpdates(list);
        }

        #endregion Update

        #region Delete

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> DeleteByID(long ID)
        {
            return await _cal.DeleteByID(ID);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> DeleteByIds(List<long> Ids)
        {
            return await _cal.DeleteByIds(Ids);
        }

        /// <summary>
        ///
        /// </summary>
        public async Task<bool> DeleteAll()
        {
            return await _cal.DeleteAll();
        }

        #endregion Delete
    }
}

 HStation.BLL.Assets.Core/GlobalUsings.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,2 @@
global using HStation.Dto.Assets;
global using HStation.BLL.Xhs;

 HStation.BLL.Assets.Core/HStation.BLL.Assets.Core.csproj

@@ -6,4 +6,14 @@
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <Folder Include="02-httpclient\" />
  </ItemGroup>

  <ItemGroup>
    <ProjectReference Include="..\BLL\HStation.BLL.Core\HStation.BLL.Core.csproj" />
    <ProjectReference Include="..\HStation.Dto.Assets.Core\HStation.Dto.Assets.Core.csproj" />
    <ProjectReference Include="..\Service\HStation.Service.Assets.Core\HStation.Service.Assets.Core.csproj" />
  </ItemGroup>

</Project>

 WinFrmUI/HStation.WinFrmUI.Assets.Core/00-PumpProductManage/PumpProductMainPanel.cs

@@ -1,6 +1,7 @@
using DevExpress.XtraRichEdit.Import.Html;
using HStation.BLL;
using HStation.Dto;
using HStation.Model;
using Mapster;
using SQLitePCL;


 WinFrmUI/HStation.WinFrmUI.Assets.Core/00-PumpProductManage/PumpProductSeriesTreeListCtrl.cs

@@ -1,6 +1,5 @@
using DevExpress.XtraEditors;
using HStation.Dto;
using ISupply.WinFrmUI;
using System.ComponentModel;

namespace HStation.WinFrmUI.Xhs.PumpProduct

 WinFrmUI/HStation.WinFrmUI.Assets.Core/GlobalUsing.cs

ÎļþÒÑɾ³ý

 WinFrmUI/HStation.WinFrmUI.Assets.Core/GlobalUsings.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,2 @@
global using HStation.Dto.Assets;
global using Yw.WinFrmUI;

 WinFrmUI/HStation.WinFrmUI.Assets.Core/HStation.WinFrmUI.Assets.Core.csproj

@@ -21,6 +21,8 @@

  <ItemGroup>
    <ProjectReference Include="..\..\BLL\HStation.BLL.Xhs.Core\HStation.BLL.Xhs.Core.csproj" />
    <ProjectReference Include="..\..\HStation.BLL.Assets.Core\HStation.BLL.Assets.Core.csproj" />
    <ProjectReference Include="..\..\HStation.Dto.Assets.Core\HStation.Dto.Assets.Core.csproj" />
    <ProjectReference Include="..\HStation.WinFrmUI.Basic\HStation.WinFrmUI.Basic.csproj" />
    <ProjectReference Include="..\Hstation.WinFrmUI.Core\HStation.WinFrmUI.Core.csproj" />
  </ItemGroup>