public ActionResult Index()
{
//MPMenu.CreateMenuDefault();
string signature = Request["signature"];
string timestamp = Request["timestamp"];
string nonce = Request["nonce"];
string echostr = Request["echostr"];
if (Request.HttpMethod == "GET")
{
//仅在微信后台填写URL验证时触发
if (MPBasicSetting.FirstCertification == "1")
{
if (CheckSignature.Check(signature, timestamp, nonce, MPBasicSetting.Token))
{
FileHelper.WriteLog(echostr);
return(Content(echostr));
}
}
}
else
{
//post method - 当有用户向公众账号发送消息时触发
#if !DEBUG
if (!CheckSignature.Check(signature, timestamp, nonce, MPBasicSetting.Token))
{
//WriteContent("服务器忙！");
FileHelper.WriteLog("Token验证失败", signature + " " + MPBasicSetting.Token);
return(Content("服务器忙..."));
}
#endif
//v4.2.2之后的版本，可以设置每个人上下文消息储存的最大数量，防止内存占用过多，如果该参数小于等于0，则不限制
var maxRecordCount = 10;
try
{
//当使用加密模式时，此参数有用。
var pm = new PostModel()
{
Signature = signature,
Msg_Signature = Request.QueryString["msg_signature"],
Timestamp = timestamp,
Nonce = nonce,
//以下保密信息不会（不应该）在网络上传播，请注意
Token = MPBasicSetting.Token,
//EncodingAESKey = "mNnY5GekpChwqhy2c4NBH90g3hND6GeI4gii2YCvKLY", //根据自己后台的设置保持一致
AppId = MPBasicSetting.AppID //根据自己后台的设置保持一致
};
var requestMessageHandler = new MPCustomMessageHandler(Request.InputStream, pm, maxRecordCount);
//执行微信处理过程
requestMessageHandler.Execute();
return(Content(requestMessageHandler.ResponseDocument.ToString()));
}
catch (Exception ex)
{
FileHelper.WriteLog("消息处理错误", ex.Message);
return(Content("服务器忙..."));
}
finally
{
}
}
ViewBag.WeChatTitleName = MPBasicSetting.WeChatTitleName;
return(View());
}
public ActionResult OldPost(string signature, string timestamp, string nonce, string echostr)
{
LocationService locationService = new LocationService();
EventService eventService = new EventService();
if (!CheckSignature.Check(signature, timestamp, nonce, WeiXinConfiguration.Token))
{
return(Content("参数错误！"));
}
XDocument requestDoc = null;
try
{
requestDoc = XDocument.Load(Request.InputStream);
var requestMessage = RequestMessageFactory.GetRequestEntity(requestDoc);
//如果不需要记录requestDoc，只需要：
//var requestMessage = RequestMessageFactory.GetRequestEntity(Request.InputStream);
requestDoc.Save(Server.MapPath("~/App_Data/" + DateTime.Now.Ticks + "_Request_" + requestMessage.FromUserName + ".txt"));//测试时可开启，帮助跟踪数据
ResponseMessageBase responseMessage = null;
switch (requestMessage.MsgType)
{
case RequestMsgType.Text: //文字
{
//TODO:交给Service处理具体信息，参考/Service/EventSercice.cs 及 /Service/LocationSercice.cs
var strongRequestMessage = requestMessage as RequestMessageText;
var strongresponseMessage =
ResponseMessageBase.CreateFromRequestMessage(requestMessage, ResponseMsgType.Text) as
ResponseMessageText;
strongresponseMessage.Content =
string.Format(
"您刚才发送了文字信息：{0}\r\n您还可以发送【位置】【图片】【语音】等类型的信息，查看不同格式的回复。\r\nSDK官方地址：http://weixin.senparc.com",
strongRequestMessage.Content);
responseMessage = strongresponseMessage;
break;
}
case RequestMsgType.Location: //位置
{
responseMessage = locationService.GetResponseMessage(requestMessage as RequestMessageLocation);
break;
}
case RequestMsgType.Image: //图片
{
//TODO:交给Service处理具体信息
var strongRequestMessage = requestMessage as RequestMessageImage;
var strongresponseMessage =
ResponseMessageBase.CreateFromRequestMessage(requestMessage, ResponseMsgType.News) as
ResponseMessageNews;
strongresponseMessage.Articles.Add(new Article()
{
Title = "您刚才发送了图片信息",
Description = "您发送的图片将会显示在边上",
PicUrl = strongRequestMessage.PicUrl,
Url = "http://weixin.senparc.com"
});
strongresponseMessage.Articles.Add(new Article()
{
Title = "第二条",
Description = "第二条带连接的内容",
PicUrl = strongRequestMessage.PicUrl,
Url = "http://weixin.senparc.com"
});
responseMessage = strongresponseMessage;
break;
}
case RequestMsgType.Voice: //语音
{
//TODO:交给Service处理具体信息
var strongRequestMessage = requestMessage as RequestMessageVoice;
var strongresponseMessage =
ResponseMessageBase.CreateFromRequestMessage(requestMessage, ResponseMsgType.Music) as
ResponseMessageMusic;
strongresponseMessage.Music.MusicUrl = "http://weixin.senparc.com/Content/music1.mp3";
responseMessage = strongresponseMessage;
break;
}
case RequestMsgType.Event: //事件
{
responseMessage = eventService.GetResponseMessage(requestMessage as RequestMessageEventBase);
break;
}
default:
throw new ArgumentOutOfRangeException();
}
var responseDoc = Senparc.Weixin.MP.Helpers.EntityHelper.ConvertEntityToXml(responseMessage);
responseDoc.Save(Server.MapPath("~/App_Data/" + DateTime.Now.Ticks + "_Response_" + responseMessage.ToUserName + ".txt"));//测试时可开启，帮助跟踪数据
return(Content(responseDoc.ToString()));
//如果不需要记录responseDoc，只需要：
//return Content(responseMessage.ConvertEntityToXmlString());
}
catch (Exception ex)
{
using (
TextWriter tw = new StreamWriter(Server.MapPath("~/App_Data/Error_" + DateTime.Now.Ticks + ".txt")))
{
tw.WriteLine(ex.Message);
tw.WriteLine(ex.InnerException.Message);
if (requestDoc != null)
{
tw.WriteLine(requestDoc.ToString());
}
tw.Flush();
tw.Close();
}
return(Content(""));
}
}
public ActionResult Post(PostModel postModel)
{
if (!CheckSignature.Check(postModel.Signature, postModel.Timestamp, postModel.Nonce, Token))
{
return(Content("参数错误！"));
}
postModel.Token = Token; //根据自己后台的设置保持一致
postModel.EncodingAESKey = EncodingAESKey; //根据自己后台的设置保持一致
postModel.AppId = WxOpenAppId; //根据自己后台的设置保持一致（必须提供）
//v4.2.2之后的版本，可以设置每个人上下文消息储存的最大数量，防止内存占用过多，如果该参数小于等于0，则不限制
var maxRecordCount = 10;
var logPath = Server.GetMapPath(string.Format("~/App_Data/WxOpen/{0}/", DateTime.Now.ToString("yyyy-MM-dd")));
if (!Directory.Exists(logPath))
{
Directory.CreateDirectory(logPath);
}
//自定义MessageHandler，对微信请求的详细判断操作都在这里面。
var messageHandler = new CustomWxOpenMessageHandler(Request.GetRequestMemoryStream(), postModel, maxRecordCount);
try
{
/* 如果需要添加消息去重功能，只需打开OmitRepeatedMessage功能，SDK会自动处理。
* 收到重复消息通常是因为微信服务器没有及时收到响应，会持续发送2-5条不等的相同内容的RequestMessage*/
messageHandler.OmitRepeatedMessage = true;
//测试时可开启此记录，帮助跟踪数据，使用前请确保App_Data文件夹存在，且有读写权限。
messageHandler.SaveRequestMessageLog(); //记录 Request 日志（可选）
messageHandler.Execute(); //执行微信处理过程（关键）
messageHandler.SaveResponseMessageLog(); //记录 Response 日志（可选）
//return Content(messageHandler.ResponseDocument.ToString());//v0.7-
return(new FixWeixinBugWeixinResult(messageHandler)); //为了解决官方微信5.0软件换行bug暂时添加的方法，平时用下面一个方法即可
//return new WeixinResult(messageHandler);//v0.8+
}
catch (Exception ex)
{
using (TextWriter tw = new StreamWriter(Server.GetMapPath("~/App_Data/Error_WxOpen_" + _getRandomFileName() + ".txt")))
{
tw.WriteLine("ExecptionMessage:" + ex.Message);
tw.WriteLine(ex.Source);
tw.WriteLine(ex.StackTrace);
//tw.WriteLine("InnerExecptionMessage:" + ex.InnerException.Message);
if (messageHandler.ResponseDocument != null)
{
tw.WriteLine(messageHandler.ResponseDocument.ToString());
}
if (ex.InnerException != null)
{
tw.WriteLine("========= InnerException =========");
tw.WriteLine(ex.InnerException.Message);
tw.WriteLine(ex.InnerException.Source);
tw.WriteLine(ex.InnerException.StackTrace);
}
tw.Flush();
tw.Close();
}
return(Content(""));
}
}
public ActionResult Index(long id = 0)
{
Log.Info("进入微信API");
var siteSetting = SiteSettingApplication.SiteSettings;
//string token = "weixin_test";
string token = "", signature = "", nonce = "", timestamp = "", echostr = "";
if (id == 0)
{
token = siteSetting.WeixinToken;
}
else
{
var _tmp = _iVShopService.GetVShopSetting(id);
if (_tmp == null)
{
throw new HimallException("错误的商铺编号");
}
token = _tmp.Token;
}
signature = Request["signature"];
nonce = Request["nonce"];
timestamp = Request["timestamp"];
echostr = Request["echostr"];
ActionResult actionResult = Content("");
Log.Info(string.Format("传入信息：signature = {0} , nonce = {1} , timestamp = {2} , echostr = {3} , id = {4}", signature, nonce, timestamp, echostr, id));
if (Request.HttpMethod == "GET")
{
if (CheckSignature.Check(signature, timestamp, nonce, token))
{
actionResult = Content(echostr);
}
}
else
{
//TODO:[lly] 微信消息处理
if (!CheckSignature.Check(signature, timestamp, nonce, token))
{
Log.Info("验证不通过");
}
XDocument requestDoc = XDocument.Load(Request.InputStream);
#if DEBUG
//调试时记录数据日志
Core.Log.Debug(requestDoc);
#endif
var requestBaseMsg = RequestMessageFactory.GetRequestEntity(requestDoc);
SceneHelper helper = new SceneHelper();
//卡券服务
var cardser = _iWXCardService;
switch (requestBaseMsg.MsgType)
{
#region Event处理
case RequestMsgType.Event:
var requestMsg = requestBaseMsg as Senparc.Weixin.MP.Entities.RequestMessageEventBase;
Log.Info("进入RequestMsgType - Event：" + requestMsg.Event.ToString());
switch (requestMsg.Event)
{
//取消公众号订阅事件
case Event.unsubscribe:
UnSubscribe(requestMsg.FromUserName);
break;
//订阅公众号事件
case Event.subscribe:
//关注红包
actionResult = SendAttentionToUser(requestBaseMsg);
#region 关注公众号，欢迎语！
int nowtime = ConvertDateTimeInt(DateTime.Now);
//string msg = "";//关注时，需要发送的内容
var data = WeixinAutoReplyApplication.GetAutoReplyByKey(CommonModel.ReplyType.Follow, "", false, true, true);
//string resxml = "<xml><ToUserName><![CDATA[" + requestBaseMsg.FromUserName + "]]></ToUserName><FromUserName><![CDATA[" + requestBaseMsg.ToUserName + "]]></FromUserName><CreateTime>" + nowtime + "</CreateTime><MsgType><![CDATA[text]]></MsgType><Content><![CDATA[" + msg + "]]></Content><FuncFlag>0</FuncFlag></xml>";
if (data == null)
{
Log.Info("请设置关注后自动回复消息内容！");
}
string resxml = GetResxml(data, requestBaseMsg);
if (!string.IsNullOrEmpty(resxml))
{
Response.Write(resxml);
}
//Response.Write(resxml);
#endregion
var requestSubscribe = requestMsg as Senparc.Weixin.MP.Entities.RequestMessageEvent_Subscribe;
#if DEBUG
Log.Debug(requestSubscribe, new Exception("进入订阅事件"));
#endif
bool isActivityBonus = false;
SceneModel sceneModel = null;
#if DEBUG
Log.Info("进入订阅事件requestSubscribe.EventKey =" + requestSubscribe.EventKey);
#endif
#region 场景二维码
if (requestSubscribe.EventKey != string.Empty)
{
var scene = requestSubscribe.EventKey.Replace("qrscene_", string.Empty);
sceneModel = helper.GetModel(scene);
if (sceneModel != null)
{
#if DEBUG
Log.Info("sceneModel.Type = " + sceneModel.SceneType.ToString());
#endif
if (sceneModel.SceneType == QR_SCENE_Type.WithDraw)
{ //提现场景（未关注时）
echostr = ProcessWithDrawScene(requestSubscribe, scene, sceneModel);
actionResult = Content(echostr);
}
else if (sceneModel.SceneType == QR_SCENE_Type.Bonus)
{
//TODO:ZJT 用户通过场景二维码扫描关注后 推送消息给用户
//isActivityBonus用于判断激发关注事件的是活动红包还是其他
isActivityBonus = true;
actionResult = SendActivityToUser(sceneModel.Object, requestBaseMsg);
}
else if (sceneModel.SceneType == QR_SCENE_Type.FlashSaleRemind)
{
#if DEBUG
Log.Info("进入限时购场景二维码事件");
#endif
long flashSaleId = (long)sceneModel.Object;
SendFlashSaleRemindMessage(flashSaleId, requestBaseMsg.FromUserName);
}
else if (sceneModel.SceneType == QR_SCENE_Type.Binding) //绑定微信
{
echostr = Binding(requestSubscribe, scene, sceneModel);
actionResult = Content(echostr);
}
}
}
#endregion
Log.Info("开始isActivityBonus=" + isActivityBonus);
//通过场景二维码进来，并且二维码不是活动红包，则进行关注送红包事件
//if (!isActivityBonus && sceneModel != null && sceneModel.SceneType == QR_SCENE_Type.Bonus)
//{
// actionResult = SendAttentionToUser(requestBaseMsg);
//}
#if DEBUG
Log.Info("开始Subscribe requestBaseMsg.FromUserName="******"进入限时购场景二维码事件");
long flashSaleId = (long)sceneModel.Object;
SendFlashSaleRemindMessage(flashSaleId, requestBaseMsg.FromUserName);
}
else if (sceneModel.SceneType == QR_SCENE_Type.Binding) //绑定微信
{
echostr = Binding(requestScan, requestScan.EventKey, sceneModel);
actionResult = Content(echostr);
}
else if (sceneModel.SceneType == QR_SCENE_Type.ShopShipper) //绑定收发货
{
echostr = BindingByShopShipper(requestScan, requestScan.EventKey, sceneModel);
actionResult = Content(echostr);
}
}
}
break;
case Event.card_pass_check:
//TODO:DZY[150907] 卡券审核通过
var reqpasscard = requestMsg as Senparc.Weixin.MP.Entities.RequestMessageEvent_Card_Pass_Check;
if (!string.IsNullOrWhiteSpace(reqpasscard.CardId))
{
cardser.Event_Audit(reqpasscard.CardId, Entities.WXCardLogInfo.AuditStatusEnum.Audited);
}
break;
case Event.card_not_pass_check:
//TODO:DZY[150907] 卡券审核失败
var reqnopasscard = requestMsg as Senparc.Weixin.MP.Entities.RequestMessageEvent_Card_Pass_Check;
if (!string.IsNullOrWhiteSpace(reqnopasscard.CardId))
{
cardser.Event_Audit(reqnopasscard.CardId, Entities.WXCardLogInfo.AuditStatusEnum.AuditNot);
}
break;
case Event.user_del_card:
//TODO:DZY[150907] 删除卡包内优惠券
var requdelcard = requestMsg as Senparc.Weixin.MP.Entities.RequestMessageEvent_User_Del_Card;
if (!string.IsNullOrWhiteSpace(requdelcard.CardId) && !string.IsNullOrWhiteSpace(requdelcard.UserCardCode))
{
cardser.Event_Unavailable(requdelcard.CardId, requdelcard.UserCardCode);
}
break;
case Event.user_get_card:
//TODO:DZY[150907] 用户获取优惠券
var requgetcard = requestMsg as Senparc.Weixin.MP.Entities.RequestMessageEvent_User_Get_Card;
Log.Debug("WXCard:" + requgetcard.CardId + "_" + requgetcard.UserCardCode);
if (!string.IsNullOrWhiteSpace(requgetcard.CardId) && !string.IsNullOrWhiteSpace(requgetcard.UserCardCode))
{
cardser.Event_Send(requgetcard.CardId, requgetcard.UserCardCode, requgetcard.FromUserName, requgetcard.OuterId);
}
break;
}
break;
#endregion
case RequestMsgType.Text:
textCase(requestBaseMsg);
break;
}
Response.End();
}
return(actionResult);
}
private readonly string Token = "weixin";//与微信公众账号后台的Token设置保持一致，区分大小写。
protected void Page_Load(object sender, EventArgs e)
{
string signature = Request["signature"];
string timestamp = Request["timestamp"];
string nonce = Request["nonce"];
string echostr = Request["echostr"];
if (Request.HttpMethod == "GET")
{
//get method - 仅在微信后台填写URL验证时触发
if (CheckSignature.Check(signature, timestamp, nonce, Token))
{
WriteContent(echostr); //返回随机字符串则表示验证通过
}
else
{
WriteContent("failed:" + signature + "," + CheckSignature.GetSignature(timestamp, nonce, Token) + "。" +
"如果你在浏览器中看到这句话，说明此地址可以被作为微信公众账号后台的Url，请注意保持Token一致。");
}
Response.End();
}
else
{
//post method - 当有用户想公众账号发送消息时触发
if (!CheckSignature.Check(signature, timestamp, nonce, Token))
{
WriteContent("参数错误！");
return;
}
//v4.2.2之后的版本，可以设置每个人上下文消息储存的最大数量，防止内存占用过多，如果该参数小于等于0，则不限制
var maxRecordCount = 10;
//自定义MessageHandler，对微信请求的详细判断操作都在这里面。
var messageHandler = new CustomMessageHandler(Request.InputStream, maxRecordCount);
try
{
//测试时可开启此记录，帮助跟踪数据
messageHandler.RequestDocument.Save(
Server.MapPath("~/App_Data/" + DateTime.Now.Ticks + "_Request_" +
messageHandler.RequestMessage.FromUserName + ".txt"));
//执行微信处理过程
messageHandler.Execute();
//测试时可开启，帮助跟踪数据
messageHandler.ResponseDocument.Save(
Server.MapPath("~/App_Data/" + DateTime.Now.Ticks + "_Response_" +
messageHandler.ResponseMessage.ToUserName + ".txt"));
WriteContent(messageHandler.ResponseDocument.ToString());
return;
}
catch (Exception ex)
{
using (TextWriter tw = new StreamWriter(Server.MapPath("~/App_Data/Error_" + DateTime.Now.Ticks + ".txt")))
{
tw.WriteLine(ex.Message);
tw.WriteLine(ex.InnerException.Message);
if (messageHandler.ResponseDocument != null)
{
tw.WriteLine(messageHandler.ResponseDocument.ToString());
}
tw.Flush();
tw.Close();
}
WriteContent("");
}
finally
{
Response.End();
}
}
}
/// <summary>
/// 开始处理
/// </summary>
public void Processing()
{
HttpContext context = HttpContext.Current;
if (context == null || context.Request == null)
{
throw new Exception("HttpContext信息错误");
}
this.Signature = context.Request.QueryString["signature"];
this.TimeStamp = context.Request.QueryString["timestamp"];
this.Nonce = context.Request.QueryString["nonce"];
this.Echostr = context.Request.QueryString["echostr"];
this.EncryptType = context.Request.QueryString["encrypt_type"];
this.MsgSignature = context.Request.QueryString["msg_signature"];
if (AppSettings.IsDebug)
{
//DebugLog
Logger.Info("MsgSig = " + MsgSignature);
Logger.Info("Signature = " + Signature);
Logger.Info("TimeStamp = " + TimeStamp);
Logger.Info("Nonce = " + Nonce);
Logger.Info("Echostr = " + Echostr);
Logger.Info("EncryptType = " + EncryptType);
Logger.Info("MsgSignature = " + MsgSignature);
}
if (string.IsNullOrEmpty(this.Signature) ||
string.IsNullOrEmpty(this.TimeStamp) ||
string.IsNullOrEmpty(this.Nonce))
{
throw new Exception("HttpContext信息错误");
}
//校验Token签名(请求来源是否为微信服务器)
if (!CheckSignature.Check(this.Signature, this.TimeStamp, this.Nonce, WechatConfig.Token))
{
throw new Exception("ERR: VerifyURL Fail, 签名校验失败。");
}
int ret = 0;
#region 首次配置服务器信息时，直接返回Echostr
if (!string.IsNullOrEmpty(this.Echostr))
{
context.Response.ContentType = "text/plain";
context.Response.Write(Echostr);
return;
}
#endregion
//获取post请求内容
StreamReader postData = new StreamReader(context.Request.InputStream);
string postDataString = postData.ReadToEnd();
if (AppSettings.IsDebug)
{
Logger.Info("postDataString = " + postDataString);
}
if (EncryptType == "aes")
{
//解密
ret = Wxcpt.DecryptMsg(MsgSignature, TimeStamp, Nonce, postDataString, ref postDataString);
if (ret != 0)
{
throw new Exception("ERR: Decrypt Fail, errorCode: " + ret);
}
}
if (AppSettings.IsDebug)
{
Logger.Info("sMsg = " + postDataString);
}
//解析XML
XmlDocument doc = new XmlDocument();
doc.LoadXml(postDataString);
ReceiveMessageEnum messageType = ReceiveMessageEnum.Unknow;
ReceiveMessage.Base messageEntity = ReceiveMessageParser.Parse(doc, ref messageType);
ReplyMessage.Base retMessage = null;
#region 根据接收消息类型 执行相应事件
switch (messageType)
{
case ReceiveMessageEnum.Unknow:
throw new Exception("未知的接收消息类型。");
case ReceiveMessageEnum.Text:
if (ProcessingText != null)
{
ProcessingTextEventArgs e = new ProcessingTextEventArgs(messageEntity as ReceiveMessage.Text);
ProcessingText(this, e);
retMessage = e.ReplyMessage;
}
break;
case ReceiveMessageEnum.Image:
if (ProcessingImage != null)
{
ProcessingImageEventArgs e = new ProcessingImageEventArgs(messageEntity as ReceiveMessage.Image);
ProcessingImage(this, e);
retMessage = e.ReplyMessage;
}
break;
case ReceiveMessageEnum.Voice:
if (ProcessingVoice != null)
{
ProcessingVoiceEventArgs e = new ProcessingVoiceEventArgs(messageEntity as ReceiveMessage.Voice);
ProcessingVoice(this, e);
retMessage = e.ReplyMessage;
}
break;
case ReceiveMessageEnum.Video:
if (ProcessingVideo != null)
{
ProcessingVideoEventArgs e = new ProcessingVideoEventArgs(messageEntity as ReceiveMessage.Video);
ProcessingVideo(this, e);
retMessage = e.ReplyMessage;
}
break;
case ReceiveMessageEnum.ShortVideo:
break;
case ReceiveMessageEnum.Location:
if (ProcessingLocation != null)
{
ProcessingLocationEventArgs e = new ProcessingLocationEventArgs(messageEntity as ReceiveMessage.Location);
ProcessingLocation(this, e);
retMessage = e.ReplyMessage;
}
break;
case ReceiveMessageEnum.Link:
break;
case ReceiveMessageEnum.Event_Subscribe:
if (ProcessingEventSubscribe != null)
{
ProcessingEventSubscribeEventArgs e = new ProcessingEventSubscribeEventArgs(messageEntity as ReceiveMessage.EventSubscribe);
ProcessingEventSubscribe(this, e);
retMessage = e.ReplyMessage;
}
break;
case ReceiveMessageEnum.Event_Scan:
break;
case ReceiveMessageEnum.Event_Location:
//如果开启位置记录，则缓存
if (this.EnablePositionRecord)
{
if (AppSettings.IsDebug)
{
Logger.Info("enablePositionRecord! key = " + CacheKey.UserLocation + messageEntity.FromUserName);
}
HttpContext.Current.Cache.Insert(CacheKey.UserLocation + messageEntity.FromUserName,
messageEntity,
null,
DateTime.UtcNow.AddHours(this.PositionRecordExpiresHours),
System.Web.Caching.Cache.NoSlidingExpiration);
}
if (ProcessingEventLocation != null)
{
ProcessingEventLocationEventArgs e = new ProcessingEventLocationEventArgs(messageEntity as ReceiveMessage.EventLocation);
ProcessingEventLocation(this, e);
retMessage = e.ReplyMessage;
}
break;
case ReceiveMessageEnum.Event_Click:
if (ProcessingEventClick != null)
{
ProcessingEventClickEventArgs e = new ProcessingEventClickEventArgs(messageEntity as ReceiveMessage.EventClick);
ProcessingEventClick(this, e);
retMessage = e.ReplyMessage;
}
break;
case ReceiveMessageEnum.Event_View:
break;
case ReceiveMessageEnum.Event_MasssEndJobFinish:
if (ProcessingEventMasssEndJobFinish != null)
{
ProcessingEventMasssEndJobFinishEventArgs e = new ProcessingEventMasssEndJobFinishEventArgs(messageEntity as ReceiveMessage.EventMasssEndJobFinish);
ProcessingEventMasssEndJobFinish(this, e);
retMessage = e.ReplyMessage;
}
break;
default:
throw new Exception("未知的接收消息类型。");
}
#endregion
if (AppSettings.IsDebug)
{
if (retMessage == null)
{
Logger.Info("retMessage = null");
}
else
{
Logger.Log("retMessage = " + retMessage.ToString());
}
}
string replyMsg = ""; //xml格式字符串（明文或加密）
if (retMessage != null)
{
//未加密明文字符串
replyMsg = ReplyMessageBuilder.BuildXml(retMessage);
if (AppSettings.IsDebug)
{
Logger.Info("replyMsg = " + replyMsg);
}
if (EncryptType == "aes")
{
//加密
//replyMsg变为xml格式的密文
ret = Wxcpt.EncryptMsg(replyMsg, TimeStamp, Nonce, ref replyMsg);
if (ret != 0)
{
throw new Exception("ERR: Encrypt Fail, errorCode: " + ret);
}
if (AppSettings.IsDebug)
{
Logger.Info("sEncryptMsg = " + replyMsg);
}
}
}
context.Response.ContentType = "text/plain";
context.Response.Write(replyMsg);
}
private readonly string Token = "YTWL414128";//与微信公众账号后台的Token设置保持一致，区分大小写。
protected void Page_Load(object sender, EventArgs e)
{
string signature = Request["signature"];
string timestamp = Request["timestamp"];
string nonce = Request["nonce"];
string echostr = Request["echostr"];
if (Request.HttpMethod == "GET")
{
//get method - 仅在微信后台填写URL验证时触发
if (CheckSignature.Check(signature, timestamp, nonce, Token))
{
WriteContent(echostr); //返回随机字符串则表示验证通过
}
else
{
WriteContent("failed:" + signature + "," + CheckSignature.GetSignature(timestamp, nonce, Token));
}
}
else
{
//判断Post或其他方式请求
//post method - 当有用户想公众账号发送消息时触发
if (!CheckSignature.Check(signature, timestamp, nonce, Token))
{
WriteContent("参数错误！");
return;
}
//post method - 当有用户想公众账号发送消息时触发
var postModel = new PostModel()
{
Signature = Request.QueryString["signature"],
Msg_Signature = Request.QueryString["msg_signature"],
Timestamp = Request.QueryString["timestamp"],
Nonce = Request.QueryString["nonce"],
//以下保密信息不会（不应该）在网络上传播，请注意
Token = Token,
EncodingAESKey = "mNnY5GekpChwqhy2c4NBH90g3hND6GeI4gii2YCvKLY", //根据自己后台的设置保持一致
AppId = "wx669ef95216eef885" //根据自己后台的设置保持一致
};
//v4.2.2之后的版本，可以设置每个人上下文消息储存的最大数量，防止内存占用过多，如果该参数小于等于0，则不限制
var maxRecordCount = 10;
//自定义MessageHandler，对微信请求的详细判断操作都在这里面。
var messageHandler = new CustomMessageHandler(Request.InputStream, postModel, maxRecordCount);
try
{
//测试时可开启此记录，帮助跟踪数据，使用前请确保App_Data文件夹存在，且有读写权限。
messageHandler.RequestDocument.Save(
Server.MapPath("~/App_Data/" + DateTime.Now.Ticks + "_Request_" +
messageHandler.RequestMessage.FromUserName + ".txt"));
//执行微信处理过程
messageHandler.Execute();
//测试时可开启，帮助跟踪数据
messageHandler.ResponseDocument.Save(
Server.MapPath("~/App_Data/" + DateTime.Now.Ticks + "_Response_" +
messageHandler.ResponseMessage.ToUserName + ".txt"));
WriteContent(messageHandler.ResponseDocument.ToString());
return;
}
catch (Exception ex)
{
using (TextWriter tw = new StreamWriter(Server.MapPath("~/App_Data/Error_" + DateTime.Now.Ticks + ".txt")))
{
tw.WriteLine(ex.Message);
tw.WriteLine(ex.InnerException.Message);
if (messageHandler.ResponseDocument != null)
{
tw.WriteLine(messageHandler.ResponseDocument.ToString());
}
tw.Flush();
tw.Close();
}
}
finally
{
Response.End();
}
}
Response.End();
}
protected void Page_Load(object sender, EventArgs e)
{
string Token = "";//与微信公众账号后台的Token设置保持一致，区分大小写。
int wid = 0;
wid = MyCommFun.RequestInt("apiid");
if (wid <= 0)
{
WriteContent("参数非法");
return;
}
wx_userweixin wbll = new wx_userweixin();
Token = wbll.GetWeiXinToken(wid);
if (Token == null || string.IsNullOrEmpty(Token))
{
WriteContent("不存在该微信号！");
return;
}
// Token = "uweixin";
string signature = Request["signature"];
string timestamp = Request["timestamp"];
string nonce = Request["nonce"];
string echostr = Request["echostr"];
if (Request.HttpMethod == "GET")
{
//get method - 仅在微信后台填写URL验证时触发
if (CheckSignature.Check(signature, timestamp, nonce, Token))
{
WriteContent(echostr); //返回随机字符串则表示验证通过
}
else
{
WriteContent("failed:" + signature + ",token:" + Token + " " + CheckSignature.GetSignature(timestamp, nonce, Token) + "。" +
"如果你在浏览器中看到这句话，说明此地址可以被作为微信公众账号后台的Url，请注意保持Token一致。");
}
Response.End();
}
else
{
//post method - 当有用户想公众账号发送消息时触发
//本地测试的时候注释掉 ----start -----
if (!CheckSignature.Check(signature, timestamp, nonce, Token))
{
WriteContent("参数错误！");
return;
}
//本地测试的时候注释掉 ----end -----
//v4.2.2之后的版本，可以设置每个人上下文消息储存的最大数量，防止内存占用过多，如果该参数小于等于0，则不限制
var maxRecordCount = 10;
//自定义MessageHandler，对微信请求的详细判断操作都在这里面。
var messageHandler = new CustomMessageHandler(Request.InputStream, maxRecordCount);
try
{
//测试时可开启此记录，帮助跟踪数据，使用前请确保App_Data文件夹存在，且有读写权限。
//messageHandler.RequestDocument.Save(
// Server.MapPath("~/App_Data/" + DateTime.Now.Ticks + "_Request_" +
// messageHandler.RequestMessage.FromUserName + ".txt"));
//执行微信处理过程
messageHandler.Execute();
//测试时可开启，帮助跟踪数据
//messageHandler.ResponseDocument.Save(
// Server.MapPath("~/App_Data/" + DateTime.Now.Ticks + "_Response_" +
// messageHandler.ResponseMessage.ToUserName + ".txt"));
WriteContent(messageHandler.ResponseDocument.ToString());
return;
}
catch (Exception ex)
{
using (TextWriter tw = new StreamWriter(Server.MapPath("~/App_Data/Error_" + DateTime.Now.Ticks + ".txt")))
{
tw.WriteLine(ex.Message);
tw.WriteLine(ex.InnerException.Message);
if (messageHandler.ResponseDocument != null)
{
tw.WriteLine(messageHandler.ResponseDocument.ToString());
}
tw.Flush();
tw.Close();
}
WriteContent("");
}
finally
{
Response.End();
}
}
}
public void ProcessRequest(HttpContext context)
{
//app.CreateLogs(new SugarModel.SystemLogs()
//{ Source = "weixin", Title = "begin", Message = "进入，开始" });
try
{
string signature = context.Request["signature"];
string timestamp = context.Request["timestamp"];
string nonce = context.Request["nonce"];
string echostr = context.Request["echostr"];
string code = context.Request["code"];
//app.CreateLogs(new SugarModel.Logs()
//{ Source = "weixin", Title = "param ", Message = context.Request.ToString() });
if (context.Request.HttpMethod == "GET")
{
//app.CreateLogs(new SugarModel.Logs()
//{ Source = "weixin", Title = "get", Message = "进入回调 get" });
if (code != null && code.Length > 0)
{
string accesstoken = HttpHelper.sendHttpPost("https://api.weixin.qq.com/sns/oauth2/access_token?appid=" + WeiXinConfig.AppId + "&secret=" + WeiXinConfig.AppSecret + "&code=" + code + "&grant_type=authorization_code", null, "Get");
JObject accesstokenp = JObject.Parse(accesstoken);
string userinf = HttpHelper.sendHttpPost("https://api.weixin.qq.com/sns/userinfo?access_token=" + accesstokenp["access_token"] + "&openid=" + accesstokenp["openid"] + "&lang=zh_CN", null, "Get");
JObject userinfp = JObject.Parse(userinf);
string nickName = userinfp["nickname"].ToString();
string openid = userinfp["openid"].ToString();
string headimgurl = userinfp["headimgurl"].ToString();
}
else
{
if (CheckSignature.Check(signature, timestamp, nonce, WeiXinConfig.WeixinToken))
{
context.Response.Output.Write(echostr);
}
}
}
else
{
//app.CreateLogs(new SugarModel.Logs()
//{ Source = "weixin", Title = "post", Message = "进入回调 post" });
if (!CheckSignature.Check(signature, timestamp, nonce, WeiXinConfig.WeixinToken))
{
//app.CreateLogs(new SugarModel.Logs()
//{ Source = "weixin", Title = "500", Message = "参数错误" });
context.Response.Output.Write("参数错误");
}
//拼接Post参数模型
var postModel = new PostModel()
{
Signature = context.Request.QueryString["signature"],
Msg_Signature = context.Request.QueryString["msg_signature"],
Timestamp = context.Request.QueryString["timestamp"],
Nonce = context.Request.QueryString["nonce"],
Token = WeiXinConfig.WeixinToken,
EncodingAESKey = WeiXinConfig.EncodingAESKey, //根据自己后台的设置保持一致
AppId = WeiXinConfig.AppId //根据自己后台的设置保持一致
};
//app.CreateLogs(new SugarModel.Logs()
//{ Source = "weixin", Title = "call", Message = "回调事件执行----前" });
//回调事件
var maxRecordCount = 10;
var messageHandler = new CustomMessageHandler(context.Request.InputStream, postModel, maxRecordCount);
//app.CreateLogs(new SugarModel.Logs()
//{ Source = "weixin", Title = "call", Message = "回调事件执行----后" });
messageHandler.Execute();
context.Response.Output.Write(messageHandler.ResponseDocument.ToString());
}
}
catch (Exception ex)
{
//app.CreateLogs(new SugarModel.Logs()
//{ Source = "weixin", Title = "catch", Message = ex.Message });
}
}
public ActionResult Get(PostModel postModel, string echostr, string appId)
{
int wxId = 0;
if (string.IsNullOrWhiteSpace(appId) && !int.TryParse(appId, out wxId))
{
return(Content("未知平台接入！"));
}
wxId = Convert.ToInt32(appId);
Weixin_Sys_Info wxInfo = null;
using (SeekAskContext context = new SeekAskContext())
{
wxInfo = context.Weixin_Sys_Info.FirstOrDefault(p => p.WxId == wxId);
if (wxInfo == null)
{
return(Content("平台未新增管理代号(" + appId + ")！"));
}
bool isCheckSignature = CheckSignature.Check(postModel.Signature, postModel.Timestamp,
postModel.Nonce, wxInfo.Wx_Token);
#region 记录接入日志
try
{
Szx_Sys_Log log = new Szx_Sys_Log()
{
LogID = Guid.NewGuid().ToString("N"),
LogName = "微信接入验证",
Source = "01",
LevelCode = 0,
RequestUrl = HttpContext.Request.Url.ToString(),
LogDate = DateTime.Now,
Message = "验证结果:" + isCheckSignature,
Create_Id = "wxjk",
Create_Name = "微信接口",
Create_Time = DateTime.Now,
Create_IP = WebSiteTools.GetRequestIP()
};
context.Szx_Sys_Log.Add(log);
context.SaveChanges();
}
catch (Exception) { }
#endregion
if (isCheckSignature)
{
try
{
wxInfo.Wx_Status = 1; //状态改为已对接
context.SaveChanges();
}
catch (Exception) { }
return(Content(echostr)); //返回随机字符串则表示验证通过
}
else
{
return(Content("failed:" + postModel.Signature + "," +
CheckSignature.GetSignature(postModel.Timestamp, postModel.Nonce, wxInfo.Wx_Token) + "。" +
"如果你在浏览器中看到这句话，说明此地址可以被作为微信公众账号后台的Url，请注意保持Token一致。"));
}
}
}
public ActionResult Post(PostModel postModel, string appId)
{
int wxId = 0;
if (string.IsNullOrWhiteSpace(appId) && !int.TryParse(appId, out wxId))
{
return(Content("未知平台接入！"));
}
wxId = Convert.ToInt32(appId);
Weixin_Sys_Info wxInfo = null;
using (SeekAskContext context = new SeekAskContext())
{
wxInfo = context.Weixin_Sys_Info.FirstOrDefault(p => p.WxId == wxId);
if (wxInfo == null)
{
return(Content("平台未新增管理代号(" + appId + ")！"));
}
if (!CheckSignature.Check(postModel.Signature, postModel.Timestamp, postModel.Nonce, wxInfo.Wx_Token))
{
return(Content("参数错误！"));
}
postModel.Token = wxInfo.Wx_Token; //根据自己后台的设置保持一致
postModel.EncodingAESKey = wxInfo.Wx_EncodingAESKey; //根据自己后台的设置保持一致
postModel.AppId = wxInfo.Wx_AppId; //根据自己后台的设置保持一致
var maxRecordCount = 10;
//自定义MessageHandler，对微信请求的详细判断操作都在这里面。
var messageHandler = new CustomMessageHandler(Request.InputStream, postModel, maxRecordCount);
try
{
/* 如果需要添加消息去重功能，只需打开OmitRepeatedMessage功能，SDK会自动处理。
* 收到重复消息通常是因为微信服务器没有及时收到响应，会持续发送2-5条不等的相同内容的RequestMessage*/
messageHandler.OmitRepeatedMessage = true;
//执行微信处理过程
messageHandler.Execute();
#region 记录微信操作日志
try
{
if (!messageHandler.CancelExcute)
{
Weixin_Msg_Request msgRequest = new Weixin_Msg_Request();
msgRequest.WxId = wxInfo.WxId;
msgRequest.MsgType = messageHandler.RequestMessage.MsgType.ToString();
if (messageHandler.RequestMessage.MsgType != RequestMsgType.Event)
{
msgRequest.MsgId = messageHandler.RequestMessage.MsgId.ToString();
}
else
{
msgRequest.MsgId = Guid.NewGuid().ToString("N");
}
msgRequest.FromUserName = messageHandler.RequestMessage.FromUserName;
msgRequest.ToUserName = messageHandler.RequestMessage.ToUserName;
msgRequest.Encrypt = null;
msgRequest.CreateTime = messageHandler.RequestMessage.CreateTime;
msgRequest.XmlDocument = messageHandler.RequestDocument.ToString();
context.Weixin_Msg_Request.Add(msgRequest);
context.SaveChanges();
}
}
catch (Exception) { }
#endregion
//return Content(messageHandler.ResponseDocument.ToString());//v0.7-
//return new FixWeixinBugWeixinResult(messageHandler);//为了解决官方微信5.0软件换行bug暂时添加的方法，平时用下面一个方法即可
return(new WeixinResult(messageHandler));//v0.8+
}
catch (Exception ex)
{
#region 记录系统日志
try
{
Szx_Sys_Log log = new Szx_Sys_Log()
{
LogID = Guid.NewGuid().ToString("N"),
LogName = "微信消息处理",
Source = "01",
LevelCode = 2,
RequestUrl = HttpContext.Request.Url.ToString(),
LogDate = DateTime.Now,
Message = "处理异常:" + ex.Message,
Create_Id = "wxjk",
Create_Name = "微信接口",
Create_Time = DateTime.Now,
Create_IP = WebSiteTools.GetRequestIP()
};
context.Szx_Sys_Log.Add(log);
context.SaveChanges();
}
catch (Exception) { }
#endregion
}
}
return(Content("参数错误！"));
}
public ActionResult Post(PostModel postModel)
{
//Loger.Current.Write("WeixinController.Post() begin");
try
{
if (!CheckSignature.Check(postModel.Signature, postModel.Timestamp, postModel.Nonce, Token))
{
return(Content("参数错误！"));
}
postModel.Token = Token;
postModel.EncodingAESKey = ConfigurationManager.AppSettings["EncodingAESKey"]; //根据自己后台的设置保持一致
postModel.AppId = ConfigurationManager.AppSettings["AppId"]; //根据自己后台的设置保持一致
//v4.2.2之后的版本，可以设置每个人上下文消息储存的最大数量，防止内存占用过多，如果该参数小于等于0，则不限制
var maxRecordCount = 10;
//自定义MessageHandler，对微信请求的详细判断操作都在这里面。
var messageHandler = new CustomMessageHandler(Request.InputStream, postModel, maxRecordCount);
try
{
//测试时可开启此记录，帮助跟踪数据，使用前请确保App_Data文件夹存在，且有读写权限。
//Loger.Current.Write("WeixinController.Post() RequestDocument=\r\n" + messageHandler.RequestDocument.ToString());
if (messageHandler.UsingEcryptMessage)
{
//Loger.Current.Write("WeixinController.Post() EcryptRequestDocument=\r\n" + messageHandler.EcryptRequestDocument.ToString());
}
/* 如果需要添加消息去重功能，只需打开OmitRepeatedMessage功能，SDK会自动处理。
* 收到重复消息通常是因为微信服务器没有及时收到响应，会持续发送2-5条不等的相同内容的RequestMessage*/
messageHandler.OmitRepeatedMessage = true;
//执行微信处理过程
messageHandler.Execute();
//测试时可开启，帮助跟踪数据
//Loger.Current.Write("WeixinController.Post() ResponseDocument=\r\n" + messageHandler.ResponseDocument.ToString());
if (messageHandler.UsingEcryptMessage)
{
//记录加密后的响应信息
//Loger.Current.Write("WeixinController.Post() FinalResponseDocument=\r\n" + messageHandler.FinalResponseDocument.ToString());
}
//return Content(messageHandler.ResponseDocument.ToString());//v0.7-
return(new FixWeixinBugWeixinResult(messageHandler));//为了解决官方微信5.0软件换行bug暂时添加的方法，平时用下面一个方法即可
//return new WeixinResult(messageHandler);//v0.8+
}
catch (Exception ex)
{
Loger.Current.Write("WeixinController.Post() err=" + ex.Message);
if (messageHandler.ResponseDocument != null)
{
//Loger.Current.Write("WeixinController.Post() ResponseDocument=\r\n" + messageHandler.ResponseDocument.ToString());
}
return(Content(""));
}
}
catch (Exception ex)
{
Loger.Current.Write("WeixinController.Post() err=" + ex.Message);
return(Content(""));
}
}
public ActionResult Post(PostModel postModel /*,[FromBody]string requestXml*/)
{
if (!CheckSignature.Check(postModel.Signature, postModel.Timestamp, postModel.Nonce, token))
{
return(Content("参数错误！"));
}
#region 打包 PostModel 信息
postModel.Token = token; //根据自己后台的设置保持一致
postModel.EncodingAESKey = encodingAESKey; //根据自己后台的设置保持一致
postModel.AppId = appId; //根据自己后台的设置保持一致
#endregion
//v4.2.2之后的版本，可以设置每个人上下文消息储存的最大数量，防止内存占用过多，如果该参数小于等于0，则不限制
var maxRecordCount = 10;
//自定义MessageHandler，对微信请求的详细判断操作都在这里面。
#if NET45
var messageHandler = new CustomMessageHandler(Request.InputStream, postModel, maxRecordCount);
#else
string body = new StreamReader(Request.Body).ReadToEnd();
byte[] requestData = Encoding.UTF8.GetBytes(body);
Stream inputStream = new MemoryStream(requestData);
//var inputStream = Request.Body;
//byte[] buffer = new byte[Request.ContentLength ?? 0];
//inputStream.Read(buffer, 0, buffer.Length);
//var requestXmlStream = new MemoryStream(buffer);
//var requestXml = Encoding.UTF8.GetString(buffer);
//int bytesRead = 0;
//while ((bytesRead = Request.Body.Read(buffer, 0, buffer.Length)) != 0)
//{
// inputStream.Write(buffer, 0, bytesRead);
//}
//Request.Body.CopyTo(inputStream);
var messageHandler = new CustomMessageHandler(inputStream, postModel, maxRecordCount);
#endif
try
{
#region 记录 Request 日志
var logPath = Server.GetMapPath(string.Format("~/App_Data/MP/{0}/", DateTime.Now.ToString("yyyy-MM-dd")));
if (!Directory.Exists(logPath))
{
Directory.CreateDirectory(logPath);
}
//测试时可开启此记录，帮助跟踪数据，使用前请确保App_Data文件夹存在，且有读写权限。
var requestDocumentFileName = Path.Combine(logPath, string.Format("{0}_Request_{1}.txt", _getRandomFileName(), messageHandler.RequestMessage.FromUserName));
var ecryptRequestDocumentFileName = Path.Combine(logPath, string.Format("{0}_Request_Ecrypt_{1}.txt", _getRandomFileName(), messageHandler.RequestMessage.FromUserName));
#if NET45
messageHandler.RequestDocument.Save(requestDocumentFileName);
if (messageHandler.UsingEcryptMessage)
{
messageHandler.EcryptRequestDocument.Save(ecryptRequestDocumentFileName);
}
#else
using (FileStream fs = new FileStream(requestDocumentFileName, FileMode.CreateNew, FileAccess.ReadWrite))
{
messageHandler.RequestDocument.Save(fs);
}
if (messageHandler.UsingEcryptMessage)
{
using (FileStream fs = new FileStream(ecryptRequestDocumentFileName, FileMode.CreateNew, FileAccess.ReadWrite))
{
messageHandler.EcryptRequestDocument.Save(fs);
}
}
#endif
#endregion
/* 如果需要添加消息去重功能，只需打开OmitRepeatedMessage功能，SDK会自动处理。
* 收到重复消息通常是因为微信服务器没有及时收到响应，会持续发送2-5条不等的相同内容的RequestMessage*/
messageHandler.OmitRepeatedMessage = true;
//执行微信处理过程
messageHandler.Execute();
#region 记录 Response 日志
//测试时可开启，帮助跟踪数据
//if (messageHandler.ResponseDocument == null)
//{
// throw new Exception(messageHandler.RequestDocument.ToString());
//}
var responseDocumentFileName = Path.Combine(logPath, string.Format("{0}_Response_{1}.txt", _getRandomFileName(), messageHandler.RequestMessage.FromUserName));
var ecryptResponseDocumentFileName = Path.Combine(logPath, string.Format("{0}_Response_Final_{1}.txt", _getRandomFileName(), messageHandler.RequestMessage.FromUserName));
if (messageHandler.ResponseDocument != null)
{
using (FileStream fs = new FileStream(responseDocumentFileName, FileMode.CreateNew, FileAccess.ReadWrite))
{
messageHandler.ResponseDocument.Save(fs);
}
}
if (messageHandler.UsingEcryptMessage && messageHandler.FinalResponseDocument != null)
{
using (FileStream fs = new FileStream(ecryptResponseDocumentFileName, FileMode.CreateNew, FileAccess.ReadWrite))
{
//记录加密后的响应信息
messageHandler.FinalResponseDocument.Save(fs);
}
}
#endregion `
//return Content(messageHandler.ResponseDocument.ToString());//v0.7-
//return new WeixinResult(messageHandler);//v0.8+
return(new FixWeixinBugWeixinResult(messageHandler));//为了解决官方微信5.0软件换行bug暂时添加的方法，平时用下面一个方法即可
}
catch (Exception ex)
{
#region 异常处理
WeixinTrace.Log("MessageHandler错误：{0}", ex.Message);
using (var fs = new FileStream(Server.GetMapPath("~/App_Data/Error_" + _getRandomFileName() + ".txt"), FileMode.CreateNew, FileAccess.ReadWrite))
{
using (TextWriter tw = new StreamWriter(fs))
{
tw.WriteLine("ExecptionMessage:" + ex.Message);
tw.WriteLine(ex.Source);
tw.WriteLine(ex.StackTrace);
//tw.WriteLine("InnerExecptionMessage:" + ex.InnerException.Message);
if (messageHandler.ResponseDocument != null)
{
tw.WriteLine(messageHandler.ResponseDocument.ToString());
}
if (ex.InnerException != null)
{
tw.WriteLine("========= InnerException =========");
tw.WriteLine(ex.InnerException.Message);
tw.WriteLine(ex.InnerException.Source);
tw.WriteLine(ex.InnerException.StackTrace);
}
tw.Flush();
//tw.Close();
}
}
return(Content(""));
#endregion
}
}
public ActionResult Post(PostModel postModel)
{
GzhCfg gzh = dp2WeiXinService.Instance.gzhContainer.GetDefault();
if (string.IsNullOrEmpty(postModel.AppId) == false)
{
gzh = dp2WeiXinService.Instance.gzhContainer.GetByAppId(postModel.AppId);
dp2WeiXinService.Instance.WriteErrorLog1("惊喜post中有appId=" + postModel.AppId);
}
if (gzh == null)
{
string tempError = "Post未找到公众号[" + postModel.AppId + "]的配置信息。";
dp2WeiXinService.Instance.WriteErrorLog1(tempError);
return(new WeixinResult(tempError));
}
// 本机调试注掉
if (!CheckSignature.Check(postModel.Signature, postModel.Timestamp, postModel.Nonce, gzh.token))
{
return(Content("参数错误！"));
}
//string appId = dp2WeiXinService.Instance.gzhContainer.GetDefault().appId;
//postModel.AppId = appId;
// 开始时间
DateTime start_time = DateTime.Now;
//与公众后台的设置保持一致
postModel.AppId = gzh.appId;
postModel.Token = gzh.token;
postModel.EncodingAESKey = gzh.encodingAESKey;
//v4.2.2之后的版本，可以设置每个人上下文消息储存的最大数量，防止内存占用过多，如果该参数小于等于0，则不限制
var maxRecordCount = 10;
// 日志总目录,使用前请确保App_Data文件夹存在，且有读写权限。
var logDir = dp2WeiXinService.Instance.weiXinLogDir;
//// 当日日志目录，用于详细输出消息
//var logToday =string.Format(logDir + "/{0}/", DateTime.Now.ToString("yyyy-MM-dd"));
//if (!Directory.Exists(logToday))
//{
// Directory.CreateDirectory(logToday);
//}
//自定义MessageHandler，对微信请求的详细判断操作都在这里面。
var messageHandler = new dp2weixinMessageHandler(Request.InputStream, postModel, maxRecordCount);
try
{
////测试时可开启此记录，帮助跟踪数据
//string id=_getRandomFileName();
//string tempPath = Path.Combine(logToday, string.Format("{0}_Request_{1}.txt", id, messageHandler.RequestMessage.FromUserName));
//messageHandler.RequestDocument.Save(tempPath);
//if (messageHandler.UsingEcryptMessage)
//{
// tempPath = Path.Combine(logToday, string.Format("{0}_Request_Ecrypt_{1}.txt", id, messageHandler.RequestMessage.FromUserName));
// messageHandler.EcryptRequestDocument.Save(tempPath);
//}
/* 如果需要添加消息去重功能，只需打开OmitRepeatedMessage功能，SDK会自动处理。
* 收到重复消息通常是因为微信服务器没有及时收到响应，会持续发送2-5条不等的相同内容的RequestMessage*/
//messageHandler.OmitRepeatedMessage = true;
//执行微信处理过程
messageHandler.Execute();
//////测试时可开启，帮助跟踪数据
//if (messageHandler.ResponseDocument != null)
//{
// //tempPath = Path.Combine(logToday, string.Format("{0}_Response_{1}.txt", id, messageHandler.RequestMessage.FromUserName));
// string path = dp2WeiXinService.Instance.weiXinDataDir+"/test.txt";
// messageHandler.ResponseDocument.Save(path);
//}
//if (messageHandler.UsingEcryptMessage)
//{
// //记录加密后的响应信息
// tempPath = Path.Combine(logToday, string.Format("{0}_Response_Final_{1}.txt", id, messageHandler.RequestMessage.FromUserName));
// messageHandler.FinalResponseDocument.Save(tempPath);
//}
//return Content(messageHandler.ResponseDocument.ToString());//v0.7-
//return new FixWeixinBugWeixinResult(messageHandler);//为了解决官方微信5.0软件换行bug暂时添加的方法，平时用下面一个方法即可
// 测试异常
//throw new Exception("test");
// 计算处理消息用了多少时间
TimeSpan time_length = DateTime.Now - start_time;
string strMsgContext = "";
if (messageHandler.RequestMessage is RequestMessageText)
{
strMsgContext = ((RequestMessageText)messageHandler.RequestMessage).Content;
}
string info = "处理[" + messageHandler.RequestMessage.CreateTime + "-" + messageHandler.RequestMessage.MsgType.ToString() + "-" + strMsgContext + "]消息，time span: " + time_length.TotalSeconds.ToString() + " secs";
if (time_length.TotalSeconds > 5)
{
info = "请求超时:" + info;
dp2WeiXinService.Instance.WriteLog1(info);
}
else
{
dp2WeiXinService.Instance.WriteLog3(info);
}
// 发送客服消息
//messageHandler.SendCustomeMessage(info);
// 如果消息是空内容，直接返回空，这样微信就不是重试了，用于 用户请求书目详细消息，公众号以客户消息返回
if (messageHandler.ResponseMessage is ResponseMessageText)
{
var mess = (ResponseMessageText)messageHandler.ResponseMessage;
if (String.IsNullOrEmpty(mess.Content) == true)
{
return(Content(""));
}
}
return(new WeixinResult(messageHandler.TextResponseMessage));// ResponseMessage);//v0.8+
}
catch (Exception ex)
{
// 发送客服消息
//messageHandler.SendCustomeMessage("异常：" + ex.Message);
string error = "ExecptionMessage:" + ex.Message + "\n";
error += ex.Source + "\n";
error += ex.StackTrace + "\n";
if (ex.InnerException != null)
{
error += "========= InnerException =========" + "\n";;
error += ex.InnerException.Message + "\n";;
error += ex.InnerException.Source + "\n";;
error += ex.InnerException.StackTrace + "\n";;
}
//将程序运行中发生的错误记录到日志
dp2WeiXinService.Instance.WriteErrorLog1(error);
// 返回error信息
return(new WeixinResult(error));
}
}
public ActionResult Index(string url, string token, RequestMsgType requestType, Event?eventType,
bool testConcurrence, int testConcurrenceCount,
bool testEncrypt, string encodingAESKey, string appId)
{
using (MemoryStream ms = new MemoryStream())
{
var requestMessaageDoc = GetrequestMessaageDoc(/*url, token,*/ requestType, eventType);
requestMessaageDoc.Save(ms);
ms.Seek(0, SeekOrigin.Begin);
string msgSigature = null;
var timeStamp = SystemTime.NowTicks.ToString();
var nonce = (SystemTime.NowTicks * 2).ToString();
string encryptTypeAll = null;
string openIdAll = null;
//对请求消息进行加密
if (testEncrypt)
{
try
{
var openId = requestMessaageDoc.Root.Element("FromUserName").Value;
var toUserName = requestMessaageDoc.Root.Element("ToUserName").Value;
WXBizMsgCrypt msgCrype = new WXBizMsgCrypt(token, encodingAESKey, appId);
string finalResponseXml = null;
var ret = msgCrype.EncryptRequestMsg(requestMessaageDoc.ToString(), timeStamp, nonce, toUserName, ref finalResponseXml, ref msgSigature);
if (ret == 0)
{
requestMessaageDoc = XDocument.Parse(finalResponseXml);//赋值最新的加密信息
openIdAll = $"openid={openId}";
encryptTypeAll = "&encrypt_type=aes";
}
}
catch (Exception ex)
{
var data = new { Success = false, LoadTime = "N/A", Result = "发生错误：" + ex.ToString() };
return(Json(data, new JsonSerializerSettings()
{
ContractResolver = new DefaultContractResolver()
}));
throw;
}
//Senparc.CO2NET.Trace.SenparcTrace.SendCustomLog("模拟测试-加密消息：", requestMessaageDoc?.ToString());
}
var sigature = CheckSignature.GetSignature(timeStamp, nonce, token);
url += url.Contains("?") ? "&" : "?";
url += $"signature={sigature}&timeStamp={timeStamp}&nonce={nonce}&msg_signature={msgSigature}{encryptTypeAll}{openIdAll}";
//参数如：signature=330ed3b64e363dc876f35e54a79e59b48739f567×tamp=1570075722&nonce=863153744&openid=olPjZjsXuQPJoV0HlruZkNzKc91E&encrypt_type=aes&msg_signature=71dc359205a4660bc3b3046b643452c994b5897d
var dt1 = SystemTime.Now;
var responseMessageXml = MessageAgent.RequestXml(null, url, token, requestMessaageDoc.ToString(), autoFillUrlParameters: false);
if (string.IsNullOrEmpty(responseMessageXml))
{
responseMessageXml = "返回消息为空，可能已经被去重。\r\nMsgId相同的连续消息将被自动去重。";
}
try
{
if (testConcurrence)
{
dt1 = SystemTime.Now;
testConcurrenceCount = testConcurrenceCount > 30 ? 30 : testConcurrenceCount;//设定最高限额
//模拟并发请求
List <Task <string> > taskList = new List <Task <string> >();
for (int i = 0; i < testConcurrenceCount; i++)
{
var task = TestAsyncTask(url, token, requestMessaageDoc, autoFillUrlParameters: false, sleepMillionSeconds: 100);
taskList.Add(task);
}
Task.WaitAll(taskList.ToArray(), 1500 * 10);
}
var cache = CacheStrategyFactory.GetObjectCacheStrategyInstance();
var data = new
{
Success = true,
LoadTime = SystemTime.DiffTotalMS(dt1, "f4"),
Result = responseMessageXml,
CacheType = cache.GetType().Name,
ConcurrenceCount = testConcurrenceCount
};
return(Json(data, new JsonSerializerSettings()
{
ContractResolver = new DefaultContractResolver()
}));
}
catch (Exception ex)
{
var msg = string.Format("{0}\r\n{1}\r\n{2}", ex.Message, null, ex.InnerException != null ? ex.InnerException.Message : null);
return(Json(new { Success = false, Result = msg }, new JsonSerializerSettings()
{
ContractResolver = new DefaultContractResolver()
}));
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
string Token = "";//与微信公众账号后台的Token设置保持一致，区分大小写。
int wid = 0;
wid = MyCommFun.RequestInt("apiid");
if (wid <= 0)
{
WriteContent("参数非法");
return;
}
wx_userweixin wbll = new wx_userweixin();
Token = wbll.GetWeiXinToken(wid);
if (Token == null || string.IsNullOrEmpty(Token))
{
WriteContent("不存在该微信号或账号已过期或已被禁用！");
return;
}
// Token = "uweixin";
string signature = Request["signature"];
string timestamp = Request["timestamp"];
string nonce = Request["nonce"];
string echostr = Request["echostr"];
if (Request.HttpMethod == "GET")
{
//get method - 仅在微信后台填写URL验证时触发
if (CheckSignature.Check(signature, timestamp, nonce, Token))
{
WriteContent(echostr); //返回随机字符串则表示验证通过
}
else
{
WriteContent("failed:" + signature + ",token:" + Token + " " + CheckSignature.GetSignature(timestamp, nonce, Token) + "。" +
"如果你在浏览器中看到这句话，说明此地址可以被作为微信公众账号后台的Url，请注意保持Token一致。");
}
Response.End();
}
else
{
//本地测试的时候注释掉 ----start -----
//if (!CheckSignature.Check(signature, timestamp, nonce, Token))
//{
// WriteContent("参数错误！");
// return;
//}
//本地测试的时候注释掉 ----end -----
//post method - 当有用户想公众账号发送消息时触发
Model.wx_userweixin uweixin = wbll.GetModel(wid);
var postModel = new PostModel()
{
Signature = Request.QueryString["signature"],
Msg_Signature = Request.QueryString["msg_signature"],
Timestamp = Request.QueryString["timestamp"],
Nonce = Request.QueryString["nonce"],
//以下保密信息不会（不应该）在网络上传播，请注意
Token = Token,
EncodingAESKey = uweixin.extStr, //根据自己后台的设置保持一致
AppId = uweixin.AppId //根据自己后台的设置保持一致
};
//v4.2.2之后的版本，可以设置每个人上下文消息储存的最大数量，防止内存占用过多，如果该参数小于等于0，则不限制
var maxRecordCount = 10;
//自定义MessageHandler，对微信请求的详细判断操作都在这里面。
var messageHandler = new CustomMessageHandler(Request.InputStream, postModel, maxRecordCount);
try
{
//测试时可开启此记录，帮助跟踪数据，使用前请确保App_Data文件夹存在，且有读写权限。
messageHandler.RequestDocument.Save(
Server.MapPath("~/App_Data/" + DateTime.Now.Ticks + "_Request_" +
messageHandler.RequestMessage.FromUserName + ".txt"));
//执行微信处理过程
messageHandler.Execute();
//测试时可开启，帮助跟踪数据
messageHandler.ResponseDocument.Save(
Server.MapPath("~/App_Data/" + DateTime.Now.Ticks + "_Response_" +
messageHandler.ResponseMessage.ToUserName + ".txt"));
//为了解决官方微信5.0软件换行bug暂时添加的方法，平时用下面一个方法即可 begin
string lastStr = "";
if (messageHandler != null && messageHandler.ResponseDocument != null && messageHandler.ResponseDocument.ToString().Trim() != "")
{
lastStr = messageHandler.ResponseDocument.ToString().Replace("\r\n", "\n");
}
else
{
lastStr = messageHandler.ResponseDocument.ToString();
}
// WriteContent( messageHandler.ResponseDocument.ToString());
//为了解决官方微信5.0软件换行bug暂时添加的方法，平时用下面一个方法即可 end
//如果自动回复已经关闭，则不返回内容，start 1220
WeiXCommFun wxcomm = new WeiXCommFun();
int apiid = wxcomm.getApiid();
if (!wxcomm.wxCloseKW(apiid))
{
lastStr = "";
}
//如果自动回复已经关闭，则不返回内容，end 1220
WriteContent(lastStr);
return;
}
catch (Exception ex)
{
using (TextWriter tw = new StreamWriter(Server.MapPath("~/App_Data/Error_" + DateTime.Now.Ticks + ".txt")))
{
tw.WriteLine(ex.Message);
tw.WriteLine(ex.InnerException.Message);
if (messageHandler.ResponseDocument != null)
{
tw.WriteLine(messageHandler.ResponseDocument.ToString());
}
tw.Flush();
tw.Close();
}
WriteContent("");
}
finally
{
Response.End();
}
}
}
public ActionResult CommonPost(PostModel postModel)
{
var account = GetAccount(GetQueryString("MpID"));
if (account == null)
{
return(new WeixinResult("未添加公众号！"));//v0.8+
}
postModel.Token = account.Token;
postModel.EncodingAESKey = account.EncodingAESKey; //根据自己后台的设置保持一致
postModel.AppId = account.AppID; //根据自己后台的设置保持一致
if (!CheckSignature.Check(postModel.Signature, postModel.Timestamp, postModel.Nonce, postModel.Token))
{
return(Content("参数错误！"));
}
//v4.2.2之后的版本，可以设置每个人上下文消息储存的最大数量，防止内存占用过多，如果该参数小于等于0，则不限制
var maxRecordCount = 10;
var logPath = Server.MapPath(string.Format("~/App_Data/MP/{0}/", DateTime.Now.ToString("yyyy-MM-dd")));
if (!Directory.Exists(logPath))
{
Directory.CreateDirectory(logPath);
}
//自定义MessageHandler，对微信请求的详细判断操作都在这里面。
var messageHandler = new CustomMessageHandler(Request.InputStream, postModel, account, entities, maxRecordCount);
try
{
//测试时可开启此记录，帮助跟踪数据，使用前请确保App_Data文件夹存在，且有读写权限。
messageHandler.RequestDocument.Save(Path.Combine(logPath, string.Format("{0}_Request_{1}.txt", DateTime.Now.Ticks, messageHandler.RequestMessage.FromUserName)));
if (messageHandler.UsingEcryptMessage)
{
messageHandler.EcryptRequestDocument.Save(Path.Combine(logPath, string.Format("{0}_Request_Ecrypt_{1}.txt", DateTime.Now.Ticks, messageHandler.RequestMessage.FromUserName)));
}
/* 如果需要添加消息去重功能，只需打开OmitRepeatedMessage功能，SDK会自动处理。
* 收到重复消息通常是因为微信服务器没有及时收到响应，会持续发送2-5条不等的相同内容的RequestMessage*/
messageHandler.OmitRepeatedMessage = true;
//执行微信处理过程
messageHandler.Execute();
//测试时可开启，帮助跟踪数据
//if (messageHandler.ResponseDocument == null)
//{
// throw new Exception(messageHandler.RequestDocument.ToString());
//}
if (messageHandler.ResponseDocument != null)
{
messageHandler.ResponseDocument.Save(Path.Combine(logPath, string.Format("{0}_Response_{1}.txt", DateTime.Now.Ticks, messageHandler.RequestMessage.FromUserName)));
}
if (messageHandler.UsingEcryptMessage)
{
//记录加密后的响应信息
messageHandler.FinalResponseDocument.Save(Path.Combine(logPath, string.Format("{0}_Response_Final_{1}.txt", DateTime.Now.Ticks, messageHandler.RequestMessage.FromUserName)));
}
//return Content(messageHandler.ResponseDocument.ToString());//v0.7-
return(new FixWeixinBugWeixinResult(messageHandler));//为了解决官方微信5.0软件换行bug暂时添加的方法，平时用下面一个方法即可
//return new WeixinResult(messageHandler);//v0.8+
}
catch (Exception ex)
{
using (TextWriter tw = new StreamWriter(Server.MapPath("~/App_Data/Error_" + DateTime.Now.Ticks + ".txt")))
{
tw.WriteLine("ExecptionMessage:" + ex.Message);
tw.WriteLine(ex.Source);
tw.WriteLine(ex.StackTrace);
//tw.WriteLine("InnerExecptionMessage:" + ex.InnerException.Message);
if (messageHandler.ResponseDocument != null)
{
tw.WriteLine(messageHandler.ResponseDocument.ToString());
}
if (ex.InnerException != null)
{
tw.WriteLine("========= InnerException =========");
tw.WriteLine(ex.InnerException.Message);
tw.WriteLine(ex.InnerException.Source);
tw.WriteLine(ex.InnerException.StackTrace);
}
tw.Flush();
tw.Close();
}
return(Content(""));
}
}
private readonly string Token = "lsyclazjj22Oo77yy";//与微信公众账号后台的Token设置保持一致，区分大小写。
protected void Page_Load(object sender, EventArgs e)
{
string signature = Request["signature"];
string timestamp = Request["timestamp"];
string nonce = Request["nonce"];
string echostr = Request["echostr"];
if (Request.HttpMethod == "GET")
{
//get method - 仅在微信后台填写URL验证时触发
if (CheckSignature.Check(signature, timestamp, nonce, Token))
{
WriteContent(echostr); //返回随机字符串则表示验证通过
}
else
{
WriteContent("failed:" + signature + "," + CheckSignature.GetSignature(timestamp, nonce, Token) + "。" +
"如果你在浏览器中看到这句话，说明此地址可以被作为微信公众账号后台的Url，请注意保持Token一致。");
}
Response.End();
}
else
{
//post method - 当有用户想公众账号发送消息时触发
if (!CheckSignature.Check(signature, timestamp, nonce, Token))
{
WriteContent("参数错误！");
return;
}
//post method - 当有用户想公众账号发送消息时触发
var postModel = new PostModel()
{
Signature = Request.QueryString["signature"],
Msg_Signature = Request.QueryString["msg_signature"],
Timestamp = Request.QueryString["timestamp"],
Nonce = Request.QueryString["nonce"],
//以下保密信息不会（不应该）在网络上传播，请注意
Token = Token,
EncodingAESKey = "dIE8PJ6i1yJivVvd7fk3fh33EDE3QVYNlLB91cbssxI", //根据自己后台的设置保持一致
AppId = "wx1b5c7dbfe9a3555d" //根据自己后台的设置保持一致
};
//v4.2.2之后的版本，可以设置每个人上下文消息储存的最大数量，防止内存占用过多，如果该参数小于等于0，则不限制
var maxRecordCount = 10;
//自定义MessageHandler，对微信请求的详细判断操作都在这里面。
//var messageHandler = new CustomMessageHandler(Request.InputStream, postModel, maxRecordCount);
//try
//{
// //测试时可开启此记录，帮助跟踪数据，使用前请确保App_Data文件夹存在，且有读写权限。
// messageHandler.RequestDocument.Save(
// Server.MapPath("~/App_Data/" + DateTime.Now.Ticks + "_Request_" +
// messageHandler.RequestMessage.FromUserName + ".txt"));
// //执行微信处理过程
// messageHandler.Execute();
// //测试时可开启，帮助跟踪数据
// messageHandler.ResponseDocument.Save(
// Server.MapPath("~/App_Data/" + DateTime.Now.Ticks + "_Response_" +
// messageHandler.ResponseMessage.ToUserName + ".txt"));
// WriteContent(messageHandler.ResponseDocument.ToString());
// return;
//}
//catch (Exception ex)
//{
// using (TextWriter tw = new StreamWriter(Server.MapPath("~/App_Data/Error_" + DateTime.Now.Ticks + ".txt")))
// {
// tw.WriteLine(ex.Message);
// tw.WriteLine(ex.InnerException.Message);
// if (messageHandler.ResponseDocument != null)
// {
// tw.WriteLine(messageHandler.ResponseDocument.ToString());
// }
// tw.Flush();
// tw.Close();
// }
//}
//finally
//{
// Response.End();
//}
}
}
public void ProcessRequest(HttpContext context)
{
context.Response.ContentType = "text/plain";
var Request = context.Request;
Response = context.Response;
var Server = context.Server;
string signature = Request["signature"];
string timestamp = Request["timestamp"];
string nonce = Request["nonce"];
string echostr = Request["echostr"];
string Token = "myweixin";
if (Request.HttpMethod == "GET")
{
//get method - 仅在微信后台填写URL验证时触发
if (CheckSignature.Check(signature, timestamp, nonce, Token))
{
WriteContent(echostr); //返回随机字符串则表示验证通过
}
else
{
WriteContent("failed:" + signature + "," + CheckSignature.GetSignature(timestamp, nonce, Token) + "。" +
"如果你在浏览器中看到这句话，说明此地址可以被作为微信公众账号后台的Url，请注意保持Token一致。");
}
Response.End();
}
else
{
//post method - 当有用户向公众账号发送消息时触发
if (!CheckSignature.Check(signature, timestamp, nonce, Token))
{
WriteContent("参数错误！");
return;
}
//post method - 当有用户向公众账号发送消息时触发
var postModel = new PostModel()
{
Signature = Request.QueryString["signature"],
Msg_Signature = Request.QueryString["msg_signature"],
Timestamp = Request.QueryString["timestamp"],
Nonce = Request.QueryString["nonce"],
//以下保密信息不会（不应该）在网络上传播，请注意
Token = Token,
EncodingAESKey = "T79NgH9wXHWta4dwPqcGxx1z92YAl4hSreDiIkZfRWo", //根据自己后台的设置保持一致
AppId = WebConfigurationManager.AppSettings["ShortWeixinAppId"] //根据自己后台的设置保持一致
};
var maxRecordCount = 10;
var messageHandler = new ShortCustomHandler(Request.InputStream, postModel, maxRecordCount);
try
{
messageHandler.Execute();
WriteContent(messageHandler.ResponseDocument.ToString());
return;
}
catch (Exception ex)
{
Logger log = LogManager.GetCurrentClassLogger();
log.ErrorException("订阅号异常", ex);
//using (TextWriter tw = new StreamWriter(Server.MapPath("~/App_Data/Error_" + DateTime.Now.Ticks + ".txt")))
//{
// tw.WriteLine(ex.Message);
// tw.WriteLine(ex.InnerException.Message);
// if (messageHandler.ResponseDocument != null)
// {
// tw.WriteLine(messageHandler.ResponseDocument.ToString());
// }
// tw.Flush();
// tw.Close();
//}
}
finally
{
Response.End();
}
}
}
public HttpResponseMessage Index(string signature, string timestamp, string nonce, string echostr)
{
if (CheckSignature.Check(signature, timestamp, nonce, Config.Token))
{
var result = new StringContent(echostr, UTF8Encoding.UTF8, "application/x-www-form-urlencoded");
var response = new HttpResponseMessage {
Content = result
};
return(response);
}
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "failed:" + signature + "," + CheckSignature.GetSignature(timestamp, nonce, Config.Token) + "。" +
"如果你在浏览器中看到这句话，说明此地址可以被作为微信公众账号后台的Url，请注意保持Token一致。"));
}
public ActionResult Post(PostModel postModel)
{
if (!CheckSignature.Check(postModel.Signature, postModel.Timestamp, postModel.Nonce, Token))
{
return(Content("参数错误！"));
}
postModel.Token = Token;
postModel.EncodingAESKey = ""; //根据自己后台的设置保持一致
postModel.AppId = GetAppSettings.AppID; //根据自己后台的设置保持一致
//v4.2.2之后的版本，可以设置每个人上下文消息储存的最大数量，防止内存占用过多，如果该参数小于等于0，则不限制
var maxRecordCount = 10;
//自定义MessageHandler，对微信请求的详细判断操作都在这里面。
var messageHandler = new CustomMessageHandler(Request.InputStream, postModel, maxRecordCount);
try
{
CommonService.CustomMessageHandler.CustomMessageHandler.CreateUserInfo(messageHandler.RequestMessage.FromUserName);
//测试时可开启此记录，帮助跟踪数据，使用前请确保App_Data文件夹存在，且有读写权限。
//messageHandler.RequestDocument.Save(Server.MapPath("~/App_Data/" + DateTime.Now.Ticks + "_Request_" + messageHandler.RequestMessage.FromUserName + ".txt"));
//if (messageHandler.UsingEcryptMessage)
//{
// messageHandler.EcryptRequestDocument.Save(Server.MapPath("~/App_Data/" + DateTime.Now.Ticks + "_Request_Ecrypt_" + messageHandler.RequestMessage.FromUserName + ".txt"));
//}
/* 如果需要添加消息去重功能，只需打开OmitRepeatedMessage功能，SDK会自动处理。
* 收到重复消息通常是因为微信服务器没有及时收到响应，会持续发送2-5条不等的相同内容的RequestMessage*/
messageHandler.OmitRepeatedMessage = true;
//执行微信处理过程
messageHandler.Execute();
//测试时可开启，帮助跟踪数据
//messageHandler.ResponseDocument.Save(Server.MapPath("~/App_Data/" + DateTime.Now.Ticks + "_Response_" + messageHandler.ResponseMessage.ToUserName + ".txt"));
//if (messageHandler.UsingEcryptMessage)
//{
// //记录加密后的响应信息
// messageHandler.FinalResponseDocument.Save(Server.MapPath("~/App_Data/" + DateTime.Now.Ticks + "_Response_Final_" + messageHandler.ResponseMessage.ToUserName + ".txt"));
//}
//return Content(messageHandler.ResponseDocument.ToString());//v0.7-
return(new FixWeixinBugWeixinResult(messageHandler));//为了解决官方微信5.0软件换行bug暂时添加的方法，平时用下面一个方法即可
//return new WeixinResult(messageHandler);//v0.8+
}
catch (Exception ex)
{
//using (TextWriter tw = new StreamWriter(Server.MapPath("~/App_Data/Error_" + DateTime.Now.Ticks + ".txt")))
//{
// tw.WriteLine("ExecptionMessage:" + ex.Message);
// tw.WriteLine(ex.Source);
// tw.WriteLine(ex.StackTrace);
// //tw.WriteLine("InnerExecptionMessage:" + ex.InnerException.Message);
// if (messageHandler.ResponseDocument != null)
// {
// tw.WriteLine(messageHandler.ResponseDocument.ToString());
// }
// tw.Flush();
// tw.Close();
//}
return(Content(""));
}
}
private readonly string AppId = WebConfigurationManager.AppSettings["AppId"]; //appid
protected void Page_Load(object sender, EventArgs e)
{
string signature = Request["signature"];
string timestamp = Request["timestamp"];
string nonce = Request["nonce"];
string echostr = Request["echostr"];
if (Request.HttpMethod == "GET")
{
//get method - 仅在微信后台填写URL验证时触发
if (CheckSignature.Check(signature, timestamp, nonce, Token))
{
WriteContent(echostr); //返回随机字符串则表示验证通过
}
else
{
WriteContent("failed:" + signature + "," + CheckSignature.GetSignature(timestamp, nonce, Token) + "。" +
"如果你在浏览器中看到这句话，说明此地址可以被作为微信公众账号后台的Url，请注意保持Token一致。");
}
Response.End();
}
else
{
//post method - 当有用户想公众账号发送消息时触发
if (!CheckSignature.Check(signature, timestamp, nonce, Token))
{
WriteContent("参数错误！");
return;
}
var postModel = new PostModel()
{
Signature = Request.QueryString["signature"],
Msg_Signature = Request.QueryString["msg_signature"],
Timestamp = Request.QueryString["timestamp"],
Nonce = Request.QueryString["nonce"],
//以下保密信息不会（不应该）在网络上传播，请注意
Token = WebConfigurationManager.AppSettings["APPToken"],
EncodingAESKey = WebConfigurationManager.AppSettings["AesKey"], //根据自己后台的设置保持一致
AppId = WebConfigurationManager.AppSettings["AppId"] //根据自己后台的设置保持一致
};
//v4.2.2之后的版本，可以设置每个人上下文消息储存的最大数量，防止内存占用过多，如果该参数小于等于0，则不限制
var maxRecordCount = 2;
//自定义MessageHandler，对微信请求的详细判断操作都在这里面
//测试时可开启此记录，帮助跟踪数据
var messageHandler = new CustomMessageHandler(Request.InputStream, postModel, maxRecordCount);
try
{
//测试时可开启此记录，帮助跟踪数据
messageHandler.RequestDocument.Save(
Server.MapPath("~/dll/" + DateTime.Now.Ticks + "_Request_" +
messageHandler.RequestMessage.FromUserName + ".txt"));
//执行微信处理过程
//if (messageHandler.UsingEcryptMessage)
//{
// messageHandler.EcryptRequestDocument.Save(Server.MapPath("~/App_Data/" + DateTime.Now.Ticks + "_Request_Ecrypt_" + messageHandler.RequestMessage.FromUserName + ".txt"));
//}
// messageHandler.UsingEcryptMessage = true;
messageHandler.Execute();
//测试时可开启，帮助跟踪数据
messageHandler.ResponseDocument.Save(
Server.MapPath("~/dll/" + DateTime.Now.Ticks + "_Response_" +
messageHandler.ResponseMessage.ToUserName + ".txt"));
if (messageHandler.UsingEcryptMessage)
{
//记录加密后的响应信息
messageHandler.FinalResponseDocument.Save(Server.MapPath("~/dll/" + DateTime.Now.Ticks + "_Response_Final_" + messageHandler.ResponseMessage.ToUserName + ".txt"));
}
WriteContent(messageHandler.FinalResponseDocument.ToString());
return;
}
catch (Exception ex)
{
using (TextWriter tw = new StreamWriter(Server.MapPath("~/dll/Error_" + DateTime.Now.Ticks + ".txt")))
{
tw.WriteLine(ex.Message);
tw.WriteLine(ex.InnerException.Message);
if (messageHandler.ResponseDocument != null)
{
tw.WriteLine(messageHandler.ResponseDocument.ToString());
}
tw.Flush();
tw.Close();
}
WriteContent("");
}
finally
{
Response.End();
}
}
}
public ActionResult Post(PostModel postModel)
{
try
{
_logger.LogTrace(string.Format("post:进入！"));
if (!CheckSignature.Check(postModel.Signature, postModel.Timestamp, postModel.Nonce, wechatOptions.Token))
{
_logger.LogTrace(string.Format("post:参数错误！"));
return(Content("参数错误！"));
}
_logger.LogTrace(string.Format("post:Check End！"));
postModel.Token = wechatOptions.Token; //根据自己后台的设置保持一致
postModel.EncodingAESKey = wechatOptions.EncodingAESKey; //根据自己后台的设置保持一致
postModel.AppId = wechatOptions.AppId; //根据自己后台的设置保持一致
//v4.2.2之后的版本，可以设置每个人上下文消息储存的最大数量，防止内存占用过多，如果该参数小于等于0，则不限制
var maxRecordCount = 10;
//XDocument xdoc = null;
//using (XmlReader reader = XmlReader.Create(Request.Body))
//{
// xdoc = XDocument.Load(reader);
//}
////自定义MessageHandler，对微信请求的详细判断操作都在这里面。
//_logger.LogTrace(string.Format("post:new Handler"));
//var messageHandler = new WechatCoreMessageHandler(wechatCoreDb, wechatOptions.AppId, wechatOptions.AppSecret, xdoc, postModel, _logger, maxRecordCount);
string body = new StreamReader(Request.Body).ReadToEnd();
byte[] requestData = Encoding.UTF8.GetBytes(body);
Stream inputStream = new MemoryStream(requestData);
var messageHandler = new WechatCoreMessageHandler(wechatCoreDb, wechatOptions.AppId, wechatOptions.AppSecret, inputStream, postModel, _logger, maxRecordCount);
/* 如果需要添加消息去重功能，只需打开OmitRepeatedMessage功能，SDK会自动处理。
* 收到重复消息通常是因为微信服务器没有及时收到响应，会持续发送2-5条不等的相同内容的RequestMessage*/
messageHandler.OmitRepeatedMessage = true;
//执行微信处理过程
messageHandler.Execute();
_logger.LogTrace($"post:finish messageHandler.Execute");
if (messageHandler.ResponseDocument != null)
{
_logger.LogTrace($"post:{messageHandler.ResponseDocument.ToString()}");
}
//return new WeixinResult(messageHandler);
//return Content("success");
return(new FixWeixinBugWeixinResult(messageHandler));//为了解决官方微信5.0软件换行bug暂时添加的方法，平时用下面一个方法即可
}
catch (Exception ex)
{
_logger.LogError(new EventId(10001), ex, "weixin post error");
var aa = ex.Message;
while (ex.InnerException != null)
{
ex = ex.InnerException;
aa += " | " + ex.Message;
}
_logger.LogError(new EventId(10002), ex, "weixin post error" + aa + ex.StackTrace);
return(Content("success"));
}
}
public ActionResult Post(PostModel postModel)
{
if (!CheckSignature.Check(postModel.Signature, postModel.Timestamp, postModel.Nonce, Token))
{
return(Content("参数错误！"));
}
postModel.Token = Token; //根据自己后台的设置保持一致
postModel.EncodingAESKey = this.EncodingAESKey; //根据自己后台的设置保持一致
postModel.AppId = AppId; //根据自己后台的设置保持一致
//v4.2.2之后的版本，可以设置每个人上下文消息储存的最大数量，防止内存占用过多，如果该参数小于等于0，则不限制
var maxRecordCount = 10;
var logPath = string.Format("{1}/App_Data/MP/{0}/", DateTime.Now.ToString("yyyy-MM-dd"), rootPath);
if (!Directory.Exists(logPath))
{
Directory.CreateDirectory(logPath);
}
var stream = this.HttpContext.Request.Body;
XDocument doc = XDocument.Load(stream);
//自定义MessageHandler，对微信请求的详细判断操作都在这里面。
var messageHandler = new CustomMessageHandler(doc, postModel, maxRecordCount);
try
{
//测试时可开启此记录，帮助跟踪数据，使用前请确保App_Data文件夹存在，且有读写权限。
string filePath = Path.Combine(logPath, string.Format("{0}_Request_{1}.txt", _getRandomFileName(), messageHandler.RequestMessage.FromUserName));
FileStream fs = new FileStream(filePath, FileMode.OpenOrCreate);
messageHandler.RequestDocument.Save(fs);
if (messageHandler.UsingEcryptMessage)
{
FileStream fsx = new FileStream(Path.Combine(logPath, string.Format("{0}_Request_Ecrypt_{1}.txt", _getRandomFileName(), messageHandler.RequestMessage.FromUserName)), FileMode.OpenOrCreate);
messageHandler.EcryptRequestDocument.Save(fsx);
}
/* 如果需要添加消息去重功能，只需打开OmitRepeatedMessage功能，SDK会自动处理。
* 收到重复消息通常是因为微信服务器没有及时收到响应，会持续发送2-5条不等的相同内容的RequestMessage*/
messageHandler.OmitRepeatedMessage = true;
//执行微信处理过程
messageHandler.Execute();
//测试时可开启，帮助跟踪数据
//if (messageHandler.ResponseDocument == null)
//{
// throw new Exception(messageHandler.RequestDocument.ToString());
//}
if (messageHandler.ResponseDocument != null)
{
FileStream fsa = new FileStream(Path.Combine(logPath, string.Format("{0}_Response_{1}.txt", _getRandomFileName(), messageHandler.RequestMessage.FromUserName)), FileMode.CreateNew);
messageHandler.ResponseDocument.Save(fsa);
}
if (messageHandler.UsingEcryptMessage)
{
FileStream fsb = new FileStream(Path.Combine(logPath, string.Format("{0}_Response_Final_{1}.txt", _getRandomFileName(), messageHandler.RequestMessage.FromUserName)), FileMode.CreateNew);
//记录加密后的响应信息
messageHandler.FinalResponseDocument.Save(fsb);
}
//return Content(messageHandler.ResponseDocument.ToString());//v0.7-
//return new FixWeixinBugWeixinResult(messageHandler);//为了解决官方微信5.0软件换行bug暂时添加的方法，平时用下面一个方法即可
return(new WeixinResult(messageHandler));//v0.8+
}
catch (Exception ex)
{
FileStream fsc = new FileStream(rootPath + "/App_Data/Error_" + _getRandomFileName() + ".txt", FileMode.CreateNew);
using (TextWriter tw = new StreamWriter(fsc))
{
tw.WriteLine("ExecptionMessage:" + ex.Message);
tw.WriteLine(ex.Source);
tw.WriteLine(ex.StackTrace);
//tw.WriteLine("InnerExecptionMessage:" + ex.InnerException.Message);
if (messageHandler.ResponseDocument != null)
{
tw.WriteLine(messageHandler.ResponseDocument.ToString());
}
if (ex.InnerException != null)
{
tw.WriteLine("========= InnerException =========");
tw.WriteLine(ex.InnerException.Message);
tw.WriteLine(ex.InnerException.Source);
tw.WriteLine(ex.InnerException.StackTrace);
}
tw.Flush();
}
return(Content(""));
}
}
private readonly string Token = "08efecf60208e6909df002";//定义一个局部变量不可以被修改，这里定义的变量要与接口配置信息中填写的Token一致
protected void Page_Load(object sender, EventArgs e)
{
log4net.LogManager.GetLogger("loginfo").Info("可以访问！");
string signature = Request["signature"];
string timestamp = Request["timestamp"];
string nonce = Request["nonce"];
string echostr = Request["echostr"];
if (Request.HttpMethod == "GET")
{
//get method - 仅在微信后台填写URL验证时触发
if (CheckSignature.Check(signature, timestamp, nonce, Token))
{
WriteContent(echostr); //返回随机字符串则表示验证通过
}
else
{
WriteContent("failed:" + signature + "," + CheckSignature.GetSignature(timestamp, nonce, Token) + "。" +
"如果你在浏览器中看到这句话，说明此地址可以被作为微信公众账号后台的Url，请注意保持Token一致。");
}
Response.End();
}
else
{
log4net.LogManager.GetLogger("loginfo").Info("开始获取accesstoken值");
var accessToken = AccessTokenContainer.TryGetAccessToken("wx422044a7a4be9609", "a12eca08b53a58d3806c6226efbb1364");//appid,appsecret
log4net.LogManager.GetLogger("loginfo").Info("已获取accesstoken");
log4net.LogManager.GetLogger("loginfo").Info("开始创建菜单");
ButtonGroup bg = new ButtonGroup();
bg.button.Add(new SingleViewButton()
{
name = "自由查单",
url = "http://client.chahuobao.net/manager/WxQuery"
});
//二级菜单
var subButton = new SubButton()
{
name = "微服务"
};
//subButton.sub_button.Add(new SingleViewButton()
//{
// url = "http://www.wuliubaoxianpingtai.com/weixin/",
// name = "关于我们"
//});
subButton.sub_button.Add(new SingleViewButton()
{
url = "http://a.app.qq.com/o/simple.jsp?pkgname=io.dcloud.H5A57DD98",
name = "软件下载"
});
bg.button.Add(subButton);
//bg.button.Add(new SingleViewButton()
//{
// name = "物流女神",
// url = "http://471280.v.caoapp.cn/mobile/cutebabyvote/index.jsp?aid=71DF2E37D6E98216&wuid=471280&isFromApiFilter=1"
//});
bg.button.Add(new SingleViewButton()
{
name = "运费券",
url = "http://wx.chahuobao.net/weixin/html/BuyPointsListNew.html"
});
var result = CommonApi.CreateMenu(accessToken, bg);
log4net.LogManager.GetLogger("loginfo").Info(result);
log4net.LogManager.GetLogger("loginfo").Info("菜单创建完毕");
//post method - 当有用户向公众账号发送消息时触发
if (!CheckSignature.Check(signature, timestamp, nonce, Token))
{
WriteContent("参数错误！");
return;
}
//post method - 当有用户想公众账号发送消息时触发
var postModel = new PostModel()
{
Signature = Request.QueryString["signature"],
Msg_Signature = Request.QueryString["msg_signature"],
Timestamp = Request.QueryString["timestamp"],
Nonce = Request.QueryString["nonce"],
//以下保密信息不会（不应该）在网络上传播，请注意
Token = Token,
EncodingAESKey = "chb7390fhunxg16sdjlkxnfhjdsk3gaz", //根据自己后台的设置保持一致
AppId = "wx422044a7a4be9609" //根据自己后台的设置保持一致
};
var maxRecordCount = 10;
//自定义MessageHandler，对微信请求的详细判断操作都在这里面。
var messageHandler = new CustomMessageHandler(Request.InputStream, postModel);
try
{
//执行微信处理过程
messageHandler.Execute();
WriteContent(messageHandler.ResponseDocument.ToString());
return;
}
catch (Exception ex)
{
using (TextWriter tw = new StreamWriter(Server.MapPath("~/App_Data/Error_" + DateTime.Now.Ticks + ".txt")))
{
tw.WriteLine(ex.Message);
tw.WriteLine(ex.InnerException.Message);
if (messageHandler.ResponseDocument != null)
{
tw.WriteLine(messageHandler.ResponseDocument.ToString());
}
tw.Flush();
tw.Close();
}
}
finally
{
Response.End();
}
}
}
public ActionResult Post(string signature, string timestamp, string nonce, string openid, string encrypt_type, string msg_signature)
{
//StringBuilder log = new StringBuilder();
LogService.AnyLog("WeChatWebHook", $"WxApi\tPost In");//{DateTime.Now.ToString("HH:mm:ss.fffffff")}\t
PostModel postModel = new PostModel()
{
Token = WechatMpSettings.Default.Token, //根据自己后台的设置保持一致
Signature = signature,
Timestamp = timestamp,
Nonce = nonce,
AppId = WechatMpSettings.Default.AppId,
EncodingAESKey = WechatMpSettings.Default.EncodingAESKey,
Msg_Signature = msg_signature,
};
try
{
//加密异常
if (encrypt_type == "aes" && string.IsNullOrEmpty(postModel.EncodingAESKey))
{
return(Content("公从号接口有异常，请通过其它途径解决您的问题，并反馈此消息"));
}
if (encrypt_type == "aes" && wxcrypt == null)
{
wxcrypt = new WXBizMsgCrypt(postModel.Token, postModel.EncodingAESKey, postModel.AppId);
}
if (!CheckSignature.Check(signature, postModel))
{
return(Content("参数错误！"));
}
String PostXml = Request.GetBodyString();
//解密信息
if (encrypt_type == "aes")
{
var aeskey = WechatMpSettings.Default.EncodingAESKey;
string detext = null;
var res = wxcrypt.DecryptMsg(postModel.Msg_Signature, postModel.Timestamp, postModel.Nonce, PostXml, ref detext);
//Console.WriteLine($"{res} detext({postModel.Token},{postModel.EncodingAESKey},{postModel.AppId},{postModel.Msg_Signature}, {postModel.Timestamp}, {postModel.Nonce},{PostXml})>{detext}");
PostXml = detext;
}
WechatResponse wxsponse = new WechatResponse(Request, PostXml);
var botsponse = wxsponse.Rebot();
LogService.AnyLog("WeChatWebHook", "响应源数据", $"{botsponse.Content}");
//加密信息
if (encrypt_type == "aes")
{
var rTimeStamp = DateTime.Now.GetTimestamp10();
var rNonce = RandomString.BuildRndString(16);
string restr = null;
var rb = wxcrypt.EncryptMsg(botsponse.Content, rTimeStamp + "", rNonce, ref restr);
if (rb == 0)
{
botsponse.Content = restr;
}
else
{
$"{rb} EncryptMsg".WriteErrorLine();
}
}
LogService.AnyLog("WeChatWebHook", "响应密数据", $"{botsponse.Content}");
return(botsponse);
}
catch (Exception ex)
{
#region 异常处理
LogService.AnyLog("WeChatWebHook", $"{ex.Message}");
LogService.Exception(ex);
return(Content(""));
#endregion
}
finally
{
LogService.AnyLog("WeChatWebHook", $"WxApi\tPost Out");
}
}
public ActionResult Post(PostModel postModel)
{
if (!CheckSignature.Check(postModel.Signature, postModel.Timestamp, postModel.Nonce, Token))
{
return(Content("参数错误！"));
}
#region 打包 PostModel 信息
postModel.Token = Token; //根据自己后台的设置保持一致
postModel.EncodingAESKey = EncodingAESKey; //根据自己后台的设置保持一致
postModel.AppId = AppId; //根据自己后台的设置保持一致
#endregion
//v4.2.2之后的版本，可以设置每个人上下文消息储存的最大数量，防止内存占用过多，如果该参数小于等于0，则不限制
var maxRecordCount = 10;
//自定义MessageHandler，对微信请求的详细判断操作都在这里面。
var messageHandler = new CustomMessageHandler(Request.GetRequestMemoryStream(), postModel, maxRecordCount);
#region 设置消息去重
/* 如果需要添加消息去重功能，只需打开OmitRepeatedMessage功能，SDK会自动处理。
* 收到重复消息通常是因为微信服务器没有及时收到响应，会持续发送2-5条不等的相同内容的RequestMessage*/
messageHandler.OmitRepeatedMessage = true;//默认已经开启，此处仅作为演示，也可以设置为false在本次请求中停用此功能
#endregion
try
{
#region 记录 Request 日志
var logPath = Server.GetMapPath(string.Format("~/App_Data/MP/{0}/", DateTime.Now.ToString("yyyy-MM-dd")));
if (!Directory.Exists(logPath))
{
Directory.CreateDirectory(logPath);
}
//测试时可开启此记录，帮助跟踪数据，使用前请确保App_Data文件夹存在，且有读写权限。
messageHandler.RequestDocument.Save(Path.Combine(logPath, string.Format("{0}_Request_{1}_{2}.txt", _getRandomFileName(),
messageHandler.RequestMessage.FromUserName,
messageHandler.RequestMessage.MsgType)));
if (messageHandler.UsingEcryptMessage)
{
messageHandler.EcryptRequestDocument.Save(Path.Combine(logPath, string.Format("{0}_Request_Ecrypt_{1}_{2}.txt", _getRandomFileName(),
messageHandler.RequestMessage.FromUserName,
messageHandler.RequestMessage.MsgType)));
}
#endregion
//执行微信处理过程
messageHandler.Execute();
#region 记录 Response 日志
//测试时可开启，帮助跟踪数据
//if (messageHandler.ResponseDocument == null)
//{
// throw new Exception(messageHandler.RequestDocument.ToString());
//}
if (messageHandler.ResponseDocument != null && messageHandler.ResponseDocument.Root != null)
{
messageHandler.ResponseDocument.Save(Path.Combine(logPath, string.Format("{0}_Response_{1}_{2}.txt", _getRandomFileName(),
messageHandler.ResponseMessage.ToUserName,
messageHandler.ResponseMessage.MsgType)));
}
if (messageHandler.UsingEcryptMessage &&
messageHandler.FinalResponseDocument != null && messageHandler.FinalResponseDocument.Root != null)
{
//记录加密后的响应信息
messageHandler.FinalResponseDocument.Save(Path.Combine(logPath, string.Format("{0}_Response_Final_{1}_{2}.txt", _getRandomFileName(),
messageHandler.ResponseMessage.ToUserName,
messageHandler.ResponseMessage.MsgType)));
}
#endregion
//return Content(messageHandler.ResponseDocument.ToString());//v0.7-
//return new WeixinResult(messageHandler);//v0.8+
return(new FixWeixinBugWeixinResult(messageHandler));//为了解决官方微信5.0软件换行bug暂时添加的方法，平时用下面一个方法即可
}
catch (Exception ex)
{
#region 异常处理
WeixinTrace.Log("MessageHandler错误：{0}", ex.Message);
using (TextWriter tw = new StreamWriter(Server.GetMapPath("~/App_Data/Error_" + _getRandomFileName() + ".txt")))
{
tw.WriteLine("ExecptionMessage:" + ex.Message);
tw.WriteLine(ex.Source);
tw.WriteLine(ex.StackTrace);
//tw.WriteLine("InnerExecptionMessage:" + ex.InnerException.Message);
if (messageHandler.ResponseDocument != null)
{
tw.WriteLine(messageHandler.ResponseDocument.ToString());
}
if (ex.InnerException != null)
{
tw.WriteLine("========= InnerException =========");
tw.WriteLine(ex.InnerException.Message);
tw.WriteLine(ex.InnerException.Source);
tw.WriteLine(ex.InnerException.StackTrace);
}
tw.Flush();
tw.Close();
}
return(Content(""));
#endregion
}
}
public async Task <ActionResult> Post(PostModel postModel)
{
if (!CheckSignature.Check(postModel.Signature, postModel.Timestamp, postModel.Nonce, Token))
{
return(new WeixinResult("参数错误！"));
}
postModel.Token = Token;
postModel.EncodingAESKey = EncodingAESKey; //根据自己后台的设置保持一致
postModel.AppId = AppId; //根据自己后台的设置保持一致
var messageHandler = new CustomMessageHandler(Request.InputStream, postModel, 10);
messageHandler.DefaultMessageHandlerAsyncEvent = Weixin.MessageHandlers.DefaultMessageHandlerAsyncEvent.SelfSynicMethod;//没有重写的异步方法将默认尝试调用同步方法中的代码（为了偷懒）
#region 设置消息去重
/* 如果需要添加消息去重功能，只需打开OmitRepeatedMessage功能，SDK会自动处理。
* 收到重复消息通常是因为微信服务器没有及时收到响应，会持续发送2-5条不等的相同内容的RequestMessage*/
messageHandler.OmitRepeatedMessage = true;//默认已经开启，此处仅作为演示，也可以设置为false在本次请求中停用此功能
#endregion
#region 记录 Request 日志
var logPath = Server.MapPath(string.Format("~/App_Data/MP/{0}/", DateTime.Now.ToString("yyyy-MM-dd")));
if (!Directory.Exists(logPath))
{
Directory.CreateDirectory(logPath);
}
//测试时可开启此记录，帮助跟踪数据，使用前请确保App_Data文件夹存在，且有读写权限。
messageHandler.RequestDocument.Save(Path.Combine(logPath, string.Format("{0}_Request_{1}_{2}.txt", _getRandomFileName(),
messageHandler.RequestMessage.FromUserName,
messageHandler.RequestMessage.MsgType)));
if (messageHandler.UsingEcryptMessage)
{
messageHandler.EcryptRequestDocument.Save(Path.Combine(logPath, string.Format("{0}_Request_Ecrypt_{1}_{2}.txt", _getRandomFileName(),
messageHandler.RequestMessage.FromUserName,
messageHandler.RequestMessage.MsgType)));
}
#endregion
await messageHandler.ExecuteAsync(); //执行微信处理过程
#region 记录 Response 日志
//测试时可开启，帮助跟踪数据
//if (messageHandler.ResponseDocument == null)
//{
// throw new Exception(messageHandler.RequestDocument.ToString());
//}
if (messageHandler.ResponseDocument != null)
{
messageHandler.ResponseDocument.Save(Path.Combine(logPath, string.Format("{0}_Response_{1}_{2}.txt", _getRandomFileName(),
messageHandler.ResponseMessage.ToUserName,
messageHandler.ResponseMessage.MsgType)));
}
if (messageHandler.UsingEcryptMessage && messageHandler.FinalResponseDocument != null)
{
//记录加密后的响应信息
messageHandler.FinalResponseDocument.Save(Path.Combine(logPath, string.Format("{0}_Response_Final_{1}_{2}.txt", _getRandomFileName(),
messageHandler.ResponseMessage.ToUserName,
messageHandler.ResponseMessage.MsgType)));
}
#endregion
MessageHandler = messageHandler;//开放出MessageHandler是为了做单元测试，实际使用过程中不需要
return(new FixWeixinBugWeixinResult(messageHandler));
}
public ActionResult Post(PostModel postModel)
{
if (!CheckSignature.Check(postModel.Signature, postModel.Timestamp, postModel.Nonce, Token))
{
return(Content("参数错误！"));
}
#region 打包 PostModel 信息
postModel.Token = Token; //根据自己后台的设置保持一致
postModel.EncodingAESKey = EncodingAESKey; //根据自己后台的设置保持一致
postModel.AppId = AppId; //根据自己后台的设置保持一致（必须提供）
#endregion
//v4.2.2之后的版本，可以设置每个人上下文消息储存的最大数量，防止内存占用过多，如果该参数小于等于0，则不限制
var maxRecordCount = 10;
//自定义MessageHandler，对微信请求的详细判断操作都在这里面。
var messageHandler = new CustomMessageHandler(Request.GetRequestMemoryStream(), postModel, maxRecordCount);
#region 设置消息去重
/* 如果需要添加消息去重功能，只需打开OmitRepeatedMessage功能，SDK会自动处理。
* 收到重复消息通常是因为微信服务器没有及时收到响应，会持续发送2-5条不等的相同内容的RequestMessage*/
messageHandler.OmitRepeatedMessage = true;//默认已经开启，此处仅作为演示，也可以设置为false在本次请求中停用此功能
#endregion
try
{
messageHandler.SaveRequestMessageLog(); //记录 Request 日志（可选）
messageHandler.Execute(); //执行微信处理过程（关键）
messageHandler.SaveResponseMessageLog(); //记录 Response 日志（可选）
//return Content(messageHandler.ResponseDocument.ToString());//v0.7-
//return new WeixinResult(messageHandler);//v0.8+
return(new FixWeixinBugWeixinResult(messageHandler));//为了解决官方微信5.0软件换行bug暂时添加的方法，平时用下面一个方法即可
}
catch (Exception ex)
{
#region 异常处理
WeixinTrace.Log("MessageHandler错误：{0}", ex.Message);
using (TextWriter tw = new StreamWriter(ServerUtility.ContentRootMapPath("~/App_Data/Error_" + _getRandomFileName() + ".txt")))
{
tw.WriteLine("ExecptionMessage:" + ex.Message);
tw.WriteLine(ex.Source);
tw.WriteLine(ex.StackTrace);
//tw.WriteLine("InnerExecptionMessage:" + ex.InnerException.Message);
if (messageHandler.ResponseDocument != null)
{
tw.WriteLine(messageHandler.ResponseDocument.ToString());
}
if (ex.InnerException != null)
{
tw.WriteLine("========= InnerException =========");
tw.WriteLine(ex.InnerException.Message);
tw.WriteLine(ex.InnerException.Source);
tw.WriteLine(ex.InnerException.StackTrace);
}
tw.Flush();
tw.Close();
}
return(Content(""));
#endregion
}
}
public ActionResult Post(PostModel postModel)
{
if (!CheckSignature.Check(postModel.Signature, postModel.Timestamp, postModel.Nonce, token))
{
return(Content("参数错误！"));
}
#region 打包 PostModel 信息
postModel.Token = token; //根据自己后台的设置保持一致
postModel.EncodingAESKey = encodingAESKey; //根据自己后台的设置保持一致
postModel.AppId = appId; //根据自己后台的设置保持一致
#endregion
//v4.2.2之后的版本，可以设置每个人上下文消息储存的最大数量，防止内存占用过多，如果该参数小于等于0，则不限制
var maxRecordCount = 10;
//自定义MessageHandler，对微信请求的详细判断操作都在这里面。
MessageHandler <CustomMessageContext> messageHandler;
var messageHandlerType = WeiXinConfiguration.WeiXinMessageHandlerType;
if (messageHandlerType != null)
{
messageHandler = Activator.CreateInstance(messageHandlerType, Request.GetRequestMemoryStream(), postModel, maxRecordCount) as MessageHandler <CustomMessageContext>;
}
else
{
messageHandler = new CustomMessageHandler(Request.GetRequestMemoryStream(), postModel, maxRecordCount);
}
#region 设置消息去重
/* 如果需要添加消息去重功能，只需打开OmitRepeatedMessage功能，SDK会自动处理。
* 收到重复消息通常是因为微信服务器没有及时收到响应，会持续发送2-5条不等的相同内容的RequestMessage*/
messageHandler.OmitRepeatedMessage = true;//默认已经开启，此处仅作为演示，也可以设置为false在本次请求中停用此功能
#endregion
try
{
#region 记录 Request 日志
//var logPath = Server.GetMapPath(string.Format("~/App_Data/MP/{0}/", DateTime.Now.ToString("yyyy-MM-dd")));
//if (!Directory.Exists(logPath))
//{
// Directory.CreateDirectory(logPath);
//}
////测试时可开启此记录，帮助跟踪数据，使用前请确保App_Data文件夹存在，且有读写权限。
//messageHandler.RequestDocument.Save(Path.Combine(logPath, string.Format("{0}_Request_{1}_{2}.txt", _getRandomFileName(),
// messageHandler.RequestMessage.FromUserName,
// messageHandler.RequestMessage.MsgType)));
//if (messageHandler.UsingEcryptMessage)
//{
// messageHandler.EcryptRequestDocument.Save(Path.Combine(logPath, string.Format("{0}_Request_Ecrypt_{1}_{2}.txt", _getRandomFileName(),
// messageHandler.RequestMessage.FromUserName,
// messageHandler.RequestMessage.MsgType)));
//}
Logger.Info($"WeChat Request Message:{messageHandler.RequestMessage.FromUserName},{messageHandler.RequestMessage.MsgType}");
#endregion
//执行微信处理过程
messageHandler.Execute();
#region 记录 Response 日志
//测试时可开启，帮助跟踪数据
//if (messageHandler.ResponseDocument == null)
//{
// throw new Exception(messageHandler.RequestDocument.ToString());
//}
//if (messageHandler.ResponseDocument != null)
//{
// messageHandler.ResponseDocument.Save(Path.Combine(logPath, string.Format("{0}_Response_{1}_{2}.txt", _getRandomFileName(),
// messageHandler.ResponseMessage.ToUserName,
// messageHandler.ResponseMessage.MsgType)));
//}
//if (messageHandler.UsingEcryptMessage && messageHandler.FinalResponseDocument != null)
//{
// 记录加密后的响应信息
// messageHandler.FinalResponseDocument.Save(Path.Combine(logPath, string.Format("{0}_Response_Final_{1}_{2}.txt", _getRandomFileName(),
// messageHandler.ResponseMessage.ToUserName,
// messageHandler.ResponseMessage.MsgType)));
//}
Logger.Info($"WeChat Response Message:{messageHandler.ResponseMessage.ToUserName},{messageHandler.ResponseMessage.MsgType}");
#endregion
return(Content(messageHandler.ResponseDocument.ToString()));//v0.7-
//return new WeixinResult(messageHandler);//v0.8+
//return new FixWeixinBugWeixinResult(messageHandler);//为了解决官方微信5.0软件换行bug暂时添加的方法，平时用下面一个方法即可
}
catch (Exception ex)
{
#region 异常处理
WeixinTrace.Log("MessageHandler错误：{0}", ex.Message);
Logger.Error("MessageHandler错误:" + ex.Message, ex);
return(Content(""));
#endregion
}
}
