SOFIA2 Desktops

T_21

The desktop of the platform constitutes the access point of any user of the platform to any of the applications provided in the project and to which the user has access.

At the platform level, different desktops can be created so that a user can access several desktops, each with different purposes and applications.

Desks are Web applications that act as containers for other applications. A platform administrator controls and configures which applications are accessible from each desk, associating them to the desktop from the platform’s own control panel.

At the same time each application administrator, giving it as a project on the platform itself, will control which users have access to the application.

So that each desk, performs the control of access to users of the platform through a login screen, and depending on the permissions that that user has on each of the applications registered, will have access or not to the registered applications as desktop applications.

Next, we will explain how to create and use them.

Seguir leyendo “SOFIA2 Desktops”

SOFIA2 Desktops

Escritorios SOFIA2

T_21

El escritorio de la plataforma constituye el punto de acceso de cualquier usuario de la plataforma a cualquiera de las aplicaciones provistas en el proyecto y a las que el usuario tuviera acceso.

A nivel de plataforma se pueden crear diferentes escritorios de manera que un usuario pueda tener acceso a varios escritorios, cada uno con propósitos y aplicaciones distintos.

Los escritorios son aplicaciones Web que actúan como contenedores de otras aplicaciones. Un administrador de la plataforma controla y configura qué aplicaciones son accesibles desde cada escritorio, asociándolas al escritorio desde el propio panel de control de la plataforma.

A su vez cada administrador de aplicación, dándola de alta como proyecto en la propia plataforma, controlará qué usuarios tienen acceso a la aplicación.

De manera que cada escritorio, realiza el control de acceso a los usuarios de la plataforma mediante una pantalla de login, y en función de los permisos de que disponga dicho usuario sobre cada una de las aplicaciones dadas de alta, tendrá acceso o no a las aplicaciones registradas como aplicaciones de escritorio.

A continuación explicaremos como crearlos y utilizarlos.

Seguir leyendo “Escritorios SOFIA2”

Escritorios SOFIA2

¿Cómo invocar a un API REST externa desde el motor de flujos Sofia2?

En este ejemplo vamos a invocar a un API Externa desde el motor de flujos integrado en la plataforma.

En la versión 3.4 de Sofia2 se integró Node-RED como motor de flujos (post aquí), una funcionalidad típica a implementar desde esta programación visual es la de invocar a un API REST externa para posteriormente procesarlo en la plataforma (almacenarlo en la BDTR, hacer analítica, representarlo,…)

En el ejemplo invocaremos al API de Análisis del Sentimiento de MeaningCloud (qué es MeaningCloud). MeaningCloud es un Servicio Web que ofrece APIs (https://www.meaningcloud.com/developer/apis) que pueden invocarse vía REST con el token que nos dan tras registrarnos. Queremos probar este API:

Para poder crear un flujo Node-RED en Sofia2 tengo que seguir estos pasos:

1. Primero debo crear un proyecto, para eso desde

selecciono

2. Dentro del proyecto debo ir a la opción y crear un dominio:

3. Una vez creado el dominio ya puedo ir a Mis Flujos:

Donde veré mi Dominio, que puedo arrancar o parar desde

4. Una vez arrancado el dominio abajo veré Mis Flujos:

Desde donde puedo ir a

5. Una vez dentro de mi dominio Node-red podré crear los flujos que necesite:

Hemos creado un flujo muy sencillo, que luego habría que completar con el procesamiento completo (que se ejecute en cierto momento y que guarde los datos).

El nodo principal es este: que realiza la llamada al API:

El nodo anterior se encarga de pasar los parámetros:

Entre ellos el key para poder invocarlo, el texto a analizar, lenguaje y las headers para poder invocarlo.

A la salida hemos puesto un nodo Debug que nos permite ver el resultado de la invocación:

Como podéis ver, el resultado me da esto:

{
"status":{
"code":"0",
"msg":"OK",
"credits":"1",
"remaining_credits":"19974"
},
"model":"general_es",
"score_tag":"P",
"agreement":"AGREEMENT",
"subjectivity":"OBJECTIVE",
"confidence":"100",
"irony":"NONIRONIC",
"sentence_list":[
{
"text":"A ver si esto te parece positivo",
"inip":"0",
"endp":"31",
"bop":"y",
"confidence":"100",
"score_tag":"P",
"agreement":"AGREEMENT",
"segment_list":[
{
"text":"A ver si esto te parece positivo",
"segment_type":"main",
"inip":"0",
"endp":"31",
"confidence":"100",
"score_tag":"P",
"agreement":"AGREEMENT",
"polarity_term_list":[
{
"text":"positivo",
"inip":"24",
"endp":"31",
"confidence":"100",
"score_tag":"P"
}
]
}
],
"sentimented_entity_list":[

],
"sentimented_concept_list":[

]
}
],
"sentimented_entity_list":[

],
"sentimented_concept_list":[

]
}

Podemos ver la documentación del API para entender bien el significado de los conceptos: https://www.meaningcloud.com/developer/sentiment-analysis/doc/2.1/response

¿Cómo invocar a un API REST externa desde el motor de flujos Sofia2?

Algunas consultas en Motor SQL de Sofia2 para acceder a Mongo

En la primera versión de 2017 se incluyó en la plataforma un nuevo motor de consultas en SQL para los escenarios en los que se usaba como BDTR MongoDB.

Este nuevo motor se describe en profundidad en este post: Soporte para consultas SQL en BDTR

Este motor permite a los usuarios de SQL manejar todas las capacidades de MongoDB desde su lenguaje favorito.

En este post queríamos mostrar algunas consultas que se simplifican mucho usando este motor SQL en Sofia2.

Para probarlo iremos al Panel de Control de mi instancia Sofia2 y dentro a Consola BDTR y BDH:

Desde ahí puedo seleccionar una ontología y pulsar botón de :

En mi caso esto me devuelve un listado con 3 instancias de AparcamientPublicoMadrid:

Veamos primero como consultar las entidades cuya fecha de inserción (atributo ContextData.timestamp) es menor de una fecha concreta:

select * from AparcamientPublicoMadrid where contextData.timestamp<TIMESTAMP("2016-12-27T13:30:00.000Z")

select * from AparcamientPublicoMadrid where contextData.timestamp<DATE("2016-12-27")

select count(*) from AparcamientPublicoMadrid where contextData.timestamp<DATE("2016-12-28")

NOTA: Recordad que en este motor se deben usar comillas dobles (“) en lugar de comillas sencillas (‘)

Probemos ahora el DISTINCT, GROUP

Veamos esta ontología:

Puedo hacer por ejemplo

SELECT distinct(Tweet.tweet_user_name) FROM Tweets_Sofia2

SELECT Tweet.tweet_user_name,count(Tweet.tweet_user_name) as numtweets FROM Tweets_Sofia2 group by Tweet.tweet_user_name

o

SELECT count(*) FROM Tweets_Sofia2 where Tweet.tweet_text like "%Indra%"

Algunas consultas en Motor SQL de Sofia2 para acceder a Mongo

Cómo hacer un gadget que comprueba estado de APIs REST con Sofia2

En este post vamos a ver cómo usando los gadgets tipo HTML5 de la plataforma puedo hacer de forma muy rápida un front de monitorización de servicios REST.

Primero accederé a mi instancia Sofia2 con un rol COLABORADOR (recordad que si tenéis rol USUARIO podéis solicitar el paso a rol COLABORADOR desde la propia consola.

Una vez logado iré a la opción Mis Gadgets:

Y seleccionaré el botón Crear Gadget.

Iré a la pestaña AVANZADO y seleccionaré HTML 5:

 

Le daré un nombre, por ejemplo StatusURLs.

Empezaremos con un ejemplo básico que iremos mejorando…

Para desarrollar el gadget en HTML5 vamos a usar la librería jQuery.

El código inicial es este:

Y el resultado:

Si echáis un ojo al código veréis que cuando pulso el botón Ejecutar hago una petición QUERY a la URL del campo y repito esta petición cada 5 segundos indicando si la petición es correcta o incorrecta.

Puedo depurar el funcionamiento de este HTML en local o copiarlo en el gadget y ver cómo se renderiza:

Tras esto daré Crear para completar la creación del gadget.

Al crear el gadget

ya tendré una URL que puedo ver desde el icono Mostrar URL ddel listado:

https://sofia2.com/console/dashboard/ca248e0e-2701-4b00-af79-0b7d0459dcec

Ahora cambiaremos un poco el gadget para que en lugar de mostrar los datos en una tabla los muestre en un gráfico de barras (para probar el error podéis desconectaros de la red):

Para pintar el gráfico hemos usado la librería CanvasJS, que es muy sencillita, se integra muy bien con jQuery y ofrece bastantes tipos de charts:

El código que añado es básicamente este:

Y la función invokeURL que queda así:

Si edito el código de mi gadget y lo guardo ahora veo:

Y si lo ejecuto:

En un siguiente post, a partir de este gadget generaremos una plantilla de gadget y crearemos un dashboard con los gadgets parametrizados.

A continuación dejamos el código del ejemplo final:

<!DOCTYPE html>

<html>
<head>
    <script type="text/javascript" src="https://code.jquery.com/jquery-1.8.2.min.js"></script>	
    <script type="text/javascript" src="https://canvasjs.com/assets/script/canvasjs.min.js"></script>
    <script type="text/javascript">		
    
        var interval;    
        var chart;
        var vecesOK=0;
        var vecesError=0;
				
        $(document).ready(function () {	
		
			chart = new CanvasJS.Chart("chartContainer", {
				animationEnabled: true,				
				theme: "light2", // "light1", "light2", "dark1", "dark2"
				title:{
					text: "Status URL: "+$("input#myURL").val()
				},
				axisY: {
					title: "Peticiones"
				},
				data: [{        
					type: "column",  
					showInLegend: true, 
					legendMarkerColor: "grey",
					legendText: "PETICIONES SERVIDOR",
					dataPoints: [      
						{ y: 0, label: "OK" },
						{ y: 0,  label: "ERROR" }
					]
				}]
			});
			chart.render();

			function invokeURL() {
                $.ajax({
                    type: "GET",
					//contentType: "application/json; charset=utf-8", NO FUNCIONAN REDIRECCIONES
                    dataType: "json",
                    async: true,
                    url: $("input#myURL").val(),
                    success: function (data,status, xhr) {	
                    	vecesOK++;
                    	//chart.options.data[0].dataPoints.push({y: 23}); // Add a new dataPoint to dataPoints array 
						chart.options.data[0].dataPoints[0].y = vecesOK ;  // Update an existing dataPoint
						chart.options.data[0].dataPoints[1].y = vecesError;
						chart.render();
                    },
					error: function (data,status,xhr) {	
						vecesError++;	
                    	//chart.options.data[0].dataPoints.push({y: 23}); // Add a new dataPoint to dataPoints array 
						chart.options.data[0].dataPoints[0].y = vecesOK ;  // Update an existing dataPoint
						chart.options.data[0].dataPoints[1].y = vecesError;
						chart.render();
					}
                });
			}
			
            $("#start").click(function () {
				interval = setInterval(invokeURL, $("input#myTimer").val());								
                return (false);
            });
			$("#stop").click(function () {
				clearInterval(interval);				
                return (false);
            });

        });
    </script>
</head>
<body>
    <p><div id="myOutput" style='font-size:12pt;font-family:sans-serif'>...</div><p>	
    <div id="chartContainer" style="height: 370px; width: 100%;"></div>
    <p>Invoca: <input id="myURL" value="https://sofia2.com/sib-api/services/rest/monitoring" type="text" size="50"/> cada <input id="myTimer" value="5000" type="text" size="4"/> ms</p>
    <p><input id="start" value="Ejecutar" type="submit"/> <input id="stop" value="Parar" type="submit"/></p>	


</body>
</html>

Cómo hacer un gadget que comprueba estado de APIs REST con Sofia2

Atención RRSS: Capturando menciones en Twitter con Zapier

Seguro que tras leer el interesante post de Raquel: Seguimos jugando con Zapier y Sofia2 sois capaces de crear vuestras orquestaciones sin ninguna ayuda!

En mi caso, este post pretende ser el primer paso para realizar una atención al cliente a través de Redes Sociales con Sofia2…empecemos:

El proceso comienza con un tweet en el que se hace mención a @SOFIA2_Platform (en este caso la mención la hago yo mismo, aunque el caso real incluiría a un usuario haciendo mención a una marca concreta):

Luego iré a Zapier y me registraré si aún no lo estoy o me logaré si lo estoy.

Una vez logado, si es la primera vez que uso Sofia2 en un ZAP tendré que acceder a esta invitación: https://zapier.com/developer/invite/78124/370d73c38b842446d8ecbc76b7f5849d/ para poder usar el conector.

Pulsando en Create me encontraré con el editor. Me aparecerá seleccionado

Iré a para seleccionar un Trigger, en mi caso Twitter:

Tras seleccionarlo me aparecerán todas las opciones de este Trigger:

– Trigger cuando aparezca una mención a un término (palabra, username, hashtag)

– Trigger cuando tuiteo

– Trigger cuando aparece una mención en una posición geográfica

– …

Las vemos aquí:

En nuestro caso seleccionaré Search Mention.

Tras esto me pedirá conectaar con una cuenta de Twitter:

Y me pedirá permiso para acceder a mi cuenta:

Y:

Tras un par de redirecciones:

Me mostrará que la conexión con mi cuenta ha funcionado:

En esta parte ya sólo me falta poner los términos de búsqueda, en mi caso:@SOFIA2_Platform:

Tras configurarlo se realiza un test, y nos muestra la información que se ha obtenido del test ejecutado:

Esta información es muy importante, ya que de entre todos estos campos luego seleccionaré los que quiero cargar en la plataforma.

Tras configurar el Trigger paso a configurar el Action, buscaré en:

Y seleccionaré Insert Data in Sofia2:

Ahora debo irme a mi instancia Sofia2, en el ejemplo yo he usado la instancia CloudLab de Sofia2 (http://sofia2.com/console/) , que como sabéis es gratuita y que os permite probar todas las capacidades de la Plataforma sin restricciones ni tiempo máximo.

Una vez registrado y con rol COLABORADOR (recordad que cuando nos registremos tenemos el rol USUARIO en la plataforma, y debo pedir la promoción a ROL COLABORADOR explicando el motivo, puedo crear mi ontología (Sofia2PlatformInTwitter):

Partiendo de la plantilla EmptyBase:

Sobre esta plantilla elijo las propiedades que deseo añadir, en mi caso quiero capturar:

· Texto del tweet

· Usuario del tweet

· Descripción del usuario

· Lenguaje del tweet

· url del tweet:

Mi ontología tiene este aspecto:

Tras esto crearé un KP y le asociaré la ontología:

Y apuntaré el token

De este proceso debo quedarme con:

· Nombre de la Ontología

· Nombre del KP + instancia 1

· Token de acceso a la plataforma

Que introduciré en los campos

Y finalmente mapearé los atributos obtenidos resultado del Trigger del paso 1 con el formato de mi ontología que es este:

{"EmptyBase":{ "text":"string","userDescription":"string","user":"string","userName":"string","lang":"string","tweetUrl":"string"}}

Para eso en la parte Data iré mapeando a través del botón:

Eligiendo los atributos:

Hasta dejarlo finalmente:

Pulsaré y finalmente:

Para comprobar que mi ZAP está funcionando volveré a mi instancia Sofia2, accederé a Consola BDTR y BDH y haré una consulta:

Donde podré ver que ya tengo los datos en la Plataforma:

Para acabar activaré mi ZAP:

Atención RRSS: Capturando menciones en Twitter con Zapier