private void ValidateMessage(MessageDefinition message)
{
var paramNames = new HashSet <string>();
var genericConstraints = new HashSet <string>();
if (message.Options.Proto)
{
if (message.GenericParameters.Count > 0)
{
_contracts.AddError(message.ParseContext, "Cannot generate .proto for generic message {0}", message.Name);
}
}
ValidateAttributes(message.Attributes);
ValidateTags(message);
foreach (var param in message.Parameters)
{
var errorContext = param.ParseContext ?? message.ParseContext;
if (!paramNames.Add(param.Name))
{
_contracts.AddError(errorContext, "Duplicate parameter name: {0}", param.Name);
}
ValidateType(param.Type, param.ParseContext);
ValidateAttributes(param.Attributes);
}
foreach (var constraint in message.GenericConstraints)
{
var errorContext = constraint.ParseContext ?? message.ParseContext;
if (!genericConstraints.Add(constraint.GenericParameterName))
{
_contracts.AddError(errorContext, "Duplicate generic constraint: '{0}'", constraint.GenericParameterName);
}
if (!message.GenericParameters.Contains(constraint.GenericParameterName))
{
_contracts.AddError(errorContext, "Undefined generic parameter: '{0}'", constraint.GenericParameterName);
}
if (constraint.IsClass && constraint.IsStruct)
{
_contracts.AddError(errorContext, "Constraint on '{0}' cannot require both class and struct", constraint.GenericParameterName);
}
foreach (var constraintType in constraint.Types)
{
ValidateType(constraintType, message.ParseContext);
}
}
foreach (var baseType in message.BaseTypes)
{
ValidateType(baseType, message.ParseContext);
}
}
private DescriptiveObject InitDescriptiveObject(Type item, MessageType eMessageType)
{
DescriptiveObject messDef;
if (eMessageType != MessageType.None)
{
messDef = new MessageDefinition()
{
Name = item.GetName(),
FullName = item.GetFullName(),
MessageType = eMessageType,
Description = _xmlReader.GetSummary(item)
};
}
else
{
messDef = new DescriptiveType()
{
Name = item.GetName(),
FullName = item.GetFullName(),
Description = _xmlReader.GetSummary(item)
};
}
return(messDef);
}
private static void ProcessMessage(MessageDefinition message)
{
foreach (var parameterDefinition in message.Parameters)
{
ProcessParameter(parameterDefinition);
}
}
public MessageDefinition Extract(Type type)
{
var result = new MessageDefinition();
var name = type.FullName;
var dotNetType = type.FullName;
foreach (PropertyInfo info in type.GetProperties())
{
var member = new MessageDefinition()
{
Name = info.Name,
DotNetType = info.PropertyType.Name,
Parent = result,
Children = new List<MessageDefinition>()
};
//TODO: Needs to walk the entire object graph not just one level deep
result.Children.Add(member);
}
result.Name = name;
result.DotNetType = dotNetType;
return result;
}
protected string Generate(MessageDefinition message)
{
var contracts = new ParsedContracts();
contracts.Messages.Add(message);
return(Generate(contracts));
}
public PackageGenerator(MessageDefinition messageDef, Package packageDef, DictionaryDefinition dictDef, Database db)
:
base(messageDef, packageDef)
{
this.db = db;
this.dictDef = dictDef;
}
public MessageDefinition Extract(Type type)
{
var result = new MessageDefinition();
var name = type.FullName;
var dotNetType = type.FullName;
foreach (PropertyInfo info in type.GetProperties())
{
var member = new MessageDefinition()
{
Name = info.Name,
DotNetType = info.PropertyType.Name,
Parent = result,
Children = new List <MessageDefinition>()
};
//TODO: Needs to walk the entire object graph not just one level deep
result.Children.Add(member);
}
result.Name = name;
result.DotNetType = dotNetType;
return(result);
}
public void WhenDuplicatedKeyExceptionThrown_NonOfTheActorHandlersIsAdded()
{
var actorHandlersMap = new ActorHandlerMap();
var simpleMessageActor = new ConfigurableActor(new[]
{
new MessageHandlerDefinition
{
Handler = null,
Message = MessageDefinition.Create <SimpleMessage>()
}
});
var exceptionMessageActor = new ConfigurableActor(new[]
{
new MessageHandlerDefinition
{
Handler = null,
Message = MessageDefinition.Create <ExceptionMessage>()
},
new MessageHandlerDefinition
{
Handler = null,
Message = MessageDefinition.Create <SimpleMessage>()
}
});
actorHandlersMap.Add(simpleMessageActor);
actorHandlersMap.Get(MessageIdentifier.Create <SimpleMessage>());
Assert.Throws <DuplicatedKeyException>(() => { actorHandlersMap.Add(exceptionMessageActor); });
actorHandlersMap.Get(MessageIdentifier.Create <SimpleMessage>());
Assert.Throws <KeyNotFoundException>(() => actorHandlersMap.Get(MessageIdentifier.Create <ExceptionMessage>()));
}
public PLSQLGenerator(MessageDefinition messageDef, Package packageDef, code_target ct, string mapi_number)
: base(messageDef, packageDef)
{
code_target = ct;
switch (code_target)
{
case code_target.hapi:
{
tableName = "HAPIRCV";
packageName = "HAPI_Rcv_Object";
break;
}
case code_target.msg:
{
tableName = "MSG_IN";
packageName = "MessageRcv_Object";
break;
}
case code_target.mapi:
{
tableName = "MAPI_IN";
packageName = "MAPIIn_" + mapi_number + "Object";
break;
}
default:
break;
}
}
public void Provider_should_return_all_matching_sla_definitions_for_given_response()
{
var provider = new SlaProvider();
var def1 = new SlaDefinition(
MessageDefinition.Create <IRequestOne>(r => r.OneId),
MessageDefinition.Create <IResponseOne>(r => r.Id),
TimeSpan.FromSeconds(1));
var def2 = new SlaDefinition(
MessageDefinition.Create <IRequestTwo>(r => r.TwoId),
MessageDefinition.Create <IResponseTwo>(r => r.Id),
TimeSpan.FromSeconds(2));
var def3 = new SlaDefinition(
MessageDefinition.Create <IExtendedRequestOne>(r => r.OneId),
MessageDefinition.Create <IResponseOne>(r => r.Id),
TimeSpan.FromSeconds(3));
var def4 = new SlaDefinition(
MessageDefinition.Create <IRequestOne>(r => r.OneId),
MessageDefinition.Create <IExtendedResponseOne>(r => r.Id),
TimeSpan.FromSeconds(3));
provider.Add(def1);
provider.Add(def2);
provider.Add(def3);
provider.Add(def4);
var definitions = provider.GetSlaDefinitionsFor(new Mock <IExtendedResponseOne>().Object);
Assert.That(definitions.ToArray(), Is.EquivalentTo(new[] { def1, def3, def4 }));
}
public void ActorHandlersMap_CanAddTwoActorsHandlingSameMessageTypeInDifferentPartitions()
{
var actorHandlersMap = new ActorHandlerMap();
var partition = Guid.NewGuid().ToByteArray();
var actorWithoutPartition = new ConfigurableActor(new[]
{
new MessageHandlerDefinition
{
Handler = null,
Message = MessageDefinition.Create <SimpleMessage>()
}
});
var actorWithPartition = new ConfigurableActor(new[]
{
new MessageHandlerDefinition
{
Handler = null,
Message = MessageDefinition.Create <SimpleMessage>(partition)
}
});
actorHandlersMap.Add(actorWithoutPartition);
actorHandlersMap.Add(actorWithPartition);
actorHandlersMap.Get(MessageIdentifier.Create(typeof(SimpleMessage), partition));
actorHandlersMap.Get(MessageIdentifier.Create(typeof(SimpleMessage)));
}
protected internal virtual void CreateOperations(BpmnModel bpmnModel)
{
foreach (Interface interfaceObject in bpmnModel.Interfaces)
{
BpmnInterface bpmnInterface = new BpmnInterface(interfaceObject.Id, interfaceObject.Name)
{
Implementation = wsServiceMap[interfaceObject.ImplementationRef]
};
foreach (Operation operationObject in interfaceObject.Operations)
{
if (!operationMap.ContainsKey(operationObject.Id))
{
MessageDefinition inMessage = messageDefinitionMap[operationObject.InMessageRef];
Webservice.Operation operation = new Webservice.Operation(operationObject.Id, operationObject.Name, bpmnInterface, inMessage)
{
Implementation = wsOperationMap[operationObject.ImplementationRef]
};
if (!string.IsNullOrWhiteSpace(operationObject.OutMessageRef))
{
if (messageDefinitionMap.ContainsKey(operationObject.OutMessageRef))
{
MessageDefinition outMessage = messageDefinitionMap[operationObject.OutMessageRef];
operation.OutMessage = outMessage;
}
}
operationMap[operation.Id] = operation;
}
}
}
}
private void WriteParameterMember(MessageDefinition message, ParameterDefinition param)
{
if (!param.Attributes.HasAttribute(KnownTypes.ProtoMemberAttribute))
{
var protoMemberParams = new StringBuilder();
protoMemberParams.Append(param.Tag);
protoMemberParams.AppendFormat(", IsRequired = {0}", param.Rules == FieldRules.Required ? "true" : "false");
if (param.IsPacked)
{
protoMemberParams.Append(", IsPacked = true");
}
WriteAttributeLine(new AttributeDefinition(KnownTypes.ProtoMemberAttribute, protoMemberParams.ToString()));
}
foreach (var attribute in param.Attributes)
{
WriteAttributeLine(attribute);
}
var isWritable = param.IsWritableProperty || message.Options.Mutable;
Writer.Write("public {0} {1}", param.Type.NetType, Identifier(MemberCase(param.Name)));
Writer.WriteLine(isWritable ? " { get; set; }" : " { get; private set; }");
Writer.WriteLine();
}
/// <summary>Sends a message to all contacts in the list.</summary>
/// <param name="service">The service to use.</param>
/// <param name="message">The message to show.</param>
public void SendAll(IMessagingService service, MessageDefinition message)
{
foreach (var item in _items)
{
item.Send(service, message);
}
}
public WSInboundGenerator(MessageDefinition messageDef, Package packageDef, bool genReceiver, bool genSender, code_target ct, String ns)
: base(messageDef, packageDef)
{
this.genReceiver = genReceiver;
this.genSender = genSender;
this.code_target = ct;
nameSpace = ns;
}
/// <summary>
/// Generate the body of the <c>encode</c> function for the given <see cref="FieldsDefinition"/>.
/// </summary>
/// <param name="definition">The definition to generate code for.</param>
/// <returns>The generated Dart <c>encode</c> function body.</returns>
public string CompileEncode(FieldsDefinition definition)
{
return(definition switch
{
MessageDefinition d => CompileEncodeMessage(d),
StructDefinition d => CompileEncodeStruct(d),
_ => throw new InvalidOperationException($"invalid CompileEncode value: {definition}"),
});
public override IEnumerable <MessageHandlerDefinition> GetInterfaceDefinition()
=> new[]
{
new MessageHandlerDefinition
{
Message = MessageDefinition.Create <LeaseRequestMessage>(clusterName),
Handler = GetLease
}
};
/// <summary>
/// Generate the body of the <c>encode</c> function for the given <see cref="TopLevelDefinition"/>.
/// </summary>
/// <param name="definition">The definition to generate code for.</param>
/// <returns>The generated CPlusPlus <c>encode</c> function body.</returns>
public string CompileEncode(TopLevelDefinition definition)
{
return(definition switch
{
MessageDefinition d => CompileEncodeMessage(d),
StructDefinition d => CompileEncodeStruct(d),
UnionDefinition d => CompileEncodeUnion(d),
_ => throw new InvalidOperationException($"invalid CompileEncode kind: {definition}"),
});
public override AstNode?VisitMessageDefinition(MessageDefinitionContext context)
{
var message = new MessageDefinition
{
IsCustom = context.customModifier != null
};
ProcessMessage(message, context);
return(message);
}
private void WriteGenericConstraints(MessageDefinition message)
{
if (message.GenericConstraints.Count == 0)
{
return;
}
using (Indent())
{
foreach (var genericConstraint in message.GenericConstraints)
{
Writer.Write("where ");
Writer.Write(Identifier(genericConstraint.GenericParameterName));
Writer.Write(" : ");
var firstConstraint = false;
if (genericConstraint.IsClass)
{
Writer.Write("class");
}
else if (genericConstraint.IsStruct)
{
Writer.Write("struct");
}
else
{
firstConstraint = true;
}
foreach (var type in genericConstraint.Types)
{
if (!firstConstraint)
{
Writer.Write(", ");
}
Writer.Write(type.NetType);
firstConstraint = false;
}
if (genericConstraint.HasDefaultConstructor && !genericConstraint.IsStruct)
{
if (!firstConstraint)
{
Writer.Write(", ");
}
Writer.Write("new()");
}
Writer.WriteLine();
}
}
}
public void Definition_should_allow_to_retrieve_proper_correlation_id()
{
var message = new TestMessage {
FirstId = Guid.NewGuid(), SecondId = Guid.NewGuid()
};
var def1 = MessageDefinition.Create <TestMessage>(m => m.FirstId);
var def2 = MessageDefinition.Create <TestMessage>(m => m.SecondId);
Assert.That(def1.GetCorrelationId(message), Is.EqualTo(message.FirstId), "It should use FirstId");
Assert.That(def2.GetCorrelationId(message), Is.EqualTo(message.SecondId), "It should use SecondId");
}
public MessageSubscription(
long id,
MessageDefinition messageDefinition,
INetworkTaskFactory taskFactory,
IDictionary <long, IMessageSubscription> subscriptions)
{
_id = id;
_taskFactory = taskFactory;
_subscriptions = subscriptions;
Definition = messageDefinition;
_receivers = new List <MessageReceiveConfig>();
}
private MessageInstance createResponseMessage(object[] results, Operation operation)
{
MessageInstance message = null;
MessageDefinition outMessage = operation.OutMessage;
if (outMessage != null)
{
message = outMessage.CreateInstance();
message.StructureInstance.LoadFrom(results);
}
return(message);
}
private JobResult GenerateClass(MessageDefinition msgDef, Package package, ICollection<Import> imports)
{
var topLevelStatements = new List<SyntaxNode>();
topLevelStatements.Add(_generator.NamespaceImportDeclaration("System"));
foreach(var import in imports)
{
topLevelStatements.Add(_generator.NamespaceImportDeclaration(import.ImportClass));
}
var members = new List<SyntaxNode>();
foreach (var msgField in msgDef.Fields)
{
members.Add(_generator.FieldDeclaration(
$"_{msgField.FieldName}",
_generator.TypeExpression(SpecialType.System_String),
Accessibility.Private));
members.Add(_generator.PropertyDeclaration(
$"{msgField.FieldName}",
_generator.TypeExpression(SpecialType.System_String),
Accessibility.Public,
getAccessorStatements: new SyntaxNode[]
{
_generator.ReturnStatement(_generator.IdentifierName($"_{msgField.FieldName}"))
},
setAccessorStatements: new SyntaxNode[]
{
_generator.AssignmentStatement(_generator.IdentifierName($"_{msgField.FieldName}"), _generator.IdentifierName("value"))
}));
}
var classDefinition = _generator.ClassDeclaration(msgDef.Name,
typeParameters: null,
accessibility: Accessibility.Public,
modifiers: DeclarationModifiers.Sealed,
baseType: null,
interfaceTypes: null,
members: members);
var packageName = package?.Name ?? "wasnull";
var ns = _generator.NamespaceDeclaration(packageName, classDefinition);
topLevelStatements.Add(ns);
var compilationUnit = _generator.CompilationUnit(topLevelStatements)
.NormalizeWhitespace();
return new JobResult
{
FileContent = compilationUnit.ToFullString(),
FileName = $"{msgDef.Name}.cs"
};
}
private static void SetInheritanceModifier(MessageDefinition message)
{
if (message.InheritanceModifier != InheritanceModifier.Default)
{
return;
}
var hasInheritedMessages = message.Attributes.Any(attr => Equals(attr.TypeName, KnownTypes.ProtoIncludeAttribute));
message.InheritanceModifier = hasInheritedMessages
? InheritanceModifier.Abstract
: InheritanceModifier.Sealed;
}
/// <summary>
/// Creates a message definition.
/// </summary>
/// <param name="messageFullName">The fully qualified type name to assign to the message definition.</param>
/// <param name="messageLocalName">The local class name to assign to the message definition.</param>
/// <param name="messageType">The message type to create the message definition from.</param>
/// <param name="parentResourceKey">The resource key of the message definitions parent.</param>
/// <returns>A message definition.</returns>
private MessageDefinition CreateMessageDefinition(string messageFullName, string messageLocalName, TypeDefinition messageType, string parentResourceKey)
{
var messageDefinition = new MessageDefinition(
GetCustomAttributeConstructorValue(messageType, SchemaAttributeType, 1),
GetCustomAttributeConstructorValue(messageType, SchemaAttributeType, 0),
messageFullName,
messageLocalName,
parentResourceKey + ":" + GetCustomAttributeConstructorValue(messageType, SchemaAttributeType, 1));
// Add the promoted properties.
messageDefinition.PromotedProperties.AddRange(ExtractPromotedProperties(messageType));
return(messageDefinition);
}
public override IEnumerable <MessageHandlerDefinition> GetInterfaceDefinition()
=> new[]
{
new MessageHandlerDefinition
{
Message = MessageDefinition.Create <InternalDiscoverLeaseProviderInstancesRequestMessage>(clusterName),
Handler = InternalDiscoverLeaseProviderInstancesRequest
},
new MessageHandlerDefinition
{
Message = MessageDefinition.Create <InternalDiscoverLeaseProviderInstancesResponseMessage>(clusterName),
Handler = InternalDiscoverLeaseProviderInstancesResponse
}
};
private void WriteMessageConstructor(MessageDefinition message)
{
Writer.WriteLine();
Writer.Write(
message.InheritanceModifier == Ast.InheritanceModifier.Abstract
? "protected"
: "public"
);
Writer.Write(" ");
Writer.Write(Identifier(message.Name));
Writer.Write("(");
var paramsToInitialize = message.Parameters
.Where(param => !param.IsWritableProperty)
.ToList();
var firstParam = true;
foreach (var param in paramsToInitialize)
{
if (firstParam)
{
firstParam = false;
}
else
{
Writer.Write(", ");
}
Writer.Write("{0} {1}", param.Type.NetType, Identifier(ParameterCase(param.Name)));
if (!string.IsNullOrEmpty(param.DefaultValue))
{
Writer.Write(" = {0}", param.DefaultValue);
}
}
Writer.WriteLine(")");
using (Block())
{
foreach (var param in paramsToInitialize)
{
Writer.WriteLine("{0} = {1};", Identifier(MemberCase(param.Name)), Identifier(ParameterCase(param.Name)));
}
}
}
/// <summary>
/// Globals the advert message.
/// </summary>
/// <param name="message">The message.</param>
protected void GlobalAdvertMessage(MessageDefinition message)
{
if (!message.Enabled)
{
return;
}
if (Repository.Static.GetLastIntervalById(message.Id).AddMinutes(message.Interval) < Repository.Static.Now)
{
Repository.Static.SetLastIntervalById(message.Id, Repository.Static.Now);
QueryRunner.SendGlobalMessage(message.TextMessage.ToMessage());
Log(message, string.Format("Global advert message successfully sent."));
}
}
public override IEnumerable <MessageHandlerDefinition> GetInterfaceDefinition()
{
return(new[]
{
new MessageHandlerDefinition
{
Message = MessageDefinition.Create <CreateLeaseProviderInstanceRequestMessage>(clusterName),
Handler = CreateLeaseProviderInstance
},
new MessageHandlerDefinition
{
Message = MessageDefinition.Create <InternalCreateLeaseProviderInstanceRequestMessage>(clusterName),
Handler = InternalCreateLeaseProviderInstance
}
});
}
private void OnSave(object sender, EventArgs e)
{
if (!ValidateChildren())
{
return;
}
Message = new MessageDefinition()
{
Subject = _txtSubject.Text,
Message = _txtMessage.Text
};
DialogResult = DialogResult.OK;
Close();
}
private static void AddInterfaces(MessageDefinition message)
{
switch (message.Type)
{
case MessageType.Event:
message.BaseTypes.Add(KnownTypes.EventInterface);
break;
case MessageType.Command:
message.BaseTypes.Add(KnownTypes.CommandInterface);
break;
case MessageType.Custom:
message.BaseTypes.Add(KnownTypes.MessageInterface);
break;
}
}
public void BuilderVisitorShouldBuildMessage()
{
#region Arrange Expected NodeTree Input
var root = new RootNode();
// Define base Message with One Field
var message = new Node(NodeType.Message, "message");
var msgName = new Node(NodeType.Identifier, "Outer");
#region Outer Message Field nodes
var field = new Node(NodeType.Field, "int32");
var type = new Node(NodeType.Type, "int32");
var name = new Node(NodeType.Identifier, "field_name");
var value = new Node(NodeType.FieldNumber, "2");
field.AddChildren(type, name, value);
#endregion Outer Message Field nodes
#region Nested Message nodes
var nestedMsg = new Node(NodeType.Message, "message");
var nestedName = new Node(NodeType.Identifier, "Inner");
var innerField = new Node(NodeType.Field, "fixed64");
var innerType = new Node(NodeType.Type, "fixed64");
var innerName = new Node(NodeType.Identifier, "field_name2");
var innerValue = new Node(NodeType.FieldNumber, "0");
innerField.AddChildren(innerType, innerName, innerValue);
#endregion Nested Message nodes
#region Nested Enumeration nodes
var enumnode = new Node(NodeType.Enum, "enum");
var enumname = new Node(NodeType.Identifier, "EnumName");
var enumfield0 = new Node(NodeType.EnumField, "DEFAULT");
var enumfieldname0 = new Node(NodeType.Identifier, "DEFAULT");
var enumfieldvalue0 = new Node(NodeType.FieldNumber, "0");
var enumfield1 = new Node(NodeType.EnumField, "VALONE");
var enumfieldname1 = new Node(NodeType.Identifier, "VALONE");
var enumfieldvalue1 = new Node(NodeType.FieldNumber, "1");
enumnode.AddChildren(enumname, enumfield0, enumfield1);
enumfield0.AddChildren(enumfieldname0, enumfieldvalue0);
enumfield1.AddChildren(enumfieldname1, enumfieldvalue1);
#endregion Nested Enumeration nodes
nestedMsg.AddChildren(nestedName, innerField);
message.AddChildren(msgName, field, enumnode, nestedMsg);
root.AddChild(message);
#endregion Arrange Expected NodeTree Input
#region Arrange Expected Output
var expFields = new List<Field>
{
new Field("int32", "field_name", 2, null, false)
};
var inFields = new List<Field>
{
new Field("fixed64", "field_name2", 0, null, false)
};
var enumDefs = new List<EnumDefinition>
{
new EnumDefinition("EnumName", null, new List<EnumField>
{
new EnumField("DEFAULT", 0, null),
new EnumField("VALONE", 1, null)
})
};
var msgDefs = new List<MessageDefinition>
{
new MessageDefinition("Inner", inFields, null, null, null, null, null)
};
var expected = new MessageDefinition("Outer", expFields, null, null, null, enumDefs, msgDefs);
#endregion Arrange Expected Output
var sut = new BuilderVisitor();
root.Accept(sut);
sut.FileDescriptor.Messages.First().Should().Be(expected);
}
/// <summary>
/// Globals the advert message.
/// </summary>
/// <param name="message">The message.</param>
protected void GlobalAdvertMessage(MessageDefinition message)
{
if (!message.Enabled) return;
if (Repository.Static.GetLastIntervalById(message.Id).AddMinutes(message.Interval) < Repository.Static.Now)
{
Repository.Static.SetLastIntervalById(message.Id, Repository.Static.Now);
QueryRunner.SendGlobalMessage(message.TextMessage.ToMessage());
Log(message, string.Format("Global advert message successfully sent."));
}
}
/// <summary>
/// Logs the information that request with <c>correlationId</c> would not be monitored due to fact that quota for requests of this type has been already reached.
/// The log level of this message is WARN
/// </summary>
/// <param name="requestDefinition">Message definition.</param>
/// <param name="correlationId">Correlation ID</param>
protected virtual void ProcessQuotaReached(MessageDefinition requestDefinition, Guid correlationId)
{
_logger.WarnFormat("SLA={0} monitoring message quota reached. Message with CorrelationId={1} is not going to be monitored.", requestDefinition.Type, correlationId);
}
protected virtual void ProcessMessageTimeout(MessageDefinition requestDefinition, TimeSpan elapsed, Guid correlationId)
{
_logSlaBreach("SLA={0} Response=monitor-timed-out ResponseTime={1} milliseconds CorrelationId={2}", new object[] { requestDefinition.Type, (long)elapsed.TotalMilliseconds, correlationId });
}
/// <summary>
/// Welcomes the message.
/// </summary>
/// <param name="e">The <see cref="TS3QueryLib.Core.Server.Notification.EventArgs.ClientJoinedEventArgs"/> instance containing the event data.</param>
/// <param name="message">The message.</param>
protected void WelcomeMessage(ClientJoinedEventArgs e, MessageDefinition message)
{
if (!message.Enabled) return;
if (e.ClientType == 0)
QueryRunner.SendTextMessage(
MessageTarget.Channel, message.Channel,
message.TextMessage.ToMessage(new MessageContext
{
ClientDatabaseId = e.ClientDatabaseId,
ClientNickname = e.Nickname
}));
Log(message, string.Format("Welcome message successfully sent to client '{0}'(id:{1}).", e.Nickname, e.ClientDatabaseId));
}
/// <summary>
/// Adverts the message.
/// </summary>
/// <param name="message">The message.</param>
protected void AdvertMessage(MessageDefinition message)
{
if (!message.Enabled) return;
if (Repository.Static.GetLastIntervalById(message.Id).AddMinutes(message.Interval) < Repository.Static.Now)
{
Repository.Static.SetLastIntervalById(message.Id, Repository.Static.Now);
QueryRunner.SendTextMessage(
MessageTarget.Server, Repository.Connection.CredentialEntity.Self.VirtualServerId,
message.TextMessage.ToMessage(new MessageContext
{
ServerId = Repository.Connection.CredentialEntity.Self.VirtualServerId
}));
Log(message, string.Format("Advert message successfully sent to server '{0}'.", Repository.Connection.CredentialEntity.Self.VirtualServerId));
}
}
public SlaDefinition(MessageDefinition request, MessageDefinition response, TimeSpan sla)
{
Request = request;
Response = response;
Sla = sla;
}
public override void Visit(Node node)
{
var name = node.Children.Single(t => t.NodeType.Equals(NodeType.Identifier)).NodeValue;
var embMsg = node.Children.Where(t => t.NodeType.Equals(NodeType.Message));
var messages = new List<MessageDefinition>();
foreach (var msg in embMsg)
{
var msgVisitor = new MessageVisitor(Errors);
msg.Accept(msgVisitor);
messages.Add(msgVisitor.Message);
}
var embEnum = node.Children.Where(t => t.NodeType.Equals(NodeType.Enum));
var enums = new List<EnumDefinition>();
foreach (var en in embEnum)
{
var enumVisitor = new EnumVisitor(Errors);
en.Accept(enumVisitor);
enums.Add(enumVisitor.EnumDefinition);
}
var fieldNodes = node.Children.Where(t => t.NodeType.Equals(NodeType.Field));
var fields = new List<Field>();
foreach (var field in fieldNodes)
{
var fieldVisitor = new FieldVisitor(Errors);
field.Accept(fieldVisitor);
fields.Add(fieldVisitor.Field);
}
Message = new MessageDefinition(name, fields, null, null, null, enums, messages);
}
