BookingHeChuan/Myshipping.Application/Service/Para/ParaService.cs

using Furion.DynamicApiController;
using Furion.FriendlyException;
using Furion.Templates;
using Mapster;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Myshipping.Application.Entity;
using Myshipping.Application.Helper;
using Myshipping.Core;
using NPOI.OpenXmlFormats.Wordprocessing;
using NPOI.SS.Formula.Functions;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Myshipping.Application
{
    /// <summary>
    /// 订舱业务参数
    /// </summary>
    [ApiDescriptionSettings("Application", Name = "Para", Order = 10)]
    public class ParaService : IParaService, IDynamicApiController
    {
        private readonly SqlSugarRepository<ParaGoodsInfo> _paraGoodsInfoRepository;
        private readonly SqlSugarRepository<ParaGoodsCategoryInfo> _paraGoodsCategoryInfoRepository;
        private readonly SqlSugarRepository<ParaContractNoInfo> _paraContractNoInfoRepository;
        private readonly ILogger<ParaService> _logger;

        public ParaService(SqlSugarRepository<ParaGoodsInfo> paraGoodsInfoRepository,
            SqlSugarRepository<ParaGoodsCategoryInfo> paraGoodsCategoryInfoRepository,
            SqlSugarRepository<ParaContractNoInfo> paraContractNoInfoRepository,
            ILogger<ParaService> logger

            )
        {
            _paraGoodsInfoRepository = paraGoodsInfoRepository;
            _paraGoodsCategoryInfoRepository = paraGoodsCategoryInfoRepository;
            _paraContractNoInfoRepository = paraContractNoInfoRepository;

            _logger = logger;
        }
        /// <summary>
        /// 保存品名参数
        /// </summary>
        /// <param name="model">品名参数</param>
        /// <returns>返回回执</returns>
        [HttpPost("/Para/SaveParaGoodsInfo")]
        public async Task<long> SaveParaGoodsInfo(ParaGoodsDto model)
        {
            ParaGoodsInfo info = null;

            try
            {
                //判断代码不能重复
                var sameList = _paraGoodsInfoRepository.AsQueryable()
                    .Where(t => t.GOODS_CODE.Equals(model.GoodsCode, StringComparison.OrdinalIgnoreCase)).ToList();

                if(sameList.Count > 0 && !string.IsNullOrWhiteSpace(model.Id) && sameList.Any(t=>t.Id != long.Parse(model.Id)))
                    throw Oops.Oh($"商品编码【{model.GoodsCode}】已存在不能重复保存");


                if (!string.IsNullOrWhiteSpace(model.Id))
                {
                    info = await _paraGoodsInfoRepository.AsQueryable().FirstAsync(t => t.Id == long.Parse(model.Id));

                    info.GOODS_CODE = model.GoodsCode;
                    info.GOODS_NAME_CN = model.GoodsNameCN;
                    info.GOODS_NAME_EN = model.GoodsNameEN;
                    info.GOODS_DESP = model.GoodsDesp;
                    info.GOODS_CATEGORY = model.GoodsCategory;
                    info.GOODS_CATEGORY_NAME = model.GoodsCategoryName;

                    await _paraGoodsInfoRepository.AsUpdateable(info).IgnoreColumns(it => new
                    {
                        it.Id,
                        it.TenantId,
                        it.CreatedTime,
                        it.CreatedUserId,
                        it.CreatedUserName
                    }).ExecuteCommandAsync();
                }
                else
                {
                    info = model.Adapt<ParaGoodsInfo>();

                    await _paraGoodsInfoRepository.InsertAsync(info);
                }
            }
            catch (Exception ex)
            {
                throw Oops.Bah($"保存品名参数异常，{ex.Message}");
            }

            return info.Id;
        }

        /// <summary>
        /// 作废品名参数
        /// </summary>
        /// <param name="Ids">品名参数主键数组</param>
        /// <returns>返回回执</returns>
        [HttpPost("/Para/DeleteParaGoodsInfo")]
        public async Task<string> DeleteParaGoodsInfo([FromBody] long[] Ids)
        {
            try
            {
                //如果没有给主键直接抛异常
                if (Ids.Length == 0)
                    throw Oops.Oh("没有提供需要作废的主键信息");

                var list = _paraGoodsInfoRepository.AsQueryable().Where(t => Ids.Contains(t.Id)).ToList();

                if (list.Count != Ids.Length)
                {
                    var noRecord = string.Join(",", Ids.GroupJoin(list, l => l, r => r.Id, (l, r) => {
                        var currList = r.ToList();

                        if (r.Count() > 0)
                            return string.Empty;

                        return l.ToString();
                    }).Where(t => !string.IsNullOrWhiteSpace(t)).ToArray());

                    throw Oops.Oh($"以下主键信息 {noRecord} 检索失败或者已作废过");
                }

                list.ForEach(async entity =>
                {
                    entity.IsDeleted = true;
                    entity.UpdatedTime = DateTime.Now;
                    entity.UpdatedUserId = UserManager.UserId;
                    entity.UpdatedUserName = UserManager.Name;

                    await _paraGoodsInfoRepository.AsUpdateable(entity).IgnoreColumns(it => new
                    {
                        it.Id,
                        it.TenantId,
                        it.CreatedTime,
                        it.CreatedUserId,
                        it.CreatedUserName
                    }).ExecuteCommandAsync();
                });

            }
            catch (Exception ex)
            {
                throw Oops.Bah($"作废品名参数异常，{ex.Message}");
            }

            return "作废成功";
        }

        /// <summary>
        /// 主键获取品名参数
        /// </summary>
        /// <param name="Id">品名主键</param>
        /// <returns>返回回执</returns>
        [HttpGet("/Para/GetParaGoodsInfo")]
        public async Task<ParaGoodsDto> GetParaGoodsInfo([FromQuery]long Id)
        {
            ParaGoodsDto model = null;

            try
            {
                ParaGoodsInfo info = _paraGoodsInfoRepository.AsQueryable().First(t => t.Id == Id);

                if(info == null)
                    throw Oops.Oh($"获取品名参数失败");


                model = info.Adapt<ParaGoodsDto>();

            }
            catch (Exception ex)
            {
                throw Oops.Bah($"获取品名参数异常，{ex.Message}");
            }

            return model;
        }

        /// <summary>
        /// 检索品名参数
        /// </summary>
        /// <param name="queryItem">检索值</param>
        /// <param name="top">默认最大行数</param>
        /// <returns>返回回执</returns>
        [HttpGet("/Para/QueryParaGoodsInfo")]
        public async Task<List<ParaGoodsDto>> QueryParaGoodsInfo([FromQuery] string queryItem, [FromQuery] int top = 10)
        {
            List<ParaGoodsDto> list = new List<ParaGoodsDto>();

            try
            {
                var query = _paraGoodsInfoRepository.AsQueryable();

                if (!string.IsNullOrWhiteSpace(queryItem))
                {
                    query = query.Where(t => t.GOODS_CODE.Contains(queryItem.Trim(), StringComparison.OrdinalIgnoreCase) ||
                    t.GOODS_NAME_CN.Contains(queryItem.Trim(), StringComparison.OrdinalIgnoreCase) ||
                    t.GOODS_NAME_EN.Contains(queryItem.Trim(), StringComparison.OrdinalIgnoreCase) ||
                    t.GOODS_DESP.Contains(queryItem.Trim(), StringComparison.OrdinalIgnoreCase) ||
                    t.GOODS_CATEGORY.Contains(queryItem.Trim(), StringComparison.OrdinalIgnoreCase) ||
                    t.GOODS_CATEGORY_NAME.Contains(queryItem.Trim(), StringComparison.OrdinalIgnoreCase)
                    );
                }

                query = query.OrderBy("GOODS_CODE asc");

                var goodsList = await query.Take(top).ToListAsync();

                if (goodsList.Count > 0)
                    list = goodsList.Select(t => t.Adapt<ParaGoodsDto>()).ToList();

            }
            catch (Exception ex)
            {
                throw Oops.Bah($"保存品名参数异常，{ex.Message}");
            }

            return list;
        }

        /// <summary>
        /// 品名参数台账查询
        /// </summary>
        /// <param name="QuerySearch">品名参数台账查询请求</param>
        /// <returns>返回结果</returns>
        [HttpPost("/Para/GetParaGoodsPage")]
        public async Task<dynamic> GetParaGoodsPageAsync(QueryParaGoodsDto QuerySearch)
        {
            DateTime createBegin = DateTime.MinValue;
            DateTime createEnd = DateTime.MinValue;

            DateTime updateBegin = DateTime.MinValue;
            DateTime updateEnd = DateTime.MinValue;

            if (!string.IsNullOrWhiteSpace(QuerySearch.CreateTimeBegin))
            {
                if (!DateTime.TryParse(QuerySearch.CreateTimeBegin, out createBegin))
                    throw Oops.Oh($"创建开始日期格式错误，{QuerySearch.CreateTimeBegin}");
            }

            if (!string.IsNullOrWhiteSpace(QuerySearch.CreateTimeEnd))
            {
                if (!DateTime.TryParse(QuerySearch.CreateTimeEnd, out createEnd))
                    throw Oops.Oh($"创建结束日期格式错误，{QuerySearch.CreateTimeEnd}");

                createEnd = createEnd.AddDays(1);
            }

            if (!string.IsNullOrWhiteSpace(QuerySearch.UpdateTimeBegin))
            {
                if (!DateTime.TryParse(QuerySearch.UpdateTimeBegin, out updateBegin))
                    throw Oops.Oh($"更新起始日期格式错误，{QuerySearch.UpdateTimeBegin}");
            }

            if (!string.IsNullOrWhiteSpace(QuerySearch.UpdateTimeEnd))
            {
                if (!DateTime.TryParse(QuerySearch.UpdateTimeEnd, out updateEnd))
                    throw Oops.Oh($"更新结束日期格式错误，{QuerySearch.UpdateTimeEnd}");

                updateEnd = updateEnd.AddDays(1);
            }

            string entityOrderCol = "CreatedTime";

            //这里因为返回给前端的台账数据是DTO，所以这里排序时候需要转换成Entity对应的字段
            if (!string.IsNullOrWhiteSpace(QuerySearch.SortField))
                entityOrderCol = MapsterExtHelper.GetAdaptProperty<ParaGoodsDto, ParaGoodsInfo>(QuerySearch.SortField);

            var entities = await _paraGoodsInfoRepository.AsQueryable().Filter(null, true)
                                     .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.GoodsCode), t => t.GOODS_CODE.Contains(QuerySearch.GoodsCode.Trim(), StringComparison.OrdinalIgnoreCase))
                                     .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.GoodsNameCN), t => t.GOODS_NAME_CN.Contains(QuerySearch.GoodsNameCN.Trim(), StringComparison.OrdinalIgnoreCase))
                                     .WhereIF(createBegin != DateTime.MinValue, t => t.CreatedTime.HasValue && t.CreatedTime.Value >= createBegin)
                                     .WhereIF(createEnd != DateTime.MinValue, t => t.CreatedTime.HasValue && t.CreatedTime.Value < createEnd)
                                     .WhereIF(updateBegin != DateTime.MinValue, t => t.UpdatedTime.HasValue && t.UpdatedTime.Value >= updateBegin)
                                     .WhereIF(updateEnd != DateTime.MinValue, t => t.UpdatedTime.HasValue && t.UpdatedTime.Value  < updateEnd)
                                     .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.GoodsDesp), t => t.GOODS_DESP.Contains(QuerySearch.GoodsDesp.Trim(), StringComparison.OrdinalIgnoreCase))
                                     .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.GoodsNameEN), t => t.GOODS_NAME_EN.Contains(QuerySearch.GoodsNameEN.Trim(), StringComparison.OrdinalIgnoreCase))
                                     .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.GoodsCategory), t => t.GOODS_CATEGORY.Equals(QuerySearch.GoodsCategory.Trim(), StringComparison.OrdinalIgnoreCase))
                                     .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.CreateUserName), t => t.GOODS_NAME_EN.Contains(QuerySearch.CreateUserName.Trim(), StringComparison.OrdinalIgnoreCase))
                                     .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.UpdateUserName), t => t.GOODS_NAME_EN.Contains(QuerySearch.UpdateUserName.Trim(), StringComparison.OrdinalIgnoreCase))
                                     .OrderBy(entityOrderCol + (QuerySearch.descSort ? " asc " : " desc "))
                                     .ToPagedListAsync(QuerySearch.PageNo, QuerySearch.PageSize);
            return new
            {
                PageNo = entities.PageIndex,
                PageSize = entities.PageSize,
                TotalPage = entities.TotalPages,
                TotalRows = entities.TotalCount,
                Rows = entities.Items.Select(t => t.Adapt<ParaGoodsDto>()).ToList()
            };
        }

        ///// <summary>
        ///// 保存品名分类参数
        ///// </summary>
        ///// <param name="model">品名分类参数</param>
        ///// <returns>返回回执</returns>
        //public async Task<CommonWebApiResult> SaveParaGoodsCategoryInfo(ParaGoodsCategoryDto model)
        //{
        //    CommonWebApiResult result = new CommonWebApiResult();

        //    return result;
        //}

        ///// <summary>
        ///// 主键获取品名分类参数
        ///// </summary>
        ///// <param name="Id">品名分类主键</param>
        ///// <returns>返回回执</returns>
        //public async Task<CommonWebApiResult> GetParaGoodsCategoryInfo(long Id)
        //{
        //    CommonWebApiResult result = new CommonWebApiResult();

        //    return result;
        //}

        ///// <summary>
        ///// 检索品名分类参数
        ///// </summary>
        ///// <param name="queryItem">检索值</param>
        ///// <returns>返回回执</returns>
        //public async Task<CommonWebApiResult> QueryParaGoodsCategoryInfo(string queryItem)
        //{
        //    CommonWebApiResult result = new CommonWebApiResult();

        //    return result;
        //}


        ///// <summary>
        ///// 保存约号参数
        ///// </summary>
        ///// <param name="model">约号参数</param>
        ///// <returns>返回回执</returns>
        //public async Task<CommonWebApiResult> SaveParaContractNoInfo(ParaGoodsCategoryDto model)
        //{
        //    CommonWebApiResult result = new CommonWebApiResult();

        //    return result;
        //}

        ///// <summary>
        ///// 主键获取约号参数
        ///// </summary>
        ///// <param name="Id">约号主键</param>
        ///// <returns>返回回执</returns>
        //public async Task<CommonWebApiResult> GetParaContractNoInfo(long Id)
        //{
        //    CommonWebApiResult result = new CommonWebApiResult();

        //    return result;
        //}

        ///// <summary>
        ///// 检索约号参数
        ///// </summary>
        ///// <param name="queryItem">检索值</param>
        ///// <returns>返回回执</returns>
        //public async Task<CommonWebApiResult> QuerytParaContractNoInfo(string queryItem)
        //{
        //    CommonWebApiResult result = new CommonWebApiResult();

        //    return result;
        //}
    }
}