Websocket API - Nodejs Environment

#!/usr/bin/env node

// Example for Nodejs - JS
//
// 1. Connect to websocket-server
// 2. Check camera 1 is connected and the light is on (on open)
// 3. If camera 1 is connected and the light is off then turn the light on
// 4. Take a jpg image and save it as file
// 5. Close connection
//
// Install dependencies:
//   npm install websocket
//


var W3CWebSocket = require('websocket').w3cwebsocket;
fs = require('fs');

const RotoClearIp = "192.168.0.102"
const RotoClearApiPort = "7000"
const myApiToken = "0123456789"
const imageName = 'myNewImage.jpg'

var connection = new W3CWebSocket("ws://" + RotoClearIp + ":" + RotoClearApiPort);

function customSendToAPI(message) {
  message["token"] = myApiToken;
  // Send message to api server. Only stringified json object is accepted
  connection.send(JSON.stringify(message));
}


connection.onerror = function () {
  console.log('Connection Error');
};

connection.onopen = function () {
  customSendToAPI({ info: ["cam1-light", "cam1-exists"] });
};

connection.onclose = function () {
  console.log('Client Closed');
};

connection.onmessage = function (e) {
  if (typeof e.data === "string") {
    // if data is of type string, then it is json
    var api_message = JSON.parse(e.data);

    if (api_message["cam1-exists"] && !api_message["cam1-light"]) {
      customSendToAPI({ "cam1-light": true });
    } else if (api_message["cam1-light"]) {
      customSendToAPI({ "jpeg": true });
    }

  } else if (typeof e.data === "object") {
    // if data is of type object, then it is jpeg
    fs.writeFile(imageName, Buffer.from(e.data), function (err) {
      if (err) return console.log(err);
    });

    // close connection after write image to file
    connection.close()
  }
};

// Dotnet Websocket API Example
// 
// Install dotnetSDK:
//   see:  https://docs.microsoft.com/de-de/dotnet/core/install
// 
// Init project in current directory:
//   dotnet new console
// 
// copy the content to your Program.cs and replace the namespace "dotnet_websocket_api_example" with yours


using System;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Net.WebSockets;
using System.IO;

namespace dotnet_websocket_api_example
{
  class Program
  {
    const string ServerIp = "192.168.0.107";
    const int ServerPort = 7000;
    const string APIToken = "0123456789";
    static string JpgFileName = "APIImage.jpg";


    public static Task SendString(ClientWebSocket ws, String data, CancellationToken cancellation)
    {
      var encoded = Encoding.UTF8.GetBytes(data);
      var buffer = new ArraySegment<Byte>(encoded, 0, encoded.Length);
      return ws.SendAsync(buffer, WebSocketMessageType.Text, true, cancellation);
    }

    public static async Task<String> ReadString(ClientWebSocket ws)
    {
      ArraySegment<Byte> buffer = new ArraySegment<byte>(new Byte[8192]);

      WebSocketReceiveResult result = null;

      using (var ms = new MemoryStream())
      {
        do
        {
          result = await ws.ReceiveAsync(buffer, CancellationToken.None);
          ms.Write(buffer.Array, buffer.Offset, result.Count);
        }
        while (!result.EndOfMessage);

        ms.Seek(0, SeekOrigin.Begin);

        using (var reader = new StreamReader(ms, Encoding.UTF8))
          return reader.ReadToEnd();
      }
    }

    public static async Task ReadAndSaveImage(ClientWebSocket ws)
    {
      ArraySegment<Byte> buffer = new ArraySegment<byte>(new Byte[8192]);

      WebSocketReceiveResult result = null;

      using (var ms = new MemoryStream())
      {
        do
        {
          result = await ws.ReceiveAsync(buffer, CancellationToken.None);
          ms.Write(buffer.Array, buffer.Offset, result.Count);
        }
        while (!result.EndOfMessage);

        ms.Seek(0, SeekOrigin.Begin);

        using (FileStream file = new FileStream(JpgFileName, FileMode.Create, System.IO.FileAccess.Write))
        {
          Console.WriteLine("Save Image from API to " + JpgFileName);
          ms.WriteTo(file);
        }
      }
    }

    static async Task Main(string[] args)
    {
      // Define the cancellation token.
      CancellationTokenSource source = new CancellationTokenSource();
      CancellationToken token = source.Token;


      using (var socket = new ClientWebSocket())
      {

        try
        {
          await socket.ConnectAsync(new Uri("ws://" + ServerIp + ":" + ServerPort), CancellationToken.None);

          await SendString(socket, "{\"token\": \"" + APIToken + "\", \"info\": [\"cam1-light\", \"cam1-exists\"]}", token);
          string message = await ReadString(socket);

          // here you can handle message 
          Console.WriteLine("Message from API: " + message);


          // We try now to get a image from API
          await SendString(socket, "{\"token\": \"" + APIToken + "\", \"jpeg\": true }", token);
          await ReadAndSaveImage(socket);
        }
        catch (Exception ex)
        {
          Console.WriteLine($"ERROR - {ex.Message}");
        }

      }
    }
  }
}

# Example in NIM - Serial Process
#
# 1. Connect to websocket-server
# 2. Check camera 1 is connected and the light is on
# 3. If camera 1 is connected and the light is off then turn the light on
# 4. Take a jpg image and save it as file
# 5. Close connection
#

import strformat, strutils, json
import ws, asyncdispatch

const
  rotoclear_ip = "192.168.0.102" 
  rotoclear_api_port = "7000" 
  my_api_token = "0123456789"

proc runProcess() {.async.} = 
  # create connection
  let conn = await newWebSocket(&"ws://{rotoclear_ip}:{rotoclear_api_port}") 
  
  # get info from API
  var message = %*{
    "token": my_api_token,
    "info": ["cam1-light", "cam1-exists"]
  }
  await conn.send($message)
  let
    response = await conn.receiveStrPacket()
    respMsg = parseJson(response)

  if respMsg.hasKey("cam1-exists"): 
    if respMsg["cam1-exists"].getBool():
      
      if not respMsg["cam1-light"].getBool(): 
        message = %*{ 
          "token": my_api_token, 
          "cam1-light": true 
        }

        await conn.send($message)
        echo await conn.receiveStrPacket() 

    # get jpeg as blob and save it
    message = %*{ "token": my_api_token, "jpeg": "" }
    await conn.send($message)
    let data: seq[byte] = await conn.receiveBinaryPacket()
    writeFile("myCurrentImg.jpg", data) 
  
  conn.close()


waitFor runProcess()