Wiki Search RPC

const wiki = require('wikijs').default;

// Initialize RPC Server wiki.search.
let wikiServer = dbridge.rpc.init("wiki.search");

// Define exposed functions.
 // Unary RPC: the client sends a single request and receives a single response.
function summary(payload, response) {
    const startTime = moment().valueOf();
    wiki().page(payload.inparam).then(page => page.summary())
        .then((data) => {
            response.end(JSON.stringify({
                statuscode: 0,
                exectime: moment().valueOf() - startTime,
                data: data
            }));
        }).catch((err) => {
            response.end(JSON.stringify({
                statuscode: 1,
                exectime: moment().valueOf() - startTime,
                data: 'wiki api exception..' + err.source + ',' + err.code + ',' + err.message
            }));
            console.log('wiki api exception..', err.source, err.code, err.message);
        });
}
// Define all exposed functions.
wikiServer.functions = function () {
    // Bind the exposed function to summary RPC server.
    wikiServer.regfn("summary", summary);
}

wikiServer.register();

import wikipedia

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

    async def summary(inparameter, response): 
        payload = inparameter["inparam"]
        try:
            start_time = time.time()
            data = wikipedia.summary(payload)
            jsonobject = {"statuscode": 0, "exectime": (time.time() - start_time), "data": data}
            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.wikiServer.regfn("summary", summary)
    except dBError as dberror:
        print("Exception: ", dberror.source, dberror.code, dberror.message)

self.wikiServer = self.dbridge.rpc.init("wiki.search")
self.wikiServer.functions = self.wikiServerFunctions

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

using WikiDotNet;

// Define exposed functions.
// RPC: the client sends a single request and receives a single response.
public async void summary(object inparameter, object response) {
    dBridges.Utils.dBParams parameter = inparameter as dBridges.Utils.dBParams;
    dBridges.responseHandler.CResponseHandler responsehandler = response as dBridges.responseHandler.CResponseHandler;
    var watch = new System.Diagnostics.Stopwatch();
    string payload = parameter.inparama;

    string searchstring = payload;
    watch.Start();
    WikiSearchSettings searchSettings = new WikiSearchSettings
    { RequestId = "Request ID", ResultLimit = 5, ResultOffset = 2, Language = "en" };

    WikiSearchResponse responsewiki = WikiSearcher.Search(searchstring, searchSettings);
    string resultstring = "";
    Dictionary<string, object> resultjson = new Dictionary<string, object>();
    resultjson.Add("statuscode", 0);
    foreach (WikiSearchResult result in responsewiki.Query.SearchResults) {
         resultstring = resultstring + result.Preview;
    }
    watch.Stop();
    resultjson.Add("data", resultstring);
    resultjson.Add("exectime", watch.ElapsedMilliseconds);
    string jsonstring = JsonConvert.SerializeObject(resultjson);
    await responsehandler.end(jsonstring);
}


// Define all exposed functions.
public void wikifunction(object eventInfo) {
    try {
        Action<object, object> icurrent = this.summary;
        (eventInfo as dBridges.remoteprocedure.Crpcserver).regfn("summary", icurrent);
    } catch (Exception e) {
        Console.WriteLine(e);
    }
}

// Initialize RPC Server wiki.search.
this.wikiServer = dbridge.rpc.init("wiki.search");

Action<object> ifunctions = this.wikifunction;
this.wikiServer.functions = ifunctions;

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

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

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

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

if self.wiki!= None:
    async def serverconnect_success(payload, metadata):
        print("dbridges:rpc.server.connect.success", payload, metadata)
        #  Execute Server function with parameter 
        await self.summary()

    #  Bind to event server.connect.success, This will be triggered when the connection to server is successfull
    self.wiki.bind("dbridges:rpc.server.connect.success", serverconnect_success)

async def summary(self):
    try:
        #  Execute Server function with argument parameter .
        p = await self.wiki.call('summary', self.searchString, 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)

// Connect to rpcServer
try
{
    wiki = await dbridge.rpc.connect("wiki.search");
}
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;
wiki.bind("dbridges:rpc.server.connect.success", connetsuccess = async (payload, metadata) => {
    // Execute Server function with parameter .
    IPromise<object> p = await wiki.call("summary", this.searchString, 1000 * 60 * 2, null);
    p.Then((response) => {
        Console.WriteLine("{1}", response);
    })
    .Catch((err) => {
        dBridges.exceptions.dBError er = err as dBridges.exceptions.dBError;
        Console.WriteLine("wiki => 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;
wiki.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}", perror.source, perror.code, perror.message);
});

// 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';

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

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

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