/// <summary>
/// Handle received data, parse the message and pass it to the registered handlers.
/// </summary>
/// <param name="data">The received data.</param>
/// <param name="recipient">The sender of the data.</param>
async public void Handle(byte[] data, IRecipient sender)
{
// Check if the data contains at least the message type id.
if (data.Length < sizeof(int))
{
return;
}
IPacket packet = ParsePacket(data);
IMessageType type = TypeConfig.GetTypeById(packet.MessageType);
if (type == null || type.Serializer == null)
{
return;
}
object obj = type.Serializer.Deserialize(packet.Payload);
if (obj is IAcknowledgeRequest)
{
var message = (IAcknowledgeRequest)obj;
await Send(sender, new AcknowledgeResponse(message.AckToken));
}
if (obj is IAcknowledgeResponse)
{
var response = (IAcknowledgeResponse)obj;
_pendingAcknowledgeRequests.TryRemove(response.AckToken, out PendingAcknowledgeRequest removed);
}
type.Handler?.Handle(obj);
}
public WSATP_TO_OBATPAdapter(IMessageType message)
{
_adaptee = new WSATP_TO_OBATPAdaptee(message);
WSATP_TO_OBATP WSATP_TO_OBATP = _adaptee.GetMessageType();
AdaptData(WSATP_TO_OBATP);
}
protected override void ProcessElements(string[] additionalData)
{
base.ProcessElements(additionalData);
var fieldSeparator = GetChildByPosition(FieldSeparatorChildPosition);
if (fieldSeparator?.Children?.Count != 1) // has encoding, not field separator, so insert it
{
var genericField = new GenericField
{
Parent = this,
ParsingInfo = ParsingInfo,
Source = ParsingInfo.FieldSeparator
};
Children.Insert(1, genericField);
}
// Set messageType
var messageData = GetChildByPosition(MessageTypeChildPosition);
if (messageData?.Children == null || !messageData.Children.Any())
{
return;
}
//TODO:ALM - remove?
var messageType = new MessageType {
GenericReferenceElement = messageData
};
MessageType = messageType;
}
public void SetReceiver(IMessageType type, IMessageReceiver receiver)
{
lock (receiversLock)
{
receivers[type.TypeId] = receiver;
}
}
static void ExportAccountResultHandler(IEnumerable <object> items, IMessageType message)
{
Console.WriteLine($"Получен ответ для сообщения:{message.MessageGUID}");
foreach (var item in items.OfType <exportAccountResultType>().Take(10))
{
Console.WriteLine(item.AccountGUID);
}
}
static void ExportHouseResultHandler(IEnumerable <object> items, IMessageType message)
{
Console.WriteLine($"Получен ответ для сообщения:{message.MessageGUID}");
foreach (var item in items.OfType <exportHouseResultType>())
{
Console.WriteLine(item.HouseUniqueNumber);
}
}
/// <summary>
/// Constructor with values
/// </summary>
/// <param name="file"></param>
/// <param name="line"></param>
/// <param name="plugin"></param>
/// <param name="message"></param>
/// <param name="type"></param>
public AnalysisResult(string file, int line, string plugin, string message, IMessageType type)
{
File = file;
Line = line;
PluginName = plugin;
Message = message;
Type = type;
}
public void OnComplite(IMessageType message)
{
BaseEventArgs args = new BaseEventArgs();
if (CompliteEvent != null)
{
args.Message = message;
CompliteEvent(this, args);
}
}
public Result Delete(IMessageType message)
{
try {
var idx = _collection.FindIndex(x => x.MessageGUID == message.MessageGUID);
_collection.RemoveAt(idx);
return(new Result());
}
catch (ArgumentNullException) {
return(new Result("В хранилище не найдено сообщение: " + message.MessageGUID));
}
}
public void ReceiveMessage(IMessageType type, byte[] content)
{
IMessageReceiver receiver;
lock (receiversLock)
{
receiver = receivers[type.TypeId];
}
receiver.Receive(content);
}
public void OnError(IMessageType message, IFault fault)
{
BaseEventArgs args = new BaseEventArgs();
if (ErrorEvent != null)
{
args.Message = message;
args.ErrorCode = fault.ErrorCode;
args.Description = fault.ErrorMessage;
ErrorEvent(this, args);
}
}
public Result Add(IMessageType message)
{
var idx = _collection.FindIndex(x => x.MessageGUID == message.MessageGUID);
if (idx != -1)
{
return(new Result("В хранилище уже имеется сообщение: " + message.MessageGUID));
}
_collection.Add(message);
return(new Result());
}
public void Send(ref IMessageType message)
{
try {
var provider = _providerLocator[message.EndPoint];
if (provider == null)
{
throw new ArgumentOutOfRangeException($"Для конечной точки {Enum.GetName(typeof(EndPoints), message.EndPoint)} отсутсвует зарегистрированный провайдер");
}
// Отправить запрос
var ack = provider.Send(message.Request);
message.SendDate = DateTime.Now;
message.ResponceGUID = Guid.Parse(ack.MessageGUID);
message.Status = MessageStatuses.SendOk;
SendCompliteEvent(message);
}
catch (System.ServiceModel.FaultException <IFault> ex) {
// Выбрать поведение в зависимости от кода ошибки soap ГИС
var action = _faultPolicy.GetAction(ex.Detail.ErrorCode);
string errorMessage = ex.Detail.ErrorCode + " " + ex.Detail.ErrorMessage;
switch (action)
{
case Polices.Actions.NeedException:
message.Status = MessageStatuses.SendCriticalError;
throw new Exception(ex.Message);
case Polices.Actions.Abort:
message.Status = MessageStatuses.SendCriticalError;
break;
case Polices.Actions.TryAgain:
message.Status = MessageStatuses.SendError;
break;
default:
message.Status = MessageStatuses.SendCriticalError;
errorMessage = $"Поведение для действия {Enum.GetName(typeof(Polices.Actions), action)} не реализовано";
break;
}
SendErrorEvent($"При отправке запроса в ГИС ЖКХ произошла ошибка {errorMessage}", message);
}
catch (TimeoutException) {
message.Status = MessageStatuses.SendTimeout;
SendErrorEvent("Запрос не отправлен, превышен интервал ожидания: ", message);
}
catch (Exception ex) {
message.Status = MessageStatuses.SendCriticalError;
SendErrorEvent("При отправке запроса произошло не обработанное исключение: " + ex.GetChainException(), message);
}
}
public DataStringMessage(IMessageType messageType, string data)
{
this.messageType = messageType;
byte[] dataStringBytes = Encoding.UTF8.GetBytes(data);
MemoryStream output = new MemoryStream();
NetworkBinaryWriter writer = new NetworkBinaryWriter(output);
writer.WriteUTF(data);
content = output.ToArray();
}
/// <summary>
/// Sends an sms message
/// </summary>
/// <param name="message">An instance of SmsMessage representing the message to be sent</param>
/// <returns>A string that can be parsed to json which provides server state of the sent message</returns>
public override string Send(IMessageType message)
{
var smsMessage = (SmsMessage)message;
//SendAsync(message)
// .RunSynchronously();
String response = "";
Task.Run(() =>
{
response = SendAsync(message).Result;
}
).Wait();
return(response);
}
public void Should_property_initialize_the_values()
{
var values = new
{
CorrelationId = Guid.NewGuid(),
Name = "Dru",
Timestamp = DateTime.UtcNow,
};
IMessageType message = TypeMetadataCache <IMessageType> .InitializeFromObject(values);
message.CorrelationId.ShouldBe(values.CorrelationId);
message.Name.ShouldBe(values.Name);
message.Timestamp.ShouldBe(values.Timestamp);
}
/// <summary>
/// Create a packet from an object.
/// </summary>
/// <param name="obj">The object to send.</param>
/// <typeparam name="T">The object type.</typeparam>
/// <returns>The created packet.</returns>
IPacket CreatePacketFromObject <T>(T obj)
{
IMessageType type = TypeConfig.GetType <T>();
if (type == null || type.Serializer == null)
{
return(null);
}
byte[] payload = type.Serializer.Serialize(obj);
if (payload == null)
{
return(null);
}
return(new Packet(type.Id, payload));
}
static void Main(string[] args)
{
var msgList = CreateCollection(typeof(IMessageType));
foreach (var item in msgList)
{
if (item.IsClass)
{
IMessageType obj = (IMessageType)Activator.CreateInstance(item);
Console.WriteLine(obj.ShowName("dynamic"));
}
}
Console.WriteLine("Press any key to continue....");
Console.ReadKey();
}
private void ReadAndAppendToChatLog(IMessageType messageType)
{
if (messageType.GetType() != typeof(ChatMessage))
{
throw new ArgumentException("Unsupported message type");
}
var message = (ChatMessage)messageType;
if (message.Type == ChatMessageType.Error)
{
throw new AggregateException(_interactiveLoginAdapter.GetCurrentOutput());
}
var currentOutput = _interactiveLoginAdapter.GetCurrentOutput();
if (!string.IsNullOrEmpty(currentOutput))
{
ChatLog = string.Concat(ChatLog, Environment.NewLine, currentOutput);
}
}
public static IPipeline Get(IMessageType messageType)
{
switch (messageType)
{
case AdminMessageType adminMessageType:
return(new AdminActivationPipeline());
case CommandMessageType commandMessageType:
return(new AdminCommandPipeLine());
case WikiMessageType wikiMessageType:
return(new WikiPipeline());
case YoutubeMessageType youtubeMessageType:
return(new YoutubePipeline());
default:
throw new NotImplementedException();
}
}
/// <summary>
/// Asynchronously sends an sms message
/// </summary>
/// <param name="message">An instance of SmsMessage representing the message to be sent</param>
/// <returns>A string that can be parsed to json which provides server state of the sent message</returns>
public override async Task <string> SendAsync(IMessageType message)
{
var smsMessage = (SmsMessage)message;
using (var httpClient = new HttpClient())
{
httpClient.DefaultRequestHeaders.Add("Authorization", $"Basic {Credential.CredentialHash}");
string content = JsonConvert.SerializeObject(new JsonSms
{
to = _ParseReceipients(smsMessage.Receipient),
text = smsMessage.Message,
from = smsMessage.Sender
});
var response = await httpClient.PostAsync(_apiUrl, new StringContent(content, Encoding.UTF8, "application/json"));
return
(await response.Content.ReadAsStringAsync());
}
}
public void GetResult(ref IMessageType message)
{
try {
var provider = _providerLocator[message.EndPoint];
if (provider == null)
{
throw new ArgumentOutOfRangeException($"Для конечной точки {Enum.GetName(typeof(EndPoints), message.EndPoint)} отсутсвует зарегистрированный провайдер");
}
IAck ack = new Ack {
MessageGUID = message.ResponceGUID.ToString().ToLower()
};
IGetStateResult stateResult = new StateResult();
foreach (var i in ATTEMS)
{
OnAction(i.Item1);
if (provider.TryGetResult(ack, out stateResult))
{
message.CompliteDate = DateTime.Now;
message.Status = MessageStatuses.GetResultOk;
message.Result = stateResult;
GetResultCompliteEvent(message);
return;
}
Thread.Sleep(i.Item2 * 500);
}
message.Status = MessageStatuses.GetResultTimeout;
}
catch (System.ServiceModel.FaultException <IFault> ex) {
var action = _faultPolicy.GetAction(ex.Detail.ErrorCode);
string errorMessage = ex.Detail.ErrorCode + " " + ex.Detail.ErrorMessage;
switch (action)
{
case Polices.Actions.NeedException:
message.Status = MessageStatuses.GetResultCriticalError;
throw new Exception($"При отправке запроса в ГИС ЖКХ произошла ошибка {errorMessage}");
case Polices.Actions.Abort:
message.Status = MessageStatuses.GetResultCriticalError;
break;
case Polices.Actions.TryAgain:
message.Status = MessageStatuses.GetResultError;
break;
default:
message.Status = MessageStatuses.GetResultCriticalError;
errorMessage = $"Поведение для действия {Enum.GetName(typeof(Polices.Actions), action)} не реализовано";
break;
}
GetResultErrorEvent($"При получении результата из ГИС ЖКХ произошла ошибка {errorMessage}", message);
}
catch (TimeoutException) {
message.Status = MessageStatuses.GetResultTimeout;
GetResultErrorEvent($"При получении результата из ГИС ЖКХ превышен интервал ожидания", message);
}
catch (Exception ex) {
message.Status = MessageStatuses.SendCriticalError;
GetResultErrorEvent("При получении результата произошло не обработанное исключение: " + ex.GetChainException(), message);
}
}
/// <summary> /// Register a message type for the server. /// </summary> /// <param name="messageType">The message type.</param> /// <typeparam name="T">The object type of the message.</typeparam> public void RegisterServerMessageType <T>(IMessageType messageType) => _serverMessageTypes[typeof(T)] = messageType;
/// <summary> /// Register a message type for the client. /// </summary> /// <param name="messageType">The message type.</param> /// <typeparam name="T">The object type of the message.</typeparam> public void RegisterClientMessageType <T>(IMessageType messageType) => _clientMessageTypes[typeof(T)] = messageType;
public EmptyMessage(IMessageType messageType)
{
this.messageType = messageType;
}
public WSATP_TO_OBATPAdaptee(IMessageType WSATP_TO_OBATP)
{
m_messageType = (WSATP_TO_OBATP)WSATP_TO_OBATP;
}
public Message(IMessageType msgType, Object[] data = null)
{
m_MsgType = msgType;
m_Data = data;
}
public RawMessage(IMessageType messageType, byte[] content)
{
this.messageType = messageType;
this.content = content;
}
public Notification(IMessageType messageType)
{
_messageType = messageType;
}
private void ClientReceiveProc(IAsyncResult iar)
{
try
{
int receivedBytes = 0;
receivedBytes = m_clientSock.EndReceive(iar);
uint messageBase = BitConverter.ToUInt32(m_clientBufRecv, 0);
if (messageBase == 2)
{
uint messageLength = BitConverter.ToUInt32(m_clientBufRecv, 4);
byte[] incomingBytes = new byte[messageLength];
Array.Copy(m_clientBufRecv, incomingBytes, messageLength);
uint messageID = BitConverter.ToUInt32(incomingBytes, 8);
if (messageID == (UInt32)Enums.Message.ID.WSATP_TO_OBATP)
{
Message message = new Message(incomingBytes);
MessageSelector messageSelector = new MessageSelector();
IMessageType messageType = messageSelector.GetMessageType((Enums.Message.ID)messageID);
IMessageType dataorj = messageType.CreateMessage(message.DATA);
WSATP_TO_OBATPAdapter adap = new WSATP_TO_OBATPAdapter(dataorj);
}
}
//if (messageID == (uint)Enums.Message.ID.OBATP_TO_WSATP)
//{
// Message message = new Message(incomingBytes);
//}
//else if(messageID == (uint)Enums.Message.ID.WSATP_TO_OBATP)
//{
// Message message = new Message(incomingBytes);
// MessageSelector messageSelector = new MessageSelector();
// IMessageType messageType = messageSelector.GetMessageType((Enums.Message.ID)messageID);
//}
if (!m_stopWatch.IsRunning)
{
m_stopWatch.Start();
}
m_stopWatch.Restart();
m_clientSock.BeginReceive(m_clientBufRecv, m_clientIndexRecv, m_clientLeftRecv, SocketFlags.None, new AsyncCallback(ClientReceiveProc), null);
}
catch (Exception e)
{
if (m_clientSock != null)
{
m_clientSock.Close();
m_clientSock = null;
}
return;
}
}
public void SetMessageReceiver(IMessageType messageType, IMessageReceiver receiver)
{
incomingMessagesRouter.SetReceiver(messageType, receiver);
}
