private static void ImportMessageSoapAction(WsdlContractConversionContext contractContext, MessageDescription message, MessageBinding wsdlMessageBinding, bool isResponse)
{
string soapAction = SoapHelper.ReadSoapAction(wsdlMessageBinding.OperationBinding);
if (contractContext != null)
{
OperationMessage wsdlOperationMessage = contractContext.GetOperationMessage(message);
string wsaAction = WsdlImporter.WSAddressingHelper.FindWsaActionAttribute(wsdlOperationMessage);
if (wsaAction == null && soapAction != null)
{
if (isResponse)
{
message.Action = "*";
}
else
{
message.Action = soapAction;
}
}
//CONSIDER, hsomu: If WS-Addressing action was found, we should verify that it is the same as the SOAP action
// (for the request message).
}
else
{
//CONSIDER, hsomu: verify SOAP action matches referenced contract.operation.message
}
}
private TreeNode MessageToTreeNode(OperationMessage omsg, SoapBindingUse use)
{
Message msg = _services.GetMessage(omsg.Message);
TreeNode node = new TreeNode();
WSDLParser.SchemaParser ngen = new WSDLParser.SchemaParser(_schemas);
ngen.BindingUse = use;
foreach (MessagePart part in msg.Parts)
{
if (part.Element == XmlQualifiedName.Empty)
{
TreeNode partNode = ngen.Translate(part.Type);
partNode.ImageIndex = 5;
partNode.SelectedImageIndex = 5;
partNode.Text = part.Name;
node.Nodes.Add(partNode);
}
else
{
TreeNode partNode = ngen.Translate(part.Element);
partNode.ImageIndex = 5;
partNode.SelectedImageIndex = 5;
partNode.Text = part.Name;
node.Nodes.Add(partNode);
}
}
return(node);
}
public string GenerateMessage(Port port, OperationBinding obin, Operation oper, string protocol, bool generateInput)
{
OperationMessage msg = null;
foreach (OperationMessage opm in oper.Messages)
{
if (opm is OperationInput && generateInput)
{
msg = opm;
}
else if (opm is OperationOutput && !generateInput)
{
msg = opm;
}
}
if (msg == null)
{
return(null);
}
switch (protocol)
{
case "Soap":
return(GenerateHttpSoapMessage(port, obin, oper, msg));
case "HttpGet":
return(GenerateHttpGetMessage(port, obin, oper, msg));
case "HttpPost":
return(GenerateHttpPostMessage(port, obin, oper, msg));
}
return("Unknown protocol");
}
private Task HandleMessageAsync(OperationMessage op, IConnectionContext connection)
{
return(_messagingProtocolHandler.HandleMessageAsync(
new OperationMessageContext(
connection,
op)));
}
/// <summary>
/// Contructor
/// </summary>
/// <param name="callingModule">Reference to the calling module</param>
/// <param name="opcode">OPCode used for the outgoing messages</param>
/// <param name="statusCodeType">Type of the enum for status code parsing on error</param>
/// <param name="destinationAddress">Destination node address</param>
/// <param name="content">Content to send in bytes</param>
public FragmentWriteTransaction(ModuleBase callingModule, OperationMessage.OPCodes opcode, Type statusCodeType, ushort destinationAddress, byte[] content)
{
this.callingModule = callingModule;
this.operationResponseOPCode = (OperationMessage.OPCodes)((int)opcode + 1);
this.applicationStatusCodeType = statusCodeType;
this.OpCode = opcode;
this.DestinationAddress = destinationAddress;
this.outputBuffer = new List <OperationMessage>();
this.totalFragments = (byte)(content.Length / MAX_CONTENT_SIZE);
for (byte i = 0; i <= this.totalFragments; i++)
{
this.CurrentFrameSize = Math.Min(MAX_CONTENT_SIZE, content.Length - (i * MAX_CONTENT_SIZE));
OperationMessage currentOp = new OperationMessage()
{
SourceAddress = 0x00,
DestinationAddress = destinationAddress,
OpCode = OperationMessage.OPCodes.ConfigWrite,
Args = new byte[this.CurrentFrameSize + 2]
};
currentOp.Args[0] = (byte)((this.totalFragments << 4) | (i & 0xF));
currentOp.Args[1] = (byte)this.CurrentFrameSize;
Buffer.BlockCopy(content, (i * MAX_CONTENT_SIZE), currentOp.Args, 2, this.CurrentFrameSize);
this.outputBuffer.Add(currentOp);
}
}
private async Task <bool> SendJoinAcceptResponse(string macAddress, ushort newAddress, Security security)
{
PendingNodeInfo info = this.PendingNodes.FirstOrDefault(n => n.MacAddress == macAddress);
if (info == null)
{
throw new InvalidOperationException("There is no pending node with the specified MAC Address");
}
OperationMessage joinAcceptResponse = OperationMessage.JoinAcceptResponse(newAddress, (ushort)security.PanId, (byte)security.Channel, security.SecurityKey, info.TemporalAddress);
bool result = await this.SendMessage(joinAcceptResponse);
if (result)
{
Debug.WriteLine(string.Format("JOIN ACCEPTED {0} -> NEW ADDRESS: 0x{1:X2}", macAddress, newAddress));
if (this.NodeJoined != null)
{
NodeJoined(this, macAddress);
}
}
else
{
Debug.WriteLine(string.Format("THE NODE {0} DOESN'T RECEIVE THE JOIN ACCEPT RESPONSE", macAddress));
}
this.PendingNodes.Remove(info);
return(result);
}
public async Task Receive_start_query()
{
/* Given */
_documentExecuter.ExecuteAsync(null, null, null, null, null).ReturnsForAnyArgs(
new ExecutionResult());
var expected = new OperationMessage
{
Type = MessageType.GQL_START,
Id = "1",
Payload = JObject.FromObject(new OperationMessagePayload
{
Query = @"{
human() {
name
height
}
}"
})
};
_transportReader.AddMessageToRead(expected);
await _transportReader.Complete();
/* When */
await _server.OnConnect();
/* Then */
Assert.Empty(_server.Subscriptions);
Assert.Contains(_transportWriter.WrittenMessages,
message => message.Type == MessageType.GQL_DATA);
Assert.Contains(_transportWriter.WrittenMessages,
message => message.Type == MessageType.GQL_COMPLETE);
}
public void Writes_OperationMessage_Nulls(IGraphQLTextSerializer serializer)
{
var message = new OperationMessage();
var actual = serializer.Serialize(message);
var expected = @"{}";
actual.ShouldBeCrossPlatJson(expected);
}
void StartOperation(OperationMessage message, IServiceProvider serviceProvider)
{
var tokenSource = new CancellationTokenSource();
var serviceScope = serviceProvider.CreateScope();
_activeGraphqlOperations.Add(message.Id, new OperationContext(message.Id, serviceScope, tokenSource));
ExecuteOperationAsync(message.Id, message.Payload.ToObject <GraphQlRequest>(), serviceScope.ServiceProvider, tokenSource.Token);
}
public MessageHandlingContext(IServerOperations server, OperationMessage message)
{
_server = server;
Reader = server.TransportReader;
Writer = server.TransportWriter;
Subscriptions = server.Subscriptions;
Message = message;
}
public static OperationMessage PercentageDimmer(this Dimmable dimmable, float percentage, byte seconds = 0)
{
byte value = (byte)(percentage * 100);
ushort destinationAddress = (ushort)(dimmable.Connector == null ? 0 : dimmable.Connector.Node.Address);
return(OperationMessage.DimmerWrite((ushort)dimmable.Id, value, seconds, destinationAddress));
}
/// <inheritdoc />
public async Task <IGraphQLSubscriptionOperation <T> > ExecuteOperation <T>(params GraphQLQueryArgument[] arguments) where T : class
{
if (!IsConnected)
{
throw new InvalidOperationException("Websocket is not connected");
}
if (!IsInitilized)
{
throw new InvalidOperationException("GraphQLSubscriptionClient is not initilized");
}
// Get operationId
long operationId;
lock (_locker)
{
operationId = _operationCounter++;
}
// Get query
var selectionSet = FieldBuilder.GenerateSelectionSet(typeof(T));
var query = QueryGenerator.GenerateQuery(GraphQLOperationType.Subscription, selectionSet, arguments);
// Generate OperationMessage for starting the operation
var message = new OperationMessage
{
Id = operationId.ToString(),
Type = MessageType.GQL_START,
Payload = JsonConvert.DeserializeObject(query)
};
// Generate stop message
var stopMessage = new OperationMessage
{
Id = operationId.ToString(),
Type = MessageType.GQL_STOP
};
// Create GraphQLOperationSource
var operationSource = new GraphQLOperationSource(() =>
{
// Generate stop
return(SendOperationMessage(stopMessage));
});
// Create IGraphQLSubscriptionOperation
var subscription = new GraphQLSubscriptionOperation <T>(operationSource, selectionSet, Deserialization);
// Add to list
_operations.Add(operationId.ToString(), operationSource);
// Send subscribe message
await SendOperationMessage(message).ConfigureAwait(false);
// Return the subscription
return(subscription);
}
private void executerCallback(OperationMessage message)
{
if (message.Type == OperationType.GraphqlError || message.Type == OperationType.GraphqlComplete)
{
CancelOperation(message.Id);
}
OnNewOperationMessage(message);
}
public static void Main()
{
try
{
// Read the 'MathService_Input_cs.wsdl' file.
ServiceDescription myDescription =
ServiceDescription.Read("MathService_Input_cs.wsdl");
PortTypeCollection myPortTypeCollection = myDescription.PortTypes;
// Get the 'OperationCollection' for 'SOAP' protocol.
OperationCollection myOperationCollection =
myPortTypeCollection[0].Operations;
Operation myOperation = new Operation();
myOperation.Name = "Add";
OperationMessage myOperationMessageInput =
(OperationMessage) new OperationInput();
myOperationMessageInput.Message = new XmlQualifiedName
("AddSoapIn", myDescription.TargetNamespace);
OperationMessage myOperationMessageOutput =
(OperationMessage) new OperationOutput();
myOperationMessageOutput.Message = new XmlQualifiedName(
"AddSoapOut", myDescription.TargetNamespace);
myOperation.Messages.Add(myOperationMessageInput);
myOperation.Messages.Add(myOperationMessageOutput);
myOperationCollection.Add(myOperation);
if (myOperationCollection.Contains(myOperation) == true)
{
Console.WriteLine("The index of the added 'myOperation' " +
"operation is : " +
myOperationCollection.IndexOf(myOperation));
}
myOperationCollection.Remove(myOperation);
// Insert the 'myOpearation' operation at the index '0'.
myOperationCollection.Insert(0, myOperation);
Console.WriteLine("The operation at index '0' is : " +
myOperationCollection[0].Name);
Operation[] myOperationArray = new Operation[
myOperationCollection.Count];
myOperationCollection.CopyTo(myOperationArray, 0);
Console.WriteLine("The operation(s) in the collection are :");
for (int i = 0; i < myOperationCollection.Count; i++)
{
Console.WriteLine(" " + myOperationArray[i].Name);
}
myDescription.Write("MathService_New_cs.wsdl");
}
catch (Exception e)
{
Console.WriteLine("Exception caught!!!");
Console.WriteLine("Source : " + e.Source);
Console.WriteLine("Message : " + e.Message);
}
}
private async void button3_Click(object sender, EventArgs e)
{
var userMod = CommunicationManager.Instance.FindModule <UserModule>();
Debug.WriteLine("Dimmer at " + dimmerValue);
await userMod.SendMessage(OperationMessage.DimmerWrite(1, dimmerValue, 0, 0x02));
dimmerValue = (byte)((dimmerValue + 10) % 130);
}
/// <summary>
/// Generate the a list item for a <see cref="OperationMessage" />.
/// </summary>
/// <param name="message">The <see cref="OperationMessage" /> instance.</param>
/// <param name="useTwoLineMode">If the two line mode should be used.</param>
/// <returns>The generated HTML content which represent as a HTML list item.</returns>
private IHtmlContent GenerateNormalItem(OperationMessage message, bool useTwoLineMode)
{
var tag = new TagBuilder("li");
tag.AddCssClass("list-group-item");
tag.AddCssClass(LevelClassMapper.MapLevel(message.Level, MessageListStyle.List));
tag.InnerHtml.AppendHtml(GenerateMessageContent(message, useTwoLineMode));
return(tag);
}
private int WriteOperationMessage(OperationMessage message, PipeWriter output)
{
var json = JsonConvert.SerializeObject(message, Formatting.None, _settings);
json += '\n';
var count = Encoding.UTF8.GetByteCount(json);
var memory = output.GetMemory(sizeHint: count);
return(Encoding.UTF8.GetBytes(json, memory.Span));
}
private OperationMessageContext CreateMessage(string type, object payload)
{
var op = new OperationMessage
{
Id = Guid.NewGuid().ToString(),
Type = type,
Payload = payload != null?JObject.FromObject(payload) : null
};
return(new OperationMessageContext(_connection, op));
}
private async Task <bool> SendJoinRequestResponse(ushort destinationAddress)
{
byte[] RSAKey = new byte[16];
Random r = new Random();
r.NextBytes(RSAKey);
OperationMessage joinResponse = OperationMessage.JoinRequestResponse(RSAKey, destinationAddress);
return(await this.SendMessage(joinResponse));
}
private OperationMessageContext CreateMessage(string type, GraphQLQuery payload)
{
var op = new OperationMessage
{
Id = Guid.NewGuid().ToString(),
Type = type,
Payload = payload
};
return(new OperationMessageContext(_connection, op));
}
public override bool RunMethod(OperationMessage message)
{
var operation = message.Operation;
if (operation.PlayerGameItemId == itemHolder.PlayerGameItem.Id)
{
//It's my message
operation.Execute(jsComponent);
}
return(true);
}
public SubscriptionHandle(OperationMessage op,
IObservable <object> stream,
IJsonMessageWriter messageWriter,
IDocumentWriter documentWriter)
{
Op = op;
Stream = stream;
_messageWriter = messageWriter;
_documentWriter = documentWriter;
Unsubscribe = stream.SubscribeAsync(OnNext, OnError, OnCompleted);
}
private async Task HandleModifyOperationMessage(WebSocketClient client, OperationMessage modifyOperationMessage)
{
using (await Lock.LockAsync())
{
var modifiedOperation = await DbUtils.ModifyOperation(client, modifyOperationMessage.GetOperation());
Broadcast(client.User.TeamId, new WebSocketServerMessage()
{
ModifyOperationMessage = new OperationMessage(modifiedOperation)
});
}
}
void WriteBody(XmlTextWriter xtw, Operation oper, OperationMessage opm, SoapBodyBinding sbb, SoapBindingStyle style)
{
Message msg = descriptions.GetMessage(opm.Message);
if (msg.Parts.Count > 0 && msg.Parts[0].Name == "parameters")
{
MessagePart part = msg.Parts[0];
if (part.Element == XmlQualifiedName.Empty)
{
WriteTypeSample(xtw, part.Type);
}
else
{
WriteRootElementSample(xtw, part.Element);
}
}
else
{
string elemName = oper.Name;
string ns = "";
if (opm is OperationOutput)
{
elemName += "Response";
}
if (style == SoapBindingStyle.Rpc)
{
xtw.WriteStartElement(elemName, sbb.Namespace);
ns = sbb.Namespace;
}
foreach (MessagePart part in msg.Parts)
{
if (part.Element == XmlQualifiedName.Empty)
{
XmlSchemaElement elem = new XmlSchemaElement();
elem.SchemaTypeName = part.Type;
elem.Name = part.Name;
WriteElementSample(xtw, ns, elem);
}
else
{
WriteRootElementSample(xtw, part.Element);
}
}
if (style == SoapBindingStyle.Rpc)
{
xtw.WriteEndElement();
}
}
WriteQueuedTypeSamples(xtw);
}
/// <summary>
/// Compare two messages in operations (with same name)
/// </summary>
/// <remarks></remarks>
private bool MatchOperationMessages(OperationMessage x, OperationMessage y)
{
if (x == null && y == null)
{
return(true);
}
else if (x == null || y == null)
{
return(false);
}
return(MatchXmlQualifiedNames(x.Message, y.Message));
}
public void SendOperationMessage(OperationMessage operationMessage)
{
switch (operationMessage.Type)
{
case OperationType.GraphqlStart:
StartOperation(operationMessage, _provider);
break;
case OperationType.GraphqlStop:
CancelOperation(operationMessage.Id);
break;
}
}
internal async ValueTask ReceiveMessageAsync(
OperationMessage message,
CancellationToken cancellationToken)
{
if (!_disposed)
{
try
{
await _channel.Writer.WriteAsync(message, cancellationToken).ConfigureAwait(false);
}
catch (ChannelClosedException) { }
}
}
private int WriteOperationMessage(OperationMessage message, PipeWriter output)
{
var jsonBytes = JsonSerializer.SerializeToUtf8Bytes(message, _messageSerializerOptions);
byte[] messageBytes = new byte[jsonBytes.Length + 1];
jsonBytes.CopyTo(messageBytes, 0);
_separatorBytes.CopyTo(messageBytes, jsonBytes.Length);
var memory = output.GetMemory(sizeHint: messageBytes.Length);
messageBytes.CopyTo(memory);
return(messageBytes.Length);
}
public void Identify(bool resetCounter = true)
{
this.ConnectionState = ConnectionStates.Identifying;
this.SendInternalMessage(OperationMessage.PingRequest());
if (resetCounter)
{
this.retriesCount = 0;
}
identifyTimeoutTimer.Start();
}
void CheckOperationMessage(OperationMessage opmsg, string msg, Type type, string action)
{
Assert.AreEqual(type, opmsg.GetType(), "#com1");
Assert.AreEqual(msg, opmsg.Message.ToString(), "#com2");
Assert.AreEqual(0, opmsg.Extensions.Count, "#com3");
Assert.AreEqual(1, opmsg.ExtensibleAttributes.Length, "#com4");
Assert.IsNull(opmsg.Name, "#com5");
XmlAttribute attr = opmsg.ExtensibleAttributes [0];
Assert.AreEqual("Action", attr.LocalName, "#ca1");
Assert.AreEqual("http://www.w3.org/2006/05/addressing/wsdl", attr.NamespaceURI, "#ca2");
Assert.AreEqual(action, attr.Value, "#ca3");
}
/// <summary>
/// Add a new message into the message collection.
/// </summary>
/// <param name="collection">The collection of messages to be adding the new message.</param>
/// <param name="level">The level of the new message.</param>
/// <param name="title">The title of the new message.</param>
/// <param name="description">The detailed description of the new message.</param>
/// <returns>The newly added <see cref="OperationMessage" /> object.</returns>
/// <exception cref="ArgumentNullException"><paramref name="collection" /> is <c>null</c>.</exception>
public static OperationMessage Add([NotNull] this ICollection<OperationMessage> collection,
OperationMessageLevel level, [CanBeNull] [LocalizationRequired] string title,
[CanBeNull] [LocalizationRequired] string description = null)
{
if (collection == null)
{
throw new ArgumentNullException(nameof(collection));
}
var item = new OperationMessage(level, title, description);
collection.Add(item);
return item;
}
/// <summary>
/// Generate the HTML content for a <see cref="OperationMessage" />.
/// </summary>
/// <param name="message">The <see cref="OperationMessage" /> instance.</param>
/// <param name="useTwoLineMode">If the two line mode should be used.</param>
/// <returns>The generated HTML content.</returns>
private static IHtmlContent GenerateMessageContent(OperationMessage message, bool useTwoLineMode)
{
var result = new DefaultTagHelperContent();
// Title
result.AppendHtml(GenerateTitle(message.Title));
// If description exists, add it
if (!string.IsNullOrEmpty(message.Description))
{
// Add a newline for two line mode.
if (useTwoLineMode)
{
// TODO: Consider a better way
result.Append("<br />");
}
result.AppendHtml(GenerateDescrption(message.Description));
}
return result;
}
/// <summary>
/// Generate the a list item for a <see cref="OperationMessage" />.
/// </summary>
/// <param name="message">The <see cref="OperationMessage" /> instance.</param>
/// <param name="useTwoLineMode">If the two line mode should be used.</param>
/// <returns>The generated HTML content which represent as a HTML list item.</returns>
private IHtmlContent GenerateNormalItem(OperationMessage message, bool useTwoLineMode)
{
var tag = new TagBuilder("li");
tag.AddCssClass("list-group-item");
tag.AddCssClass(LevelClassMapper.MapLevel(message.Level, MessageListStyle.List));
tag.InnerHtml.AppendHtml(GenerateMessageContent(message, useTwoLineMode));
return tag;
}
/// <summary>
/// Generate the a alert dialog for a <see cref="OperationMessage" />.
/// </summary>
/// <param name="message">The <see cref="OperationMessage" /> instance.</param>
/// <param name="isClosable">If the alert dialog is closable.</param>
/// <param name="useTwoLineMode">If the two line mode should be used.</param>
/// <returns>The generated HTML content which represent as a HTML alert dialog.</returns>
private IHtmlContent GenerateAlertItem(OperationMessage message, bool isClosable, bool useTwoLineMode)
{
// Real style
var listStyle = isClosable ? MessageListStyle.AlertDialogClosable : MessageListStyle.AlertDialog;
var tag = new TagBuilder("div");
tag.AddCssClass("alert");
tag.AddCssClass(LevelClassMapper.MapLevel(message.Level, listStyle));
// Closable handling
if (isClosable)
{
tag.AddCssClass("alert-dismissible");
}
tag.MergeAttribute("role", "alert");
var content = new DefaultTagHelperContent();
if (isClosable)
{
// Close button
// TODO: Localization the "label" text
content.AppendHtml(
"<button type =\"button\" class=\"close\" data-dismiss=\"alert\" aria-label=\"Close\"><span aria-hidden=\"true\">×</span></button>");
}
content.AppendHtml(GenerateMessageContent(message, useTwoLineMode));
// Internal content
tag.InnerHtml.AppendHtml(content);
return tag;
}
// Methods
public int Add(OperationMessage operationMessage) {}
public void Insert(int index, OperationMessage operationMessage) {}
public int IndexOf(OperationMessage operationMessage) {}
public bool Contains(OperationMessage operationMessage) {}
public void Remove(OperationMessage operationMessage) {}
public void CopyTo(OperationMessage[] array, int index) {}
