Weather RPC

// Initialize RPC Server weather.now.
let weathersvr = dbridge.rpc.init("weather.now");

// Define  exposed functions.
function currentWeather(payload, response) {
    const startTime = moment().valueOf();
    // Using openweathermap.org api to fetch realtime weather data.
    const weatherURI = 'https://api.openweathermap.org/data/2.5/weather?q=' + payload.inparam + '&appid=' + weather_APPID + '&units=metric'; 
    let fetchRes = fetch(weatherURI);
    fetchRes.then((retResponse) => {
        if (!retResponse.ok) {
            throw new Error('Network response was not OK');
        }
        return retResponse.json();
    }).then(async (resp) => {
        let responseData = 'Weather Condition : ' + resp.weather[0].main + '\n'
        responseData = responseData + 'Temperature : ' + resp.main.temp + '\u00b0C, feels like ' + resp.main.feels_like + '\u00b0C, humidity : ' + resp.main.humidity + '\n'
        responseData = responseData + 'Pressure : ' + resp.main.temp + ' hPa , Visibility : ' + resp.visibility + ' meter, Cloudiness : ' + resp.clouds.all + ' %' + '\n'
        responseData = responseData + 'Wind : Speed ' + resp.wind.speed + ' meter/sec , Wind direction : ' + resp.wind.deg + ' \u00b0' + '\n'
        responseData = responseData + 'Sunrise : ' + moment.unix(resp.sys.sunrise).format('h:mm:ss A') + ', Sunset : ' + moment.unix(resp.sys.sunset).format('h:mm:ss A') + '\n'
        response.end(JSON.stringify({
            statuscode: 0,
            exectime: moment().valueOf() - startTime,
            data: responseData
        }));
    }).catch((err) => {
        console.log('Error in fetching weather details', err);
        response.end(JSON.stringify({
            statuscode: 1,
            exectime: moment().valueOf() - startTime,
            data: 'openweathermap.org api exception..' + err.source + ',' + err.code + ',' + err.message
        }));
    });
}

// Define all exposed functions.
weathersvr.functions = function () {
    weathersvr.regfn("currentWeather", currentWeather);
}

// Bind to server.registration.success, This will be triggered When weathersvr is ready to serve.
weathersvr.bind("dbridges:rpc.server.registration.success", (payload, metadata) => {
    console.log(moment().format('h:mm:ss:ms'), "dbridges:rpc.server.registration.success");
});
// Bind to server.registration.fail, This will be triggered When any registration issue is raised.
weathersvr.bind("dbridges:rpc.server.registration.fail", (payload, metadata) => {
    console.log(moment().format('h:mm:ss:ms'),"dbridges:rpc.server.registration.fail");
});

// Bind to server.online, This will be triggered When MathServer is ready to serve.
weathersvr.bind("dbridges:rpc.server.online", (payload, metadata) => {
    console.log(moment().format('h:mm:ss:ms'), "dbridges:rpc.server.online");
});

// Register RPC Server with dBrdige network.
weathersvr.register();

# Define all exposed functions.
async def rpc_expose_functions(self):

    async def currentWeather(inparameter, response):
        #  Enable this to receive response tracker event.
        payload = inparameter["inparam"]
        weatherURI = 'https://api.openweathermap.org/data/2.5/weather?q=' + payload + '&appid=' + self.weatherAPPId + '&units=metric';

        try:
            ssl_context = ssl.create_default_context(cafile=certifi.where())
            async with aiohttp.ClientSession() as session:
                async with session.get(weatherURI, ssl=ssl_context) as r:
                    if r.status != 200:
                        jsonobject = {"statuscode": 1,"exectime": (time.time() - start_time), "data": ""}
                        await response.end(json.dumps(jsonobject))
                    if r.status == 200:
                        rdata = await r.text()
                        resp = json.loads(rdata)
                        responseData = "Weather Condition : " + str(resp["weather"][0]["main"]) + "\n"
                        responseData = responseData + "Temperature : " + str(resp["main"]["temp"]) + "\u00b0C, feels like " + str(resp["main"]["feels_like"]) + "\u00b0C, humidity : " + str(resp["main"]["humidity"] )+ "\n"
                        responseData = responseData + "Pressure : " + str(resp["main"]["temp"]) + " hPa , Visibility : " + str(resp["visibility"]) + " meter, Cloudiness : " + str(resp["clouds"]["all"]) + " %" + "\n"
                        responseData = responseData + "Wind : Speed " + str(resp["wind"]["speed"]) + " meter/sec , Wind direction : " + str(resp["wind"]["deg"] )+ " \u00b0" + "\n"
                        responseData = responseData + "Sunrise : " + str(resp["sys"]["sunrise"])+ ", Sunset : " + str(resp["sys"]["sunset"] )+ "\n"
                        jsonobject = {"statuscode": 0,
                        "exectime": (time.time() - start_time),
                        "data": responseData }
                        await response.end(json.dumps(jsonobject))
        except Exception as e:
            jsonobject = {"statuscode": 1,"exectime": (time.time() - start_time), "data": ""}
            await response.end(json.dumps(jsonobject))

    try:
        #  Bind the exposed function, so that library can register it for receiving calls.
        self.rpcServer.regfn("currentWeather", currentWeather)
    except dBError as dberror:
        print("Exception: ", dberror.source, dberror.code, dberror.message)


# Initialize RPC Server weather.now1.
self.rpcServer = self.dbridge.rpc.init("weather.now")
self.rpcServer.functions = self.rpc_expose_functions

try:
    #  Register RPC Server with dBrdige network.
    await self.rpcServer.register()
except dBError as dberror:
    #  Catch any registration error.
    print("Exception: ", dberror.source, dberror.code, dberror.message)

// Define exposed functions.
// RPC: the client sends a single request and receives a single response.
public async void currentWeather(object inparameter, object response)
{
    dBridges.Utils.dBParams parameter = inparameter as dBridges.Utils.dBParams;
    dBridges.responseHandler.CResponseHandler responsehandler = response as dBridges.responseHandler.CResponseHandler;

    using (var client = new HttpClient()) {
        try {
            ServicePointManager.ServerCertificateValidationCallback += (sender, cert, chain, sslPolicyErrors) => true;
            string payload = parameter.inparama;
            var watch = new System.Diagnostics.Stopwatch();
            string url = "https://api.openweathermap.org/data/2.5/weather?q=" + payload + "&appid=" + this.weatherAPPId + "&units=metric";
            var responsedata = await client.GetAsync(new Uri(url));

            if (!responsedata.IsSuccessStatusCode) {
                Dictionary<string, object> resultjson = new Dictionary<string, object>();
                resultjson.Add("statuscode", 1);
                watch.Stop();
                resultjson.Add("data", responsedata.ReasonPhrase);
                resultjson.Add("exectime", watch.ElapsedMilliseconds);
                jsonstring = JsonConvert.SerializeObject(resultjson);
                await responsehandler.end(jsonstring);
            } else {
                string jsonstring = await responsedata.Content.ReadAsStringAsync();
                dynamic resp = JsonConvert.DeserializeObject(jsonstring);
                string responseData = "Weather Condition : " + resp["weather"][0]["main"] + "\n";
                responseData = responseData + "Temperature : " + resp["main"]["temp"] + "\u00b0C, feels like " + resp["main"]["feels_like"] + "\u00b0C, humidity : " + resp["main"]["humidity"] + "\n";
                responseData = responseData + "Pressure : " + (resp["main"]["temp"]) + " hPa , Visibility : " + (resp["visibility"]) + " meter, Cloudiness : " + (resp["clouds"]["all"]) + " %" + "\n";
                responseData = responseData + "Wind : Speed " + (resp["wind"]["speed"]) + " meter/sec , Wind direction : " + (resp["wind"]["deg"]) + " \u00b0" + "\n";
                responseData = responseData + "Sunrise : " + (resp["sys"]["sunrise"]) + ", Sunset : " + (resp["sys"]["sunset"]) + "\n";
                Dictionary<string, object> resultjson = new Dictionary<string, object>();
                resultjson.Add("statuscode", 0);
                watch.Stop();
                resultjson.Add("data", responseData);
                resultjson.Add("exectime", watch.ElapsedMilliseconds);
                jsonstring = JsonConvert.SerializeObject(resultjson);
                await responsehandler.end(jsonstring);
            }
        } catch (Exception e) {
            Dictionary<string, object> resultjson = new Dictionary<string, object>();
            resultjson.Add("statuscode", 1);
            watch.Stop();
            resultjson.Add("data", "");
            resultjson.Add("exectime", watch.ElapsedMilliseconds);
            jsonstring = JsonConvert.SerializeObject(resultjson);
            await responsehandler.end(jsonstring);
        }
    }
}

// Define all exposed functions.
public void rpcfunction(object eventInfo)
{
    try {
        Action<object, object> icurrentWeather = this.currentWeather;
        (eventInfo as dBridges.remoteprocedure.Crpcserver).regfn("currentWeather", icurrentWeather);

    } catch (Exception e) {
        Console.WriteLine(e);
    }
}

// Initialize RPC Server weather.now.
this.rpcServer = dbridge.rpc.init("weather.now");

Action<object> ifunctions = this.rpcfunction;
this.rpcServer.functions = ifunctions;

// Register RPC Server with dBrdige network.
await this.rpcServer.register();

// Bind to server.registration.success, This will be triggered When summary is ready to serve.
Action<object, object> rconnectsuccess;
this.rpcServer.bind("dbridges:rpc.server.registration.success", rconnectsuccess = (object payload, object metadata) => {
    Console.WriteLine("dbridges:rpc.server.success {0} {1} {2} {3}", payload, metadata, this.rpcServer.getServerName(), this.rpcServer.isOnline());
});
// Bind to server.online, This will be triggered When summary is ready to serve.
Action<object, object> rconnectonline;
this.rpcServer.bind("dbridges:rpc.server.online", rconnectonline = (object payload, object metadata) => {
    Console.WriteLine("dbridges:rpc.server.online {0} {1} {2} {3}", payload, metadata, this.rpcServer.getServerName(), this.rpcServer.isOnline());
});
// Bind to server.registration.fail, This will be triggered When any registration issue is raised.
Action<object, object> rconnectfail;
this.rpcServer.bind("dbridges:rpc.server.registration.fail", rconnectfail = (object payload, object metadata) => {
    Console.WriteLine("dbridges:rpc.server.fail {0} {1} {2} {3}", payload, metadata, this.rpcServer.getServerName(), this.rpcServer.isOnline());
});

// Connect to weather.now server
weather = dbridge.rpc.connect("weather.now");
// We will bind to rpc server connection success event. On success, we will call remote functions.
weather.bind("dbridges:rpc.server.connect.success", () => {
    // Unary RPC: The client sends a single request and receives a single response.
    weather.call("currentWeather", cityName, 1000 * 60 * 2, null).then((response) => {
        const resp = JSON.parse(response);
        console.log(resp.data);
    }).catch((err) => {
        console.log(err);
    });
});

#  Connect to rpcServer
try:
    self.weather =  await self.dbridge.rpc.connect("weather.now")
except Exception as dberror:
    print("Exception: ", dberror.source, dberror.code, dberror.message)

if self.weather!= None:
    #  Bind to event server.connect.success, This will be triggered when the connection to server is successfull
    async def serverconnect_success(payload, metadata):
        print("dbridges:rpc.server.connect.success", payload, metadata)
        #  Execute Server function with parameter 
        await self.currentWeather()
    self.weather.bind("dbridges:rpc.server.connect.success", serverconnect_success)

    #  Bind to server.connect.fail. This will be triggered either if connection to rpcServer fails or reconnect fails.
    async def serverconnect_fail(payload, metadata):
        print("dbridges:rpc.server.connect.fail", payload, metadata)
    self.weather.bind("dbridges:rpc.server.connect.fail", serverconnect_fail)

async def currentWeather(self):
    try:
        #  Execute Server function with argument parameter .
        p = await self.weather.call('currentWeather', self.city, 10000, None)

        def onResult(res):
            #  Response will be received here. 
            print(res)

        def onError(res):
            #  Catch execption for .call
            print("Error", res.source, res.code, res.message, )

        p.then(onResult).catch(onError)

    except Exception as dberror:
        print("Exception: ", dberror.source, dberror.code, dberror.message)

dBridges.remoteprocedure.CrpCaller weather = null;
// Connect to rpcServer
try {
    weather = await dbridge.rpc.connect("weather.now");
} catch (dBridges.exceptions.dBError err)  {
    // Catch connect exception
    Console.WriteLine("dBridge rpc.connect exception {0} {1} {2}", err.source, err.code, err.message);
}

// Bind to event server.connect.success, This will be triggered when the connection to server is success
Action<object, object> connetsuccess;
weather.bind("dbridges:rpc.server.connect.success", connetsuccess = async (payload, metadata) => {
    // Execute Server function with parameter .
    IPromise<object> p = await weather.call("currentWeather", this.city, 1000 * 60 * 2, null);
    p.Then((response) => {
        Console.WriteLine("{1}", response);
    })
    .Catch((err) => {
        dBridges.exceptions.dBError er = err as dBridges.exceptions.dBError;
        Console.WriteLine("weather => exception {0} , {1} , {2}",  er.source, er.code, er.message);
    });
});

// Bind to server.connect.fail. This will be triggered either if connection to rpcServer fails or reconnect fails.
Action<object, object> connetfail;
weather.bind("dbridges:rpc.server.connect.fail", connetfail = (payload, metadata) => {
    dBridges.exceptions.dBError perror = payload as dBridges.exceptions.dBError;
    Console.WriteLine("dbridges:rpc.server.connect.fail {0} {1} {2} {3}", perror.source, perror.code, perror.message, metadata);
});

// Replace your dataBrdiges Application Key,Application Secret and Authentication URL below.
const dbApplnKey = 'appkey';
const dbAuthURL = 'auth_url';
const dbApplnSecret = 'appsecret';
const weatherAPPId = 'weather_APPID';

// Replace your dataBrdiges Application Key and Authentication URL below.
self.dbApplnKey = 'appkey'
self.dbAuthURL = 'auth_url'
self.dbApplnSecret = 'appsecret'
self.weatherAPPId = 'weather_APPID'

// Replace your dataBrdiges Application Key and Authentication URL below.
private string dbApplnKey = 'appkey';
private string dbAuthURL = 'auth_url';
private string dbApplnSecret = 'appsecret';
private string weatherAPPId = 'weather_APPID';

// Replace your dataBrdiges Application Key and Authentication URL below.
const dbApplnKey = 'appkey';
const dbAuthURL = 'auth_url';

// Replace your dataBrdiges Application Key and Authentication URL below.
self.dbApplnKey = 'appkey'
self.dbAuthURL = 'auth_url'

// Replace your dataBrdiges Application Key and Authentication URL below.
private string dbApplnKey = 'appkey';
private string dbAuthURL = 'auth_url';