移动系统liao
2024-05-13 d7fec17e093788d71dcd89bb0d94030a9f6ecfae
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
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
using System;
using System.Threading.Tasks;
using CoreCms.Net.Configuration;
using CoreCms.Net.IServices;
using CoreCms.Net.IServices.baifenbingfa;
using CoreCms.Net.Loging;
using CoreCms.Net.Model.Entities;
using CoreCms.Net.Model.ViewModels.UI;
using CoreCms.Net.Utility.Extensions;
using CoreCms.Net.Utility.Helper;
using Essensoft.Paylink.WeChatPay.V2;
using Essensoft.Paylink.WeChatPay.V2.Notify;
using InitQ.Abstractions;
using InitQ.Attributes;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
 
namespace CoreCms.Net.RedisMQ
{
    /// <summary>
    /// 订单完结后走代理或经销商提成处理
    /// </summary>
    public class OrderAgentOrDistributionSubscribe : IRedisSubscribe
    {
        private readonly ICoreCmsBillPaymentsServices _billPaymentsServices;
 
        private readonly ICoreCmsDistributionOrderServices _distributionOrderServices;
        private readonly ICoreCmsDistributionServices _distributionServices;
        private readonly ICoreCmsSettingServices _settingServices;
        private readonly ICoreCmsUserServices _userServices;
        private readonly ICoreCmsAgentOrderServices _agentOrderServices;
 
        private readonly IBfbfComAPIService _bfbfComAPIService;
 
 
        public OrderAgentOrDistributionSubscribe(ICoreCmsBillPaymentsServices billPaymentsServices, ICoreCmsDistributionOrderServices distributionOrderServices, ICoreCmsDistributionServices distributionServices, ICoreCmsSettingServices settingServices, ICoreCmsUserServices userServices, ICoreCmsAgentOrderServices agentOrderServices ,IBfbfComAPIService bfbfComAPIService)
        {
            _billPaymentsServices = billPaymentsServices;
            _distributionOrderServices = distributionOrderServices;
            _distributionServices = distributionServices;
            _settingServices = settingServices;
            _userServices = userServices;
            _agentOrderServices = agentOrderServices;
            _bfbfComAPIService= bfbfComAPIService;
 
        }
 
        /// <summary>
        /// 订单完结后走代理或经销商提成处理
        /// </summary>
        /// <param name="msg"></param>
        /// <returns></returns>
        [Subscribe(RedisMessageQueueKey.OrderAgentOrDistribution)]
 
        private async Task OrderAgentOrDistribution(string msg)
        {
            try
            {
                var order = JsonConvert.DeserializeObject<CoreCmsOrder>(msg);
                if (order != null)
                {
                    var allConfigs = await _settingServices.GetConfigDictionaries();
                    //是否开启三级分销(1开启,2未开启)
                    var openDistribution = CommonHelper.GetConfigDictionary(allConfigs, SystemSettingConstVars.OpenDistribution).ObjectToInt(0);
                    //是否开启代理模块(1开启,2未开启)
                    var isOpenAgent = CommonHelper.GetConfigDictionary(allConfigs, SystemSettingConstVars.IsOpenAgent).ObjectToInt(0);
                    //佣金分配模式
                    var commissionChannel = CommonHelper.GetConfigDictionary(allConfigs, SystemSettingConstVars.CommissionChannel).ObjectToInt(1);
 
                    switch (commissionChannel)
                    {
                        case (int)GlobalEnumVars.CommissionChannel.仅代理 when isOpenAgent == 1:
                        {
                            var jm = await _agentOrderServices.AddData(order);
                            jm.status = true;
                            jm.msg = "分销成功";
                            NLogUtil.WriteAll(NLog.LogLevel.Info, LogType.RedisMessageQueue, "订单完结后走代理结佣-仅代理", JsonConvert.SerializeObject(jm));
                            return;
                        }
                        case (int)GlobalEnumVars.CommissionChannel.仅分销 when openDistribution == 1:
                        {
                            var jm = await _distributionOrderServices.AddData(order); //添加分享关联订单日志
                            //判断是否可以成为经销商
                            //先判断是否已经是经销商了。
                            //百分兵法同意判决经销商
                            bool check = await _distributionServices.ExistsAsync(p => p.userId == order.userId);
                                //bool check = await _bfbfComAPIService.IsDictionary( order.userId);
 
                                var distributionType = CommonHelper.GetConfigDictionary(allConfigs, SystemSettingConstVars.DistributionType).ObjectToInt(0);
                            if (distributionType == 3)  //无需审核,但是要满足提交
                            {
                                var info = new CoreCmsDistribution();
                                //判断是否经销商
                                if (check == false)
                                {
                                    await _distributionServices.CheckCondition(allConfigs, info, order.userId);
                                    if (info.ConditionStatus && info.ConditionProgress == 100)
                                    {
                                        //添加用户
                                        var user = await _userServices.QueryByClauseAsync(p => p.id == order.userId);
                                        var iData = new CoreCmsDistribution();
                                        iData.userId = order.userId;
                                        iData.mobile = user.mobile;
                                        iData.name = !string.IsNullOrEmpty(user.nickName) ? user.nickName : user.mobile;
                                        iData.verifyStatus = (int)GlobalEnumVars.DistributionVerifyStatus.VerifyYes;
                                        iData.verifyTime = DateTime.Now;
 
                                        await _distributionServices.AddData(iData, order.userId);
                                    }
                                }
                            }
                            //已经是经销商的判断是否可以升级
                            if (check)
                            {
                                await _distributionServices.CheckUpdate(order.userId);
                            }
                            NLogUtil.WriteAll(NLog.LogLevel.Info, LogType.RedisMessageQueue, "订单完结后走分销结佣-仅分销", JsonConvert.SerializeObject(jm));
                            return;
                        }
                        case (int)GlobalEnumVars.CommissionChannel.先代理后分销 when openDistribution == 1 && isOpenAgent == 1:
                        {
                            var jm = await _agentOrderServices.AddData(order);
 
                            //判断是走代理还是走分销
                            if (jm.status)
                            {
                                NLogUtil.WriteAll(NLog.LogLevel.Info, LogType.RedisMessageQueue, "订单完结后走代理结佣-先代理后分销", JsonConvert.SerializeObject(jm));
                                return;
                            }
 
                            await _distributionOrderServices.AddData(order); //添加分享关联订单日志
                            //判断是否可以成为经销商
                            //先判断是否已经是经销商了。
                            bool check = await _distributionServices.ExistsAsync(p => p.userId == order.userId);
                            var distributionType = CommonHelper.GetConfigDictionary(allConfigs, SystemSettingConstVars.DistributionType).ObjectToInt(0);
                            if (distributionType == 3)  //无需审核,但是要满足提交
                            {
                                var info = new CoreCmsDistribution();
                                //判断是否经销商
                                if (check == false)
                                {
                                    await _distributionServices.CheckCondition(allConfigs, info, order.userId);
                                    if (info.ConditionStatus && info.ConditionProgress == 100)
                                    {
                                        //添加用户
                                        var user = await _userServices.QueryByClauseAsync(p => p.id == order.userId);
                                        var iData = new CoreCmsDistribution();
                                        iData.userId = order.userId;
                                        iData.mobile = user.mobile;
                                        iData.name = !string.IsNullOrEmpty(user.nickName) ? user.nickName : user.mobile;
                                        iData.verifyStatus = (int)GlobalEnumVars.DistributionVerifyStatus.VerifyYes;
                                        iData.verifyTime = DateTime.Now;
 
                                        await _distributionServices.AddData(iData, order.userId);
                                    }
                                }
                            }
                            //已经是经销商的判断是否可以升级
                            if (check)
                            {
                                await _distributionServices.CheckUpdate(order.userId);
                            }
                            jm.status = true;
                            jm.msg = "分销成功";
                            NLogUtil.WriteAll(NLog.LogLevel.Info, LogType.RedisMessageQueue, "订单完结后走分销结佣-先代理后分销", JsonConvert.SerializeObject(jm));
                            return;
                        }
                        case (int)GlobalEnumVars.CommissionChannel.先分销后代理 when openDistribution == 1 && isOpenAgent == 1:
                        {
                            var jm = await _distributionOrderServices.AddData(order);
                            if (jm.status)
                            {
                                bool check = await _distributionServices.ExistsAsync(p => p.userId == order.userId);
                                var distributionType = CommonHelper.GetConfigDictionary(allConfigs, SystemSettingConstVars.DistributionType).ObjectToInt(0);
                                if (distributionType == 3)  //无需审核,但是要满足提交
                                {
                                    var info = new CoreCmsDistribution();
                                    //判断是否经销商
                                    if (check == false)
                                    {
                                        await _distributionServices.CheckCondition(allConfigs, info, order.userId);
                                        if (info.ConditionStatus && info.ConditionProgress == 100)
                                        {
                                            //添加用户
                                            var user = await _userServices.QueryByClauseAsync(p => p.id == order.userId);
                                            var iData = new CoreCmsDistribution();
                                            iData.userId = order.userId;
                                            iData.mobile = user.mobile;
                                            iData.name = !string.IsNullOrEmpty(user.nickName) ? user.nickName : user.mobile;
                                            iData.verifyStatus = (int)GlobalEnumVars.DistributionVerifyStatus.VerifyYes;
                                            iData.verifyTime = DateTime.Now;
 
                                            await _distributionServices.AddData(iData, order.userId);
                                        }
                                    }
                                }
                                //已经是经销商的判断是否可以升级
                                if (check)
                                {
                                    await _distributionServices.CheckUpdate(order.userId);
                                }
                                jm.status = true;
                                jm.msg = "分销成功";
                                NLogUtil.WriteAll(NLog.LogLevel.Info, LogType.RedisMessageQueue, "订单完结后走分销结佣-先分销后代理", JsonConvert.SerializeObject(jm));
                                return;
                            }
                            else
                            {
                                jm = await _agentOrderServices.AddData(order);
                                NLogUtil.WriteAll(NLog.LogLevel.Info, LogType.RedisMessageQueue, "订单完结后走代理结佣-先分销后代理", JsonConvert.SerializeObject(jm));
                                return;
                            }
                        }
                    }
 
                }
                else
                {
                    NLogUtil.WriteAll(NLog.LogLevel.Info, LogType.RedisMessageQueue, "订单完结结佣", "订单获取失败");
                }
            }
            catch (Exception ex)
            {
                NLogUtil.WriteAll(NLog.LogLevel.Error, LogType.RedisMessageQueue, "订单完结结佣", msg, ex);
                throw;
            }
            await Task.CompletedTask;
        }
 
 
 
 
    }
}