iWare_RawMaterialWarehouse.git

using Admin.NET.Core.Service;
using Admin.NET.Application.Entity;
using Microsoft.AspNetCore.Http;
using System.Data;
using System.Web;
using System.Text;
using Furion.DatabaseAccessor;
using Admin.NET.Application.Service.ReportCenter.WmsOtherReport.Dto;
 
namespace Admin.NET.Application;
/// <summary>
/// 出入库库存推移图 服务
/// </summary>
[ApiDescriptionSettings(ApplicationConst.ReportCenterGroupName, Order = 100)]
public class WmsStockPassMapService : IDynamicApiController, ITransient
{
    private readonly SqlSugarRepository<WmsStockQuan> _rep;
    private readonly SqlSugarRepository<v_wms_stock_quan> _v_wms_stock_quanRep;
    private readonly SqlSugarRepository<WmsRecordReceivingDelivery> _wmsRecordReceivingDelivery;
    private readonly SqlSugarRepository<WmsBaseContainer> _repWmsContainer;
    private readonly SqlSugarRepository<v_wms_stock_quan_for_use> _v_wms_stock_quan_for_useRep;
    private readonly SqlSugarRepository<V_WmsOrderMovementDetails> _v_WmsOrderMovementDetailsRep;
    public WmsStockPassMapService(
        SqlSugarRepository<V_WmsOrderMovementDetails> v_WmsOrderMovementDetailsRep,
        SqlSugarRepository<WmsStockQuan> rep
        , SqlSugarRepository<v_wms_stock_quan_for_use> v_wms_stock_quan_for_useRep
        , SqlSugarRepository<v_wms_stock_quan> v_wms_stock_quanRep, SqlSugarRepository<WmsRecordReceivingDelivery> wmsRecordReceivingDelivery
, SqlSugarRepository<WmsBaseContainer> repWmsContainer)
 
    {
        _v_WmsOrderMovementDetailsRep = v_WmsOrderMovementDetailsRep;
        _rep = rep;
        _v_wms_stock_quanRep = v_wms_stock_quanRep;
        _v_wms_stock_quan_for_useRep = v_wms_stock_quan_for_useRep;
        _wmsRecordReceivingDelivery = wmsRecordReceivingDelivery;
        _repWmsContainer = repWmsContainer;
    }
 
    /// <summary>
    /// 上下架推移图
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "Page")]
    [Description("WmsStockPassMap/Page")]
    public async Task<List<WmsStockPassMapOutput>> Page([FromQuery] WmsStockPassMapInput input)
    {
        List<WmsStockPassMapOutput> outputlist = new List<WmsStockPassMapOutput>();
        DateTime currentDate = DateTime.Today;
 
        //选择为12日的情况
        if (input.DayOrWeekOrMonth == 1)
        {
            //总的数据
            DateTime all_startDate = currentDate.AddDays(-11);
            DateTime all_endDate = currentDate.Date.AddDays(1).AddTicks(-1);
            var all_recordsOfDay = await _v_WmsOrderMovementDetailsRep.AsQueryable().Where(r => r.CreateTime >= all_startDate && r.CreateTime <= all_endDate
                && (r.OrderStatus == OrderStatusEnum.已完成)
                && (r.OrderType == OrderTypeEnum.上架单 || r.OrderType == OrderTypeEnum.下架单)
               ).ToListAsync();
 
 
            for (int i = 0; i < 12; i++)
            {
                DateTime startDate = currentDate.AddDays(-i);
                DateTime endDate = startDate.Date.AddDays(1).AddTicks(-1);
 
                // 查询在这一天内的记录
                var recordsOfDay = all_recordsOfDay.Where(r => r.CreateTime >= startDate && r.CreateTime <= endDate
                ).ToList();
 
 
                var summary = new WmsStockPassMapOutput
                {
                    Time = 12 - i,
                    InWare = recordsOfDay.Where(x => x.OrderType == OrderTypeEnum.上架单).ToList().Sum(x => x.Quantity),
                    OutWare = recordsOfDay.Where(x => x.OrderType == OrderTypeEnum.下架单).ToList().Sum(x => x.Quantity),
                    StockNum = 0,
                    AveStockNum = 0,
                    Date = startDate.Date.ToString("yyyy-MM-dd")
                    // 在这里根据 recordsOfDay 计算出入库汇总，例如求和或其他聚合操作
                    // summary.StockInTotal = recordsOfDay.Where(r => r.Type == "StockIn").Sum(r => r.Quantity);
                    // summary.StockOutTotal = recordsOfDay.Where(r => r.Type == "StockOut").Sum(r => r.Quantity);
                };
 
                outputlist.Add(summary);
            }
        }
        //选择12周
        else if (input.DayOrWeekOrMonth == 2)
        {
            //总的数据
            DateTime all_startDate = GetStartOfWeek(currentDate).AddDays(-7 * 11);
            DateTime all_endDate = GetEndOfWeek(currentDate);
            var all_recordsOfDay = await _v_WmsOrderMovementDetailsRep.AsQueryable().Where(r => r.CreateTime >= all_startDate && r.CreateTime <= all_endDate
                && (r.OrderStatus == OrderStatusEnum.已完成)
                && (r.OrderType == OrderTypeEnum.上架单 || r.OrderType == OrderTypeEnum.下架单)
               ).ToListAsync();
 
            for (int i = 0; i < 12; i++)
            {
                // 计算当前周的起始日期
                DateTime startDate = GetStartOfWeek(currentDate).AddDays(-7 * i);
                DateTime endDate = GetEndOfWeek(startDate);
 
                // 查询在这一周内的出入库记录
                var recordsOfWeek = all_recordsOfDay.Where(r => r.CreateTime >= startDate && r.CreateTime <= endDate).ToList();
 
                // 汇总出入库记录
                var summary = new WmsStockPassMapOutput
                {
                    Time = 12 - i,
                    InWare = recordsOfWeek.Where(x => x.OrderType == OrderTypeEnum.上架单).ToList().Sum(x => x.Quantity),
                    OutWare = recordsOfWeek.Where(x => x.OrderType == OrderTypeEnum.下架单).ToList().Sum(x => x.Quantity),
                    StockNum = 0,
                    AveStockNum = 0,
                    Date = startDate.Date.ToString("MMdd") + "～" + endDate.Date.ToString("MMdd")
                };
 
                outputlist.Add(summary);
            }
        }
        //选择12个月
        else if (input.DayOrWeekOrMonth == 3)
        {
            //总的数据
            DateTime all_startDate = currentDate.AddMonths(-11).AddDays(1 - currentDate.Day);
            DateTime all_endDate = currentDate.AddMonths(1).AddDays(-1);
            var all_recordsOfDay = await _v_WmsOrderMovementDetailsRep.AsQueryable().Where(r => r.CreateTime >= all_startDate && r.CreateTime <= all_endDate
                && (r.OrderStatus == OrderStatusEnum.已完成)
                && (r.OrderType == OrderTypeEnum.上架单 || r.OrderType == OrderTypeEnum.下架单)
               ).ToListAsync();
 
            for (int i = 0; i < 12; i++)
            {
                DateTime startDate = currentDate.AddMonths(-i).AddDays(1 - currentDate.Day);
                DateTime endDate = startDate.AddMonths(1).AddDays(-1);
 
                // 查询在这个月内的出入库记录
                var recordsOfMonth = all_recordsOfDay.Where(r => r.CreateTime >= startDate && r.CreateTime <= endDate).ToList();
 
                // 汇总出入库记录
                var summary = new WmsStockPassMapOutput
                {
                    Time = 12 - i,
                    InWare = recordsOfMonth.Where(x => x.OrderType == OrderTypeEnum.上架单).ToList().Sum(x => x.Quantity),
                    OutWare = recordsOfMonth.Where(x => x.OrderType == OrderTypeEnum.下架单).ToList().Sum(x => x.Quantity),
                    StockNum = 0,
                    AveStockNum = 0,
                    Date = startDate.ToString("yyyy-MM")
                };
 
                outputlist.Add(summary);
            }
        }
 
        //排序
        outputlist = outputlist.OrderBy(x => x.Time).ToList();
 
        return outputlist;
    }
 
 
    #region 私有方法
 
    // 获取当前日期所在周的起始日期（周一）
    private DateTime GetStartOfWeek(DateTime currentDate)
    {
        int diff = currentDate.DayOfWeek - DayOfWeek.Monday;
        if (diff < 0) diff += 7; // 处理周日的情况
        return currentDate.AddDays(-1 * diff).Date;
    }
 
    // 获取当前日期所在周的结束日期（周日）
    private DateTime GetEndOfWeek(DateTime startDate)
    {
        return startDate.AddDays(6); // 因为起始日期已经是周一，所以直接加6天即可得到周日
    }
 
    /// <summary>
    /// 公共查询实时库存条件
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    private ISugarQueryable<WmsStockQuanOutput> CommonPageFilter(WmsStockQuanInput input)
    {
        var query = _rep.AsQueryable()
            .WhereIF(!string.IsNullOrWhiteSpace(input.SearchKey), u =>
                u.ContainerCode.Contains(input.SearchKey.Trim())
                || u.MaterialCode.Contains(input.SearchKey.Trim())
                || u.SupplierBatch.Contains(input.SearchKey.Trim())
                || u.Batch.Contains(input.SearchKey.Trim())
                || u.CreateUserName.Contains(input.SearchKey.Trim())
                || u.UpdateUserName.Contains(input.SearchKey.Trim())
                || u.SupplierCode.Contains(input.SearchKey.Trim())
                || u.SupplierName.Contains(input.SearchKey.Trim())
                || u.MaterialName.Contains(input.SearchKey.Trim())
                || u.SN_1d.Contains(input.SearchKey.Trim())
                || u.SN_2d.Contains(input.SearchKey.Trim())
                || u.SNCode.Contains(input.SearchKey.Trim())
                || u.ErpOrderNo.Contains(input.SearchKey.Trim())
                || u.ErpCode.Contains(input.SearchKey.Trim())
                || u.ErpVoucher.Contains(input.SearchKey.Trim())
            )
            .WhereIF(input.ContainerId > 0, u => u.ContainerId == input.ContainerId)
            .WhereIF(!string.IsNullOrWhiteSpace(input.ContainerCode), u => u.ContainerCode.Contains(input.ContainerCode.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.MaterialCode), u => u.MaterialCode.Contains(input.MaterialCode.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.SupplierBatch), u => u.SupplierBatch.Contains(input.SupplierBatch.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.Batch), u => u.Batch.Contains(input.Batch.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.SupplierCode), u => u.SupplierCode.Contains(input.SupplierCode.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.SupplierName), u => u.SupplierName.Contains(input.SupplierName.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.MaterialName), u => u.MaterialName.Contains(input.MaterialName.Trim()))
            .WhereIF(input.StockStatus.HasValue, u => u.StockStatus == input.StockStatus)
            .WhereIF(!string.IsNullOrWhiteSpace(input.SN_1d), u => u.SN_1d.Contains(input.SN_1d.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.SN_2d), u => u.SN_2d.Contains(input.SN_2d.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.SNCode), u => u.SNCode.Contains(input.SNCode.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.ErpOrderNo), u => u.ErpOrderNo.Contains(input.ErpOrderNo.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.ErpCode), u => u.ErpCode.Contains(input.ErpCode.Trim()))
            .WhereIF(input.QCStatus.HasValue, u => u.QCStatus == input.QCStatus)
            .WhereIF(!string.IsNullOrWhiteSpace(input.ErpVoucher), u => u.ErpVoucher.Contains(input.ErpVoucher.Trim()))
            .Select<WmsStockQuanOutput>();
        if (input.RecordInsertTimeRange != null && input.RecordInsertTimeRange.Count > 0)
        {
            DateTime? start = input.RecordInsertTimeRange[0].Value.AddDays(-1);
            query = query.WhereIF(start.HasValue, u => u.RecordInsertTime > start);
            if (input.RecordInsertTimeRange.Count > 1 && input.RecordInsertTimeRange[1].HasValue)
            {
                var end = input.RecordInsertTimeRange[1].Value.AddDays(1);
                query = query.Where(u => u.RecordInsertTime < end);
            }
        }
        if (input.ActionTimeRange != null && input.ActionTimeRange.Count > 0)
        {
            DateTime? start = input.ActionTimeRange[0].Value.AddDays(-1);
            query = query.WhereIF(start.HasValue, u => u.ActionTime > start);
            if (input.ActionTimeRange.Count > 1 && input.ActionTimeRange[1].HasValue)
            {
                var end = input.ActionTimeRange[1].Value.AddDays(1);
                query = query.Where(u => u.ActionTime < end);
            }
        }
        return query;
    }
 
 
    private ISugarQueryable<v_wms_stock_quan> CommonPageViewFilter(WmsStockQuanInput input)
    {
        var query = _v_wms_stock_quanRep.AsQueryable()
            .WhereIF(!string.IsNullOrWhiteSpace(input.SearchKey), u =>
                u.ContainerCode.Contains(input.SearchKey.Trim())
                || u.MaterialCode.Contains(input.SearchKey.Trim())
                || u.SupplierBatch.Contains(input.SearchKey.Trim())
                || u.Batch.Contains(input.SearchKey.Trim())
                || u.CreateUserName.Contains(input.SearchKey.Trim())
                || u.UpdateUserName.Contains(input.SearchKey.Trim())
                || u.SupplierCode.Contains(input.SearchKey.Trim())
                || u.SupplierName.Contains(input.SearchKey.Trim())
                || u.MaterialName.Contains(input.SearchKey.Trim())
                || u.SN_1d.Contains(input.SearchKey.Trim())
                || u.SN_2d.Contains(input.SearchKey.Trim())
                || u.SNCode.Contains(input.SearchKey.Trim())
                || u.ErpOrderNo.Contains(input.SearchKey.Trim())
                || u.ErpCode.Contains(input.SearchKey.Trim())
                || u.ErpVoucher.Contains(input.SearchKey.Trim())
                || u.ActionRemark.Contains(input.SearchKey.Trim())
            )
            .WhereIF(!string.IsNullOrWhiteSpace(input.ContainerCode), u => u.ContainerCode.Contains(input.ContainerCode.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.MaterialCode), u => u.MaterialCode.Contains(input.MaterialCode.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.SupplierBatch), u => u.SupplierBatch.Contains(input.SupplierBatch.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.Batch), u => u.Batch.Contains(input.Batch.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.PlaceName), u => u.PlaceName == input.PlaceName)
            .WhereIF(!string.IsNullOrWhiteSpace(input.AreaName), u => u.AreaName == input.AreaName)
 
 
            .WhereIF(!string.IsNullOrWhiteSpace(input.SupplierCode), u => u.SupplierCode.Contains(input.SupplierCode.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.SupplierName), u => u.SupplierName.Contains(input.SupplierName.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.MaterialName), u => u.MaterialName.Contains(input.MaterialName.Trim()))
            .WhereIF(input.StockStatus.HasValue, u => u.StockStatus == input.StockStatus)
            .WhereIF(!string.IsNullOrWhiteSpace(input.SN_1d), u => u.SN_1d.Contains(input.SN_1d.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.SN_2d), u => u.SN_2d.Contains(input.SN_2d.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.SNCode), u => u.SNCode.Contains(input.SNCode.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.ErpOrderNo), u => u.ErpOrderNo.Contains(input.ErpOrderNo.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.ErpCode), u => u.ErpCode.Contains(input.ErpCode.Trim()))
            .WhereIF(input.QCStatus.HasValue, u => u.QCStatus == input.QCStatus)
            .WhereIF(!string.IsNullOrWhiteSpace(input.ErpVoucher), u => u.ErpVoucher.Contains(input.ErpVoucher.Trim()))
            .Select<v_wms_stock_quan>();
        if (input.RecordInsertTimeRange != null && input.RecordInsertTimeRange.Count > 0)
        {
            DateTime? start = input.RecordInsertTimeRange[0].Value.AddDays(-1);
            query = query.WhereIF(start.HasValue, u => u.RecordInsertTime > start);
            if (input.RecordInsertTimeRange.Count > 1 && input.RecordInsertTimeRange[1].HasValue)
            {
                var end = input.RecordInsertTimeRange[1].Value.AddDays(1);
                query = query.Where(u => u.RecordInsertTime < end);
            }
        }
        if (input.ActionTimeRange != null && input.ActionTimeRange.Count > 0)
        {
            DateTime? start = input.ActionTimeRange[0].Value.AddDays(-1);
            query = query.WhereIF(start.HasValue, u => u.ActionTime > start);
            if (input.ActionTimeRange.Count > 1 && input.ActionTimeRange[1].HasValue)
            {
                var end = input.ActionTimeRange[1].Value.AddDays(1);
                query = query.Where(u => u.ActionTime < end);
            }
        }
        return query;
    }
 
    /// <summary>
    /// 重复性验证
    /// </summary>
    /// <param name="input">验证对象</param>
    /// <param name="isEdit">是否是编辑</param>
    /// <returns></returns>
    private async Task CheckExist(WmsStockQuan input, bool isEdit = false)
    {
 
 
 
        //没有配置组合校验，不需要验重
 
 
        //没有配置单独校验，不需要验重
    }
 
    /// <summary>
    /// 根据组合校验和单独校验验证数据是否已存在-导入时验证
    /// </summary>
    /// <param name="inputs"></param>
    /// <returns></returns>
    private async Task CheckExisitForImport(List<WmsStockQuan> inputs)
    {
        if (inputs?.Count <= 0)
        {
            throw Oops.Oh($"导入数据不能为空");
        }
        //根据组合校验验证表格中中是否已存在相同数据  
 
 
 
 
 
 
 
 
        //根据单独校验验证表格中中是否已存在相同数据  
 
 
 
    }
    #endregion
 
}