Con Google Apps Script il concetto è semplice, bisogna accedere a Drive e creare un nuovo documento. Andare su Altro e poi Collega altre applicazioni.

Filtrando tra quelle di Google, dobbiamo aggiungere Google Apps Script.

Ora tra i documenti disponibili abbiamo anche Google Apps Script.

Creiamo quindi un nuovo documento script.

Si aprirà un documento dove possiamo scrivere codice javascript.

Come si legge nella documentazione:

Quando uno script viene pubblicato come una web app , la funzioni speciali di callback doGet( ) e doPost( ) vengono invocate quando viene effettuata una richiesta per l’URL dello script . Invece di restituire un oggetto dell’interfaccia utente creato con l’UI Service o l’HTML Service, il Content Service può essere utilizzato per restituire contenuto testuale crudo. Questo consente di scrivere script che agiscono come “servizi” , rispondendo alle richieste GET e POST e servono dati di vario tipo MIME.

Possiamo quindi costruire il nostro servizio web, scrivendo ad esempio queste poche righe di codice:

function doGet(){
returnContentService.createTextOutput('Hello, world!');}

Di fatto abbiamo realizzato un servizio che risponde a una chiamata GET scrivendo “Hello, world!”.

Ora siamo pronti per pubblicarlo, per capire come funziona la pubblicazione. Poi potremmo fare qualcosa di più utile, come ad esempio rispondere con un JSON contenente qualche dato elaborato a partire da un parametro passato nella chiamata.

Le istruzioni per la pubblicazione sono riportate qui, ma di fatto è sufficiente andare da menu Pubblica > Distribuisci come applicazione web.. e vedremo apparire questa finestra. Dopo aver salvato la versione del progetto, ci verrà chiesto come pubblicare la nostra applicazione.

Esegui applicazione come: stabilisce qual’è l’utente che esegue lo script. Se scegliamo di farlo eseguire dall’utente che accede, quest’ultimo dovrà approvare l’esecuzione dello script prima di poterlo lanciare, se invece si sceglie di farlo eseguire come se stessi, l’utente sviluppatore dovrà approvare lo script la prima volta, poi chiunque accede potrà lanciarlo senza doverlo approvare. Con questa seconda opzione sarà quindi possibile distribuire il web service che stiamo creando anche a utenti anonimi (non loggati in Google).

Chi accede all’applicazione: abbiamo diversi gradi, possiamo scegliere di tenere il servizio privato, oppure pubblico per utenti loggati in google o addirittura per qualsiasi utente, e di conseguenza anche qualsiasi applicazione di terzi.

Di fatto ora possiamo chiamare da browser l’url che Google ci restituisce dopo la pubblicazione, per vedere apparire il nostro “Hello, world!”.

Vediamo come fare qualcosa di più evoluto, ad esempio un servizio che prende in pasto un numero e restituisce un JSON con scritto se è pari o dispari.

Scriviamo questo codice:

function doGet(request) {
var number = request.parameter.number;
if (number % 2 == 0) { var type = "pari"; } else { var type = "dispari"; }
var result = {
numero: number,
tipologia: type,
};
return ContentService.createTextOutput(JSON.stringify(result))
.setMimeType(ContentService.MimeType.JSON);
}

Abbiamo aggiunto l’oggetto request tra i parametri della funzione doGet(), ci salviamo il parametro “number” in una variabile e calcoliamo se è pari o dispari. Poi scriviamo tutto nell’oggetto result, restituendolo come JSON.

Dovremo salvare una nuova versione dello script, andando su File > Gestisci Versioni.. e poi tornare a pubblicare lo script in questa nuova versione. Se all’url ora aggiungiamo la stringa ?number=42, otterremo questo risultato, chiamandolo dal browser:

{"numero":"42","tipologia":"pari"}

Di fatto abbiamo realizzato un web service o lo abbiamo reso pubblico in un attimo, il tutto senza mai lasciare il nostro browser.

Se poi volessimo spingerci oltre, potremmo addirittura anche andare a leggere un foglio spreadsheet e restituire i valori delle celle che contiene. Pensiamo a quante mirabolanti applicazioni potremmo costruire se avessimo una infrastruttura basata sulle Google Apps for Enterprise, potremmo ad esempio costruire web service che pubblicano i dati di un foglio condiviso, dove più utenti di una stessa azienda collaborano alla definizione di dati che poi vengono distribuiti ad applicazioni terze.

E per restituire le prime 9 celle di un foglio chiamato “Foglio1″ sarebbe sufficiente un pezzo di codice così:

function doGet(request) {
var key = request.parameter.key;
if (key == "chiave_di_autenticazione") {
var ss = SpreadsheetApp.openById(id_del_documento);
var values = ss.getSheetByName("Foglio1").getRange(1,1,3,3).getValues();
return ContentService.createTextOutput(values);
} else {
return ContentService.createTextOutput("Invalid Key");
}
}

Bello vero? :)

Supponiamo di aver realizzato un function module in SAP semplicissimo: due parametri in ingresso (un numero e una stringa) e due parametri in uscita (lo stesso numero al quadrato e la stessa stringa).
Di seguito il codice ABAP di tale funzione:

FUNCTION Z_TEST000.
*"----------------------------------------------------------------------
*"*"Interfaccia locale:
*" IMPORTING
*" VALUE(NUM) LIKE BAPISDHD1-DUN_COUNT DEFAULT 4
*" VALUE(TEXTTEST) LIKE MARA-MATNR
*" EXPORTING
*" VALUE(RETURNNUM) LIKE BAPISDHD1-DUN_COUNT
*" VALUE(RETURNCHAR) LIKE MARA-MATNR
*"----------------------------------------------------------------------
returnnum = num * num.
returnchar = texttest.
ENDFUNCTION.

Supponiamo anche di averla pubblicata come web service, in modo da avere l’indirizzo del WSDL per poter aggiungere il riferimento al servizio nella nostra soluzione di Visual Studio. Le indicazioni che trovate qui, per aggiungere il servizio in modo da poterlo utilizzare nel codice restano valide, in estrema sintesi: tasto destro sul nome della soluzione (il nodo root del nostro sito web) poi aggiungi.. -> riferimento al servizio..

Nella maschera che appare basta mettere l’url del documento WSDL e dare un nome al servizio, che nel nostro caso è ztestoneee.

Questo il codice del front-end, una pagina in cui c’è solamente un pulsante che lancia un metodo per chiamare il web service e una label in cui visualizzeremo i risultati di questa chiamata.

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %>
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
<title></title>
</head>
<body>
<form id="form1" runat="server">
<div>
<asp:Button ID="Button1" runat="server" Text="Vai bello!" OnClick="button_click" />
<asp:Label ID="Label1" runat="server" Text="incrocia le dita"></asp:Label>
</div>
</form>
</body>
</html>

A questo punto non resta che vedere il codice C# per consumare effettivamente il web service. Ci servono di fatto 3 oggetti:

• input: contiene i parametri da inviare al web service
• client: è l’oggetto che esegue la chiamata
• response: è l’oggetto che raccoglie la risposta dal web service

Leggendo il codice sotto e i relativi commenti si può capire al volo il concetto.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Globalization;
using ztestoneee;
public partial class _Default : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
//al caricamento della pagina non succede nulla
}
protected void button_click(object sender, EventArgs e)
{
//inizializzo oggetti: input, client e response
ztestoneee.Z_TEST000 input = new ztestoneee.Z_TEST000();
ztestoneee.ztestoneClient client = new ztestoneee.ztestoneClient();
ztestoneee.Z_TEST000Response response = new ztestoneee.Z_TEST000Response();
//inserisco valori da passare alla chiamata
input.NUM = 3;
input.NUMSpecified = true;
input.TEXTTEST = "Nice!";
//chiamata a web service
response = client.Z_TEST000(input);
//elaboro e pubblico la risposta
decimal returnnum = response.RETURNNUM;
string returnchar = response.RETURNCHAR;
Label1.Text = "Hey dude: " + returnnum + returnchar;
}
}

Il gioco è fatto.

Il prerequisito di base è che la function abbia alcune proprietà basilari: “Modulo accessibile in remoto”, vedi figura dalla transazione SE37.

Per pubblicarla come servizio web, basta andare da menu, sempre nella SE37: Utilities -> Altre Utilities -> Generare servizio web -> Dal function module (vedi figura)

Bisognerà poi seguire il wizard come da figure sotto, dando un nome al web service.

Per pubblicare senza richiesta di autenticazione, selezionare come da figura sottostante:

Scegliere il pacchetto e la richiesta di trasporto.

Cliccare su “completare”, si aprirà la maschera di creazione del servizio e resterà solamente da attivare il servizio (con l’icona di attivazione).

Ora bisognerà terminare il lavoro dalla transazione SOAMANAGER (introdotta con l’ECC 6).
Si aprirà una finestra del browser, da qui bisogna andare su “Web service configuration”

Da qui è possibile ricercare il web service appena creato, selezionarlo, premere “apply selection” e andare sulla tab “configuration”

Qui bisogna creare un nuovo servizio.

Bisogna inserire un nome per il servizio e per il binding, poi premere “Apply Settings”

Sotto si aprire una maschera con le impostazioni del servizio, bisognerà configurarle. Se ad esempio si vuole impostare un utenza fissa, in modo tale che le applicazioni esterne chiamino il servizio senza autenticarsi ogni volta, si può configurare come in figura sotto. Alla fine premere “Save”.

A questo punto è tutto pronto.

Bisognerà premere su “Open WSDL document for selected binding or service” per ottenere l’url della definizione del web service, da utilizzare ad esempio su SOAP UI per poter consumare il web service e testarlo.

E se un giorno volessimo ripubblicare il servizio dopo aver cambiato la function?

Magari viene aggiunto un parametro di input/output, il web service non recepirà queste modifiche finchè non lo torniamo a pubblicare. Per fare ciò, da SAP, dobbiamo accedere alla transazione SE80. Selezionare il pacchetto in cui è stata salvata la function e poi selezionare il proprio servizio web sotto “Enterprise Service -> Service Provider”. Andare in modifica e da menù come da immagine sottostante.

Salvare e attivare.

Ora il web service avrà ereditato le modifiche.

Lato SAP, dopo aver scritto il nostro function module in ABAP (che in questo esempio estrae una tabella di dati tramite alcuni parametri in input e averlo reso disponibile pubblicandolo come web service), per evitare che sia necessario passare le credenziali di accesso durante la chiamata al web service, possiamo pubblicarlo con un utente di default. Per fare ciò: dalla transazione SICF, individuare il web service nel ramo sap/bc/srt/rfc/sap/, entrare in modifica e settare l’utente nella sezione “Dati di logon anonimi”.

Avevo già appuntato qualche nota su come consumare un web service da una pagina ASPX, tutto quello che sta scritto in quell’articolo è ovviamente valido, ma questa volta aggiungeremo il servizio al nostro progetto in un modo leggermente diverso. Da Visual Studio 2010, cliccando col tasto destro sul nome del progetto e selezionando la voce di menù “Aggiungi riferimento al servizio..”

Nella popup che appare inseriremo l’url del servizio web di SAP e sceglieremo un nome: in questo caso d’esempio lo chiameremo “Ws_Factory”.

A questo punto siamo pronti per sfruttare il web service su una pagina aspx. La pagina avrà un DataGrid che servirà per pubblicare la tabella restituita dal web service, in questo datagrid vengono esplicitate solo le colonne da visualizzare, i nomi sono esattamente gli stessi nomi dei campi della tabella su SAP (se avessimo voluto far visualizzare tutta la tabella, bastava non riportare alcuna colonna). Ecco il codice aspx:


<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title>Esempio Webservice</title>
<link href="StyleSheet.css" rel="stylesheet" type="text/css" />
</head>
<body>
<form id="form1" runat="server">
<div id="container">
<div id="main-container">
<asp:GridView ID="GridVisual" AutoGenerateColumns="false" runat="server" CellPadding="0" CellSpacing="0">
<Columns>
<asp:BoundField HeaderText="CdL" DataField="ARBPL"></asp:BoundField>
<asp:BoundField HeaderText="Materiale" DataField="MATNR"></asp:BoundField>
<asp:BoundField HeaderText="Squadra" DataField="TEAMTXT" ItemStyle-CssClass="team"></asp:BoundField>
<asp:BoundField HeaderText="T Setup" DataField="SETUP_TIME"></asp:BoundField>
<asp:BoundField HeaderText="T Lavorato" DataField="WORKED_TIME"></asp:BoundField>
<asp:BoundField HeaderText="T Sospensione" DataField="TIMEOUT"></asp:BoundField>
<asp:BoundField HeaderText="Pz Teorici" DataField="QTY_THEORETICAL"></asp:BoundField>
<asp:BoundField HeaderText="Pz Reali" DataField="LMNGA"></asp:BoundField>
<asp:BoundField HeaderText="Pz Scarto" DataField="XMNGA"></asp:BoundField>
<asp:BoundField HeaderText="Efficienza Prod" DataField="EFFICIENCY"></asp:BoundField>
<asp:BoundField HeaderText="Pz da Produrre" DataField="QTY_TO_PROD"></asp:BoundField>
<asp:BoundField HeaderText="T al Setup Succ" DataField="NEXT_SETUP"></asp:BoundField>
<asp:BoundField HeaderText="Stato" DataField="VM_STATUS"></asp:BoundField>
</Columns>
</asp:GridView>
</div>
</div>
</form>
</body>
</html>

Il codice C# necessario è riportato sotto, con relativi commenti che spiegano tutti i passaggi:


using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using Ws_factory; //riferimento al Web Service di SAP
public partial class _Default : System.Web.UI.Page
{
// Inizializzazione oggetti
Ws_factory.YSVISUAL_MNGT MyVisual = new Ws_factory.YSVISUAL_MNGT();
Ws_factory.ys_ws_factory_vmClient MyClient = new Ws_factory.ys_ws_factory_vmClient();
Ws_factory.YS_FACTORY_VMRequest MyRequest = new Ws_factory.YS_FACTORY_VMRequest();
Ws_factory.YS_FACTORY_VMResponse MyResponse = new Ws_factory.YS_FACTORY_VMResponse();
protected void Page_Load(object sender, EventArgs e)
{
/* YSVISUAL_MNGT[] è la tabella dove vengono restituiti i dati dal web service di SAP
* Inizializzo come vuota */
YSVISUAL_MNGT[] MyVisual = new YSVISUAL_MNGT[] { };
/* Compilo i parametri della richiesta mettendo i filtri che mi interessano */
//MyRequest.CT_YSVISUAL_MNGT = MyVisual;
MyRequest.IV_ARBPL = "";
MyRequest.IV_DTOEE = "";
MyRequest.IV_NEW_RUN = "";
MyRequest.IV_WERKS = "P100";
/* Lancio il metodo via web passando i parametri appena impostati sopra,
* il riferimento della tab da popolare coi risultati è la tabella MyVisual */
MyClient.YS_FACTORY_VM(ref MyVisual, MyRequest.IV_ARBPL, MyRequest.IV_DTOEE, MyRequest.IV_NEW_RUN, MyRequest.IV_WERKS);
MyResponse.CT_YSVISUAL_MNGT = MyVisual;
/* Ora elaboro i dati restituiti per farli visualizzare sulla pagina */
GridVisual.DataSource = MyResponse.CT_YSVISUAL_MNGT;
GridVisual.DataBind();
}
}

Questo è semplicemente il punto di partenza, da qui è ovviamente possibile spingersi oltre e perdere tempo a volontà.. ;)

SAP è un mondo, ma ogni tanto questo mondo deve poter essere “visto” e “manipolato” dall’esterno. Senza infinte elucubrazioni sulla SOA (Service Oriented Architecture), venendo subito al sodo: l’obiettivo di questo articolo è fissare i passaggi per pubblicare come web service un function module di SAP scritto in ABAP.

Dopo aver creato il function module (transazione SE37), dovremo avviare il wizard per la pubblicazione (il wizard funziona correttamente con il logon in inglese):

• Su ECC5.0:  Menu Utilities > Altre utility > Generare servizio web > Dal function module
• Su ECC6.0:  Tasto destro > Creare Web Service

In seguito attivare i servizi sulla transazione SICF:

• /default_host/sap/bc/soap
• /default_host/sap/bc/srt
• Ogni web service è rappresentato come servizio ICF nel ramo /default_host/sap/bc/srt/rfc/sap/

Bisognerà poi recuperare l’url del web service pubblicato. Le transazioni disponibili dipendono dalla versione del Service Pack:

• WSADMIN
• WSCONFIG
• SOAMANAGER

I passaggi sono i seguenti:

• Cercare e selezionare il web service nel nodo SOAP Application for RFC-Compliant FMs
• Menu Web Service > WSDL
• Nella popup selezionare Document Style
• Si apre il browser con il link e  la definizione del WSDL
  • Non serve la configurazione del J2EE. Nel caso sia attivata, configurarla da Menu: Passaggio a > Parametrizzazione Amministrazione (esempio http://dominio.it:50000)
  • Se non è attivata la parte J2EE, il WSDL lavora sulla porta dell’ITS (esempio http://dominio.it:8000/sap/bc/srt/rfc/sap/Z_WS_TEST_CUSTOMER_DETAIL?sap-client=600&wsdl=1.1 )
• Il link per le BAPI standard è: http://dominio.it:8000/sap/bc/soap/wsdl11?services=BAPI_CUSTOMER_GETDETAIL2&sap-client=600

Per testare il web service si può utilizzare un programma come SOAP UI. Dopo averlo installato, i passaggi da fare sono i seguenti:

• Creare nuovo progetto
• Nel progetto aggiungere un WSDL
• Indicare il link recuperato dalla transazione WSADMIN
• Inserire username e password dell’account SAP nel riquadro in basso a sinistra

Nella zona di sinistra vanno inseriti i parametri di input, rimuovendo i punti interrogativi. Poi premere il tasto con la freccia verde e nella parte di destra comparirà il risultato restituito dal web service.

Non vado oltre anche se il tema meriterebbe molti approfondimenti, riporto queste poche informazioni come promemoria per chiunque si debba cimentare; nel caso qualcuno voglia maggiori informazioni lascio qualche link utile:

• http://help.sap.com/saphelp_nwpi71/helpdata/en/bb/ddb33d2ae46b3be10000000a114084/frameset.htm
• http://help.sap.com/saphelp_nwpi71/helpdata/en/9b/dad1ae3908ee44a5caf57e10918be9/frameset.htm
• http://www.dataxstream.com/2009/09/turn-any-sap-remote-enabled-function-module-into-a-web-service-%E2%80%93-part-1/
• http://www.dataxstream.com/2009/10/turn-any-sap-remote-enabled-function-module-into-a-web-service-%E2%80%93-part-2/

• Web Service su Wikipedia
• Guida Web Service

L’obiettivo di questo articolo è fissare un esempio pratico per interrogare un web service e sfruttare i risultati che restituisce utilizzando C# e Visual Studio.

Supponiamo di dover accedere al webservice di esempio su W3C, descritto a questa pagina: http://www.w3schools.com/webservices/tempconvert.asmx
La descrizione del servizio è fornita a questo URL:  http://www.w3schools.com/webservices/tempconvert.asmx

Il servizio ha 2 metodi  - FahrenheitToCelsius() e CelsiusToFahrenheit() - che accettano entrambi un solo parametro di input e convertono la temperatura da gradi fahrenhait a Celsius e viceversa.

La risposta del server è un XML di questo tipo:
<?xml version="1.0" encoding="utf-8" ?><string xmlns="http://tempuri.org/">38</string>

Su Visual Studio, cliccando sul nome del progetto web col tasto destro, si apre un menu dove è possibile aggiungere una Web Reference.

Qui si inserisce l’indirizzo della descrizione WSDL del web service.

Il software identifica l’interfaccia del servizio web, con i metodi che mette a disposizione.
Per aggiungerlo al progetto si clicca sul tasto Add Reference. Fatto questo ci troveremo l’oggetto nel Solution Explorer.

Ora nel codice della pagina aspx su cui vogliamo consumare il web service è necessario aggiungere il riferimento con questo codice:
using com.w3schools.www;

Ora dichiariamo un oggetto per la web reference, che sarà possibile utilizzare con tutti i sui metodi come qualsiasi altro oggetto:

com.w3schools.www.TempConvert MyProxy = new com.w3schools.www.TempConvert();

L’esempio finale completo potrebbe essere una pagine con una textbox che nella quale l’utente scrive la temperatura, un bottone di invio invoca il webservice e il risultato appare in una label. In questo caso il codice della classe sarebbe il seguente:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using com.w3schools.www;
public partial class _Default : System.Web.UI.Page{
com.w3schools.www.TempConvert MyProxy = new com.w3schools.www.TempConvert();
protected void Page_Load(object sender, EventArgs e)    { }
protected void Button1_Click(object sender, EventArgs e)    {
Label1.Text = MyProxy.CelsiusToFahrenheit(TextBox1.Text);
}
}


Mentre il codice della pagina il seguente:

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title></title>
</head>
<body>
<form id="form1" runat="server">
<div>
<asp:TextBox ID="TextBox1" runat="server"></asp:TextBox>&nbsp;<asp:Button ID="Button1" runat="server" onclick="Button1_Click" Text="Button" /><br />
<asp:Label ID="Label1" runat="server" Text="Label"></asp:Label>
</div>
</form>
</body>
</html>


E ora non resta che sbizzarrirsi, una volta imparato il mestiere va affinato.

Lascio qualche link per chi i web service li vuole anche costruire:

• How to create and invoke Java web service
• Your first C# Web Service