Affichage des articles dont le libellé est app inventor. Afficher tous les articles
Affichage des articles dont le libellé est app inventor. Afficher tous les articles

13/03/2016

big data facile - une application pour insérer des données sur un serveur Fuseki

[ cet article fait partie de la série RDF FACILE - Mon petit BigData ]

Repartons de l'application Android faite avec AppInventor pour visualiser les informations de notre serveur Fuseki comme nous l'avons construite ici : http://smag0.blogspot.fr/2016/03/bigdata-facile-une-application-android.html

Si vous avez tout bien suivi, vous avez créé un écran "Saisie", et nous avons sur cette page http://smag0.blogspot.fr/2016/03/un-serveur-fuseki-rdf-bigdata-sur.html  une piste pour construire la requete que nous devons envoyer pour insérer des données :

PREFIX rdf:   <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX rdfs:   <http://www.w3.org/2000/01/rdf-schema#>
PREFIX ex:   <http://example.org/>
PREFIX zoo:   <http://example.org/zoo/>
PREFIX owl: <http://www.w3.org/2002/07/owl#>


INSERT DATA {
GRAPH <http://example/bookStore>
{
ex:dog1    rdf:type         ex:animal .
ex:cat1    rdf:type         ex:cat .
ex:cat     rdfs:subClassOf  ex:animal .
zoo:host   rdfs:range       ex:animal .
ex:zoo1    zoo:host         ex:cat2 .
ex:cat3    owl:sameAs       ex:cat2 .
}
}

Je rappelle que pour les flémards, le code de la première partie (récupération des données) est accessible ici : http://ai2.appinventor.mit.edu/?galleryId=4993525195735040

Les données au format RDF se présentent sous la forme de triplets, si c'est pas clair pour toi, jette un oeil là https://fr.wikipedia.org/wiki/Resource_Description_Framework .
Nous avons donc besoin de trois champs.
Dans App Inventor, passez sur l'écran "Saisie" que nous avons créé dans le tuto précédent, et insérez trois zone de texte ( on va repasser en english, car la traduction en français pose quelques problèmes lors des tests...)
Comme pour la page "Visualisation", insérons un bouton retour accueil, avec le même code que précedemment.
Ainsi que trois zones de texte, profitez-en pour les renommer, passer leur "width" à "Fill Parent" et mettre des Hint selon le contenu que l'on attend : Sujet, propriete, Objet... ça sera plus parlant pour la suite.
Oui , je sais , Sujet et Objet ont droit à la majuscule, mais pas "propriété", c'est un peu comme ça en RDF... alors gardons cette norme, ça ne peut pas faire de mal...
N'oubliez pas aussi d'ajouter un composant Web1 que vous trouverez dans Connectivity, c'est lui qui va nous faire la requête POST, mais pour ça, il va falloir lui donner la bonne requête.
Complétez par une nouvelle zone de texte, que l'on nommera "Résultat", avec Height et Width à "Fill Parent, et "Hint" à "Attente resultat".



Passons maintenant à l'envers du décor, en cliquant sur le bouton "Blocks".
Pour faire au plus simple, considérons que les trois éléments que nous allons insérer avec notre première requête, ont tous le même préfixe :  PREFIX ex:   <http://example.org/>.

Notre application devra donc envoyer la requete :

PREFIX ex:   <http://example.org/>

INSERT DATA {
GRAPH <http://example/bookStore>
{
ex:Sujet    ex:propriete         ex:Objet .
}
}

Et pour ce faire, nous aurons besoin de récupérer les valeurs qui se trouvent dans nos trois zones de texte.

Commençons par la ligne où se trouve notre triplet (ex:Sujet    ex:propriete         ex:Objet .)
Les quelques blocs suivants devraient nous faire apparaître notre ligne dans la zone de texte "Résultat" :
On initialise nos variables Sujet, propriete, Objet, ainsi que la requeteUpdate.
Au click du bouton, on concatène la chaîne "ex:" avec chacune des valeurs récupérées dans nos trois textBox.
On construit ensuite notre requeteUpdate, en joignant nos trois variables, en les séparant d'un espace .
Astuce : pour ajouter une nouvelle ligne dans un "join", cliquez sur la roue sur fond bleu.
Attention, bien mettre un espace dans les deux blocs entre "get  global Sujet " et "get global propriete" ainsi que entre les blocs "get global propriete" et "get global Objet" .
On termine notre "set global requeteUpdate" par un bloc texte qui contient un espace et un point " .", c'est ainsi qu'on termine un triplet simple en rdf.
Et pour finir, on affiche notre "global requeteUpdate" dans la zone texte "Resultat"



Pour tester, utilisez l'appli " compagnon App Inventor", et entrez un triplet rdf, par exemple :
dans Sujet : David
dans propriété : type
et dans Objet : Personne
cliquez ensuite sur "Envoyer"

Si tout se passe bien, vous devriez immédiatement voir apparaître :
ex:David ex:type ex:Personne . 
Si c'est le cas, BRAVO ! on y est presque, il suffit juste d'envoyer tout ça au serveur (http://rdf-smag0.rhcloud.com/) mais avant de pouvoir lui demander d'intégrer ces information, nous devons y mettre les formes...

L'enrobage sauvage...
Pour voir si ça marche, on va juste englober notre triplet par le strict nécessaire :
Avant notre triplet, on va mettre :
PREFIX ex:   <http://example.org/>
INSERT DATA {
GRAPH <http://example/bookStore>
{
et à près, on fermera par
}
}

C'est pas très orthodoxe, mais le principal, c'est de tester si ça marche, alors on va la faire simple, on aura tout le loisir de faire joli ensuite.
Attention.... POF :
-  une variable "debutRequete" avec comme valeur :
PREFIX ex:   <http://example.org/> INSERT DATA { GRAPH <http://example/bookStore> 
- et une variable "finRequete" avec comme valeur :
}}

Bouhhh ! c'est pas bien !!!



On complète ensuite notre "requeteUpdate", en ajoutant deux blocs :
 "get global debutRequete" (avant "get global Sujet" )
et "get global finRequete" (après le bloc " .").

Votre code devrait maintenant ressembler à ceci :


et le texte qui s'affiche dans la zone de texte "Resultat" à ceci :
PREFIX ex:   <http://example.org/> INSERT DATA { GRAPH <http://example/bookStore> ex:David ex:type ex:Personne . }}


Nous avons maintenant nos données, que nous avons mis dans une enveloppe.
Le destinataire, c'est le serveur http://rdf-smag0.rhcloud.com/, on va même être plus précis, car sa boite au lettre se trouve à l'adresse : http://rdf-smag0.rhcloud.com/update, et il va falloir envoyer à cette adresse, une requête de type POST.
Il ne reste plus qu'à mettre en place le transporteur... et c'est là qu'intervient notre composant "WEB1" que nous avions inséré au tout début de ce post...

Créons maintenant une nouvelle variable que nous nommerons "endpointUpdate" et donnons-lui la valeur de l'adresse de la boite aux lettres de notre serveur "http://rdf-smag0.rhcloud.com/ds/update"

Ensuite, on sort le bloc "set Resultat.Text" du bloc "When EnvoyerBouton.click", et à la place, on y met deux blocs : "set Web1.Url" et "Call Web1.PostText" qui vont respectivement donner à WEB1 l'adresse de destination, et la valeur du paramètre "update=".

Et bien voilà, le plus dur est fait... pas insurmontable, quand même...
juste une toute petite dernière chose, pour être sûr du résultat...
Ajouter un bloc "When Web1.gotText" qui s'exécutera dès que la réponse du serveur arrivera... avec à l'intérieur, l'affichage dans la zone de texte "Résultat", de la valeur "reponseContent".



Lorsque vous testez maintenant votre appli, ( MIT compagnon) et que vous cliquez sur "Envoyer", vous devriez voir apparaitre dans la zone "Résultat", la ligne suivante :
<html><head></head><body><h1>Success</h1><p>Update succeeded </p></body></html>


et c'est plutôt bon signe : <h1>Success</h1><p>Update succeeded </p>

Pour vérifier, repassez sur l'écran d'accueil après avoir ajouté le code du bouton "retour Accueil", puis sur l'écran "Visualisation" comme nous l'avons implémenté ici http://smag0.blogspot.fr/2016/03/bigdata-facile-une-application-android.html
mais c'est plus joli ici http://rdf-smag0.rhcloud.com/ds/query?query=select+*+where+%7B%3Fs+%3Fp+%3Fo%7D&output=text , car pour l'instant dans la visualisation, on n'a pas formaté le résultat...


Si t'es arrivé jusque là, t'es plus un flemmard, alors cadeau : le code sur AppInventor : http://ai2.appinventor.mit.edu/?galleryId=5233374557372416

Les retours sont les bienvenus, si j'ai fait des boulettes, ou si je ne suis pas clair. Pour rappel : ceux qui veulent s'installer leur propre serveur peuvent le faire en local (en téléchargeant Apache Fuseki ou sur le cloud , par exemple Openshift en récupérant le source ici : https://github.com/scenaristeur/smag0-fuseki-rdf-openshift



[ cet article fait partie de la série RDF FACILE - Mon petit BigData ]



bigdata facile - une application Android pour visualiser, les informations sur un serveur bigdata perso

[ cet article fait partie de la série RDF FACILE - Mon petit BigData ]

Le but de ce post est de faciliter la construction d'une petite appli pour mettre à jour, consulter, visualiser les informations d'un serveur Fuseki (serveur RDF/Sparql), et de créer ainsi, notre petit #bigdata à nous ;-).

La première étape est d'avoir accès à un serveur Fuseki/Sparql. Pour ce faire, vous pouvez suivre les instructions décrites ici : http://smag0.blogspot.fr/2016/03/un-serveur-fuseki-rdf-bigdata-sur.html ou utiliser celui qui y est mentionné ( serveur de test : http://rdf-smag0.rhcloud.com/ )

Pour créer l'appli, on va utiliser ce qu'il y a de plus simple --> Pas la peine de se prendre la tête...


Créez un compte sur App inventor, et commencez un nouveau projet. ( Les flémards peuvent aussi piquer le code ici : http://ai2.appinventor.mit.edu/?galleryId=4993525195735040).

Si vous n'avez jamais pratiqué App Inventor, faites-vous la main avec les tutos, ou posez-vos questions en commentaire de ce post, on trouvera bien quelqu'un pour vous répondre...
Mais d'abord commençons par faire le point sur ce qui va nous être utile :
  1. une requête pour aller interroger le serveur : http://rdf-smag0.rhcloud.com/ds/query?query=select+*+where+%7B%3Fs%3Fp%3Fo%7D&output=json . Je sais, c'est un peu brut pour ceux qui ne connaissent pas le rdf, et les requêtes Sparql, mais ce n'est pas le sujet de cet article...
Entrons dans le vif du sujet
Lorsque vous ouvrez un nouveau projet sur App inventor, le premier écran est Screen1, on va en créer deux autres grâce au bouton "ajouter écran" (en admettant que vous ayez passé votre interface de App Inventor en français... si si, c'est possible, en haut à droite ).
Nos deux nouveaux écrans pourraient par exemple s'appeler "Visualisation" et "Saisie".
Sur l'écran Screen1, créez deux boutons pour accéder aux écrans que l'on vient de créer, et affectez leur le code pour ouvrir les écrans respectifs.
( Pour la bascule Designer / Bloc, utilisez les deux boutons "Designer" & "Blocs", juste au dessus du panneau "Propriétés" )




Avec les blocs : 




Attaquons-nous pour commencer à l'écran "Visualisation".
Pour voir ce que notre serveur a dans le ventre, on va ajouter un composant "WEB", on le trouve dans "Connectivité" de la "Palette". C'est lui qui se chargera de la requete.
Ajoutez aussi un bouton pour le retour sur l'écran d'accueil,  une "zone de texte" avec les propriétés Height et Width en "remplir parent", et "Nuance" en "Attente résultat", c'est là que l'on affichera le retour de la requête, dans un premier temps.


Et en backstage : 



Dans le mode "Blocs", Ajouter une variable , nommez-la "requeteTest" et donnez-lui la valeur : http://rdf-smag0.rhcloud.com/ds/query?query=select+*+where+%7B%3Fs%3Fp%3Fo%7D&output=json 
Complétez les blocs de codes comme l'image ci dessus : 

Quand "Visualisation initialise, faire " / mettre Web1.Url à obtenir global requestTest, appeler Web1.Obtenir

Quand Web1.Texte reçu, faire / Mettre TextBox1.Texte à / obtenir Contenu de réponse

et le code pour le retour sur la page d'accueil : 

Quand Bouton1Click, faire / Fermer l'écran

Vous pouvez déjà tester votre appli , le mieux , c'est avec le AI Compagnon, dans le menu "Connecté", mais c'est pas encore au point, repassez sur l'interface en anglais, orsque vous souhaitez tester votre application --> attention, verifiez que "contenu de réponse s'est bien traduit en "Content réponse" .

Si tout va bien, vous devriez voir appraitre dans la zone de texte, un truc qui ressemble à : 



{
  "head": {
    "vars": [ "s" , "p" , "o" ]
  } ,
  "results": {
    "bindings": [
      {
        "s": { "type": "uri" , "value": "http://example.org/dog1" } ,
        "p": { "type": "uri" , "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type" } ,
        "o": { "type": "uri" , "value": "http://example.org/animal" }
      } ,
      {
        "s": { "type": "uri" , "value": "http://example.org/cat1" } ,
        "p": { "type": "uri" , "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type" } ,
        "o": { "type": "uri" , "value": "http://example.org/cat" }
      } ,
      {
        "s": { "type": "uri" , "value": "http://example.org/cat" } ,
        "p": { "type": "uri" , "value": "http://www.w3.org/2000/01/rdf-schema#subClassOf" } ,
        "o": { "type": "uri" , "value": "http://example.org/animal" }
      } ,
      {
        "s": { "type": "uri" , "value": "http://example.org/zoo/host" } ,
        "p": { "type": "uri" , "value": "http://www.w3.org/2000/01/rdf-schema#range" } ,
        "o": { "type": "uri" , "value": "http://example.org/animal" }
      } ,
      {
        "s": { "type": "uri" , "value": "http://example.org/zoo1" } ,
        "p": { "type": "uri" , "value": "http://example.org/zoo/host" } ,
        "o": { "type": "uri" , "value": "http://example.org/cat2" }
      } ,
      {
        "s": { "type": "uri" , "value": "http://example.org/cat3" } ,
        "p": { "type": "uri" , "value": "http://www.w3.org/2002/07/owl#sameAs" } ,
        "o": { "type": "uri" , "value": "http://example.org/cat2" }
      }
    ]
  }
}


c'est le résultat de notre requete au format JSON !!! 
Yahou, Wahou, on a récupéré nos infos...
Et maintenant ???

Maintenant, nous plusieurs pistes :
1. modifier la requête pour qu'elle ne renvoie que les résultat qui nous intéressent, Thérèse.
2. traiter et mettre en forme ces données pour les afficher selon notre besoin,
3. créer la page de saisie pour insérer de nouvelles données sur notre serveur

Laquelle de ces trois pistes souhaitez-vous pour le prochain article ? 



[ cet article fait partie de la série RDF FACILE - Mon petit BigData ]



15/01/2015

Android et RDF sur le serveur Fuseki - Jena

une application android créée avec App-Inventor permet d'inserer et de lire les informations RDF présentes sur le serveur FUSEKI : http://fuseki-smag0.rhcloud.com/, elles sont récupérées au format JSON.


Cette démo est un premier test... juste pour la preuve du concept.
Maintenant je peux envoyer des infos sur mon serveur FUSEKI, et les récupérer sur mon smartphone Android. Utile pour envoyer des infos au système multi-agent Smag qui gère mon domicile : http://smag-smag0.rhcloud.com/ . Le code est disponible ici : https://github.com/scenaristeur/smagserver


ici se trouve le code source et l'apk : https://drive.google.com/folderview?id=0B0zEK4yLB5C6UUVsMWNkbDZ0WEU&usp=sharing

le fichier Projet.aia est à importer en tant que nouveau projet sur App-inventor : http://ai2.appinventor.mit.edu/

le fichier Projet.apk est prêt à l'emploi

deux fonctions sont incluses pour l'instant : Derniers projets et Ajout d'un projet (Connection internet /wifi activée nécessairement)
Parfois le serveur fuseki met du temps à démarrer. attendez 30 secondes et renouvelez en cas d'échec

!!!! première étape franchie !!! Yahou !!!!

Les deux serveurs Fuseki et Smag sont hébergés sur openshift . Le serveur Smag utilise le système multi-agent Janus