iWare_RawMaterialWarehouse.git

using Admin.NET.Core.Service;
using Admin.NET.Application.Entity;
using Microsoft.AspNetCore.Http;
using Furion.DatabaseAccessor;
using static SKIT.FlurlHttpClient.Wechat.Api.Models.CgibinGetCurrentAutoReplyInfoResponse.Types.KeywordAutoReplyRule.Types.Reply.Types;
using System.Web;
using System.Data;
using System.Text;
 
namespace Admin.NET.Application;
/// <summary>
/// 往来单位服务
/// </summary>
[ApiDescriptionSettings(ApplicationConst.WmsBaseGroupName, Order = 100)]
public class BaseCustomerService : IDynamicApiController, ITransient
{
    private readonly SqlSugarRepository<WmsBaseCustomer> _rep;
    private readonly SqlSugarRepository<WmsConfigSerialRule> _repRuleDetailRep;
    private readonly SqlSugarRepository<WmsConfigSerialSN> _repSNRep;
    private readonly SqlSugarRepository<WmsBaseMaterial> _wmsMaterialRep;
    private readonly SqlSugarRepository<WmsBaseMaterialCustomer> _wmsMaterialCustomerRep;
 
    public BaseCustomerService(SqlSugarRepository<WmsBaseCustomer> rep, SqlSugarRepository<WmsConfigSerialRule> repRuleDetailRep, SqlSugarRepository<WmsConfigSerialSN> repSNRep, SqlSugarRepository<WmsBaseMaterial> wmsMaterialRep, SqlSugarRepository<WmsBaseMaterialCustomer> wmsMaterialCustomerRep)
    {
        _rep = rep;
        _repRuleDetailRep = repRuleDetailRep;
        _repSNRep = repSNRep;
        _wmsMaterialRep = wmsMaterialRep;
        _wmsMaterialCustomerRep = wmsMaterialCustomerRep;
    }
 
    /// <summary>
    /// 分页查询往来单位
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Page")]
    public async Task<SqlSugarPagedList<BaseCustomerOutput>> Page(BaseCustomerInput input)
    {
        var query = _rep.AsQueryable()
            .WhereIF(!string.IsNullOrWhiteSpace(input.SearchKey), u =>
                u.CustCode.Contains(input.SearchKey.Trim())
                || u.CustChinaName.Contains(input.SearchKey.Trim())
                || u.CustEnglishName.Contains(input.SearchKey.Trim())
            )
              .WhereIF(input.IsDisabled != null, u => u.IsDisabled == input.IsDisabled)
            .WhereIF(!string.IsNullOrWhiteSpace(input.CustCode), u => u.CustCode.Contains(input.CustCode.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.CustChinaName), u => u.CustChinaName.Contains(input.CustChinaName.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.CustEnglishName), u => u.CustEnglishName.Contains(input.CustEnglishName.Trim()))
            .WhereIF(input.CustType > 0, u => u.CustType == input.CustType)
            .WhereIF(!string.IsNullOrWhiteSpace(input.Province), u => u.Province.Contains(input.Province.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.City), u => u.City.Contains(input.City.Trim()))
            .Select<BaseCustomerOutput>();
        return await query.OrderBuilder(input).ToPagedListAsync(input.Page, input.PageSize);
    }
 
    /// <summary>
    /// 增加往来单位
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Add")]
    [UnitOfWork]
    public async Task<long> Add(AddBaseCustomerInput input)
    {
        var entity = input.Adapt<WmsBaseCustomer>();
        await CheckExisit(entity);
        entity.CustTypeName = entity.CustType.ToString();
        await _rep.InsertAsync(entity);
        return entity.Id;
    }
 
    /// <summary>
    /// 删除往来单位
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Delete")]
    public async Task Delete(DeleteBaseCustomerInput input)
    {
        var entity = await _rep.GetFirstAsync(u => u.Id == input.Id) ?? throw Oops.Oh(ErrorCodeEnum.D1002);
        //物料客户关联
        var wmsMaterialCustomerList = await _wmsMaterialCustomerRep.GetFirstAsync(u => u.CustCode == entity.CustCode  && u.IsDelete == false);
        if (wmsMaterialCustomerList != null)
        {
            throw Oops.Oh($"存在绑定关系，不可删除");
        }
        //await _rep.FakeDeleteAsync(entity);   //假删除
        await _rep.DeleteAsync(entity);   //真删除
    }
 
    /// <summary>
    /// 更新往来单位
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Update")]
    public async Task Update(UpdateBaseCustomerInput input)
    {
 
        var entity = input.Adapt<WmsBaseCustomer>();
        await CheckExisit(entity, true);
        entity.CustTypeName = GetEnumDescriptionUtil.GetEnumDescription(input.CustType);//名称对应修改
        await _rep.AsUpdateable(entity).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommandAsync();
    }
 
    /// <summary>
    /// 获取往来单位
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "Detail")]
    public async Task<WmsBaseCustomer> Detail([FromQuery] QueryByIdBaseCustomerInput input)
    {
        return await _rep.GetFirstAsync(u => u.Id == input.Id);
    }
 
    /// <summary>
    /// 获取往来单位列表
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "List")]
    public async Task<List<BaseCustomerOutput>> List([FromQuery] BaseCustomerInput input)
    {
        return await _rep.AsQueryable().WhereIF(!string.IsNullOrWhiteSpace(input.SearchKey), u =>
                u.CustCode.Contains(input.SearchKey.Trim())
                || u.CustChinaName.Contains(input.SearchKey.Trim())
                || u.CustEnglishName.Contains(input.SearchKey.Trim())
                || u.Province.Contains(input.SearchKey.Trim())
                || u.City.Contains(input.SearchKey.Trim())
            )
            .WhereIF(!string.IsNullOrWhiteSpace(input.CustCode), u => u.CustCode.Contains(input.CustCode.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.CustChinaName), u => u.CustChinaName.Contains(input.CustChinaName.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.CustEnglishName), u => u.CustEnglishName.Contains(input.CustEnglishName.Trim()))
            .WhereIF(input.CustType > 0, u => u.CustType == input.CustType)
            .WhereIF(!string.IsNullOrWhiteSpace(input.Province), u => u.Province.Contains(input.Province.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.City), u => u.City.Contains(input.City.Trim())).Select<BaseCustomerOutput>().ToListAsync();
    }
 
    #region 导入
 
    /// <summary>
    /// Excel模板导入往来单位功能
    /// </summary>
    /// <param name="file">Excel模板文件</param>
    /// <returns>导入的记录数</returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "ImportExcel")]
    [Description("BaseCustomer/ImportExcel")]
    public async Task<int> ImportExcelAsync(IFormFile file)
    {
        int _HeadStartLine = 2;//第1行是说明,第2行是列名
        int _DataStartLine = 3;//第3行开始是数据
        DataTable importDataTable = ExcelUtil.ImportExcelToDataTable(file, _HeadStartLine, _DataStartLine);
        var addList = await CommonImport(importDataTable, _DataStartLine);
        await _rep.InsertRangeAsync(addList);
        return addList.Count;
    }
 
    /// <summary>
    ///  DataTable转换实体对象列表
    /// </summary>
    /// <param name="dataTable"></param>
    /// <param name="dataStartLine">模版列名开始行</param>
    /// <returns></returns>
    private async Task<List<WmsBaseCustomer>> CommonImport(DataTable dataTable, int dataStartLine)
    {
        var details = new List<WmsBaseCustomer>();
        int index = dataStartLine;//模版列名开始行
        foreach (System.Data.DataRow row in dataTable.Rows)
        {
            index++;
            //导入模版定制化代码（替换模版使用）
 
            var addItem = new WmsBaseCustomer();
            #region 定义变量
            var _CustCode = "";//客户编号
            var _CustChinaName = "";//客户中文名称
            var _CustEnglishName = "";//客户英文名称
            var _MnemonicCode = "";//助记码
            var _CustType = "";//类型
            //var _CustTypeName = "";//类型名称
            var _LinkMan = "";//联系人
            var _Phone = "";//电话
            var _Email = "";//电子邮件
            var _ZipCode = "";//邮编
            var _Province = "";//省份
            var _City = "";//城市
            var _Address = "";//地址
            var _IsDisabled = "";//是否禁用
            #endregion
 
 
            #region 取值
            _CustCode = row["客户编号"]?.ToString();
            _CustChinaName = row["客户中文名称"]?.ToString();
            _CustEnglishName = row["客户英文名称"]?.ToString();
            _MnemonicCode = row["助记码"]?.ToString();
            _CustType = row["类型"]?.ToString();
            //_CustTypeName = row["类型名称"]?.ToString();
            _LinkMan = row["联系人"]?.ToString();
            _Phone = row["电话"]?.ToString();
            _Email = row["电子邮件"]?.ToString();
            _ZipCode = row["邮编"]?.ToString();
            _Province = row["省份"]?.ToString();
            _City = row["城市"]?.ToString();
            _Address = row["地址"]?.ToString();
            _IsDisabled = row["是否禁用"]?.ToString();
            #endregion
 
 
            #region 验证
 
            if (string.IsNullOrEmpty(_CustCode))
            {
                throw Oops.Oh($"第{index}行[客户编号]{_CustCode}不能为空！");
            }
 
            if (!string.IsNullOrEmpty(_CustCode))
            {
                var isExist = await _rep.AsQueryable().FirstAsync(p => p.CustCode == _CustCode);
                if (isExist != null) throw Oops.Oh("该客户编号" + _CustCode + "已存在");
                addItem.CustCode = (string)(_CustCode.Trim());
            }
 
            if (string.IsNullOrEmpty(_CustChinaName))
            {
                throw Oops.Oh($"第{index}行[客户中文名称]{_CustChinaName}不能为空！");
            }
 
            if (!string.IsNullOrEmpty(_CustChinaName))
            {
                addItem.CustChinaName = (string)(_CustChinaName.Trim());
            }
            if (!string.IsNullOrEmpty(_CustEnglishName))
            {
                addItem.CustEnglishName = (string)(_CustEnglishName.Trim());
            }
            if (!string.IsNullOrEmpty(_MnemonicCode))
            {
                addItem.MnemonicCode = (string)(_MnemonicCode.Trim());
            }
 
            if (string.IsNullOrEmpty(_CustType))
            {
                throw Oops.Oh($"第{index}行[类型]{_CustType}不能为空！");
            }
 
            if (!string.IsNullOrEmpty(_CustType))
            {
             if(_CustType.Contains("承运人") )
                {
                    addItem.CustTypeName = _CustType;
                    addItem.CustType = BaseCustomerTypeEnum.承运人;
                }else if(_CustType.Contains("收货人"))
                {
                    addItem.CustTypeName = _CustType;
                    addItem.CustType = BaseCustomerTypeEnum.收货人;
                }
                else if (_CustType.Contains("供应商"))
                {
                    addItem.CustTypeName = _CustType;
                    addItem.CustType = BaseCustomerTypeEnum.供应商;
                }
                else if (_CustType.Contains("其他"))
                {
                    addItem.CustTypeName = _CustType;
                    addItem.CustType = BaseCustomerTypeEnum.其他;
                }
                else if (_CustType.Contains("货主"))
                {
                    addItem.CustTypeName = _CustType;
                    addItem.CustType = BaseCustomerTypeEnum.货主;
                }
 
            }
            //if (!string.IsNullOrEmpty(_CustTypeName))
            //{
            //    addItem.CustTypeName = (string)(_CustTypeName.Trim());
            //}
            if (!string.IsNullOrEmpty(_LinkMan))
            {
                addItem.LinkMan = (string)(_LinkMan.Trim());
            }
            if (!string.IsNullOrEmpty(_Phone))
            {
                addItem.Phone = (string)(_Phone.Trim());
            }
            if (!string.IsNullOrEmpty(_Email))
            {
                addItem.Email = (string)(_Email.Trim());
            }
            if (!string.IsNullOrEmpty(_ZipCode))
            {
                addItem.ZipCode = (string)(_ZipCode.Trim());
            }
            if (!string.IsNullOrEmpty(_Province))
            {
                addItem.Province = (string)(_Province.Trim());
            }
            if (!string.IsNullOrEmpty(_City))
            {
                addItem.City = (string)(_City.Trim());
            }
            if (!string.IsNullOrEmpty(_Address))
            {
                addItem.Address = (string)(_Address.Trim());
            }
 
            if (string.IsNullOrEmpty(_IsDisabled))
            {
                throw Oops.Oh($"第{index}行[是否禁用]{_IsDisabled}不能为空！");
            }
 
            if (!string.IsNullOrEmpty(_IsDisabled))
            {
                if (!_IsDisabled.Equals("是") && !_IsDisabled.Equals("否"))
                {
                    throw Oops.Oh($"第{index}行[是否禁用]{_IsDisabled}值不正确！");
                }
                else
                {
                    bool outIsDisabled = _IsDisabled.Equals("是") ? true : false;
                    addItem.IsDisabled = outIsDisabled;
                }
            }
 
            #endregion
 
 
            details.Add(addItem);
        }
        //验重
        await CheckExisitForImport(details);
        return details;
    }
 
    /// <summary>
    /// 根据版本下载往来单位的Excel导入模板
    /// </summary>
    /// <returns>下载的模板文件</returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "DownloadExcelTemplate")]
    [Description("BaseCustomer/DownloadExcelTemplate")]
    public IActionResult DownloadExcelTemplate()
    {
        string _path = TemplateConst.EXCEL_TEMPLATEFILE_导入模版路径 + $"\\往来单位{TemplateConst.EXCEL_TEMPLATEFILE_导入模版名称后缀}.xlsx";
        var fileName = HttpUtility.UrlEncode($"导入模板(往来单位).xlsx", Encoding.GetEncoding("UTF-8"));
        return new FileStreamResult(new FileStream(_path, FileMode.Open), "application/octet-stream") { FileDownloadName = fileName };
    }
 
    #endregion
 
    #region 私有方法
 
    /// <summary>
    /// 根据联合主键验证数据是否已存在-数据库
    /// </summary>
    /// <param name="input"></param>
    /// <param name="isEdit"></param>
    /// <returns></returns>
    private async Task CheckExisit(WmsBaseCustomer input, bool isEdit = false)
    {
        //输出数据已存在错误
        ErrorCodeItemMetadataAttribute metadata = ErrorCodeEnum.D1006.GetErrorCodeItemMetadata();
 
        WmsBaseCustomer _existItem = null;
        if (!isEdit)//新增
        {
            _existItem = await _rep.GetFirstAsync(u => u.CustCode.Equals(input.CustCode));
            if (_existItem != null) throw Oops.Oh($"客户编号[{input.CustCode}]{metadata.ErrorMessage}");
 
            _existItem = await _rep.GetFirstAsync(u => u.CustChinaName.Equals(input.CustChinaName));
            if (_existItem != null) throw Oops.Oh($"中文名称[{input.CustChinaName}]{metadata.ErrorMessage}");
 
            _existItem = await _rep.GetFirstAsync(u => u.CustEnglishName.Equals(input.CustEnglishName));
            if (_existItem != null) throw Oops.Oh($"英文名称[{input.CustEnglishName}]{metadata.ErrorMessage}");
        }
        else//编辑 
        {
            //当前编辑数据以外是否存在重复
            _existItem = await _rep.GetFirstAsync(u => u.Id != input.Id && u.CustCode.Equals(input.CustCode));
            if (_existItem != null) throw Oops.Oh($"客户编号[{input.CustCode}]{metadata.ErrorMessage}");
 
            _existItem = await _rep.GetFirstAsync(u => u.Id != input.Id && u.CustChinaName.Equals(input.CustChinaName));
            if (_existItem != null) throw Oops.Oh($"中文名称[{input.CustChinaName}]{metadata.ErrorMessage}");
 
            _existItem = await _rep.GetFirstAsync(u => u.Id != input.Id && u.CustEnglishName.Equals(input.CustEnglishName));
            if (_existItem != null) throw Oops.Oh($"英文名称[{input.CustEnglishName}]{metadata.ErrorMessage}");
        }
 
    }
 
    #endregion
 
    /// <summary>
    /// 根据组合校验和单独校验验证数据是否已存在-导入时验证
    /// </summary>
    /// <param name="inputs"></param>
    /// <returns></returns>
    private async Task CheckExisitForImport(List<WmsBaseCustomer> inputs)
    {
        if (inputs?.Count <= 0)
        {
            throw Oops.Oh($"导入数据不能为空");
        }
        //根据组合校验验证表格中中是否已存在相同数据  
 
 
 
 
 
 
 
 
        //根据单独校验验证表格中中是否已存在相同数据  
 
 
 
    }
 
    /// <summary>
    /// 创建单据需要的物料 ly
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "DetailForOrders")]
    public async Task<List<ForOrdersBaseCustomerOutput>> DetailForOrders([FromQuery] DiyQueryByIdBaseCustomerInput input)
    {
        //先获取物料绑定的往来单位 再获取往来单位的数据
        if (String.IsNullOrEmpty(input.MaterialCode))
        {
            throw Oops.Oh("请传入物料编号");
        }
        //物料客户关联
        var wmsMaterialCustomerList = await _wmsMaterialCustomerRep.AsQueryable()
                                          .Where(u => u.MaterialCode == input.MaterialCode)
                                          .Where(u => u.MaterialId > 0)
                                          .Where(u => u.IsDelete == false)
                                          .OrderBy(o => o.CreateTime)
                                          .Select<WmsMaterialCustomerOutput>().Distinct().ToListAsync();
        var resultListNotf = wmsMaterialCustomerList.Distinct().Adapt<List<ForOrdersBaseCustomerOutput>>();
 
        List<ForOrdersBaseCustomerOutput> resultList = new List<ForOrdersBaseCustomerOutput>();
        if (wmsMaterialCustomerList == null || wmsMaterialCustomerList.Count > 0)
        {
            //过滤不是供应商的
            var resaLL = await _rep.AsQueryable().Where(u => u.CustType == BaseCustomerTypeEnum.供应商).Select<BaseCustomerOutput>().ToListAsync(); 
            foreach (var w in resultListNotf)
            {
                var itemGys = resaLL.Where(u => u.CustType == BaseCustomerTypeEnum.供应商 && u.CustCode == w.CustCode).ToList();
                if (itemGys != null && itemGys.Count > 0)
                {
                    resultList.Add(w);
                }
            }
            //resultList = wmsMaterialCustomerList.Adapt<List<ForOrdersBaseCustomerOutput>>();
        }
 
        if (resultList == null || resultList.Count == 0)
        {
            var res = await _rep.AsQueryable()
            .WhereIF(!string.IsNullOrWhiteSpace(input.CustCode), u => u.CustCode == input.CustCode)
            .Where(u => u.CustType == BaseCustomerTypeEnum.供应商)
           .Select<BaseCustomerOutput>().Distinct().ToListAsync(); //BaseCustomerOutput
            resultList = res.Adapt<List<ForOrdersBaseCustomerOutput>>();
        }
        return resultList;
    }
 
 
}