public void CanHandleVoiceMessages()
{
var paramses = new HandlerParams(null, new Update
{
Message = new Message
{
Voice = new Voice
{
}
}
}, null, "testbot");
var attribute = new MessageAttribute(Enums.MessageFlag.HasVoice);
Assert.True(attribute.CanHandleInternal(paramses));
paramses = new HandlerParams(null, new Update()
{
Message = new Message()
{
Animation = new Animation()
}
}, null, "testbot");
Assert.False(attribute.CanHandleInternal(paramses));
}
public void Awake()
{
Type[] types = ETModel.Game.Hotfix.GetHotfixTypes();
foreach (Type type in types)
{
object[] attrs = type.GetCustomAttributes(typeof(MessageAttribute), false);
if (attrs.Length == 0)
{
continue;
}
MessageAttribute messageAttribute = attrs[0] as MessageAttribute;
if (messageAttribute == null)
{
continue;
}
this.opcodeTypes.Add(messageAttribute.Opcode, type);
}
foreach (Type type in types)
{
object[] attrs = type.GetCustomAttributes(typeof(ProtoContractAttribute), false);
if (attrs.Length == 0)
{
continue;
}
PType.RegisterType(type.FullName, type);
}
}
public void MessageDescriptor_can_be_created_from_MessageAttribute(MessageAttribute attribute)
{
var messageDescriptor = new MessageDescriptor(attribute);
Assert.That(messageDescriptor.Name, Is.EqualTo(attribute.Name));
Assert.That(messageDescriptor.Namespace, Is.EqualTo(attribute.Namespace));
}
public AnalyzedPacket(int len, byte[] msg, long time, MessageAttribute mark)
{
Length = len;
Message = msg;
Timestamp = time;
RouteMark = mark;
}
/// <summary>
/// Creates an AttributeSet instance for AttributeSet nodes specified in recipe with inner count as 1.
/// </summary>
/// <param name="attributeSetNode">The AttributeSet node specified in recipe with inner count as 1.</param>
/// <param name="xpathNodeVal">The base xpath applied to all child attributes.</param>
/// <param name="message">The message from which to extract information.</param>
/// <returns>An AttributeSet instance for the AttributeSet node in recipe</returns>
/// <exception cref="MessageParsingException">
/// If XPath attribute of the Attribute node is not found.
/// If Attribute node is mandatory and no corresponding node is found in message.
/// If Type of Attribute node is not found or is empty.
/// </exception>
/// <exception cref="MessageValidationException">
/// If MessageAttribute constructor throws exception.
/// </exception>
private static AttributeSet CreateAttributeSet(XmlNode attributeSetNode, string xpathNodeVal,
XmlDocument message)
{
//Get all child attribute nodes
XmlNodeList attributeNodes = attributeSetNode.ChildNodes;
IList <MessageAttribute> attributes = new List <MessageAttribute>();
//Create the attributes for the attributeSet
for (int i = 0; i < attributeNodes.Count; i++)
{
//Create MessageAttribute instance
MessageAttribute createdAttribute = GetMessageAttribute(attributeNodes[i], message, xpathNodeVal);
//Ignore attributes that were not mandatory and were not found
if (createdAttribute != null)
{
attributes.Add(createdAttribute);
}
}
//Convert attributes list to array
MessageAttribute[] attributesArr = new MessageAttribute[attributes.Count];
attributes.CopyTo(attributesArr, 0);
return(new AttributeSet(attributesArr));
}
public static string GetMessageKey(this MessageAttribute message, object value)
=> message?
.Id?
.ToString()?
.Split('.')
.Aggregate(value, (from, name) => Versioned.CallByName(from, name, CallType.Get))?
.ToString();
public override async Task <int> SaveChangesAsync(bool acceptAllChangesOnSuccess,
CancellationToken cancellationToken = new CancellationToken())
{
var domainEntities = this.ChangeTracker
.Entries <Entity>()
.Where(x => x.Entity.DomainEvents != null && x.Entity.DomainEvents.Any()).ToList();
var domainEvents = domainEntities
.SelectMany(x => x.Entity.DomainEvents)
.ToList();
domainEntities.ForEach(entity => entity.Entity.ClearDomainEvents());
foreach (var domainEvent in domainEvents)
{
var message = MessageAttribute.Get(domainEvent.GetType());
if (message == null)
{
continue;
}
var eventBody = JsonConvert.SerializeObject(domainEvent, new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
});
Console.WriteLine($"\n------\nA domain event has been published!\n" +
$"Event: {domainEvent.GetType().Name}\n" +
$"TopicName: {message.Name}\n" +
$"EventBody: {eventBody}\n");
await Events.AddAsync(new Event(domainEvent.GetType().Name, eventBody, message.Name), cancellationToken);
}
return(await base.SaveChangesAsync(acceptAllChangesOnSuccess, cancellationToken));
}
public void CanHandleMultiContent()
{
var paramses = new HandlerParams(null, new Update
{
Message = new Message
{
Voice = new Voice
{
},
Game = new Game
{
}
}
}, null, "testbot");
var attribute = new MessageAttribute(Enums.MessageFlag.HasVoice);
Assert.True(attribute.CanHandleInternal(paramses));
paramses = new HandlerParams(null, new Update()
{
Poll = new Poll
{
}
}, null, "testbot");
Assert.False(attribute.CanHandleInternal(paramses));
}
public void MessageDescriptor_can_be_created_from_MessageAttribute_with_no_namespace(string name)
{
var attribute = new MessageAttribute(name);
var messageDescriptor = new MessageDescriptor(attribute);
Assert.That(messageDescriptor.Name, Is.EqualTo(attribute.Name));
Assert.That(messageDescriptor.Namespace, Is.EqualTo(MessageDescriptor.NamespaceFallback));
}
public StoreRecord(string key, object[] items, long storeVersion, long streamVersion, MessageAttribute[] attributes)
{
Items = items;
StoreVersion = storeVersion;
StreamVersion = streamVersion;
Key = key;
Attributes = attributes;
}
public void MessageAttributeConstructorTest()
{
string name = string.Empty; // TODO: Initialize to an appropriate value
byte number = 0; // TODO: Initialize to an appropriate value
MessageAttribute target = new MessageAttribute(name, number);
Assert.Inconclusive("TODO: Implement code to verify target");
}
public new static MappedAddressAttribute FromGenericAttribute(MessageAttribute attr)
{
return(new MappedAddressAttribute
{
Type = attr.Type,
AttributeLength = attr.AttributeLength,
Value = attr.Value
});
}
/// <summary>
/// Creates a variable number of AttributeSet instances for an AttributeSet node with inner count as *.
/// </summary>
/// <param name="attributeSetNode">The AttributeSet node specified in recipe with inner count as 1.</param>
/// <param name="basePath">The base xpath applied to all child attributes.</param>
/// <param name="message">The message from which to extract information.</param>
/// <returns>A list of AttributeSet instances for the AttributeSet node in recipe</returns>
/// <exception cref="MessageParsingException">
/// If XPath attribute of Attribute node is missing.
/// </exception>
/// <exception cref="MessageValidationException">
/// If MessageAttribute class throws exception at constructor.
/// </exception>
private static IList <AttributeSet> CreateAttributeSets(XmlNode attributeSetNode,
string basePath, XmlDocument message)
{
//Select all child Attribute nodes
XmlNodeList attributeNodes = attributeSetNode.ChildNodes;
//Get all the queries to be run. Also get the names of the MessageAttributes to create
IList <string> xPathQueries = new List <string>();
IList <string> names = new List <string>();
foreach (XmlNode attrNode in attributeNodes)
{
xPathQueries.Add(basePath + GetXmlAttributeValue(attrNode, "XPath", true, false));
names.Add(GetXmlAttributeValue(attrNode, "Name", false, false));
}
//Get the query results
IList <XmlNodeList> xPathResults = new List <XmlNodeList>();
foreach (string query in xPathQueries)
{
xPathResults.Add(message.SelectNodes(query));
}
//Get least number of AttributeSets required
int count = int.MaxValue;
foreach (XmlNodeList nodeList in xPathResults)
{
count = Math.Min(nodeList.Count, count);
}
//Create the required number of AttributeSets
IList <AttributeSet> ret = new List <AttributeSet>();
for (int i = 0; i < count; i++)
{
MessageAttribute[] attributes = new MessageAttribute[attributeNodes.Count];
for (int j = 0; j < attributeNodes.Count; j++)
{
//Exceptions thrown by DataEntities must be caught and rethrown as MessageValidationException
try
{
attributes[j] = new MessageAttribute(names[j], xPathResults[i][j].InnerText, names[j]);
}
catch (Exception e)
{
throw new MessageValidationException("Invalid parameters for MessageAttribute constructor.", e);
}
}
ret.Add(new AttributeSet(attributes));
}
return(ret);
}
public void NumberTest()
{
string name = string.Empty; // TODO: Initialize to an appropriate value
byte number = 0; // TODO: Initialize to an appropriate value
MessageAttribute target = new MessageAttribute(name, number); // TODO: Initialize to an appropriate value
byte expected = 0; // TODO: Initialize to an appropriate value
byte actual;
target.Number = expected;
actual = target.Number;
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verify the correctness of this test method.");
}
private void ValidateAttribute(MessageAttribute messageAttribute, string[] route)
{
if (messageAttribute == null)
{
throw new Exception("MessageAttribute is missing!");
}
if (messageAttribute.IsBroadcast)
{
var broadcaseAttr = (BroadcastMessageAttribute)messageAttribute;
if (broadcaseAttr.Target == BroadcastTarget.Application && !(route == null || route.Length == 0))
{
throw new Exception($"Usage of 'Route' and 'BroadcastTarget.Application' will introduce not logical result!");
}
}
}
public void Publish(IMessage message, string route)
{
MessageAttribute messageAttribute = GetMessageAttribute(message.GetType());
ValidateAttribute(messageAttribute, route);
if (messageAttribute.IsBroadcast)
{
broadcastMessageProcessor.Publish(_channel, message.GetType().FullName, messageAttribute.Durable, message, route);
}
else
{
directMessageProcessor.Publish(_channel, message.GetType().FullName, messageAttribute.Durable, message);
}
}
public void ListenMessage <T>(Action <T> callback, string[] routes) where T : IMessage
{
MessageAttribute messageAttribute = GetMessageAttribute(typeof(T));
ValidateAttribute(messageAttribute, routes);
if (messageAttribute.IsBroadcast)
{
var broadcastAttribute = (BroadcastMessageAttribute)messageAttribute;
broadcastMessageProcessor.ListenRabbitMessage(_channel, typeof(T).FullName, messageAttribute.Durable, callback, routes, broadcastAttribute.Target);
}
else
{
directMessageProcessor.ListenRabbitMessage(_channel, typeof(T).FullName, messageAttribute.Durable, callback);
}
}
/// <summary>
/// добавляет пользовательский атрибут с ссответствующим типом
/// </summary>
/// <param name="attributeName"></param>
/// <param name="value"></param>
/// <returns></returns>
public SendMessageBatchRequestEntry SetMessageAttribute(string attributeName, byte[] value)
{
var attr = new MessageAttributeValue()
{
DataType = AttributeValueType.Binary, BinaryValue = value
};
if (MessageAttribute.ContainsKey(attributeName))
{
MessageAttribute[attributeName] = attr;
}
else
{
MessageAttribute.Add(attributeName, attr);
}
return(this);
}
static void Main()
{
Assembly assembly = Assembly.GetExecutingAssembly();
Type[] types = assembly.GetTypes();
foreach (Type type in types)
{
//MessageAttribute attr = (MessageAttribute)type.GetCustomAttribute(typeof(MessageAttribute));
MessageAttribute attr = type.GetCustomAttribute <MessageAttribute>();
if (attr != null)
{
Console.WriteLine("Classe " + type.FullName + ": " + attr.Value);
}
}
}
/// <summary>
/// добавляет пользовательский атрибут с ссответствующим типом
/// </summary>
/// <param name="attributeName"></param>
/// <param name="value"></param>
/// <returns></returns>
public SendMessageBatchRequestEntry SetMessageAttribute(string attributeName, int value)
{
var attr = new MessageAttributeValue()
{
DataType = AttributeValueType.Number, StringValue = value.ToString()
};
if (MessageAttribute.ContainsKey(attributeName))
{
MessageAttribute[attributeName] = attr;
}
else
{
MessageAttribute.Add(attributeName, attr);
}
return(this);
}
/// <summary>
/// добавляет пользовательский атрибут с ссответствующим типом
/// </summary>
/// <param name="attributeName"></param>
/// <param name="value"></param>
/// <returns></returns>
public SendMessageRequest SetMessageAttribute(string attributeName, string value)
{
var attr = new MessageAttributeValue()
{
DataType = AttributeValueType.String, StringValue = value
};
if (MessageAttribute.ContainsKey(attributeName))
{
MessageAttribute[attributeName] = attr;
}
else
{
MessageAttribute.Add(attributeName, attr);
}
return(this);
}
private static void ValidateMessageAttributesOfComponent(MonoBehaviour behaviour)
{
var type = behaviour.GetType();
MessageAttribute invalidAttribute;
var message = string.Empty;
var fields = ReflectionUtils.GetCachedFields(type);
foreach (var field in fields)
{
if (MessageAttribute.TryFindInvalidAttribute(behaviour, field, out invalidAttribute))
{
message = string.Format("The attribute 'MessageAttribute' of the field {0} of the component {1} has the error -> '{2}'", field, type.Name, invalidAttribute.Message);
Debug.LogError(message, behaviour);
error_count++;
}
}
}
private Message GenerateMessageFromAttribute(MessageAttribute messageAttribute, ISchemaRepository schemaRepository)
{
if (messageAttribute?.PayloadType == null)
{
return(null);
}
var message = new Message
{
Payload = _schemaGenerator.GenerateSchema(messageAttribute.PayloadType, schemaRepository),
Name = messageAttribute.Name ?? _options.SchemaIdSelector(messageAttribute.PayloadType),
Title = messageAttribute.Title,
Summary = messageAttribute.Summary,
Description = messageAttribute.Description,
};
return(message);
}
public ServerProxy(Type proxy, IServiceManager serviceManager)
: base(proxy)
{
ServiceAttribute sattr = proxy.GetCustomAttribute <ServiceAttribute>();
if (sattr != null)
{
serviceType = sattr.ServiceType;
}
MessageAttribute mttr = proxy.GetCustomAttribute <MessageAttribute>();
if (mttr != null)
{
messageType = mttr.MessageType;
}
this.serviceManager = serviceManager;
}
private static IMessage GenerateMessageFromAttribute(MessageAttribute messageAttribute, AsyncApiSchemaResolver schemaResolver, JsonSchemaGenerator jsonSchemaGenerator)
{
if (messageAttribute?.PayloadType == null)
{
return(null);
}
var message = new Message
{
Payload = jsonSchemaGenerator.Generate(messageAttribute.PayloadType, schemaResolver),
Title = messageAttribute.Title,
Summary = messageAttribute.Summary,
Description = messageAttribute.Description,
Bindings = messageAttribute.BindingsRef != null ? new MessageBindingsReference(messageAttribute.BindingsRef) : null,
};
message.Name = messageAttribute.Name ?? message.Payload.ActualSchema.Id;
return(schemaResolver.GetMessageOrReference(message));
}
public void CanHandleLeftChatMember()
{
var handles = new HandlerParams(null, new Update()
{
Message = new Message()
{
LeftChatMember =
new User()
{
Id = 12345,
FirstName = "Fulan",
Username = "******",
LastName = "Bin Fulan"
}
}
}, null, "testbot");
var attribute = new MessageAttribute(MessageFlag.HasLeftChatMember);
Assert.True(attribute.CanHandleInternal(handles));
}
public MessageAttribute[] ReadAttributes(Stream stream)
{
using (var reader = new BitReader(stream))
{
var attributeCount = reader.Read7BitInt();
if (attributeCount == 0)
{
return(Empty);
}
var attributes = new MessageAttribute[attributeCount];
for (var i = 0; i < attributeCount; i++)
{
var key = reader.ReadString();
var value = reader.ReadString();
attributes[i] = new MessageAttribute(key, value);
}
return(attributes);
}
}
public void CanHandleCaptionMessages()
{
var paramses = new HandlerParams(null, new Update()
{
Message = new Message()
{
Caption = "Blah",
Voice = new Voice
{
}
}
}, null, "testbot");
var attribute = new MessageAttribute(Enums.MessageFlag.HasCaption);
Assert.True(attribute.CanHandleInternal(paramses));
attribute = new MessageAttribute("Foo");
Assert.False(attribute.CanHandleInternal(paramses));
attribute = new MessageAttribute("/test");
Assert.False(attribute.CanHandleInternal(paramses));
}
public void Load()
{
this.opcodeTypes.Clear();
this.typeMessages.Clear();
List <Type> types = Game.EventSystem.GetTypes();
foreach (Type type in types)
{
object[] attrs = type.GetCustomAttributes(typeof(MessageAttribute), false);
if (attrs.Length == 0)
{
continue;
}
MessageAttribute messageAttribute = attrs[0] as MessageAttribute;
if (messageAttribute == null)
{
continue;
}
this.opcodeTypes.Add(messageAttribute.Opcode, type);
this.typeMessages.Add(messageAttribute.Opcode, Activator.CreateInstance(type));
}
}
GUIContent GetContent()
{
MessageAttribute target = attribute as MessageAttribute;
return(new GUIContent(target.Message, ConvertTypeToIcon(target.IconType)));
}
public MessageResolverResultSet(MessageId id, Type type, MessageAttribute messageAttribute)
{
Id = id;
Type = type;
MessageAttribute = messageAttribute;
}
public MessageAttribute[] ReadAttributes(Stream stream)
{
using (var reader = new BitReader(stream))
{
var attributeCount = reader.Read7BitInt();
if (attributeCount == 0) return Empty;
var attributes = new MessageAttribute[attributeCount];
for (var i = 0; i < attributeCount; i++)
{
var key = reader.ReadString();
var value = reader.ReadString();
attributes[i] = new MessageAttribute(key, value);
}
return attributes;
}
}
