protected async Task TryCacheResult(IHandlerContext handlerContext, object result, HttpRequestMessage request, HttpResponseMessage response)
{
if (!Enabled)
{
return;
}
var context = GetContext(handlerContext);
var cacheEntry = new CacheEntry(result, request, response, context);
var requestValidation = context.RequestValidator(context);
if (requestValidation == RequestValidationResult.OK)
{
var validationResult = context.ResponseValidator(context, cacheEntry.Metadata);
if (validationResult == ResponseValidationResult.OK ||
validationResult == ResponseValidationResult.MustRevalidate)
{
await _cacheManager.Put(context, cacheEntry);
}
await context.HandlerRegister.OnStore(context, cacheEntry.Value);
}
else
{
await ExpireResult(context, requestValidation);
}
}
public string ResolveAttributeExpression(string expression, IHandlerContext handlerContext)
{
string text = expression;
int leftMarkerIndex = text.IndexOf(LEFT_MARKER);
int rightMarkerIndex = text.IndexOf(RIGHT_MARKER, leftMarkerIndex + LEFT_MARKER.Length);
while ((leftMarkerIndex != -1) && (rightMarkerIndex != -1))
{
string attributeName = text.Substring(leftMarkerIndex + LEFT_MARKER.Length, (rightMarkerIndex) - (leftMarkerIndex + LEFT_MARKER.Length)).Trim();
try
{
object attribute = handlerContext.GetAttribute(attributeName);
if (attribute != null)
{
string attributeString = attribute.ToString();
text = text.Substring(0, leftMarkerIndex) + attributeString + text.Substring(rightMarkerIndex + RIGHT_MARKER.Length);
rightMarkerIndex = rightMarkerIndex + attributeString.Length - attributeName.Length - LEFT_MARKER.Length - RIGHT_MARKER.Length;
}
}
catch (Exception e)
{
//log.Debug("attribute '" + attributeName + "' could not be resolved in attribute expression '" + expression + "'. Exception: " + e.Message);
}
leftMarkerIndex = text.IndexOf(LEFT_MARKER, rightMarkerIndex + RIGHT_MARKER.Length);
rightMarkerIndex = text.IndexOf(RIGHT_MARKER, leftMarkerIndex + LEFT_MARKER.Length);
}
return(text);
}
/// <summary>
/// 调用。
/// </summary>
/// <param name="context">处理上下文。</param>
/// <returns>任务。</returns>
public override Task Invoke(IHandlerContext context)
{
var requestMessage = context.GetRequestMessage();
//得到消息的唯一标识。
var identity = GetMessageIdentity(requestMessage);
#region 删除无效的消息标识以节省资源
for (var i = 0; i < MessageIdentity.Count; i++)
{
var item = MessageIdentity[i];
//消息处理时间大于30秒则删除该条标识。
if (item.Value.AddSeconds(30) < DateTime.Now)
{
MessageIdentity.Remove(item);
}
}
#endregion 删除无效的消息标识以节省资源
//如果消息已经被标识为处理则跳过。
if (MessageIdentity.Any(i => i.Key == identity))
return EmptyHandlerMiddleware.Instance.Invoke(context);
//标识消息正在处理。
MessageIdentity.Add(new KeyValuePair<string, DateTime>(identity, DateTime.Now));
return Next.Invoke(context);
}
public void ProcessMessage(IHandlerContext <AddRoleCommand> context)
{
var message = context.Message;
if (string.IsNullOrEmpty(message.Name))
{
return;
}
using (_databaseContextFactory.Create())
{
var key = Role.Key(message.Name);
if (_keyStore.Contains(key))
{
return;
}
var id = Guid.NewGuid();
_keyStore.Add(id, key);
var role = new Role(id);
var stream = _eventStore.CreateEventStream(id);
stream.AddEvent(role.Add(message.Name));
_eventStore.Save(stream);
}
}
public void ProcessMessage(IHandlerContext <OrderProcessArchivedEvent> context)
{
using (_databaseContextFactory.Create(ProcessManagementData.ConnectionStringName))
{
_orderProcessViewQuery.Remove(context.Message.OrderProcessId);
}
}
public void ProcessMessage(IHandlerContext <SetUserRoleCommand> context)
{
var message = context.Message;
using (_databaseContextFactory.Create())
{
if (!message.Active && message.RoleName.Equals("administrator") && _systemUserQuery.AdministratorCount() == 1)
{
return;
}
var user = new User(message.UserId);
var stream = _eventStore.Get(message.UserId);
stream.Apply(user);
if (message.Active && !user.IsInRole(message.RoleName))
{
stream.AddEvent(user.AddRole(message.RoleName));
}
if (!message.Active && user.IsInRole(message.RoleName))
{
stream.AddEvent(user.RemoveRole(message.RoleName));
}
_eventStore.Save(stream);
}
}
public void ProcessMessage(IHandlerContext <RegisterServerCommand> context)
{
var message = context.Message;
using (_databaseContextFactory.Create())
{
var id = _serverQuery.FindId(message.MachineName, message.BaseDirectory);
if (id.HasValue)
{
_serverQuery.Save(
id.Value,
message.IPv4Address,
message.InboxWorkQueueUri,
message.ControlInboxWorkQueueUri);
}
else
{
_serverQuery.Add(
message.MachineName,
message.BaseDirectory,
message.IPv4Address,
message.InboxWorkQueueUri,
message.ControlInboxWorkQueueUri);
}
}
}
public void ProcessMessage(IHandlerContext <RemoveDataStoreCommand> context)
{
using (_databaseContextFactory.Create())
{
_dataStoreQuery.Remove(context.Message.Id);
}
}
public void ProcessMessage(IHandlerContext <CancelOrderProcessCommand> context)
{
using (_databaseContextFactory.Create(ProcessManagementData.ConnectionStringName))
{
var stream = _eventStore.Get(context.Message.OrderProcessId);
var orderProcess = new OrderProcess(context.Message.OrderProcessId);
stream.Apply(orderProcess);
if (!orderProcess.CanCancel)
{
context.Publish(new CancelOrderProcessRejectedEvent
{
OrderProcessId = context.Message.OrderProcessId,
Status = orderProcess.Status
});
return;
}
_eventStore.Remove(context.Message.OrderProcessId);
}
context.Publish(new OrderProcessCancelledEvent
{
OrderProcessId = context.Message.OrderProcessId
});
}
/// <summary>解码</summary>
/// <param name="context"></param>
/// <param name="pk"></param>
/// <returns></returns>
protected override IList <Packet> Decode(IHandlerContext context, Packet pk)
{
var ss = context.Owner as IExtend;
var pc = ss["Codec"] as PacketCodec;
if (pc == null)
{
ss["Codec"] = pc = new PacketCodec {
Expire = Expire, GetLength = p => GetLength(p, Offset, Size)
}
}
;
var pks = pc.Parse(pk);
// 跳过头部长度
var len = Offset + Math.Abs(Size);
foreach (var item in pks)
{
item.Set(item.Data, item.Offset + len, item.Count - len);
}
return(pks);
}
public void ProcessMessage(IHandlerContext <EMailSentEvent> context)
{
if (!context.TransportMessage.IsHandledHere())
{
return;
}
var orderProcessId = new Guid(context.TransportMessage.CorrelationId);
using (_databaseContextFactory.Create(ProcessManagementData.ConnectionStringName))
{
var stream = _eventStore.Get(orderProcessId);
if (stream.IsEmpty)
{
throw new ApplicationException(
string.Format("Could not find an order process with correlation id '{0}'.",
context.TransportMessage.CorrelationId));
}
var orderProcess = new OrderProcess(orderProcessId);
stream.Apply(orderProcess);
stream.AddEvent(orderProcess.ChangeStatus("Dispatched-EMail Sent"));
_eventStore.Save(stream);
}
context.Send(new CompleteOrderProcessCommand
{
OrderProcessId = orderProcessId
}, c => c.Local());
}
/// <summary>写入数据</summary>
/// <param name="context"></param>
/// <param name="message"></param>
/// <returns></returns>
public override Object Write(IHandlerContext context, Object message)
{
if (message is T msg)
{
message = Encode(context, msg);
if (message == null)
{
return(null);
}
// 加入队列，忽略请求消息
if (message is IMessage msg2)
{
if (!msg2.Reply)
{
AddToQueue(context, msg);
}
}
else
{
AddToQueue(context, msg);
}
}
return(base.Write(context, message));
}
/// <summary>解码</summary>
/// <param name="context"></param>
/// <param name="pk"></param>
/// <returns></returns>
protected override IList <IMessage> Decode(IHandlerContext context, Packet pk)
{
var ss = context.Owner as IExtend;
if (ss["Codec"] is not PacketCodec pc)
{
ss["Codec"] = pc = new PacketCodec
{
GetLength = DefaultMessage.GetLength,
Tracer = (context.Owner as ISocket)?.Tracer
};
}
var pks = pc.Parse(pk);
var list = pks.Select(e =>
{
var msg = new DefaultMessage();
if (!msg.Read(e))
{
return(null);
}
return(msg as IMessage);
}).ToList();
return(list);
}
/// <summary>读取数据</summary>
/// <param name="context"></param>
/// <param name="message"></param>
/// <returns></returns>
public override Object Read(IHandlerContext context, Object message)
{
if (!(message is Packet pk))
{
return(base.Read(context, message));
}
// 解码得到消息
var msg = new HttpMessage();
msg.Read(pk);
// 匹配输入回调，让上层事件收到分包信息
context.FireRead(msg);
//if (pk.ToStr(null, 0, 4) == "HTTP")
//{
// var response = new HttpResponse();
// if (!response.ParseHeader(pk)) return base.Read(context, message);
// // 匹配输入回调，让上层事件收到分包信息
// context.FireRead(response);
//}
//else
//{
// var request = new HttpRequest();
// if (!request.ParseHeader(pk)) return base.Read(context, message);
// // 匹配输入回调，让上层事件收到分包信息
// context.FireRead(request);
//}
return(null);
}
Boolean TryDecodePacket(Packet buffer, IHandlerContext context, out DataPacket packet)
{
if (!buffer.IsReadable(2)) // packet consists of at least 2 bytes
{
packet = null;
return(false);
}
Int32 signature = buffer.ReadByte();
if (!TryDecodeRemainingLength(buffer, out var remainingLength) || !buffer.IsReadable(remainingLength))
{
packet = null;
return(false);
}
packet = DecodePacketInternal(buffer, signature, ref remainingLength, context);
if (remainingLength > 0)
{
throw new DecoderException($"Declared remaining length is bigger than packet data size by {remainingLength}.");
}
return(true);
}
protected override void Decode(IHandlerContext context, Packet input, List <Object> output)
{
try
{
switch (this.State)
{
case ParseState.Ready:
if (!TryDecodePacket(input, context, out var packet))
{
this.RequestReplay();
return;
}
output.Add(packet);
this.Checkpoint();
break;
case ParseState.Failed:
// read out data until connection is closed
input.SkipBytes(input.ReadableBytes);
return;
default:
throw new ArgumentOutOfRangeException();
}
}
catch (DecoderException)
{
input.SkipBytes(input.ReadableBytes);
this.Checkpoint(ParseState.Failed);
throw;
}
}
public void ProcessMessage(IHandlerContext <OrderProcessRegisteredEvent> context)
{
using (_databaseContextFactory.Create(ProcessManagementData.ConnectionStringName))
{
_orderProcessViewQuery.Add(context.Message);
}
}
public void ProcessMessage(IHandlerContext <OrderProcessCompletedEvent> context)
{
using (_databaseContextFactory.Create(ProcessManagementData.ConnectionStringName))
{
_orderProcessViewQuery.SaveStatus(context.TransportMessage.OrderProcessId(), "Completed");
}
}
/// <summary>加入队列</summary>
/// <param name="context"></param>
/// <param name="msg"></param>
/// <returns></returns>
protected override void AddToQueue(IHandlerContext context, IMessage msg)
{
if (!msg.Reply)
{
base.AddToQueue(context, msg);
}
}
/// <summary>加入队列</summary>
/// <param name="context"></param>
/// <param name="msg"></param>
/// <returns></returns>
protected virtual void AddToQueue(IHandlerContext context, T msg)
{
if (msg != null && context["TaskSource"] is TaskCompletionSource <Object> source)
{
Queue.Add(context.Owner, msg, Timeout, source);
}
}
public void ProcessMessage(IHandlerContext <ArchiveOrderProcessCommand> context)
{
using (_databaseContextFactory.Create(ProcessManagementData.ConnectionStringName))
{
var orderProcess = _repository.Get(context.Message.OrderProcessId);
if (!orderProcess.CanArchive())
{
context.Publish(new ArchiveOrderProcessRejectedEvent
{
OrderProcessId = context.Message.OrderProcessId,
Status = orderProcess.Status().Status
});
return;
}
_repository.Remove(orderProcess);
}
context.Publish(new OrderProcessArchivedEvent
{
OrderProcessId = context.Message.OrderProcessId
});
}
/// <summary>
/// 调用。
/// </summary>
/// <param name="context">处理上下文。</param>
/// <returns>任务。</returns>
public override Task Invoke(IHandlerContext context)
{
var dependencyResolver = context.GetDependencyResolver();
var requestMessageFactory = dependencyResolver.GetService <IRequestMessageFactory>();
var content = context.Content;
var parameters = context.GetRequestParameters();
#region Decrypt
var encryptType = parameters["encrypt_type"];
if (encryptType != null)
{
var nonce = parameters["nonce"];
var signature = parameters["msg_signature"];
var timestamp = parameters["timestamp"];
var baseInfo = context.GetMessageHandlerBaseInfo();
var appId = baseInfo.AppId;
var encodingAesKey = baseInfo.EncodingAesKey;
var token = baseInfo.Token;
var wxBizMsgCrypt = new WXBizMsgCrypt(token, encodingAesKey, appId);
wxBizMsgCrypt.DecryptMsg(signature, timestamp, nonce, content, ref content);
}
#endregion Decrypt
context.SetRequestMessage(requestMessageFactory.CreateRequestMessage(content));
return(Next.Invoke(context));
}
public void ProcessMessage(IHandlerContext <ArchiveOrderProcessCommand> context)
{
using (_databaseContextFactory.Create(ProcessManagementData.ConnectionStringName))
{
var stream = _eventStore.Get(context.Message.OrderProcessId);
var orderProcess = new OrderProcess(context.Message.OrderProcessId);
stream.Apply(orderProcess);
if (!orderProcess.CanArchive)
{
context.Publish(new ArchiveOrderProcessRejectedEvent
{
OrderProcessId = context.Message.OrderProcessId,
Status = orderProcess.Status
});
return;
}
stream.AddEvent(orderProcess.ChangeStatus("Order Archived"));
_eventStore.SaveEventStream(stream);
}
context.Publish(new OrderProcessArchivedEvent
{
OrderProcessId = context.Message.OrderProcessId
});
}
/// <summary>读取数据</summary>
/// <param name="context"></param>
/// <param name="message"></param>
/// <returns></returns>
public override Object Read(IHandlerContext context, Object message)
{
if (!(message is Packet pk))
{
return(base.Read(context, message));
}
// 解码得到多个消息
var list = Decode(context, pk);
if (list == null)
{
return(null);
}
foreach (var msg in list)
{
// 把数据发送给后续处理器
var rs = base.Read(context, msg);
// 匹配输入回调，让上层事件收到分包信息
context.FireRead(rs);
}
return(null);
}
/// <summary>
/// ���á�
/// </summary>
/// <param name="context">���������ġ�</param>
/// <returns>����</returns>
public override Task Invoke(IHandlerContext context)
{
var request = context.Request;
var dependencyResolver = context.GetDependencyResolver();
var requestMessageFactory = dependencyResolver.GetService<IRequestMessageFactory>();
var content = Encoding.UTF8.GetString(request.InputStream.ReadBytes());
#region Decrypt
var encryptType = request.QueryString["encrypt_type"];
if (encryptType != null)
{
var nonce = request.QueryString["nonce"];
var signature = request.QueryString["msg_signature"];
var timestamp = request.QueryString["timestamp"];
var baseInfo = context.GetMessageHandlerBaseInfo();
var appId = baseInfo.AppId;
var encodingAesKey = baseInfo.EncodingAesKey;
var token = baseInfo.Token;
var wxBizMsgCrypt = new WXBizMsgCrypt(token, encodingAesKey, appId);
wxBizMsgCrypt.DecryptMsg(signature, timestamp, nonce, content, ref content);
}
#endregion Decrypt
context.SetRequestMessage(requestMessageFactory.CreateRequestMessage(content));
return Next.Invoke(context);
}
/// <summary>读取</summary>
/// <param name="context"></param>
/// <param name="message"></param>
/// <returns></returns>
public override Object Read(IHandlerContext context, Object message)
{
var ctx = context as NetHandlerContext;
var session = ctx.Session;
if (message is Packet pk)
{
var len = pk.Total;
if (len > 100)
{
XTrace.WriteLine("Echo {0} [{1}]", session, len);
}
else
{
XTrace.WriteLine("Echo {0} [{1}] {2}", session, len, pk.ToStr());
}
}
else
{
XTrace.WriteLine("{0}", message);
}
session.SendMessage(message);
return(null);
}
public String ResolveAttributeExpression(String expression, IHandlerContext handlerContext)
{
String text = expression;
int leftMarkerIndex = text.IndexOf(LEFT_MARKER);
int rightMarkerIndex = text.IndexOf(RIGHT_MARKER, leftMarkerIndex + LEFT_MARKER.Length);
while ((leftMarkerIndex != - 1) && (rightMarkerIndex != - 1))
{
String attributeName = text.Substring(leftMarkerIndex + LEFT_MARKER.Length, (rightMarkerIndex) - (leftMarkerIndex + LEFT_MARKER.Length)).Trim();
try
{
Object attribute = handlerContext.GetAttribute(attributeName);
if (attribute != null)
{
String attributeString = attribute.ToString();
text = text.Substring(0, leftMarkerIndex) + attributeString + text.Substring(rightMarkerIndex + RIGHT_MARKER.Length);
rightMarkerIndex = rightMarkerIndex + attributeString.Length - attributeName.Length - LEFT_MARKER.Length - RIGHT_MARKER.Length;
}
}
catch (Exception e)
{
log.Debug("attribute '" + attributeName + "' could not be resolved in attribute expression '" + expression + "'. Exception: " + e.Message);
}
leftMarkerIndex = text.IndexOf(LEFT_MARKER, rightMarkerIndex + RIGHT_MARKER.Length);
rightMarkerIndex = text.IndexOf(RIGHT_MARKER, leftMarkerIndex + LEFT_MARKER.Length);
}
return text;
}
public void ProcessMessage(IHandlerContext <RegisterArgumentValueCommand> context)
{
var message = context.Message;
using (_databaseContextFactory.Create())
{
var stream = _eventStore.Get(message.ArgumentId);
if (stream.IsEmpty)
{
return;
}
var argument = new Argument(message.ArgumentId);
stream.Apply(argument);
if (!argument.ContainsValue(message.Value))
{
stream.AddEvent(argument.AddValue(message.Value));
_eventStore.Save(stream);
}
}
}
public void ProcessMessage(IHandlerContext <InvoiceCreatedEvent> context)
{
if (!context.TransportMessage.IsHandledHere())
{
return;
}
var orderProcessId = new Guid(context.TransportMessage.CorrelationId);
var orderProcess = new OrderProcess(orderProcessId);
using (_databaseContextFactory.Create(ProcessManagementData.ConnectionStringName))
{
var stream = _eventStore.Get(orderProcessId);
if (stream.IsEmpty)
{
throw new ApplicationException(
string.Format("Could not find an order process with correlation id '{0}'.",
context.TransportMessage.CorrelationId));
}
stream.Apply(orderProcess);
stream.AddEvent(orderProcess.ChangeStatus("Invoice Created"));
stream.AddEvent(orderProcess.AssignInvoiceId(context.Message.InvoiceId));
_eventStore.SaveEventStream(stream);
}
context.Send(orderProcess.SendEMailCommand());
}
public void ProcessMessage(IHandlerContext <RegisterArgumentCommand> context)
{
var message = context.Message;
if (string.IsNullOrEmpty(message.Name) ||
string.IsNullOrEmpty(message.DataTypeName))
{
return;
}
using (_databaseContextFactory.Create())
{
var key = Argument.Key(message.Name);
var existingId = _keyStore.Get(key);
if (!message.Id.Equals(existingId ?? message.Id))
{
return;
}
var stream = _eventStore.Get(message.Id);
var argument = new Argument(stream.Id);
stream.Apply(argument);
_keyStore.Remove(Argument.Key(argument.Name));
stream.AddEvent(argument.Register(message.Name, message.DataTypeName));
_eventStore.Save(stream);
_keyStore.Add(argument.Id, key);
}
}
public void ProcessMessage(IHandlerContext <ArchiveOrderProcessRejectedEvent> context)
{
using (_databaseContextFactory.Create(ProcessManagementData.ConnectionStringName))
{
_orderProcessViewQuery.SaveStatus(context.Message.OrderProcessId, context.Message.Status);
}
}
/// <summary>解码</summary>
/// <param name="context"></param>
/// <param name="pk"></param>
/// <returns></returns>
protected override IList <IMessage> Decode(IHandlerContext context, Packet pk)
{
var ss = context.Owner as IExtend;
var pc = ss["Codec"] as PacketCodec;
if (pc == null)
{
ss["Codec"] = pc = new PacketCodec {
GetLength = DefaultMessage.GetLength
}
}
;
var pks = pc.Parse(pk);
var list = pks.Select(e =>
{
var msg = new DefaultMessage();
if (!msg.Read(e))
{
return(null);
}
return(msg as IMessage);
}).ToList();
return(list);
}
public void ProcessMessage(IHandlerContext <EMailSentEvent> context)
{
if (!context.TransportMessage.IsHandledHere())
{
return;
}
OrderProcess orderProcess;
using (_databaseContextFactory.Create(ProcessManagementData.ConnectionStringName))
{
orderProcess = _repository.Get(new Guid(context.TransportMessage.CorrelationId));
if (orderProcess == null)
{
throw new ApplicationException(
string.Format("Could not find an order process with correlation id '{0}'.",
context.TransportMessage.CorrelationId));
}
var orderProcessStatus = new OrderProcessStatus("EMail Sent");
orderProcess.AddStatus(orderProcessStatus);
_repository.AddStatus(orderProcessStatus, orderProcess.Id);
}
context.Send(new CompleteOrderProcessCommand
{
OrderProcessId = orderProcess.Id
}, c => c.Local());
}
/// <summary>
/// 执行。
/// </summary>
/// <param name="context">处理上下文。</param>
/// <returns>任务。</returns>
public Task Execute(IHandlerContext context)
{
var middlewareItems = (ICollection<KeyValuePair<object, object[]>>)_builder.Properties["Rabbit.Middlewares"];
var fristMiddleware = GetFirstMiddleware(middlewareItems);
return fristMiddleware.Invoke(context);
}
/// <summary>
/// 调用。
/// </summary>
/// <param name="context">处理上下文。</param>
/// <returns>任务。</returns>
public override Task Invoke(IHandlerContext context)
{
Context = context;
var requestMessage = context.GetRequestMessage();
IResponseMessage responseMessage;
switch (requestMessage.MessageType)
{
case RequestMessageType.Event:
responseMessage = OnEventRequest(requestMessage as EventMessageBase);
break;
case RequestMessageType.Image:
responseMessage = OnImageRequest(requestMessage as RequestMessageImage);
break;
case RequestMessageType.Link:
responseMessage = OnLinkRequest(requestMessage as RequestMessageLink);
break;
case RequestMessageType.Location:
responseMessage = OnLocationRequest(requestMessage as RequestMessageLocation);
break;
case RequestMessageType.ShortVideo:
responseMessage = OnShortVideoRequest(requestMessage as RequestMessageShortVideo);
break;
case RequestMessageType.Text:
responseMessage = OnTextRequest(requestMessage as RequestMessageText);
break;
case RequestMessageType.Video:
responseMessage = OnVideoRequest(requestMessage as RequestMessageVideo);
break;
case RequestMessageType.Voice:
responseMessage = OnVoiceRequest(requestMessage as RequestMessageVoice);
break;
default:
throw new NotSupportedException("不支持的请求消息类型：" + requestMessage.MessageType);
}
if (responseMessage != null)
{
//基本信息初始化。
responseMessage.CreateTime = DateTime.Now;
responseMessage.FromUserName = requestMessage.ToUserName;
responseMessage.ToUserName = requestMessage.FromUserName;
}
context.SetResponseMessage(responseMessage);
return Next.Invoke(context);
}
/// <summary>
/// 调用。
/// </summary>
/// <param name="context">处理上下文。</param>
/// <returns>任务。</returns>
public override Task Invoke(IHandlerContext context)
{
var responseMessage = context.GetResponseMessage();
if (responseMessage == null)
{
context.ResponseXml = string.Empty;
}
else
{
var requestMessage = context.GetRequestMessage();
//基本信息初始化。
responseMessage.CreateTime = DateTime.Now;
responseMessage.FromUserName = requestMessage.ToUserName;
responseMessage.ToUserName = requestMessage.FromUserName;
var dependencyResolver = context.GetDependencyResolver();
var responseMessageFactory = dependencyResolver.GetService<IResponseMessageFactory>();
var content = responseMessageFactory.GetXmlByReponseMessage(responseMessage);
#region Encrypt
if (!string.IsNullOrWhiteSpace(content))
{
var request = context.Request;
var encryptType = request.QueryString["encrypt_type"];
if (encryptType != null)
{
var nonce = request.QueryString["nonce"];
var timestamp = request.QueryString["timestamp"];
var baseInfo = context.GetMessageHandlerBaseInfo();
var appId = baseInfo.AppId;
var encodingAesKey = baseInfo.EncodingAesKey;
var token = baseInfo.Token;
var wxBizMsgCrypt = new WXBizMsgCrypt(token, encodingAesKey, appId);
wxBizMsgCrypt.EncryptMsg(content, timestamp, nonce, ref content);
}
}
#endregion Encrypt
context.ResponseXml = content;
}
return Next.Invoke(context);
}
/// <summary>
/// 调用。
/// </summary>
/// <param name="context">处理上下文。</param>
/// <returns>任务。</returns>
public override Task Invoke(IHandlerContext context)
{
var request = context.Request;
var signature = request.QueryString["signature"];
var timestamp = request.QueryString["timestamp"];
var nonce = request.QueryString["nonce"];
var token = context.GetMessageHandlerBaseInfo().Token;
var dependencyResolver = context.GetDependencyResolver();
var signatureService = dependencyResolver.GetService<ISignatureService>();
if (!signatureService.Check(signature, timestamp, nonce, token))
throw new Exception("非法请求。");
return Next.Invoke(context);
}
/// <summary>
/// 调用。
/// </summary>
/// <param name="context">处理上下文。</param>
/// <returns>任务。</returns>
public override Task Invoke(IHandlerContext context)
{
var request = context.Request;
//HTTP正文。
var bytes = context.Request.InputStream.ReadBytes();
//根据查询字符串变量集合得到一个参数字典表。
var parameters = request.QueryString.AllKeys.ToDictionary(i => i, i => request.QueryString[i]);
//得到最终的请求Url。
var postUrl = AppendParameter(_agentRequestModel.Uri.ToString(), parameters);
Func<Task<string>> getPostTask =
() =>
{
var task = Task.Factory.StartNew(() => Encoding.UTF8.GetString(HttpHelper.Post(postUrl, bytes)));
//防止出错时程序崩溃。
task.ContinueWith(t => { }, TaskContinuationOptions.OnlyOnFaulted);
return task;
};
string content = null;
Exception exception = null;
//开始请求。
for (var i = 0; i < _agentRequestModel.RetryCount + 1/*重试次数加上一次必需请求的次数*/; i++)
{
var task = getPostTask();
var isTimeout = !task.Wait(_agentRequestModel.Timeout);
exception = task.Exception;
//超时或者失败则进行尝试。
if (isTimeout || task.IsFaulted)
continue;
content = task.Result;
//结束请求。
break;
}
if (content == null)
throw new Exception("代理请求次数超过了重试次数并且目标方还是没有正确响应" + (exception == null ? "。" : "错误消息：" + exception.Message));
context.ResponseXml = content;
return Next.Invoke(context);
}
/// <summary>
/// 调用。
/// </summary>
/// <param name="context">处理上下文。</param>
/// <returns>任务。</returns>
public override Task Invoke(IHandlerContext context)
{
_sessionCollection = context.GetDependencyResolver().GetService<IUserSessionCollection>();
var requestMessage = context.GetRequestMessage();
//设置用户会话。
context.SetSession(_sessionCollection.GetOrAdd(requestMessage.FromUserName));
return Next.Invoke(context);
}
/// <summary>
/// 初始化一个新的微信结果。
/// </summary>
/// <param name="context">处理上下文。</param>
public WeiXinResult(IHandlerContext context)
: this(context.ResponseXml)
{
}
/// <summary> /// 调用。 /// </summary> /// <param name="context">处理上下文。</param> /// <returns>任务。</returns> public abstract Task Invoke(IHandlerContext context);
protected static void TryBuild(IHandlerContext context, IRoutingTable routes)
{
Try(() => handler = new DefaultChannelMessageHandler(context, routes));
}
private IActor ResolveArgument(IActor resolvedActor, String expression, int index, IHandlerContext handlerContext)
{
String argument = null;
log.Debug("resolving actor expression '" + expression + "', resolvedActor is " + resolvedActor);
String whiteSpace = " ".Substring(0, index);
log.Debug(" " + whiteSpace + "^");
String[] parameters = null;
int argumentEndIndex = expression.IndexOf("->", index);
if (argumentEndIndex == - 1)
{
argumentEndIndex = expression.Length;
}
int parametersStartIndex = expression.IndexOf("(", index);
int parametersEndIndex = - 1;
if ((parametersStartIndex != - 1) && (parametersStartIndex < argumentEndIndex))
{
argument = expression.Substring(index, (parametersStartIndex) - (index)).Trim();
parametersEndIndex = expression.IndexOf(")", parametersStartIndex + 1);
if (parametersEndIndex > argumentEndIndex)
{
throw new SystemException("can't resolve assigner expression : couldn't find closing bracket for bracket on index '" + parametersStartIndex + "' in expression '" + expression + "'");
}
// the next exception happens when a parameter contains a right bracket.
String shouldBewhiteSpace = expression.Substring(parametersEndIndex + 1, (argumentEndIndex) - (parametersEndIndex + 1));
if (!"".Equals(shouldBewhiteSpace.Trim()))
{
throw new SystemException("can't resolve assigner expression : only whitespace allowed between closing bracket of the parameterlist of an argument and the end of the argument : closing bracket position '" + parametersEndIndex + "' in expression '" + expression + "'");
}
String parametersText = expression.Substring(parametersStartIndex + 1, (parametersEndIndex) - (parametersStartIndex + 1));
ArrayList parameterList = new ArrayList();
StringTokenizer tokenizer = new StringTokenizer(parametersText, ",");
IEnumerator tokenEnum = tokenizer.GetEnumerator();
while (tokenEnum.MoveNext())
{
parameterList.Add(tokenEnum.Current.ToString().Trim());
}
if (parameterList.Count > 0)
{
parameters = new String[parameterList.Count];
parameters = (String[]) parameterList.ToArray(typeof (String));
}
else
{
parameters = new String[0];
}
}
else
{
argument = expression.Substring(index, (argumentEndIndex) - (index)).Trim();
parameters = new String[0];
}
if ("".Equals(argument))
{
throw new SystemException("can't resolve assigner expression : can't resolve empty argument on index '" + index + "' for expression '" + expression + "'");
}
String methodName = "ResolveArgument" + argument.Substring(0, 1).ToUpper() + argument.Substring(1);
try
{
MethodInfo method = this.GetType().GetMethod(methodName, (Type[]) RESOLVE_METHOD_ARGUMENT_TYPES);
Object[] args = new Object[] {resolvedActor, parameters, handlerContext};
resolvedActor = (IActor) method.Invoke(this, (Object[]) args);
log.Debug(methodName + " came up with " + resolvedActor);
}
catch (Exception t)
{
throw new SystemException("can't resolve assigner expression : couldn't resolve argument '" + argument + "' : " + t.Message,t);
}
if (argumentEndIndex != expression.Length)
{
if (argumentEndIndex < expression.Length)
{
argumentEndIndex = expression.IndexOf("->", argumentEndIndex) + 2;
}
resolvedActor = ResolveArgument(resolvedActor, expression, argumentEndIndex, handlerContext);
}
return resolvedActor;
}
/// <summary>
/// 调用。
/// </summary>
/// <param name="context">处理上下文。</param>
/// <returns>任务。</returns>
public override Task Invoke(IHandlerContext context)
{
return Task.Factory.StartNew(() => { });
}
public IActor ResolveArgument(String expression, IHandlerContext handlerContext)
{
return ResolveArgument(null, expression, 0, handlerContext);
}
