//WhatsApp Node - where '551199991111' is the user identifier
  "551199991111@wa.gw.msging.net"

  //Blip Chat Node - where '0mn.io' is the Blip Chat domain identifier
  "df83582a-87b9-45b4-9e76-d4a4a743e2a6@0mn.io"

  //Messenger Node
  "213681763812763812@messenger.gw.msging.net"

  var message = new Message
  {
      Id = "65603604-fe19-479c-c885-3195b196fe8e",
      From = "551199991111@0mn.io/182310923192",
      To = "mycontact@msging.net",
      Content = new PlainText
      {
          Text = "Hello World"
      }
  };

var message = {
  id: "65603604-fe19-479c-c885-3195b196fe8e",
  from: "551199991111@0mn.io/182310923192",
  to: "mycontact@msging.net",
  type: "text/plain",
  content: "Hello World"
}

message = Message(
  id="65603604-fe19-479c-c885-3195b196fe8e",
  from_n="551199991111@0mn.io/182310923192",
  to="mycontact@msging.net",
  type_n="text/plain",
  content="Hello World"
)

{
  "id": "65603604-fe19-479c-c885-3195b196fe8e",
  "from": "551199991111@0mn.io/182310923192",
  "to": "mycontact@msging.net",
  "type": "text/plain",
  "content": "Hello World"
}

//reply a received message sample
public class PlainTextMessageReceiver : IMessageReceiver
{
    private readonly ISender _sender;
    private readonly Settings _settings;

    public PlainTextMessageReceiver(ISender sender, Settings settings)
    {
        _sender = sender;
        _settings = settings;
    }

    public async Task ReceiveAsync(Message message, CancellationToken cancellationToken)
    {
        // Write the received message to the console
        Console.WriteLine(message.Content.ToString());
        // Responds to the received message
        _sender.SendMessageAsync("Hi. I just received your message!", message.From, cancellationToken);
    }

}

//send a message after connection has been stablished sample
client.connect()
    .then(function(session) {
        // After connection is possible send messages
        var msg = { type: 'text/plain', content: 'Hello, world', to: '553199990000@0mn.io' };
        client.sendMessage(msg);
    });

message = Message(
    id='1',
    type_n='text/plain',
    content='Hello, world',
    to='553199990000@0mn.io'
)

await client.connect_async()

client.send_message(message)

POST https://{{contract.id}}.http.msging.net/messages HTTP/1.1
Content-Type: application/json
Authorization: Key bWVzc2FnaW5naHViQHRha2VuZXQuY29tLmJyOjEyMzQ=
Content-Length: 131

{
    "id": "123e4567-e89b-12d3-a456-426655440000",
    "to": "551100001111@0mn.io",
    "type": "text/plain",
    "content": "Hello, how can I help you?"
}

//A `IMessageReceiver` can be defined as follows
public class PlainTextMessageReceiver : IMessageReceiver
{
    private readonly ISender _sender;
    private readonly Settings _settings;

    public PlainTextMessageReceiver(ISender sender, Settings settings)
    {
        _sender = sender;
        _settings = settings;
    }

    public async Task ReceiveAsync(Message message, CancellationToken cancellationToken)
    {
        // Write the received message to the console
        Console.WriteLine(message.Content.ToString());
    }

}

//add simple message receiver example
client.addMessageReceiver(true, (message) => {
  // Process received message

});

//Example of message receiver with filter of originator
client.addMessageReceiver((message) => { message.from === "553199990000@0mn.io" },
(message) => {
  // Process received message
});

//Each registration of receivers return a `handler` that can be used to cancell the registration:
var removeJsonReceiver = client.addMessageReceiver("application/json", handleJson);
// ...
removeJsonReceiver();

def message_processor(message: Message) -> None:
    # Process received message
    pass

# Add simple message receiver example
client.add_message_receiver(Receiver(True, message_processor))

# Example of message receiver with filter of originator
client.add_message_receiver(Receiver(lambda m: m.from == '553199990000@0mn.io', message_processor))

# Each registration of receivers return a `handler` that can be used to cancell the registration:
remove_json_receiver = client.add_message_receiver(Receiver(lambda m: m.type_n == 'application/json', lambda m: print(m)))
# ...
remove_json_receiver()

POST https://your.endpoint/messages HTTP/1.1
Content-Type: application/json

{
  "id": "99cf454e-f25d-4ebd-831f-e48a1c612cd4",
  "from": "551100001111@0mn.io/4ac58r6e3",
  "to": "blipmessaginghubapp@msging.net",
  "type": "text/plain",
  "content": "Help"
}

var notification = new Notification
{
    Id = "65603604-fe19-479c-c885-3195b196fe8e",
    From = "551199991111@0mn.io/182310923192",
    To = "mycontact@msging.net",
    Event = Event.Received
};

notification = Notification(
  id='65603604-fe19-479c-c885-3195b196fe8e',
  from_n='551199991111@0mn.io/182310923192',
  to='mycontact@msging.net',
  event='received'
)

var notification = {
  id: "65603604-fe19-479c-c885-3195b196fe8e",
  from: "551199991111@0mn.io/182310923192",
  to: "mycontact@msging.net",
  event: "received"
}

POST https://{{contract_id}}.http.msging.net/notifications HTTP/1.1
Content-Type: application/json

{
  "id": "65603604-fe19-479c-c885-3195b196fe8e",
  "from": "551199991111@0mn.io/182310923192",
  "to": "mycontact@msging.net",
  "event": "received"
}

var notification = new Notification
{
    Id = "65603604-fe19-479c-c885-3195b196fe8e",
    From = "551199991111@0mn.io/182310923192",
    To = "mycontact@msging.net",
    Event = Event.Failed,
    Reason = new Reason
    {
        Code = 42,
        Description = "Destination not found"
    }
};

var notification = {
  id: "65603604-fe19-479c-c885-3195b196fe8e",
  from: "postmaster@msging.net/server1",
  to: "mycontact@msging.net",
  event: "failed",
  reason: {
    code: 42,
    description: "Destination not found"
  }
}

notification = Notification(
  id='65603604-fe19-479c-c885-3195b196fe8e',
  from_n='postmaster@msging.net/server1',
  to='mycontact@msging.net',
  event='failed',
  reason= Reason(42, 'Destination not found')
)

# or with .from_json

notification = Notification.from_json(
  {
    'id': '65603604-fe19-479c-c885-3195b196fe8e',
    'from': 'postmaster@msging.net/server1',
    'to': 'mycontact@msging.net',
    'event': 'failed',
    'reason': {
      'code': 42,
      'description': 'Destination not found'
    }
  }
)

POST https://{{contract_id}}.http.msging.net/notifications HTTP/1.1
Content-Type: application/json

{
  "id": "65603604-fe19-479c-c885-3195b196fe8e",
  "from": "postmaster@msging.net/server1",
  "to": "mycontact@msging.net",
  "event": "failed",
  "reason": {
    "code": 42,
    "description": "Destination not found"
  }
}

client.connect()
    .then((session) => {
        // Sending "received" notification
        var notification = {
            id: 'ef16284d-09b2-4d91-8220-74008f3a5788',
            to: '553199990000@0mn.io',
            event: Lime.NotificationEvent.RECEIVED
        };
        client.sendNotification(notification);
    });

// Using await keyword
let session = await client.connect();
let notification = {
    id: 'ef16284d-09b2-4d91-8220-74008f3a5788',
    to: '553199990000@0mn.io',
    event: Lime.NotificationEvent.RECEIVED
};

client.sendNotification(notification);

await client.connect_async()

# Sending "received" notification
notification = Notification.from_json(
    {
        'id': 'ef16284d-09b2-4d91-8220-74008f3a5788',
        'to': '553199990000@0mn.io',
        'event': lime_python.NotificationEvent.RECEIVED
    }
)
client.send_notification(notification)

public class PlainTextMessageReceiver : IMessageReceiver
{
    private readonly ISender _sender;
    private readonly Settings _settings;

    public PlainTextMessageReceiver(ISender sender, Settings settings)
    {
        _sender = sender;
        _settings = settings;
    }

    public async Task ReceiveAsync(Message message, CancellationToken cancellationToken)
    {
         var notification = new Notification
            {
                Id = message.Id,
                To = message.From,
                Event = Event.Consumed
            };

        await _sender.SendNotificationAsync(notification, cancellationToken);
    }
}

POST https://{{contract_id}}.http.msging.net/notifications HTTP/1.1
Content-Type: application/json
Authorization: Key {key}
Content-Length: 131

{
    "id": "99cf454e-f25d-4ebd-831f-e48a1c612cd4",
    "from": "551100001111@0mn.io/4ac58r6e3",
    "event": "consumed"
}

client.addNotificationReceiver("received", function(notification) {
  // Process received notifications
});

// Using expression lambda
client.addNotificationReceiver(() => true, function(message) {
  // Process received notifications
});

def notification_processor(notification: Notification) -> None:
    # Process received notifications
    pass

client.add_notification_receiver(Receiver(lambda n: n.event == 'received', notification_processor))

public class ConsumedNotificationReceiver : INotificationReceiver
{
    public async Task ReceiveAsync(Notification notification, CancellationToken cancellationToken)
    {
        // Write the received notification to the console
        Console.WriteLine(notification.ToString());
    }
}

POST https://your.endpoint/notifications HTTP/1.1
Content-Type: application/json

{
  "id": "123e4567-e89b-12d3-a456-426655440000",
  "from": "551100001111@0mn.io/4ac58r6e3",
  "to": "blipmessaginghubapp@msging.net/7a8fr233x",
  "event": "received"
}

var command = new Command()
{
    Id = EnvelopeId.NewId(),
    To = "postmaster@broadcast.msging.net",
    Method = CommandMethod.Set,
    Uri = new LimeUri("/lists"),
    Resource = new JsonDocument(DistributionList.MediaType)
    {
        {"identity", "list@broadcast.msging.net"}
    }
};

var command = {
  id:  "1",
  to: "postmaster@broadcast.msging.net",
  method: "set",
  uri: "/lists",
  type: "application/vnd.iris.distribution-list+json",
  resource: {
    identity:  "list@broadcast.msging.net"
  }
} 

command = Command(
  id='1',
  to='postmaster@broadcast.msging.net',
  method='set',
  uri='/lists',
  type_n='application/vnd.iris.distribution-list+json',
  resource={
    'identity':  'list@broadcast.msging.net'
  }
) 

# Or using the .from_json static method

command = Command.from_json(
  {
    'id':  '1',
    'to': 'postmaster@broadcast.msging.net',
    'method': 'set',
    'uri': '/lists',
    'type': 'application/vnd.iris.distribution-list+json',
    'resource': {
      'identity':  'list@broadcast.msging.net'
    }
  }
)

POST https://{{contract_id}}.http.msging.net/commands HTTP/1.1
Content-Type: application/json
Authorization: Key bWVzc2FnaW5naHViQHRha2VuZXQuY29tLmJyOjEyMzQ=
Content-Length: 131

{
  "id":  "1",
  "to": "postmaster@broadcast.msging.net",
  "method": "set",
  "uri": "/lists",
  "type": "application/vnd.iris.distribution-list+json",
  "resource": {
    "identity":  "list@broadcast.msging.net"
  }
} 

HTTP/1.1 200 OK
Content-Type: application/json

{
  "id": "1",
  "from": "postmaster@broadcast.msging.net/#hmgirismsging2",
  "to": "my-contact@msging.net/default",
  "method": "set",
  "status": "success"
} 

HTTP/1.1 200 OK
Content-Type: application/json

{
  "id": "1",
  "from": "postmaster@broadcast.msging.net/#hmgirismsging2",
  "to": "my-contact@msging.net/default",
  "method": "set",
  "status": "failure",
  "reason": {
   "code": 60,
   "description": "Invalid list identifier"
  }
} 

// For this case, the command response is received on a synchronous way.

public class PlainTextMessageReceiver : IMessageReceiver
{
    private readonly ISender _sender;
    private readonly Settings _settings;

    public PlainTextMessageReceiver(ISender sender, Settings settings)
    {
        _sender = sender;
        _settings = settings;
    }

    public async Task ReceiveAsync(Message message, CancellationToken cancellationToken)
    {
        var command = new Command {
            Id = 1,
            Method = CommandMethod.Get,
            Uri = new LimeUri("/account")
        };

        var response = await _sender.ProcessCommandAsync(command, cancellationToken);
    }
}

var pingCommand = {
    id: Lime.Guid(),
    uri: '/ping',
    method: 'get'
};

messagingHubClient
    .sendCommand(pingCommand)
    .then(function (commandResponse) {
        utils.logLimeCommand(pingCommand, 'Ping sent');
        utils.logLimeCommand(commandResponse, 'Ping response');
    })
    .catch(function (err) {
        utils.logMessage('An error occurred: ' + err);
    });

command = Command.from_json(
    {
        'id': '1',
        'method': 'get',
        'uri': '/ping'
    }
)

response = await client.process_command_async(command)
# or sync
# response = client.process_command(command)

POST https://{{contract_id}}.http.msging.net/commands HTTP/1.1
Authorization: Key bWVzc2FnaW5naHViQHRha2VuZXQuY29tLmJyOjEyMzQ=
Content-Type: application/json
Content-Length: 393

{  
    "id":"2",
    "to":"postmaster@scheduler.msging.net",
    "method":"set",
    "uri":"/schedules",
    "type":"application/vnd.iris.schedule+json",
    "resource":{  
    "message":{  
        "id":"ad19adf8-f5ec-4fff-8aeb-2e7ebe9f7a67",
        "to":"553100001111@0mn.io",
        "type":"text/plain",
        "content":"Scheduled Message"
    },
    "when":"2016-07-25T17:50:00.000Z"
    }
}

Note: For this sample, bWVzc2FnaW5naHViQHRha2VuZXQuY29tLmJyOjEyMzQ is a valid Key.

POST https://{{contract.id}}.http.msging.net/messages HTTP/1.1
Content-Type: application/json
Authorization: Key bWVzc2FnaW5naHViQHRha2VuZXQuY29tLmJyOjEyMzQ=
Content-Length: 131

{
    "id": "123e4567-e89b-12d3-a456-426655440000",
    "to": "551100001111@0mn.io",
    "type": "text/plain",
    "content": "Hello, how can I help you?"
}

//Check an example of how to set your application.json file:
{
  "identifier": "xpto",
  "accessKey": "cXkzT1Rp",
  "messageReceivers": [
    {
      "type": "PlainTextMessageReceiver",
      "mediaType": "text/plain"
    }
  ]
}

// Create a client instance passing the identifier and accessKey of your chatbot 
var client = new ClientBuilder()
    .withIdentifier(identifier)
    .withAccessKey(accessKey)
    .withTransportFactory(() => new WebSocketTransport())
    .build();

// Register a receiver for messages of 'text/plain' type
client.addMessageReceiver('text/plain', function(message) {
  // TODO: Proccess the received message
});

// Register a receiver to any notification
client.addNotificationReceiver(true, function(notification) {
  // TODO: Proccess the received notification
});

// Connect with server asynchronously
// Connection will occurr via websocket on 8081 port.
client.connect() // This method return a 'promise'.
    .then(function(session) { 
        // Connection success. Now is possible send and receive envelopes from server. */ 
        })  
    .catch(function(err) { /* Connection failed. */ }); 

dotnet new -i "Take.Blip.Client.Templates::*"

mkdir MyBot
cd MyBot
dotnet new blip-console

{
  "identifier": "your-identifier",
  "accessKey": "your-access-key",

  // other stuffs
}

{
  "identifier": "xpto",
  "accessKey": "cXkzT1Rp",
  "messageReceivers": [
    {
      "type": "PlainTextMessageReceiver",
      "mediaType": "text/plain"
    }
  ]
}

public class PlainTextMessageReceiver : IMessageReceiver
{
    public async Task ReceiveAsync(Message message, CancellationToken cancellationToken)
    {
        // Write the received message to the console
        Console.WriteLine(message.Content.ToString());
    }
}

public class ConsumedNotificationReceiver : INotificationReceiver
{
    public async Task ReceiveAsync(Notification notification, CancellationToken cancellationToken)
    {
        // Write the received notification to the console
        Console.WriteLine(notification.ToString());
    }
}

{
  "identifier": "xpto",
  "accessKey": "cXkzT1Rp",
  "messageReceivers": [
    {
      "type": "PlainTextMessageReceiver",
      "mediaType": "text/plain"
    }
  ],
  "notificationReceivers": [
    {
      "type": "ConsumedNotificationReceiver",
    }
  ]
}

public class PlainTextMessageReceiver : IMessageReceiver
{
    private readonly ISender _sender;

    public PlainTextMessageReceiver(IMessagingHubSender sender)
    {
        _sender = sender;
    }

    public async Task ReceiveAsync(Message message, CancellationToken cancellationToken)
    {
        // Write the received message to the console
        Console.WriteLine(message.Content.ToString());
        // Responds to the received message
        _sender.SendMessageAsync("Hi. I just received your message!", message.From, cancellationToken);
    }
}

using System.Threading;
using System.Threading.Tasks;
using Lime.Protocol;
using Take.Blip.Client;
using Take.Blip.Client.Receivers;
using Take.Blip.Client.Extensions.EventTracker;

namespace Extensions
{
    public class PlainTextMessageReceiver : IMessageReceiver
    {
        private readonly IEventTrackExtension _eventTrackExtension;

        public PlainTextMessageReceiver(IEventTrackExtension eventTrackExtension)
        {
            _eventTrackExtension = eventTrackExtension;
        }

        public async Task ReceiveAsync(Message message, CancellationToken cancellationToken)
        {
            await _eventTrackExtension.AddAsync("payments", "success-order");
        }
    }
}

// For this case, the command response is received on a synchronous way.

public class PlainTextMessageReceiver : IMessageReceiver
{
    private readonly ISender _sender;
    private readonly Settings _settings;

    public PlainTextMessageReceiver(ISender sender, Settings settings)
    {
        _sender = sender;
        _settings = settings;
    }

    public async Task ReceiveAsync(Message message, CancellationToken cancellationToken)
    {
        var command = new Command {
            Id = 1,
            Method = CommandMethod.Set,
            Uri = new LimeUri("/event-track"),
            Resource = new EventTrack
            {
                Category = "payments",
                Action = "success-order",
            }
        };

        var response = await _sender.ProcessCommandAsync(command, cancellationToken);
    }
}

mkdir MyBot
cd MyBot
npm init

npm install --save blip-sdk lime-transport-websocket

import * as BlipSdk from 'blip-sdk';
import * as WebSocketTransport from 'lime-transport-websocket'

// Put your identifier and access key here
let IDENTIFIER = '';
let ACCESS_KEY = '';

// Create a client instance passing the identifier and accessKey of your chatbot
let client = new BlipSdk.ClientBuilder()
    .withIdentifier(IDENTIFIER)
    .withAccessKey(ACCESS_KEY)
    .withTransportFactory(() => new WebSocketTransport())
    .build();

// Connect with server asynchronously
// Connection will occurr via websocket on 8081 port.
client.connect() // This method return a 'promise'.
    .then(function(session) {
        // Connection success. Now is possible send and receive envelopes from server. */
        console.log('Application started. Press Ctrl + c to stop.')
    })
    .catch(function(err) { /* Connection failed. */ });

client.addMessageReceiver(true, function(message) {
  // Process received message
});

client.addMessageReceiver(function(message) { message.from === "553199990000@0mn.io" }, function(message) {
  // Process received message
});

var removeJsonReceiver = client.addMessageReceiver("application/json", handleJson);
// ...
removeJsonReceiver();

client.addNotificationReceiver("received", function(notification) {
  // Process received notifications
});

// Using lambda expression
client.addNotificationReceiver(() => true, function(notification) {
  // Process received notifications
});

client.connect()
    .then(function(session) {
        // After connection is possible send messages
        var msg = {
            type: "text/plain",
            content: "Hello, world",
            to: "553199990000@0mn.io"
        };
        client.sendMessage(msg);
    });

client.connect()
    .then(function(session) {
        // Sending "received" notification
        var notification = {
            id: "ef16284d-09b2-4d91-8220-74008f3a5788",
            to: "553199990000@0mn.io",
            event: Lime.NotificationEvent.RECEIVED
        };
        client.sendNotification(notification);
    });

let resource = { category: 'payments', action: 'success-order' };

client.sendCommand({
    id: Lime.Guid(),
    method: Lime.CommandMethod.SET,
    type: 'application/vnd.iris.eventTrack+json',
    uri: '/event-track',
    resource: resource
})

mkdir my-bot
cd my-bot

# if you use pipenv
pipenv --python 3.9

pipenv install blip-sdk lime-python lime-transport-websocket

# or with pip
pip install blip-sdk lime-python lime-transport-websocket

import asyncio

from lime_transport_websocket import WebSocketTransport
from blip_sdk import ClientBuilder


async def main_async() -> None:
    # Create a client instance passing the identifier and access key of your chatbot
    client = ClientBuilder() \
        .with_identifier(IDENTIFIER) \
        .with_access_key(ACCESS_KEY) \
        .with_transport_factory(lambda: WebSocketTransport()) \
        .build()

    # Connect with the server asynchronously
    # Connection will occurr via websocket on the 8081 port
    await client.connect_async()
    print('Application started. Press Ctrl + c to stop.')

loop = asyncio.get_event_loop()
loop.run_until_complete(main_async())
loop.run_forever()

from time import sleep
from lime_transport_websocket import WebSocketTransport
from blip_sdk import ClientBuilder


def main() -> None:
    # Create a client instance passing the identifier and access key of your chatbot
    client = ClientBuilder() \
        .with_identifier(IDENTIFIER) \
        .with_access_key(ACCESS_KEY) \
        .with_transport_factory(lambda: WebSocketTransport()) \
        .build()

    # Connect with the server asynchronously
    # Connection will occurr via websocket on the 8081 port
    client.connect()
    print('Application started. Press Ctrl + c to stop.')

main()

while True:
    sleep(1)

from blip_sdk import ClientBuilder, Receiver
# ...

client.add_message_receiver(Receiver(True, lambda m: print(m)))

from lime_python import Message
from blip_sdk import ClientBuilder, Receiver
# ...

def filter_originator(message: Message) -> bool:
    return message.from_n == '553199990000@0mn.io'

def message_processor(message: Message) -> None:
    # Process received message
    pass

client.add_message_receiver(Receiver(filter_originator, message_processor))

from lime_python import Message
from blip_sdk import ClientBuilder, Receiver
# ...

def json_filter(message: Message) -> bool:
    return message.type_n == 'application/json'

def message_processor(message: Message) -> None:
    # Process received message
    pass

remove_receiver = client.add_message_receiver(Receiver(json_filter, message_processor))

# ...
remove_receiver()

from lime_python import Notification, NotificationEvent
from blip_sdk import ClientBuilder, Receiver
# ...

def notifications_filter(notification: Notification) -> bool:
    return notification.event == NotificationEvent.RECEIVED

async def notification_processor_async(notification: Notification) -> None:
    # Process received notifications
    pass

client.add_notification_receiver(
    Receiver(
        notification_filter,
        notification_processor_async
    )
)

client.add_notification_receiver(
    Receiver(
        lambda n: n.event == NotificationEvent.CONSUMED,
        lambda m: print(m)
    )
)

import asyncio

from lime_python import Message
from blip_sdk import ClientBuilder
# ...

async def main_async() -> None:
    # ...
    await client.connect_async()

    msg = Message(
        'text/plain',
        'Hello, world!',
        to='553199990000@0mn.io'
    )
    client.send_message(message)

# ...

import asyncio

from lime_python import Notification, NotificationEvent
from blip_sdk import ClientBuilder
# ...

async def main_async() -> None:
    # ...
    await client.connect_async()

    notification = Notification(
        NotificationEvent.RECEIVED,
        to='553199990000@0mn.io'
    )
    client.send_notification(notification)

# ...

from lime_python import Command
from blip_sdk import ClientBuilder
# ...

resource = {
    'category': 'payments', 
    'action': 'success-order'
}

client.send_command(
    Command(
        CommandMethod.SET,
        '/event-track',
        'application/vnd.iris.eventTrack+json',
        resource
    )
)

from lime_python import Command
from blip_sdk import ClientBuilder
# ...

resource = {
    'category': 'payments', 
    'action': 'success-order'
}

# In order to use process command sync you can't have a event loop runnning
# This method should only be used in scripts where the connection where made synchronously
result = client.process_command(
    Command(
        CommandMethod.SET,
        '/event-track',
        'application/vnd.iris.eventTrack+json',
        resource
    )
)

print(result)

import asyncio

from lime_python import Notification, NotificationEvent
from blip_sdk import ClientBuilder
# ...

async def main_async() -> None:
    # ...
    await client.connect_async()

    resource = {
        'category': 'payments', 
        'action': 'success-order'
    }
    client.send_notification(notification)

    result = await client.process_command_async(
        Command(
            CommandMethod.SET,
            '/event-track',
            'application/vnd.iris.eventTrack+json',
            resource
       )
    )

# ...

{
  "id": "99cf454e-f25d-4ebd-831f-e48a1c612cd4",
  "from": "551100001111@0mn.io/4ac58r6e3",
  "to": "blipmessaginghubapp@msging.net",
  "type": "text/plain",
  "content": "Help"
}

POST https://{{contract.id}}.http.msging.net/messages HTTP/1.1
Content-Type: application/json
Authorization: Key bWVzc2FnaW5naHViQHRha2VuZXQuY29tLmJyOjEyMzQ=
Content-Length: 131

{
  "id": "123e4567-e89b-12d3-a456-426655440000",
  "to": "551100001111@0mn.io",
  "type": "text/plain",
  "content": "Hello, how can I help you?"
}

{
  "id": "123e4567-e89b-12d3-a456-426655440000",
  "from": "551100001111@0mn.io/4ac58r6e3",
  "to": "blipmessaginghubapp@msging.net/7a8fr233x",
  "event": "received"
}

POST https://{{contract_id}}.http.msging.net/notifications HTTP/1.1
Content-Type: application/json
Authorization: Key bWVzc2FnaW5naHViQHRha2VuZXQuY29tLmJyOjEyMzQ=
Content-Length: 131

{
  "id": "99cf454e-f25d-4ebd-831f-e48a1c612cd4",
  "from": "551100001111@0mn.io/4ac58r6e3",
  "event": "consumed"
}

POST https://{{contract_id}}.http.msging.net/commands HTTP/1.1
Content-Type: application/json
Authorization: Key {YOUR_TOKEN}

{  
  "id": "1",
  "to": "postmaster@scheduler.msging.net",
  "method": "set",
  "uri": "/schedules",
  "type": "application/vnd.iris.schedule+json",
  "resource": {  
    "message": {  
      "id": "ad19adf8-f5ec-4fff-8aeb-2e7ebe9f7a67",
      "to": "destination@0mn.io",
      "type": "text/plain",
      "content": "Scheduling test."
    },
    "when": "2016-07-25T17:50:00.000Z",
    "name": "New Schedule"
  }
}

HTTP/1.1 200 OK
Content-Type: application/json

{
  "method": "set",
  "status": "success",
  "id": "1",
  "from": "postmaster@scheduler.msging.net/#az-iris4",
  "to": "destination@0mn.io",
  "metadata": {
    "#command.uri": "lime://destination@0mn.io/schedules"
  }
}

If you want to see all content-types working, clone our SDK sample project:
github.com/takenet/blip-sdk-csharp/tree/master/src/Samples/MessageTypes

POST https://{{contract.id}}.http.msging.net/messages HTTP/1.1
Content-Type: application/json
Authorization: Key {YOUR_TOKEN}
{
  "id": "9dc08447-8b23-4bc2-8673-664dca202ee2",
  "from": "128271320123982@messenger.gw.msging.net",
  "to": "mybot@msging.net",
  "type": "text/plain",
  "content": "Hello",
  "metadata": {
      "messenger.mdi": "mid.$cAAAu_n30PEFiJQdYSlb8785KMO5E",
      "messenger.seq": "19062"
  }
}

HTTP/1.1 200 OK
Content-Type: application/json
{
  "id": "2dc05467-4b23-1bc2-8673-664dca202ee2",
  "from": "128271320123982@messenger.gw.msging.net",
  "to": "mybot@msging.net",
  "type": "text/plain",
  "content": "Get started",
  "metadata": {
      "messenger.ref": "website",
      "messenger.source": "SHORTLINK",
      "messenger.type": "OPEN_THREAD"
  }
}

using System.Threading;
using System.Threading.Tasks;
using Lime.Messaging.Contents;
using Lime.Protocol;
using Take.Blip.Client;

namespace MessageTypes
{
public class OptionChatStateMessageReceiver : IMessageReceiver
{
private readonly ISender _sender;
private readonly Settings _settings;

public OptionChatStateMessageReceiver(ISender sender)
{
    _sender = sender;
    _settings = settings;
}

public async Task ReceiveAsync(Message message, CancellationToken cancellationToken)
{
    var chatState = new ChatState
    {
        State = ChatStateEvent.Composing
    };
    await _sender.SendMessageAsync(chatState, message.From, cancellationToken);
}

}
}

client.sendMessage({
        id: Lime.Guid(),
        to:"104222@telegram.gw.msging.net",
        type:"application/vnd.lime.chatstate+json",
        content: {
            "state": "composing"
        }
    });

client.send_message(
    Message.from_json(
        {
            'to':'104222@telegram.gw.msging.net',
            'type':'application/vnd.lime.chatstate+json',
            'content': {
                'state': 'composing'
            }
        }
    )
)

POST https://{{contract.id}}.http.msging.net/messages HTTP/1.1
Content-Type: application/json
Authorization: Key {YOUR_TOKEN}

{
    "to":"104222@telegram.gw.msging.net",
    "type":"application/vnd.lime.chatstate+json",
    "content": {
        "state": "composing"
    }
}

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Lime.Messaging.Contents;
using Lime.Protocol;
using Take.Blip.Client;

public class OptionDocumentCollectionMessageReceiver : IMessageReceiver
{
private readonly ISender _sender;
private readonly Settings _settings;

public OptionDocumentCollectionMessageReceiver(ISender sender)
{
    _sender = sender;
    _settings = settings;
}

PlainText[] documents = new PlainText[]
{
    new PlainText
    {
        Text = "Text 1"
    },
    new PlainText
    {
        Text = "Text 2"
    },
    new PlainText
    {
        Text = "Text 3"
    }
};

public async Task ReceiveAsync(Message message, CancellationToken cancellationToken)
{
    var document = new DocumentCollection
    {
        ItemType = "text/plain",
        Items = documents
    };
    await _sender.SendMessageAsync(document, message.From, cancellationToken);
}
}

    client.sendMessage({
        id: Lime.Guid(),
        type: "application/vnd.lime.collection+json",
        to: "128271320123982@messenger.gw.msging.net",
        content: {
            itemType: "text/plain",
            items: [
                "Text 1",
                "Text 2",
                "Text 3"
            ]
        }
    });

client.send_message(
    Message.from_json(
        {
            'to': '553199990000@0mn.io',
            'type': 'application/vnd.lime.collection+json',
            'content': {
                'itemType': 'text/plain',
                'items': [
                    'Text 1',
                    'Text 2',
                    'Text 3'
                ]
            }   
        }
    )
)

POST https://{{contract.id}}.http.msging.net/messages HTTP/1.1
Content-Type: application/json
Authorization: Key {YOUR_TOKEN}

{
    "to": "553199990000@0mn.io",
    "type": "application/vnd.lime.collection+json",
    "content": {
        "itemType": "text/plain",
        "items": [
            "Text 1",
            "Text 2",
            "Text 3"
        ]
    }   
}

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Lime.Messaging.Contents;
using Lime.Protocol;
using Take.Blip.Client;

public class CollectionWithDiferentTypes : IMessageReceiver
{
private readonly ISender _sender;
private readonly Settings _settings;

public CollectionWithDiferentTypes(ISender sender)
{
    _sender = sender;
    _settings = settings;
}

DocumentContainer[] documents = new DocumentContainer[]
{
    new DocumentContainer{
        Value = new MediaLink
        {
            Uri = new Uri("http://www.petshoplovers.com/wp-content/uploads/2014/03/CUIDADOS-B%C3%81SICOS-PARA-CRIAR-COELHOS.jpg"),
            Text = "Welcome to our store!",
            Type = "image/jpeg"
        }
    },
    new DocumentContainer{
        Value = new Select
        {
            Text = "Choose what you need",
            Options = new SelectOption[]
            {
                new SelectOption
                {
                    Order = 1,
                    Text = "See our stock"
                },
                new SelectOption
                {
                    Order = 2,
                    Text = "Follow an order"
                }
            }

        }
    }
};

public async Task ReceiveAsync(Message message, CancellationToken cancellationToken)
{
    var document = new DocumentCollection
    {
        ItemType = "application/vnd.lime.container+json",
        Items = documents
    };
    await _sender.SendMessageAsync(document, message.From, cancellationToken);
}
}

client.sendMessage({
    id: Lime.Guid(),
    type: "application/vnd.lime.collection+json",
    to: "128271320123982@messenger.gw.msging.net",
    content: {
        itemType: "application/vnd.lime.container+json",
        items: [
            {
                type: "application/vnd.lime.media-link+json",
                value: {
                    text: "Welcome to our store!",
                    type: "image/jpeg",
                    uri: "http://www.petshoplovers.com/wp-content/uploads/2014/03/CUIDADOS-B%C3%81SICOS-PARA-CRIAR-COELHOS.jpg"
                }
            },
            {
                type: "application/vnd.lime.select+json",
                value: {
                    text: "Choose what you need",
                    options: [
                        {
                            order: 1,
                            text: "See our stock"
                        },
                        {
                            order: 2,
                            text: "Follow an order"
                        }
                    ]
                }
            }
        ]
    }
});

client.send_message(
    Message.from_json(
        {
            'to': '553199990000@0mn.io',
            'type': 'application/vnd.lime.collection+json',
            'content': {
            'itemType': 'application/vnd.lime.container+json',
            'items': [
                {
                    'type': 'application/vnd.lime.media-link+json',
                    'value': {
                        'text': 'Welcome to our store!',
                        'type': 'image/jpeg',
                        'uri': 'http://www.petshoplovers.com/wp-content/uploads/2014/03/CUIDADOS-B%C3%81SICOS-PARA-CRIAR-COELHOS.jpg'
                    }
                },
                {
                    'type': 'application/vnd.lime.select+json',
                    'value': {
                        'text': 'Choose what you need',
                        'options': [
                            {
                                'order': 1,
                                'text': 'See our stock'
                            },
                            {
                                'order': 2,
                                'text': 'Follow an order'
                            }
                        ]
                    }
                }
            ]
            }
        }
    )
)

POST https://{{contract.id}}.http.msging.net/messages HTTP/1.1
Content-Type: application/json
Authorization: Key {YOUR_TOKEN}

{
    "to": "553199990000@0mn.io",
    "type": "application/vnd.lime.collection+json",
    "content": {
       "itemType": "application/vnd.lime.container+json",
       "items": [
           {
               "type": "application/vnd.lime.media-link+json",
               "value": {
                   "text": "Welcome to our store!",
                   "type": "image/jpeg",
                   "uri": "http://www.petshoplovers.com/wp-content/uploads/2014/03/CUIDADOS-B%C3%81SICOS-PARA-CRIAR-COELHOS.jpg"
               }
           },
           {
               "type": "application/vnd.lime.select+json",
               "value": {
                   "text": "Choose what you need",
                   "options": [
                       {
                           "order": 1,
                           "text": "See our stock"
                       },
                       {
                           "order": 2,
                           "text": "Follow an order"
                       }
                   ]
               }
           }
       ]
    }
}

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Lime.Messaging.Contents;
using Lime.Protocol;
using Take.Blip.Client;

public class CollectionMultimidiaMenu : IMessageReceiver
{
private readonly ISender _sender;
private readonly Settings _settings;

JsonDocument jsonDocuments;
JsonDocument jsonDocuments2;
JsonDocument jsonDocuments3;

public CollectionMultimidiaMenu(ISender sender)
{
    _sender = sender;
}

DocumentSelect[] documents = new DocumentSelect[]
{
    jsonDocuments = new JsonDocument();
    jsonDocuments2 = new JsonDocument();
    jsonDocuments3 = new JsonDocument();

    jsonDocuments.Add("Key1", "value1");
    jsonDocuments.Add("Key2", "2");

    jsonDocuments2.Add("Key3", "value3");
    jsonDocuments2.Add("Key4", "4");

    jsonDocuments3.Add("Key5", "value5");
    jsonDocuments3.Add("Key6", "6");

    DocumentSelect[] documents = new DocumentSelect[]
    {
        new DocumentSelect
        {
            Header = new DocumentContainer
            {
                Value = new MediaLink
                {
                    Title = "Title",
                    Text = "This is a first item",
                    Type = "image/jpeg",
                    Uri = new Uri("http://www.isharearena.com/wp-content/uploads/2012/12/wallpaper-281049.jpg"),
                }
            },
            Options = new DocumentSelectOption[]
            {
                new DocumentSelectOption
                {
                    Label = new DocumentContainer
                    {
                        Value = new WebLink
                        {
                            Title = "Link",
                            Uri = new Uri("http://www.adoteumgatinho.org.br/")
                        }
                    }
                },
                new DocumentSelectOption
                {
                    Label = new DocumentContainer
                    {
                        Value = new PlainText
                        {
                            Text = "Text 1"
                        }
                    },
                    Value = new DocumentContainer
                    {
                        Value = jsonDocuments
                    }
                }
            }
        },
        new DocumentSelect
        {
            Header = new DocumentContainer
            {
                Value = new MediaLink
                {
                    Title = "Title 2",
                    Text = "This is another item",
                    Type = "image/jpeg",
                    Uri = new Uri("http://www.freedigitalphotos.net/images/img/homepage/87357.jpg")
                }
            },
            Options = new DocumentSelectOption[]
            {
                new DocumentSelectOption
                {
                    Label = new DocumentContainer
                    {
                        Value = new WebLink
                        {
                            Title = "Second link",
                            Text = "Weblink",
                            Uri = new Uri("https://pt.dreamstime.com/foto-de-stock-brinquedo-pl%C3%A1stico-amarelo-do-pato-image44982058")
                        }
                    }
                },
                new DocumentSelectOption
                {
                    Label = new DocumentContainer
                    {
                        Value = new PlainText {
                            Text = "Second text"
                        }
                    },
                    Value = new DocumentContainer
                    {
                        Value = jsonDocuments2
                    }
                },
                new DocumentSelectOption
                {
                    Label = new DocumentContainer
                    {
                        Value = new PlainText {
                            Text = "More one text"
                        }
                    },
                    Value = new DocumentContainer
                    {
                        Value = jsonDocuments3
                    }
                }
            }
        }
    };

public async Task ReceiveAsync(Message message, CancellationToken cancellationToken)
{
    var document = new DocumentCollection
    {
        ItemType = "application/vnd.lime.document-select+json",
        Items = documents,
    };
    await _sender.SendMessageAsync(document, message.From, cancellationToken);
}
}

    client.sendMessage({
        id: Lime.Guid(),
        type: "application/vnd.lime.collection+json",
        to: "128271320123982@messenger.gw.msging.net",
        content: {
            itemType: "application/vnd.lime.document-select+json",
            items: [
                {
                    header: {
                        type: "application/vnd.lime.media-link+json",
                        value: {
                            title: "Title",
                            text: "This is a first item",
                            type: "image/jpeg",
                            uri: "http://www.isharearena.com/wp-content/uploads/2012/12/wallpaper-281049.jpg"
                        }
                    },
                    options: [
                        {
                            label: {
                                type: "application/vnd.lime.web-link+json",
                                value: {
                                    title: "Link",
                                    uri: "http://www.adoteumgatinho.org.br/"
                                }
                            }
                        },
                        {
                            label: {
                                type: "text/plain",
                                value: "Text 1"
                            },
                            value: {
                                type: "application/json",
                                value: {
                                    key1: "value1",
                                    key2: 2
                                }
                            }
                        }
                    ]
                },
                {
                    header: {
                        type: "application/vnd.lime.media-link+json",
                        value: {
                            title: "Title 2",
                            text: "This is another item",
                            type: "image/jpeg",
                            uri: "http://www.freedigitalphotos.net/images/img/homepage/87357.jpg"
                        }
                    },
                    options: [
                        {
                            label: {
                                type: "application/vnd.lime.web-link+json",
                                value: {
                                    title: "Second link",
                                    text: "Weblink",
                                    uri: "https://pt.dreamstime.com/foto-de-stock-brinquedo-pl%C3%A1stico-amarelo-do-pato-image44982058"
                                }
                            }
                        },
                        {
                            label: {
                                type: "text/plain",
                                value: "Second text"
                            },
                            value: {
                                type: "application/json",
                                value: {
                                    key3: "value3",
                                    key4: 4
                                }
                            }
                        },
                        {
                            label: {
                                type: "text/plain",
                                value: "More one text"
                            },
                            value: {
                                type: "application/json",
                                value: {
                                    key5: "value5",
                                    key6: 6
                                }
                            }
                        }
                    ]
                }
            ]
        }
    });

client.send_message(
    Message.from_json(
        {
            'id': '5',
            'to': '1042221589186385@messenger.gw.msging.net',
            'type': 'application/vnd.lime.collection+json',
            'content': {
                'itemType': 'application/vnd.lime.document-select+json',
                'items': [
                    {
                        'header': {
                            'type': 'application/vnd.lime.media-link+json',
                            'value': {
                                'title': 'Title',
                                'text': 'This is a first item',
                                'type': 'image/jpeg',
                                'uri': 'http://www.isharearena.com/wp-content/uploads/2012/12/wallpaper-281049.jpg'
                            }
                        },
                        'options': [
                            {
                                'label': {
                                    'type': 'application/vnd.lime.web-link+json',
                                    'value': {
                                        'title': 'Link',
                                        'uri': 'http://www.adoteumgatinho.org.br'
                                    }
                                }
                            },
                            {
                                'label': {
                                    'type': 'text/plain',
                                    'value': 'Text 1'
                                },
                                'value': {
                                    'type': 'application/json',
                                    'value': {
                                        'key1': 'value1',
                                        'key2': 2
                                    }
                                }
                            }
                        ]
                    },
                    {
                        'header': {
                            'type': 'application/vnd.lime.media-link+json',
                            'value': {
                                'title': 'Title 2',
                                'text': 'This is another item',
                                'type': 'image/jpeg',
                                'uri': 'http://www.freedigitalphotos.net/images/img/homepage/87357.jpg'
                            }
                        },
                        'options': [
                            {
                                'label': {
                                    'type': 'application/vnd.lime.web-link+json',
                                    'value': {
                                        'title': 'Second link',
                                        'text': 'Weblink',
                                        'uri': 'https://pt.dreamstime.com/foto-de-stock-brinquedo-pl%C3%A1stico-amarelo-do-pato-image44982058'
                                    }
                                }
                            },
                            {
                                'label': {
                                    'type': 'text/plain',
                                    'value': 'Second text'
                                },
                                'value': {
                                    'type': 'application/json',
                                    'value': {
                                        'key3': 'value3',
                                        'key4': 4
                                    }
                                }
                            },
                            {
                                'label': {
                                    'type': 'text/plain',
                                    'value': 'More one text'
                                },
                                'value': {
                                    'type': 'application/json',
                                    'value': {
                                        'key5': 'value5',
                                        'key6': 6
                                    }
                                }
                            }
                        ]
                    }
                ]
            }
        }
    )
)

POST https://{{contract.id}}.http.msging.net/messages HTTP/1.1
Content-Type: application/json
Authorization: Key {YOUR_TOKEN}

{
    "id": "5",
    "to": "1042221589186385@messenger.gw.msging.net",
    "type": "application/vnd.lime.collection+json",
    "content": {
        "itemType": "application/vnd.lime.document-select+json",
        "items": [
            {
                "header": {
                    "type": "application/vnd.lime.media-link+json",
                    "value": {
                        "title": "Title",
                        "text": "This is a first item",
                        "type": "image/jpeg",
                        "uri": "http://www.isharearena.com/wp-content/uploads/2012/12/wallpaper-281049.jpg"
                    }
                },
                "options": [
                    {
                        "label": {
                            "type": "application/vnd.lime.web-link+json",
                            "value": {
                                "title": "Link",
                                "uri": "http://www.adoteumgatinho.org.br"
                            }
                        }
                    },
                    {
                        "label": {
                            "type": "text/plain",
                            "value": "Text 1"
                        },
                        "value": {
                            "type": "application/json",
                            "value": {
                                "key1": "value1",
                                "key2": 2
                            }
                        }
                    }
                ]
            },
            {
                "header": {
                    "type": "application/vnd.lime.media-link+json",
                    "value": {
                        "title": "Title 2",
                        "text": "This is another item",
                        "type": "image/jpeg",
                        "uri": "http://www.freedigitalphotos.net/images/img/homepage/87357.jpg"
                    }
                },
                "options": [
                    {
                        "label": {
                            "type": "application/vnd.lime.web-link+json",
                            "value": {
                                "title": "Second link",
                                "text": "Weblink",
                                "uri": "https://pt.dreamstime.com/foto-de-stock-brinquedo-pl%C3%A1stico-amarelo-do-pato-image44982058"
                            }
                        }
                    },
                    {
                        "label": {
                            "type": "text/plain",
                            "value": "Second text"
                        },
                        "value": {
                            "type": "application/json",
                            "value": {
                                "key3": "value3",
                                "key4": 4
                            }
                        }
                    },
                    {
                        "label": {
                            "type": "text/plain",
                            "value": "More one text"
                        },
                        "value": {
                            "type": "application/json",
                            "value": {
                                "key5": "value5",
                                "key6": 6
                            }
                        }
                    }
                ]
            }
        ]
    }
}