wgh/coreshoppro
1
0
Fork 0
mirror of http://git.coreshop.cn/jianweie/coreshoppro.git synced 2025-12-06 18:43:26 +08:00
Code Issues Packages Projects Releases Wiki Activity

添加项目文件。

Browse Source
This commit is contained in:
JianWeie
2021-12-20 21:27:32 +08:00
parent 747486f5cb
commit 82d825b7a5
3514 changed files with 887941 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
CoreCms.Net.RedisMQ/CoreCms.Net.RedisMQ.csproj Normal file
View File

@@ -0,0 +1,22 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net5.0</TargetFramework>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Essensoft.Paylink.WeChatPay" Version="4.0.6" />
<PackageReference Include="InitQ" Version="1.0.0.7" />
<PackageReference Include="Qc.YilianyunSdk" Version="1.0.7" />
<PackageReference Include="SKIT.FlurlHttpClient.Wechat.Api" Version="1.9.0" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\CoreCms.Net.Caching\CoreCms.Net.Caching.csproj" />
<ProjectReference Include="..\CoreCms.Net.Configuration\CoreCms.Net.Configuration.csproj" />
<ProjectReference Include="..\CoreCms.Net.IServices\CoreCms.Net.IServices.csproj" />
<ProjectReference Include="..\CoreCms.Net.Loging\CoreCms.Net.Loging.csproj" />
<ProjectReference Include="..\CoreCms.Net.WeChat.Service\CoreCms.Net.WeChat.Service.csproj" />
</ItemGroup>
</Project>

71
CoreCms.Net.RedisMQ/Subscribe/AfterSalesReviewSubscribe.cs Normal file
View File

@@ -0,0 +1,71 @@
using System;
using System.Threading.Tasks;
using CoreCms.Net.Configuration;
using CoreCms.Net.IServices;
using CoreCms.Net.Loging;
using CoreCms.Net.Model.Entities;
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.Subscribe
{
/// <summary>
/// 售后审核通过后处理
/// </summary>
public class AfterSalesReviewSubscribe : IRedisSubscribe
{
private readonly ICoreCmsBillAftersalesServices _aftersalesServices;
private readonly ICoreCmsDistributionOrderServices _distributionOrderServices;
private readonly ICoreCmsAgentOrderServices _agentOrderServices;
public AfterSalesReviewSubscribe(ICoreCmsBillAftersalesServices aftersalesServices, ICoreCmsDistributionOrderServices distributionOrderServices, ICoreCmsAgentOrderServices agentOrderServices)
{
_aftersalesServices = aftersalesServices;
_distributionOrderServices = distributionOrderServices;
_agentOrderServices = agentOrderServices;
}
/// <summary>
/// 售后审核通过后处理
/// </summary>
/// <param name="msg"></param>
/// <returns></returns>
[Subscribe(RedisMessageQueueKey.AfterSalesReview)]
private async Task AfterSalesReview(string msg)
{
try
{
if (string.IsNullOrEmpty(msg))
{
NLogUtil.WriteAll(NLog.LogLevel.Error, LogType.RedisMessageQueue, "售后审核通过后处理", "审核单编号获取失败");
return;
}
var info = await _aftersalesServices.QueryByClauseAsync(p => p.aftersalesId == msg);
if (info != null)
{
await _distributionOrderServices.CancleOrderByOrderId(info.orderId);
await _agentOrderServices.CancleOrderByOrderId(info.orderId);
NLogUtil.WriteAll(NLog.LogLevel.Info, LogType.RedisMessageQueue, "售后审核通过后处理", msg);
}
else
{
NLogUtil.WriteAll(NLog.LogLevel.Info, LogType.RedisMessageQueue, "售后审核通过后处理", "售后单查询失败");
}
}
catch (Exception ex)
{
NLogUtil.WriteAll(NLog.LogLevel.Error, LogType.RedisMessageQueue, "售后审核通过后处理", msg, ex);
throw;
}
await Task.CompletedTask;
}
}
}

31
CoreCms.Net.RedisMQ/Subscribe/LogingSubscribe.cs Normal file
View File

@@ -0,0 +1,31 @@
using System.Threading.Tasks;
using CoreCms.Net.Configuration;
using CoreCms.Net.Loging;
using InitQ.Abstractions;
using InitQ.Attributes;
using NLog;
namespace CoreCms.Net.RedisMQ.Subscribe
{
public class LogingSubscribe : IRedisSubscribe
{
[Subscribe(RedisMessageQueueKey.LogingQueue)]
private async Task SubRedisOrder2(string msg)
{
NLogUtil.WriteDbLog(LogLevel.Debug, LogType.RedisMessageQueue, "消息队列", $"接口端订阅从队列{RedisMessageQueueKey.LogingQueue} 接受到 消息:{msg}");
await Task.CompletedTask;
}
[Subscribe(RedisMessageQueueKey.SmsQueue)]
private async Task SubSmsQueue1(string msg)
{
NLogUtil.WriteDbLog(LogLevel.Debug, LogType.RedisMessageQueue, "消息队列", $"接口端订阅从队列{RedisMessageQueueKey.SmsQueue} 接受到 消息:{msg}");
await Task.CompletedTask;
}
}
}

120
CoreCms.Net.RedisMQ/Subscribe/OrderAgentOrDistributionSubscribe.cs Normal file
View File

@@ -0,0 +1,120 @@
using System;
using System.Threading.Tasks;
using CoreCms.Net.Configuration;
using CoreCms.Net.IServices;
using CoreCms.Net.Loging;
using CoreCms.Net.Model.Entities;
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.Subscribe
{
/// <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;
public OrderAgentOrDistributionSubscribe(ICoreCmsBillPaymentsServices billPaymentsServices, ICoreCmsDistributionOrderServices distributionOrderServices, ICoreCmsDistributionServices distributionServices, ICoreCmsSettingServices settingServices, ICoreCmsUserServices userServices, ICoreCmsAgentOrderServices agentOrderServices)
{
_billPaymentsServices = billPaymentsServices;
_distributionOrderServices = distributionOrderServices;
_distributionServices = distributionServices;
_settingServices = settingServices;
_userServices = userServices;
_agentOrderServices = agentOrderServices;
}
/// <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 jm = await _agentOrderServices.AddData(order);
//判断是走代理还是走分销
if (jm.status == true)
{
NLogUtil.WriteAll(NLog.LogLevel.Info, LogType.RedisMessageQueue, "订单完结后走代理结佣", JsonConvert.SerializeObject(jm));
return;
}
else
{
await _distributionOrderServices.AddData(order); //添加分享关联订单日志
//判断是否可以成为分销商
//先判断是否已经是经销商了。
bool check = await _distributionServices.ExistsAsync(p => p.userId == order.userId);
var allConfigs = await _settingServices.GetConfigDictionaries();
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 == true && 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
{
NLogUtil.WriteAll(NLog.LogLevel.Info, LogType.RedisMessageQueue, "订单完结结佣", "订单获取失败");
}
}
catch (Exception ex)
{
NLogUtil.WriteAll(NLog.LogLevel.Error, LogType.RedisMessageQueue, "订单完结结佣", msg, ex);
throw;
}
await Task.CompletedTask;
}
}
}

99
CoreCms.Net.RedisMQ/Subscribe/OrderAutomaticDeliverySubscribe.cs Normal file
View File

@@ -0,0 +1,99 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using CoreCms.Net.Configuration;
using CoreCms.Net.IServices;
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.Subscribe
{
/// <summary>
/// 门店订单自动发货
/// </summary>
public class OrderAutomaticDeliverySubscribe : IRedisSubscribe
{
private readonly ICoreCmsOrderServices _orderServices;
private readonly ICoreCmsOrderItemServices _orderItemServices;
private readonly ICoreCmsSettingServices _settingServices;
public OrderAutomaticDeliverySubscribe(ICoreCmsSettingServices settingServices, ICoreCmsAgentOrderServices agentOrderServices, ICoreCmsOrderServices orderServices, ICoreCmsOrderItemServices orderItemServices)
{
_settingServices = settingServices;
_orderServices = orderServices;
_orderItemServices = orderItemServices;
}
/// <summary>
/// 订单完成时，门店订单自动发货
/// </summary>
/// <param name="msg"></param>
/// <returns></returns>
[Subscribe(RedisMessageQueueKey.OrderAutomaticDelivery)]
private async Task OrderAutomaticDelivery(string msg)
{
try
{
var order = JsonConvert.DeserializeObject<CoreCmsOrder>(msg);
if (order != null)
{
var goodItems = await _orderItemServices.QueryListByClauseAsync(p => p.orderId == order.orderId);
if (!goodItems.Any())
{
NLogUtil.WriteAll(NLog.LogLevel.Info, LogType.RedisMessageQueue, "订单自动发货", "明细获取失败");
return;
}
Dictionary<int, int> items = new Dictionary<int, int>();
goodItems.ForEach(p =>
{
items.Add(p.productId, p.nums);
});
var result = new WebApiCallBack();
if (order.receiptType == (int)GlobalEnumVars.OrderReceiptType.SelfDelivery)
{
result = await _orderServices.Ship(order.orderId, "shangmenziti", "无", items, order.shipName, order.shipMobile, order.shipAddress, order.memo, order.storeId, order.shipAreaId);
}
else if (order.receiptType == (int)GlobalEnumVars.OrderReceiptType.IntraCityService)
{
result = await _orderServices.Ship(order.orderId, "benditongcheng", "无", items, order.shipName, order.shipMobile, order.shipAddress, order.memo, order.storeId, order.shipAreaId);
}
NLogUtil.WriteAll(result.status ? NLog.LogLevel.Info : NLog.LogLevel.Error,
LogType.RedisMessageQueue, "订单自动发货", JsonConvert.SerializeObject(result));
}
else
{
NLogUtil.WriteAll(NLog.LogLevel.Error, LogType.RedisMessageQueue, "订单自动发货", "订单获取失败");
}
}
catch (Exception ex)
{
NLogUtil.WriteAll(NLog.LogLevel.Error, LogType.RedisMessageQueue, "订单自动发货", msg, ex);
throw;
}
await Task.CompletedTask;
}
}
}

78
CoreCms.Net.RedisMQ/Subscribe/OrderFinishCommandSubscribe.cs Normal file
View File

@@ -0,0 +1,78 @@
using System;
using System.Threading.Tasks;
using CoreCms.Net.Configuration;
using CoreCms.Net.IServices;
using CoreCms.Net.Loging;
using CoreCms.Net.Model.Entities;
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.Subscribe
{
/// <summary>
/// 订单完成时，结算该订单
/// </summary>
public class OrderFinishCommandSubscribe : 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;
public OrderFinishCommandSubscribe(ICoreCmsBillPaymentsServices billPaymentsServices, ICoreCmsDistributionOrderServices distributionOrderServices, ICoreCmsDistributionServices distributionServices, ICoreCmsSettingServices settingServices, ICoreCmsUserServices userServices, ICoreCmsAgentOrderServices agentOrderServices)
{
_billPaymentsServices = billPaymentsServices;
_distributionOrderServices = distributionOrderServices;
_distributionServices = distributionServices;
_settingServices = settingServices;
_userServices = userServices;
_agentOrderServices = agentOrderServices;
}
/// <summary>
/// 订单完成时，结算该订单|延迟队列
/// </summary>
/// <param name="msg"></param>
/// <returns></returns>
[SubscribeDelay(RedisMessageQueueKey.OrderFinishCommand)]
private async Task OrderFinishCommand(string msg)
{
try
{
if (string.IsNullOrEmpty(msg))
{
NLogUtil.WriteAll(NLog.LogLevel.Info, LogType.RedisMessageQueue, "订单完结结佣", "订单编号获取失败");
return;
}
else
{
await _distributionOrderServices.FinishOrder(msg);
await _agentOrderServices.FinishOrder(msg);
NLogUtil.WriteAll(NLog.LogLevel.Info, LogType.RedisMessageQueue, "订单完结结佣", "订单编号获取正常：" + msg);
}
}
catch (Exception ex)
{
NLogUtil.WriteAll(NLog.LogLevel.Error, LogType.RedisMessageQueue, "订单完结结佣", msg, ex);
throw;
}
await Task.CompletedTask;
}
}
}

194
CoreCms.Net.RedisMQ/Subscribe/OrderPrintSubscribe.cs Normal file
View File

@@ -0,0 +1,194 @@
using System;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using CoreCms.Net.Configuration;
using CoreCms.Net.IServices;
using CoreCms.Net.Loging;
using CoreCms.Net.Model.Entities;
using CoreCms.Net.Utility.Helper;
using InitQ.Abstractions;
using InitQ.Attributes;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using Qc.YilianyunSdk;
using LogLevel = NLog.LogLevel;
namespace CoreCms.Net.RedisMQ.Subscribe
{
public class OrderPrintSubscribe : IRedisSubscribe
{
private readonly YilianyunService _yilianyunService;
private readonly ICoreCmsApiAccessTokenServices _accessTokenServices;
private readonly ICoreCmsOrderItemServices _orderItemServices;
private readonly ICoreCmsAreaServices _areaServices;
private readonly string _machineCode = AppSettingsConstVars.YiLianYunConfigMachineCode; //设备号
private readonly string _msign = AppSettingsConstVars.YiLianYunConfigMsign;// 终端密钥
private readonly string _printerName = AppSettingsConstVars.YiLianYunConfigPrinterName; // 打印机名称
private readonly string _phone = AppSettingsConstVars.YiLianYunConfigPhone; //手机卡号
private readonly bool _enabled = AppSettingsConstVars.YiLianYunConfigEnabled; //是否开启
public OrderPrintSubscribe(YilianyunService yilianyunService, ICoreCmsApiAccessTokenServices accessTokenServices, ICoreCmsOrderItemServices orderItemServices, ICoreCmsAreaServices areaServices)
{
_yilianyunService = yilianyunService;
_accessTokenServices = accessTokenServices;
_orderItemServices = orderItemServices;
_areaServices = areaServices;
}
/// <summary>
/// 订单打印队列
/// </summary>
/// <param name="msg"></param>
/// <returns></returns>
[Subscribe(RedisMessageQueueKey.OrderPrint)]
private async Task PrintQueue(string msg)
{
try
{
if (_enabled == false)
{
NLogUtil.WriteAll(NLog.LogLevel.Info, LogType.RedisMessageQueue, "订单打印队列", "打印机未开启");
return;
}
var order = JsonConvert.DeserializeObject<CoreCmsOrder>(msg);
if (order == null)
{
NLogUtil.WriteAll(NLog.LogLevel.Info, LogType.RedisMessageQueue, "订单打印队列", "订单获取失败");
return;
}
var accessModel = await _accessTokenServices.QueryByClauseAsync(p => p.code == GlobalEnumVars.ThirdPartyEquipment.YiLianYun.ToString() && p.machineCode == _machineCode);
string accessToken = string.Empty;
if (accessModel == null)
{
var onPostAuthTerminal = _yilianyunService.AuthTerminal(_machineCode, _msign, _phone, _printerName);
if (onPostAuthTerminal.IsSuccess())
{
accessToken = onPostAuthTerminal.Body.Access_Token;
accessModel = new CoreCmsApiAccessToken();
accessModel.code = GlobalEnumVars.ThirdPartyEquipment.YiLianYun.ToString();
accessModel.name = EnumHelper.GetEnumDescriptionByKey<GlobalEnumVars.ThirdPartyEquipment>(GlobalEnumVars.ThirdPartyEquipment.YiLianYun.ToString());
accessModel.machineCode = _machineCode;
accessModel.accessToken = onPostAuthTerminal.Body.Access_Token;
accessModel.refreshToken = onPostAuthTerminal.Body.Refresh_Token;
accessModel.expiresIn = onPostAuthTerminal.Body.Expires_In != null ? Convert.ToInt32(onPostAuthTerminal.Body.Expires_In) : 0;
accessModel.expiressEndTime = onPostAuthTerminal.Body.ExpiressEndTime;
accessModel.parameters = JsonConvert.SerializeObject(onPostAuthTerminal.Body);
accessModel.createTime = DateTime.Now;
await _accessTokenServices.InsertAsync(accessModel);
}
else
{
NLogUtil.WriteAll(NLog.LogLevel.Error, LogType.RedisMessageQueue, "易联云重新获取Token失败", JsonConvert.SerializeObject(onPostAuthTerminal));
return;
}
}
else
{
//判断是否过期
var dt = DateTime.Now;
if (dt >= accessModel.expiressEndTime)
{
var result = _yilianyunService.RefreshToken(accessModel.machineCode, accessModel.refreshToken);
if (result.IsSuccess())
{
accessToken = result.Body.Access_Token;
accessModel.accessToken = result.Body.Access_Token;
accessModel.refreshToken = result.Body.Refresh_Token;
accessModel.expiresIn = result.Body.Expires_In != null ? Convert.ToInt32(result.Body.Expires_In) : 0;
accessModel.expiressEndTime = result.Body.ExpiressEndTime;
await _accessTokenServices.UpdateAsync(accessModel);
}
else
{
NLogUtil.WriteAll(NLog.LogLevel.Error, LogType.RedisMessageQueue, "易联云更新Token失败", JsonConvert.SerializeObject(result));
return;
}
}
else
{
accessToken = accessModel.accessToken;
}
}
//获取打印机是否在线
var printerStatus = string.Empty;
var resultOnline = _yilianyunService.PrinterGetStatus(accessModel.accessToken, accessModel.machineCode);
if (resultOnline.IsSuccess())
{
printerStatus = resultOnline.Body.State.ToString();
}
if (printerStatus == "在线")
{
var payStr = EnumHelper.GetEnumDescriptionByKey<GlobalEnumVars.PaymentsTypes>(order.paymentCode);
var items = await _orderItemServices.QueryListByClauseAsync(p => p.orderId == order.orderId);
var areas = await _areaServices.GetAreaFullName(order.shipAreaId);
order.shipAreaName = areas.status ? areas.data + "" : "";
var receiptType = string.Empty;
if (order.receiptType == (int)GlobalEnumVars.OrderReceiptType.IntraCityService)
{
receiptType = "同城配送";
}
else if (order.receiptType == (int)GlobalEnumVars.OrderReceiptType.Logistics)
{
receiptType = "物流快递";
}
else if (order.receiptType == (int)GlobalEnumVars.OrderReceiptType.SelfDelivery)
{
receiptType = "门店自提";
}
var printStr = new StringBuilder();
printStr.Append("<center>--" + receiptType + "订单--</center>\r");
printStr.Append("................................\r");
printStr.Append("<center>--" + payStr + "--</center>\r");
printStr.Append("下单时间：" + order.createTime.ToString("yyyy-MM-dd HH:mm:ss") + "\r");
printStr.Append("订单编号：" + order.orderId + "\r");
printStr.Append("**************商品**************\r");
printStr.Append("<center>--购买明细--</center>\r");
if (items != null && items.Any())
{
foreach (var item in items)
{
printStr.Append(item.name + "*" + item.nums + "\r");
}
}
//printStr.Append("<center>--其他消费--</center>\r");
//printStr.Append("餐盒 1 2\r");
printStr.Append("................................\r");
printStr.Append("积分抵扣：￥" + order.pointMoney + "\r");
printStr.Append("订单优惠：￥" + order.orderDiscountAmount + "\r");
printStr.Append("商品优惠：￥" + order.goodsDiscountAmount + "\r");
printStr.Append("优惠券：￥" + order.couponDiscountAmount + "\r");
printStr.Append("总价：￥" + order.orderAmount + "\r");
printStr.Append("*******************************\r");
printStr.Append("区域：" + order.shipAreaName + "\r");
printStr.Append("地址：" + order.shipAddress + "\r");
printStr.Append("联系：" + order.shipName + " " + order.shipMobile + "\r");
printStr.Append("***************完结*************\r");
var onPostPrintText = _yilianyunService.PrintText(accessToken, _machineCode, printStr.ToString());
NLogUtil.WriteAll(NLog.LogLevel.Trace, LogType.RedisMessageQueue, "易联云打印结果", JsonConvert.SerializeObject(onPostPrintText));
}
else
{
NLogUtil.WriteAll(LogLevel.Trace, LogType.RedisMessageQueue, "易联云机器离线", JsonConvert.SerializeObject(resultOnline));
}
}
catch (Exception ex)
{
NLogUtil.WriteAll(NLog.LogLevel.Error, LogType.RedisMessageQueue, "订单打印队列", msg, ex);
throw;
}
await Task.CompletedTask;
}
}
}

258
CoreCms.Net.RedisMQ/Subscribe/SendWxTemplateMessageSubscribe.cs Normal file
View File

@@ -0,0 +1,258 @@
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using CoreCms.Net.Caching.AccressToken;
using CoreCms.Net.Configuration;
using CoreCms.Net.IServices;
using CoreCms.Net.Loging;
using CoreCms.Net.Model.Entities;
using CoreCms.Net.Model.ViewModels.UI;
using CoreCms.Net.WeChat.Service.Enums;
using CoreCms.Net.WeChat.Service.HttpClients;
using CoreCms.Net.WeChat.Service.Models;
using InitQ.Abstractions;
using InitQ.Attributes;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using SKIT.FlurlHttpClient.Wechat.Api;
using SKIT.FlurlHttpClient.Wechat.Api.Models;
namespace CoreCms.Net.RedisMQ.Subscribe
{
/// <summary>
/// 微信模板消息【小程序，公众号都走这里】
/// </summary>
public class SendWxTemplateMessageSubscribe : IRedisSubscribe
{
private readonly ICoreCmsUserWeChatInfoServices _userWeChatInfoServices;
private readonly ICoreCmsUserWeChatMsgSubscriptionServices _userWeChatMsgSubscriptionServices;
private readonly ICoreCmsUserWeChatMsgTemplateServices _userWeChatMsgTemplateServices;
private readonly IWeChatApiHttpClientFactory _weChatApiHttpClientFactory;
public SendWxTemplateMessageSubscribe(ICoreCmsUserWeChatInfoServices userWeChatInfoServices, ICoreCmsUserWeChatMsgSubscriptionServices userWeChatMsgSubscriptionServices, ICoreCmsUserWeChatMsgTemplateServices userWeChatMsgTemplateServices, IWeChatApiHttpClientFactory weChatApiHttpClientFactory)
{
_userWeChatInfoServices = userWeChatInfoServices;
_userWeChatMsgSubscriptionServices = userWeChatMsgSubscriptionServices;
_userWeChatMsgTemplateServices = userWeChatMsgTemplateServices;
_weChatApiHttpClientFactory = weChatApiHttpClientFactory;
}
/// <summary>
/// 微信模板消息【小程序，公众号都走这里】
/// </summary>
/// <param name="msg"></param>
/// <returns></returns>
[Subscribe(RedisMessageQueueKey.SendWxTemplateMessage)]
private async Task SendWxTemplateMessage(string msg)
{
try
{
var request = JsonConvert.DeserializeObject<SendWxTemplateMessage>(msg);
if (request != null)
{
if (!request.parameters.ContainsKey("parameters"))
{
NLogUtil.WriteAll(NLog.LogLevel.Error, LogType.RedisMessageQueue, "微信模板消息", "参数获取失败");
return;
}
var parameters = (JObject)request.parameters["parameters"];
if (parameters == null)
{
NLogUtil.WriteAll(NLog.LogLevel.Error, LogType.RedisMessageQueue, "微信模板消息", "参数实例化失败");
return;
}
else if (string.IsNullOrEmpty(request.code))
{
NLogUtil.WriteAll(NLog.LogLevel.Error, LogType.RedisMessageQueue, "微信模板消息", "消息类型获取失败");
return;
}
if (request.code == GlobalEnumVars.PlatformMessageTypes.SellerOrderNotice.ToString())
{
NLogUtil.WriteAll(NLog.LogLevel.Error, LogType.RedisMessageQueue, "微信模板消息", "商家不通知");
return;
}
if (request.userId == 0 || string.IsNullOrEmpty(request.code))
{
NLogUtil.WriteAll(NLog.LogLevel.Error, LogType.RedisMessageQueue, "微信模板消息", "用户编码获取失败");
return;
}
var templateData = await GetUserIsTip(request.userId, request.code);
if (templateData == null)
{
NLogUtil.WriteAll(NLog.LogLevel.Error, LogType.RedisMessageQueue, "微信模板消息", "未查询到订阅编码");
return;
}
var weChatUserInfo = await _userWeChatInfoServices.QueryByClauseAsync(p => p.userId == request.userId);
if (weChatUserInfo == null)
{
NLogUtil.WriteAll(NLog.LogLevel.Error, LogType.RedisMessageQueue, "微信模板消息", "微信用户数据查询失败");
return;
}
var templateMessageData = new Dictionary<string, CgibinMessageSubscribeSendRequest.Types.DataItem>();
var pageUrl = string.Empty;
if (request.code == GlobalEnumVars.PlatformMessageTypes.CreateOrder.ToString())
{
templateMessageData[templateData.data01] = new CgibinMessageSubscribeSendRequest.Types.DataItem() { Value = parameters["orderId"].ToString() };
templateMessageData[templateData.data02] = new CgibinMessageSubscribeSendRequest.Types.DataItem() { Value = parameters["orderAmount"].ToString() };
templateMessageData[templateData.data03] = new CgibinMessageSubscribeSendRequest.Types.DataItem() { Value = parameters["shipName"].ToString() };
templateMessageData[templateData.data04] = new CgibinMessageSubscribeSendRequest.Types.DataItem() { Value = parameters["shipMobile"].ToString() };
templateMessageData[templateData.data05] = new CgibinMessageSubscribeSendRequest.Types.DataItem() { Value = parameters["shipAddress"].ToString() };
pageUrl = "/pages/member/order/detail/detail?orderId=" + parameters["orderId"];
}
else if (request.code == GlobalEnumVars.PlatformMessageTypes.RemindOrderPay.ToString())
{
templateMessageData[templateData.data01] = new CgibinMessageSubscribeSendRequest.Types.DataItem() { Value = parameters["orderId"].ToString() };
templateMessageData[templateData.data02] = new CgibinMessageSubscribeSendRequest.Types.DataItem() { Value = parameters["orderAmount"].ToString() };
templateMessageData[templateData.data03] = new CgibinMessageSubscribeSendRequest.Types.DataItem() { Value = parameters["createTime"].ToString() };
templateMessageData[templateData.data04] = new CgibinMessageSubscribeSendRequest.Types.DataItem() { Value = "订单即将失效，请及时付款！" };
pageUrl = "/pages/member/order/detail/detail?orderId=" + parameters["orderId"];
}
else if (request.code == GlobalEnumVars.PlatformMessageTypes.OrderPayed.ToString())
{
templateMessageData[templateData.data01] = new CgibinMessageSubscribeSendRequest.Types.DataItem() { Value = parameters["orderId"].ToString() };
templateMessageData[templateData.data02] = new CgibinMessageSubscribeSendRequest.Types.DataItem() { Value = parameters["orderAmount"].ToString() };
templateMessageData[templateData.data03] = new CgibinMessageSubscribeSendRequest.Types.DataItem() { Value = parameters["paymentTime"].ToString() };
pageUrl = "/pages/member/order/detail/detail?orderId=" + parameters["orderId"];
}
else if (request.code == GlobalEnumVars.PlatformMessageTypes.DeliveryNotice.ToString())
{
templateMessageData[templateData.data01] = new CgibinMessageSubscribeSendRequest.Types.DataItem() { Value = parameters["orderId"].ToString() };
templateMessageData[templateData.data02] = new CgibinMessageSubscribeSendRequest.Types.DataItem() { Value = parameters["logiName"].ToString() };
templateMessageData[templateData.data03] = new CgibinMessageSubscribeSendRequest.Types.DataItem() { Value = parameters["logiNo"].ToString() };
pageUrl = "/pages/member/order/detail/detail?orderId=" + parameters["orderId"];
}
else if (request.code == GlobalEnumVars.PlatformMessageTypes.AfterSalesPass.ToString())
{
templateMessageData[templateData.data01] = new CgibinMessageSubscribeSendRequest.Types.DataItem() { Value = parameters["orderId"].ToString() };
templateMessageData[templateData.data02] = new CgibinMessageSubscribeSendRequest.Types.DataItem() { Value = parameters["orderAmount"].ToString() };
templateMessageData[templateData.data03] = new CgibinMessageSubscribeSendRequest.Types.DataItem() { Value = parameters["aftersalesId"].ToString() };
templateMessageData[templateData.data04] = new CgibinMessageSubscribeSendRequest.Types.DataItem() { Value = parameters["aftersalesStatus"].ToString() };
pageUrl = "/pages/member/order/detail/detail?orderId=" + parameters["orderId"];
}
else if (request.code == GlobalEnumVars.PlatformMessageTypes.RefundSuccess.ToString())
{
templateMessageData[templateData.data01] = new CgibinMessageSubscribeSendRequest.Types.DataItem() { Value = parameters["sourceId"].ToString() };
templateMessageData[templateData.data02] = new CgibinMessageSubscribeSendRequest.Types.DataItem() { Value = parameters["aftersalesId"].ToString() };
templateMessageData[templateData.data03] = new CgibinMessageSubscribeSendRequest.Types.DataItem() { Value = parameters["money"].ToString() };
templateMessageData[templateData.data04] = new CgibinMessageSubscribeSendRequest.Types.DataItem() { Value = parameters["paymentCode"].ToString() };
templateMessageData[templateData.data05] = new CgibinMessageSubscribeSendRequest.Types.DataItem() { Value = parameters["createTime"].ToString() };
}
var result = await Send(weChatUserInfo.openid, templateData.templateId, templateMessageData, pageUrl);
NLogUtil.WriteAll(NLog.LogLevel.Info, LogType.RedisMessageQueue, "微信模板消息", JsonConvert.SerializeObject(result));
}
else
{
NLogUtil.WriteAll(NLog.LogLevel.Error, LogType.RedisMessageQueue, "微信模板消息", "模板消息推送数据为空");
}
}
catch (Exception ex)
{
NLogUtil.WriteAll(NLog.LogLevel.Error, LogType.RedisMessageQueue, "微信模板消息", msg, ex);
throw;
}
await Task.CompletedTask;
}
#region 判断是否需要通知用户返回 null或者 模板数据
/// <summary>
/// 判断是否需要通知用户返回 null或者 模板数据
/// </summary>
/// <param name="userId"></param>
/// <param name="code"></param>
/// <returns></returns>
private async Task<CoreCmsUserWeChatMsgTemplate> GetUserIsTip(int userId, string code)
{
var newCode = string.Empty;
if (code == GlobalEnumVars.PlatformMessageTypes.CreateOrder.ToString())
{
newCode = GlobalEnumVars.WeChatMsgTemplateType.order.ToString();
}
else if (code == GlobalEnumVars.PlatformMessageTypes.RemindOrderPay.ToString())
{
newCode = GlobalEnumVars.WeChatMsgTemplateType.cancel.ToString();
}
else if (code == GlobalEnumVars.PlatformMessageTypes.OrderPayed.ToString())
{
newCode = GlobalEnumVars.WeChatMsgTemplateType.pay.ToString();
}
else if (code == GlobalEnumVars.PlatformMessageTypes.DeliveryNotice.ToString())
{
newCode = GlobalEnumVars.WeChatMsgTemplateType.ship.ToString();
}
else if (code == GlobalEnumVars.PlatformMessageTypes.AfterSalesPass.ToString())
{
newCode = GlobalEnumVars.WeChatMsgTemplateType.aftersale.ToString();
}
else if (code == GlobalEnumVars.PlatformMessageTypes.RefundSuccess.ToString())
{
newCode = GlobalEnumVars.WeChatMsgTemplateType.refund.ToString();
}
else
{
return null;
}
var info = await _userWeChatMsgSubscriptionServices.QueryByClauseAsync(p => p.userId == userId && p.type == newCode);
if (info != null)
{
return await _userWeChatMsgTemplateServices.QueryByClauseAsync(p => p.templateId == info.templateId);
}
return await _userWeChatMsgTemplateServices.QueryByClauseAsync(p => p.templateTitle == newCode);
//return null;
}
#endregion
#region 异步发送微信模板消息
/// <summary>
/// 异步发送微信模板消息
/// </summary>
/// <param name="openId">openId</param>
/// <param name="templateId">模板编号</param>
/// <param name="tmpData">发送数据</param>
/// <param name="pageUrl">路径（如：pages/index/index）</param>
/// <returns></returns>
private async Task<WebApiCallBack> Send(string openId, string templateId, Dictionary<string, CgibinMessageSubscribeSendRequest.Types.DataItem> tmpData, string pageUrl)
{
var jm = new WebApiCallBack();
var accessToken = WeChatCacheAccessTokenHelper.GetWxOpenAccessToken();
var client = _weChatApiHttpClientFactory.CreateWxOpenClient();
var request = new CgibinMessageSubscribeSendRequest();
request.AccessToken = accessToken;
request.MiniProgramPagePath = pageUrl;
request.TemplateId = templateId;
request.ToUserOpenId = openId;
request.Data = tmpData;
request.MiniProgramState = "formal";
var response = await client.ExecuteCgibinMessageSubscribeSendAsync(request);
if (response.IsSuccessful())
{
jm.status = true;
jm.msg = "消息已发送，请注意查收";
}
else
{
jm.status = false;
jm.msg = response.ErrorMessage;
}
return jm;
}
#endregion
}
}

105
CoreCms.Net.RedisMQ/Subscribe/UserSubscribe.cs Normal file
View File

@@ -0,0 +1,105 @@
/***********************************************************************
* Project: CoreCms
* ProjectName: 核心内容管理系统
* Web: https://www.corecms.net
* Author: 大灰灰
* Email: jianweie@163.com
* CreateTime: 2021/7/10 22:41:46
* Description: 暂无
***********************************************************************/
using System;
using System.Threading.Tasks;
using CoreCms.Net.Configuration;
using CoreCms.Net.IServices;
using CoreCms.Net.Loging;
using CoreCms.Net.Model.Entities;
using InitQ.Abstractions;
using InitQ.Attributes;
using Newtonsoft.Json;
using SqlSugar;
namespace CoreCms.Net.RedisMQ.Subscribe
{
/// <summary>
/// 用户相关队列操作
/// </summary>
public class UserSubscribe : IRedisSubscribe
{
private readonly ICoreCmsUserServices _userServices;
private readonly ICoreCmsOrderServices _orderServices;
private readonly ICoreCmsBillRefundServices _billRefundServices;
private readonly ICoreCmsUserGradeServices _userGradeServices;
public UserSubscribe(ICoreCmsUserServices userServices, ICoreCmsOrderServices orderServices, ICoreCmsBillRefundServices billRefundServices, ICoreCmsUserGradeServices userGradeServices)
{
_userServices = userServices;
_orderServices = orderServices;
_billRefundServices = billRefundServices;
_userGradeServices = userGradeServices;
}
/// <summary>
/// 订单完成-用户升级处理
/// </summary>
/// <param name="msg"></param>
/// <returns></returns>
[Subscribe(RedisMessageQueueKey.UserUpGrade)]
private async Task UserUpGradeHandler(string msg)
{
try
{
var orderModel = JsonConvert.DeserializeObject<CoreCmsOrder>(msg);
if (orderModel == null)
{
NLogUtil.WriteAll(NLog.LogLevel.Info, LogType.RedisMessageQueue, "订单完成-用户升级处理", "订单数据获取失败");
return;
}
var userInfo = await _userServices.QueryPageAsync(p => p.id == orderModel.userId);
if (userInfo == null)
{
NLogUtil.WriteAll(NLog.LogLevel.Info, LogType.RedisMessageQueue, "订单完成-用户升级处理", "用户数据获取失败");
return;
}
//订单支付的金额
var payedMoney = await _orderServices.GetSumAsync(
p => p.payStatus != (int)GlobalEnumVars.OrderAllStatusType.ALL_PENDING_PAYMENT && p.userId == orderModel.userId,
p => p.orderAmount);
//订单退款金额
var refundMoney = await _billRefundServices.GetSumAsync(
p => p.type == (int)GlobalEnumVars.BillRefundType.Order && p.userId == orderModel.userId &&
p.status != (int)GlobalEnumVars.BillRefundStatus.STATUS_REFUND, p => p.money);
var money = payedMoney - refundMoney;
//取所有用户等级信息
var userGradeModel = await _userGradeServices.QueryListByClauseAsync(p => p.id > 0, p => p.id, OrderByType.Asc);
//var id = 0;
foreach (var item in userGradeModel)
{
}
NLogUtil.WriteAll(NLog.LogLevel.Info, LogType.RedisMessageQueue, "订单完成-用户升级处理", msg);
}
catch (Exception ex)
{
NLogUtil.WriteAll(NLog.LogLevel.Error, LogType.RedisMessageQueue, "订单完成-用户升级处理", msg, ex);
throw;
}
await Task.CompletedTask;
}
}
}

83
CoreCms.Net.RedisMQ/Subscribe/WeChatPayNoticeSubscribe.cs Normal file
View File

@@ -0,0 +1,83 @@
using System;
using System.Threading.Tasks;
using CoreCms.Net.Configuration;
using CoreCms.Net.IServices;
using CoreCms.Net.Loging;
using CoreCms.Net.Model.Entities;
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.Subscribe
{
/// <summary>
/// 微信支付成功后推送到接口进行数据处理
/// </summary>
public class WeChatPayNoticeSubscribe : 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;
public WeChatPayNoticeSubscribe(ICoreCmsBillPaymentsServices billPaymentsServices, ICoreCmsDistributionOrderServices distributionOrderServices, ICoreCmsDistributionServices distributionServices, ICoreCmsSettingServices settingServices, ICoreCmsUserServices userServices, ICoreCmsAgentOrderServices agentOrderServices)
{
_billPaymentsServices = billPaymentsServices;
_distributionOrderServices = distributionOrderServices;
_distributionServices = distributionServices;
_settingServices = settingServices;
_userServices = userServices;
_agentOrderServices = agentOrderServices;
}
/// <summary>
/// 微信支付成功后推送到接口进行数据处理
/// </summary>
/// <param name="msg"></param>
/// <returns></returns>
[Subscribe(RedisMessageQueueKey.WeChatPayNotice)]
private async Task WeChatPayNotice(string msg)
{
try
{
var notify = JsonConvert.DeserializeObject<WeChatPayUnifiedOrderNotify>(msg);
if (notify is { ReturnCode: WeChatPayCode.Success })
{
if (notify.ResultCode == WeChatPayCode.Success)
{
var money = Math.Round((decimal)notify.TotalFee / 100, 2);
await _billPaymentsServices.ToUpdate(notify.OutTradeNo,
(int)GlobalEnumVars.BillPaymentsStatus.Payed,
GlobalEnumVars.PaymentsTypes.wechatpay.ToString(), money, notify.ResultCode,
notify.TransactionId);
}
else
{
var money = Math.Round((decimal)notify.TotalFee / 100, 2);
var message = notify.ErrCode + ":" + notify.ErrCodeDes;
await _billPaymentsServices.ToUpdate(notify.OutTradeNo,
(int)GlobalEnumVars.BillPaymentsStatus.Other,
GlobalEnumVars.PaymentsTypes.wechatpay.ToString(), money, notify.ReturnMsg, notify.TransactionId);
}
}
NLogUtil.WriteAll(NLog.LogLevel.Info, LogType.RedisMessageQueue, "微信支付成功后推送到接口进行数据处理", msg);
}
catch (Exception ex)
{
NLogUtil.WriteAll(NLog.LogLevel.Error, LogType.RedisMessageQueue, "微信支付成功后推送到接口进行数据处理", msg, ex);
throw;
}
await Task.CompletedTask;
}
}
}