yanjinhui
2025-10-18 d48e486d63ae2a0fc454c27c79b8f12115e4bcbe
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
using HslCommunication;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core;
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Helper;
using WIDESEA_DTO.SquareCabin;
using WIDESEA_IWMsInfoServices;
using WIDESEA_Model.Models;
using static WIDESEA_DTO.SquareCabin.TowcsDto;
 
namespace WIDESEA_WMsInfoServices
{
    public class InventoryInfoService : ServiceBase<Dt_InventoryInfo, IRepository<Dt_InventoryInfo>>, IInventoryInfoService
    {
        public InventoryInfoService(IRepository<Dt_InventoryInfo> BaseDal) : base(BaseDal)
        {
        }
        public IRepository<Dt_InventoryInfo> Repository => BaseDal;
 
        /// <summary>
        /// wcs回传给我调用我的方法
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public ApiResponse<Dt_InventoryInfo> OrderFeedback(EdiOrderCallbackRequest request)
        {
            try
            {
                if (request == null || request.details == null || !request.details.Any())
                {
                    return new ApiResponse<Dt_InventoryInfo> { code = "500", msg = "请求参数无效" };
                }
 
                BaseDal.Db.Ado.BeginTran(); // 开启事务
 
                foreach (var detail in request.details)
                {
                    // 获取明细中的总入库数量(自动转为正数)
                    decimal orderQty = detail.orderDetails?
                        .Sum(x => decimal.TryParse(x.quantity, out var q) ? Math.Abs(q) : 0)
                        ?? 0;
 
                    //盘点
                    decimal diffQty = detail.stocktakingDetails?
                        .Sum(x => Convert.ToDecimal(x.differenceQuantity))
                        ?? 0;
 
                    // 根据物料编号 + 批次号 查找是否已有库存
                    var entity = BaseDal.Db.Queryable<Dt_InventoryInfo>()
                        .First(x => x.MaterielCode == detail.productCode && x.BatchNo == detail.batchNo);
 
                    if (entity == null)
                    {
                        // 🆕 不存在则新建库存记录
                        entity = new Dt_InventoryInfo
                        {
                            PalletCode = detail.orderDetails?.FirstOrDefault()?.palletCode ?? "",
                            WarehouseCode = 001.ToString(),  // 默认库房编号,可根据业务改
                            LocationCode = "", // 暂无可空
                            StockStatus = 1,   // 立库固定为 1
                            MaterielCode = detail.productCode ?? detail.productName,
                            MaterielName = detail.productName ?? "",
                            MaterielSpec = detail.productSpecifications ?? "",
                            BatchNo = detail.batchNo,
                            // 初次入库数量 = 实际入库数量
                            StockQuantity = 0,
                            OutboundQuantity = 0,
                            SupplyQuantity = 0,
                            InDate = DateTime.Now,
                            ProductionDate = detail.finishDate.ToString("yyyy-MM-dd"),
                            ShelfLife = 0,
                            ValidityPeriod = "",
                            Remark = "WCS回传创建"
                        };
                    }
 
                    switch (request.orderType)
                    {
                        case "1": // 入库
                            entity.StockQuantity += orderQty;
                            entity.InDate = DateTime.Now;
                            entity.Remark = "入库单回传";
                            break;
 
                        case "2": // 出库
                            entity.OutboundQuantity += orderQty;
                            entity.StockQuantity -= orderQty;
                            if (entity.StockQuantity < 0) entity.StockQuantity = 0;
                            entity.Remark = "出库单回传";
                            break;
 
                        case "3": // 盘点
                            if (detail.stocktakingDetails != null && detail.stocktakingDetails.Any())
                            {
                                foreach (var stock in detail.stocktakingDetails)
                                {
                                    decimal diff = Convert.ToDecimal(stock.differenceQuantity);
                                    if (stock.IsProfit == "1") // 盘盈
                                    {
                                        entity.SupplyQuantity += Math.Abs(diff);
                                    }
                                    else // 盘亏
                                    {
                                        entity.SupplyQuantity -= Math.Abs(diff);
                                        if (entity.SupplyQuantity < 0) entity.SupplyQuantity = 0;
                                    }
                                    entity.PalletCode = stock.palletCode;
                                    entity.Remark = "盘点单回传";
                                }
                            }
                            break;
                    }
 
                    // 插入或更新数据库
                    if (entity.Id == 0)
                    {
                        BaseDal.Db.Insertable(entity).ExecuteCommand();
                    }
                    else
                    {
                        BaseDal.Db.Updateable(entity).ExecuteCommand();
                    }
                }
 
                BaseDal.Db.Ado.CommitTran();
                return new ApiResponse<Dt_InventoryInfo> { code = "0", msg = "成功" };
            }
            catch (Exception ex)
            {
                BaseDal.Db.Ado.RollbackTran();
                return new ApiResponse<Dt_InventoryInfo> { code = "500", msg = ex.Message };
            }
        }
 
 
 
 
 
 
 
 
        /// <summary>
        /// 推送异常信息给上游系统1.入库单接口;2.入库单报完成接口;3.出库单接口;4.出库报完成接口;5.药品基础信息同步接口;6.供应商信息接口;7.客户信息接口;8.库存
        /// </summary>
        public void SendErrorToUpstream(int type, string code, string message, string remark)
        {
            try
            {
                var url = "http://121.37.118.63:80/GYZ2/95fck/exceptionLog";
 
                var requestData = new
                {
                    type = type.ToString(),
                    code = code,
                    message = message,
                    remark = remark
                };
 
                var result = HttpHelper.Post(url, requestData.ToJsonString());
                // 可以反序列化检查 resultCode 是否为0
            }
            catch (Exception e)
            {
                // 这里不要再抛异常了,避免死循环
                Console.WriteLine("异常接口推送失败:" + e.Message);
            }
        }
    }
}