Un service web se présente comme une application web à la différence qu'un service web est consommé ou utilisé par un programme informatique et non par un individu.
Il existe de nombreux exemples de services web, tous très spécialisés : des services de conversion monétaire, de météorologie, etc. Par exemple lorsque vous écoutez un CD musical avec Windows Media-Player, ce dernier télécharge le nom de l'album et les titres depuis internet : en fait il interroge un service web.
Les services web sont de plus en plus utilisés pour intégrer des programmes dans un ensemble d'applications : on parle d'interopérabilité entre applications.
Plusieurs clients nous ont déjà demandé d'étendre et d'automatiser les fonctions d'import / export d'HYPERPLANNING pour échanger des données avec d'autres programmes. Il apparaît rapidement que l'import / export sous forme fichier n'est pas assez souple pour échanger des données complexes. HYPERPLANNING Service web vise à combler cette lacune.
Il n'est pas nécessaire d'être développeur d'applications pour écrire un script ou un programme consommant un service web, il faut juste connaître les bases de programmation comme
Vous pouvez écrire juste un script (PowerShell, Python, etc.) ou utiliser un environnement de programmation (Java, .net, C++, Pascal, etc.) selon vos besoins et votre niveau de programmation. Votre programme tourne sur la plateforme de votre choix (le serveur n'est disponible quant à lui que sous MS-Windows, voir plus loin).
Nous avons choisi de nous appuyer sur des standards pour l'implémentation d'HYPERPLANNING Service web : le service est décrit par un document WSDL et communique avec les applications en utilisant le protocole SOAP sur une connexion HTTP (ou HTTPS). Tous les langages de programmation récents intègrent ce qu'il faut pour interroger un serveur de ce type sans connaissance préalable de WSDL, SOAP ou HTTP, et il existe des extensions pour le faire également sur la quasi-totalité des langages plus anciens.
HYPERPLANNING Service web est conçu pour fonctionner sous :
Les versions Windows Serveur sont recommandées car sur celles-ci le nombre de connexions simultanées n'est pas limité.
Pour HYPERPLANNING Serveur, HYPERPLANNING Service web est vu comme HYPERPLANNING Client (au décompte des licences près).
HYPERPLANNING Service web consomme une licence de connexion HYPERPLANNING.net : chaque licence HYPERPLANNING.net vous permet d'exécuter simultanément pour chaque serveur HYPERPLANNING Service web et HYPERPLANNING.net.
Choisissez un planning, ajoutez lui une publication (clic droit, Créer une nouvelle publication) et lancez cette publication.
Cliquez sur Paramètres de publication pour spécifier les différents paramètres et réserver le préfixe d'URL. Cette réservation nécessite de connaître un compte administrateur Windows du poste.
Si vous choisissez le protocole HTTPS, vous devez également créer une liaison avec un certificat. Cela peut se faire en même temps que la création de la réservation ou plus tard depuis le menu Assistance, Administration des paramètres Windows.
Cliquez sur Démarrer le service web pour démarrer la publication puis sur le bouton Ouvrir dans un navigateur : la page de présentation du service doit apparaître. Cette page donne accès au document WSDL sous plusieurs formes, voir plus loin.
Si votre navigateur est récent, le document WSDL est affiché sous forme arborescente, ce qui facilite la lecture du document.
Un service web expose en général un seul document WSDL pour décrire les opérations qu'il sait traiter. Cependant certains types de clients de services web ont des limitations propres que d'autres n'ont pas et il serait dommage de dégrader pour tous les types de clients un WSDL riche en information en un document WSDL plus pauvre juste parce que tel ou tel type de client ne sait pas le traiter.
Ainsi nous avons pris le parti d'exposer trois documents WSDL complets, chacun étant décliné en autant de WSDL partiels qu'il y a d'interfaces.
<xsd:simpleType name="THpSvcWCleMatiere">Ces déclarations d'alias sont enlevées du document WSDL et le type de base est utilisé partout à la place des alias.
<xsd:restriction base="xsd:unsignedInt" />
</xsd:simpleType>
Les langages de programmation évolués proposent tous d'importer le document WSDL une fois pour toutes, permettant ainsi un accès rapide au service web.
Les langages moins évolués et les langages de script chargent par contre le document WSDL à chaque lancement. L'accès au service web est alors très lent.
Pour ces langages nous exposons un document WSDL par interface (type de port) et par type de document WSDL.
Ainsi un script manipulant uniquement l'interface IHpSvcWEtudiants peut-il charger le WSDL partiel de cette interface, ce document WSDL est beaucoup plus petit et l'accès sera d'autant plus rapide.
Les exemples donnés ici nécessitent la version 3.0 ou supérieure de la plateforme Microsoft .net.
Depuis la version 3.0 de la plateforme Microsoft .net l'authentification HTTP Basic n'est plus gérée pour HTTP (mais seulement pour HTTPS). Pour contourner cette limitation nous allons construire un assemblage HpSvcW.Authentification.dll qui définit la classe AuthentificationHpSvcW qui s'occupe de tout.
Commencez par enregistrer le fichier suivant sous le nom HpSvcW.Authentification.cs :
using System;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Description;
using System.ServiceModel.Dispatcher;
using System.Text;
namespace HpSvcW.Authentification
{
// Classe sachant ajouter l'entête HTTP pour l'authentification HTTP Basic de
// HYPERPLANNING Service Web
public class AuthentificationHpSvcW : IClientMessageInspector, IEndpointBehavior
{
// Valeur pour l'entête HTTP Autorization
private string m_Authorisation;
// Constructeur
public AuthentificationHpSvcW(string aIdentifiant, string aMotDePasse)
{
string lAEncoder = aIdentifiant + ":" + aMotDePasse;
string lEncode = Convert.ToBase64String(Encoding.ASCII.GetBytes(lAEncoder));
m_Authorisation = "Authorization: Basic " + lEncode;
}
// Implémentation de IClientMessageInspector
// Ajoute l'entête HTTP
public object BeforeSendRequest(ref Message request, IClientChannel channel)
{
// On ajoute l'entête HTTP
HttpRequestMessageProperty lEntetes;
object lPropriete;
if (request.Properties.TryGetValue(HttpRequestMessageProperty.Name, out lPropriete) == true)
{
lEntetes = lPropriete as HttpRequestMessageProperty;
}
else
{
lEntetes = new HttpRequestMessageProperty();
request.Properties.Add(HttpRequestMessageProperty.Name, lEntetes);
}
lEntetes.Headers.Add(m_Authorisation);
return null;
}
public void AfterReceiveReply(ref Message reply, object correlationState)
{
// Rien
}
// Implémentation de IEndpointBehavior
// S'enregistre en tant que IClientMessageInspector pour être appelée sur chaque requête
public void AddBindingParameters(ServiceEndpoint endpoint, BindingParameterCollection bindingParameters)
{
// Rien
}
public void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
{
clientRuntime.MessageInspectors.Add(this);
}
public void ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
{
// Rien
}
public void Validate(ServiceEndpoint endpoint)
{
// Rien
}
}
}
Le compilateur C# csc.exe est présent sur votre poste si le Kit de développement Windows (Windows SDK) est installé. C'est le cas si Visual Studio est installé. Il se trouve quelque part sous C:\Windows\Microsoft.NET\Framework.
Compilez HpSvcW.Authentification.cs comme ceci :
csc.exe /target:library HpSvcW.Authentification.cs
Cela construit l'assemblage HpSvcW.Authentification.dll
Sous Visual Studio créez un nouveau projet Fichier / Nouveau / Projet ... / Application console, Nom = TestHpSvcW
Menu Projet / Ajouter une référence de service ..., Adresse = http://monserveur/hpsw/wsdl/SansTypeSimple, Espace de noms = HpSvcW, OK.
Menu Projet / Ajouter une référence ... / Parcourir, choisissez HpSvcW.Authentification.dll compilée à l'étape précédente.
Modifiez ensuite Program.cs comme suit :
using System;
using System.Net;
using System.ServiceModel;
using System.Text;
using HpSvcW.Authentification;
using TestHpSvcW.HpSvcW;
namespace TestHpSvcW
{
class Program
{
static void Main(string[] args)
{
try
{
Console.Write("Identifiant : ");
string lIndentifiant = Console.ReadLine();
Console.Write("Mot de passe : ");
string lMotDePasse = Console.ReadLine();
AuthentificationHpSvcW lAuthentification = new AuthentificationHpSvcW(lIndentifiant, lMotDePasse);
// Interfaces utilisées
HpSvcWAdminClient lAdmin = new HpSvcWAdminClient();
lAdmin.Endpoint.Behaviors.Add(lAuthentification);
HpSvcWMatieresClient lMatieres = new HpSvcWMatieresClient();
lMatieres.Endpoint.Behaviors.Add(lAuthentification);
//Affichage de la version
Console.WriteLine("Connecté à " + lAdmin.Version());
// Affichage du nombre de matières
Console.WriteLine("Il y a {0:D} matières dans la base", lMatieres.NombreMatieres());
// Affichage de la liste des matières
THpSvcWTableauClesMatieres lCles = lMatieres.ToutesLesMatieres();
lCles = lMatieres.TrierTableauDeMatieresParLibelleEtCode(lCles);
THpSvcWTableauChaines lCodes = lMatieres.CodesTableauDeMatieres(lCles);
THpSvcWTableauChaines lLibelles = lMatieres.LibellesTableauDeMatieres(lCles);
THpSvcWTableauChaines lLibellesLongs = lMatieres.LibellesLongsTableauDeMatieres(lCles);
for (int lIndice = 0; lIndice < lCles.Count; lIndice++)
Console.WriteLine("{0,3:D} {1,-8} {2,-20} {3}",
lCles[lIndice],
lCodes[lIndice],
lLibelles[lIndice],
lLibellesLongs[lIndice]);
}
catch (Exception lException)
{
Console.WriteLine("ÉCHEC : " + lException.Message);
}
}
}
}
Vous pouvez maintenant générer la solution et l'exécuter en ligne de commande.
# Arrête l'exécution à la première erreur $ErrorActionPreference="stop"; [String]$lPrefixeWsdl='http://monserveur/hpsw/wsdl/SansTypeSimple'; # Fenêtre d'authentification $lIdentification = Get-Credential; # Interfaces utilisées $lAdmin = New-WebServiceProxy -uri "$lPrefixeWsdl/IHpSvcWAdmin" -Credential $lIdentification; $lMatieres = New-WebServiceProxy -uri "$lPrefixeWsdl/IHpSvcWMatieres" -Credential $lIdentification; # Affichage de la version "Connecté à " + $lAdmin.Version(); # Affichage du nombre de matières "Il y a {0:D} matières dans la base" -f $lMatieres.NombreMatieres(); # Affichage de la liste des matières $lCles = $lMatieres.ToutesLesMatieres(); $lCles = $lMatieres.TrierTableauDeMatieresParLibelleEtCode($lCles); $lCodes = $lMatieres.CodesTableauDeMatieres($lCles); $lLibelles = $lMatieres.LibellesTableauDeMatieres($lCles); $lLibellesLongs = $lMatieres.LibellesLongsTableauDeMatieres($lCles); for ($lIndice = 0; $lIndice -lt $lCles.Count; $lIndice++) {"{0,3:D} {1,-8} {2,-20} {3}" -f $lCles[$lIndice], $lCodes[$lIndice], $lLibelles[$lIndice], $lLibellesLongs[$lIndice]};
Vous pouvez exécuter ces commandes une à une sur la ligne de commande PowerShell ou encore les enregistrer dans un fichier TestHpSvcW.ps1 que vous pouvez exécuter comme ceci :
.\TestHpSvcW.ps1
sur la ligne de commande PowerShell, ou encore comme ceci :
PowerShell .\TestHpSvcW.ps1
dans un fichier batch ou sur la ligne de commande MsDos.
Il vous faudra peut-être exécuter auparavant la commande
Set-ExecutionPolicy RemoteSigned
sur la ligne de commande PowerShell.
Cet exemple s'appuie sur l'environnement de développement NetBeans mais tout autre environnement de développement Java peut faire l'affaire.
Créez une nouvelle application Java
Maintenant modifiez Main.java comme ceci
package testhpsvcw; import com.indexeducation.frahtm.hpsvcw.*; import java.util.List; import javax.xml.ws.BindingProvider; public class Main { public static void main(String[] args) { try { java.io.DataInput lEntrees = new java.io.DataInputStream(System.in); System.out.print("Identifiant : "); String lIdentifiant = lEntrees.readLine(); System.out.print("Mot de passe : "); String lMotDePasse = lEntrees.readLine(); // Services utilisés HpSvcWAdmin lServiceAdmin = new HpSvcWAdmin (); HpSvcWDonnees lServiceDonnees = new HpSvcWDonnees (); // Interfaces utilisées IHpSvcWAdmin lAdmin = lServiceAdmin.getPortAdmin(); ((BindingProvider)lAdmin).getRequestContext().put(BindingProvider.USERNAME_PROPERTY, lIdentifiant); ((BindingProvider)lAdmin).getRequestContext().put(BindingProvider.PASSWORD_PROPERTY, lMotDePasse); IHpSvcWMatieres lMatieres = lServiceDonnees.getPortMatieres(); ((BindingProvider)lMatieres).getRequestContext().put(BindingProvider.USERNAME_PROPERTY, lIdentifiant); ((BindingProvider)lMatieres).getRequestContext().put(BindingProvider.PASSWORD_PROPERTY, lMotDePasse); //Affichage de la version System.out.println("Connecté à " + lAdmin.version()); // Affichage du nombre de matières System.out.println(String.format("Il y a %d matières dans la base", lMatieres.nombreMatieres())); // Affichage de la liste des matières THpSvcWTableauClesMatieres lCles = lMatieres.toutesLesMatieres(); lCles = lMatieres.trierTableauDeMatieresParLibelleEtCode(lCles); THpSvcWTableauChaines lCodes = lMatieres.codesTableauDeMatieres(lCles); THpSvcWTableauChaines lLibelles = lMatieres.libellesTableauDeMatieres(lCles); THpSvcWTableauChaines lLibellesLongs = lMatieres.libellesLongsTableauDeMatieres(lCles); List<Long> lListeCles = lCles.getTHpSvcWCleMatiere(); List<String> lListeCodes = lCodes.getString(); List<String> lListeLibelles = lLibelles.getString(); List<String> lListeLibellesLongs = lLibellesLongs.getString(); for (int lIndice = 0; lIndice < lListeCles.size(); lIndice++) System.out.println(String.format("%1$3d %2$-8s %3$-20s %4$s", lListeCles.get(lIndice), lListeCodes.get(lIndice), lListeLibelles.get(lIndice), lListeLibellesLongs.get(lIndice))); } catch(Exception lException) { System.out.println("ÉCHEC : " + lException.getMessage()); } } }
Vous pouvez maintenant exécuter le projet.
Delphi sait générer du code d'accès à un service web depuis son document WSDL :
Cela génère l'unité Delphi wsdl.pas.
Cette unité peut aussi être générée en ligne de commande comme suit :
WSDLImp.exe -P -Ou- http://monserveur/hpsw/wsdl
Créez maintenant ce programme ligne de commande (TestHpSvcW.dpr) :
program TestHpSvcW; {$APPTYPE CONSOLE} uses Soap.SOAPHTTPClient, // THTTPRIO Soap.SOAPHTTPTrans, // THTTPReqResp System.NetEncoding, // TNetEncoding System.SysUtils, // Exception Winapi.ActiveX, // CoInitialize Winapi.WinInet, // HttpAddRequestHeaders wsdl; // Unité générée par Delphi depuis le document WSDL (******************************************************************************) type TTestHpSvcW = class (TObject) private fAuthentification : string; // Événement affecté à HTTPWebNode.OnBeforePost dans CreerRio () // afin de gérer l'authentification HTTP Basic procedure AjouterAuthentification (const aHTTPWebNode : THTTPReqResp; aHandle : Pointer); function CreerRio () : THTTPRIO; public constructor create (const aIdentifiant, aMotDePasse : string); // Crée puis supprime une nouvelle matière en donnant le nombre de // matières avant et après chaque étape procedure CreerMatiereHyperPlanning (); // Interroge HYPERPLANNING pour récupérer la liste des matières procedure ListerLesMatieresHyperPlanning (); end; (******************************************************************************) procedure TTestHpSvcW.AjouterAuthentification (const aHTTPWebNode : THTTPReqResp; aHandle : Pointer); begin if not HttpAddRequestHeaders (aHandle, PChar (fAuthentification), Length (fAuthentification), HTTP_ADDREQ_FLAG_ADD) then Assert (False, 'Échec de HttpAddRequestHeaders ()'); end; (******************************************************************************) function TTestHpSvcW.CreerRio () : THTTPRIO; begin Result := THTTPRIO.Create (Nil); Result.HTTPWebNode.OnBeforePost := AjouterAuthentification; end; (******************************************************************************) constructor TTestHpSvcW.create (const aIdentifiant, aMotDePasse : string); var lAEncoder : TBytes; begin inherited Create (); lAEncoder := TEncoding.ANSI.GetBytes (aIdentifiant + ':' + aMotDePasse); fAuthentification := 'Authorization: Basic ' + TNetEncoding.Base64.EncodeBytesToString (lAEncoder); end; (******************************************************************************) procedure TTestHpSvcW.CreerMatiereHyperPlanning (); var lAdmin : IHpSvcWAdmin; lMatieres : IHpSvcWMatieres; lMatiere : THpSvcWCleMatiere; begin // On affiche le numéro de version de HYPERPLANNING Service web lAdmin := GetIHpSvcWAdmin (False, '', CreerRio ()); Writeln ('Connecté à ' + lAdmin.Version ()); lMatieres := GetIHpSvcWMatieres (False, '', CreerRio ()); with lMatieres do begin Writeln (Format ('Il y a %d matières dans la base.', [NombreMatieres ()])); LMatiere := CreerMatiere ('Toto', 'TT'); Writeln (Format ('Création réussie : il y a %d matières dans la base.', [NombreMatieres ()])); SupprimerMatiere (LMatiere); Writeln (Format ('Suppression réussie : il y a à nouveau %d matières dans la base.', [NombreMatieres ()])); end; end; (******************************************************************************) procedure TTestHpSvcW.ListerLesMatieresHyperPlanning (); const C_FormatColonnes = '%0:3d %1:-8s %2:-20s %3:s'; var lMatieres : IHpSvcWMatieres; lCles : THpSvcWTableauClesMatieres; lCodes, lLibelles, lLibellesLongs : THpSvcWTableauChaines; lIndice : integer; begin lMatieres := GetIHpSvcWMatieres (False, '', CreerRio ()); with lMatieres do begin lCles := TrierTableauDeMatieresParLibelleEtCode (ToutesLesMatieres ()); lCodes := CodesTableauDeMatieres (lCles); lLibelles := LibellesTableauDeMatieres (lCles); lLibellesLongs := LibellesLongsTableauDeMatieres (lCles); end; for lIndice := low (lCles) to high (lCles) do Writeln (Format (C_FormatColonnes, [lCles [lIndice], lCodes [lIndice], lLibelles [lIndice], lLibellesLongs [lIndice]])); end; (******************************************************************************) (******************************************************************************) procedure MainTestHpSvcW (); var lIdentifiant, lMotDePasse : string; lTest : TTestHpSvcW; begin Write ('Identifiant : '); Readln (lIdentifiant); Write ('Mot de passe : '); Readln (lMotDePasse); lTest := TTestHpSvcW.Create (lIdentifiant, lMotDePasse); try lTest.CreerMatiereHyperPlanning (); lTest.ListerLesMatieresHyperPlanning (); except on lException : Exception do Writeln (lException.Message); end; lTest.Destroy (); end; (******************************************************************************) begin // CoInitialize nécessaire pour msxmldom.CreateDOMDocument CoInitialize (nil); MainTestHpSvcW (); CoUninitialize (); end.
Vous pouvez maintenant compiler le projet et l'exécuter en ligne de commande.
Depuis la version 5, PHP intègre l'extension SOAP qui permet de facilement créer et interroger un service web.
Vérifiez que l'extension soap est activée dans le fichier php.ini (--enable-soap)
Voici un exemple de client soap qui permet d'interroger HYPERPLANNING Service web :
<?php // URL du document WSDL de HYPERPLANNING Service web $WSDL = "http://localhost/hpsw/wsdl/RpcEncoded"; // Identifiant et mot de passe de connexion $LOGIN = "SW"; $PASS = "SWSW"; // Creation du client SOAP $client = new SoapClient($WSDL, array('login'=> $LOGIN,'password'=> $PASS)); // Affichage du nombre d'enseignants $NombreEnseignants = $client->NombreEnseignants(); print "<strong>$NombreEnseignants enseignants.</strong><br/>\n"; // Affichage des "Nom et Prénom" des enseignants $Enseignants = $client->TousLesEnseignants(); print "<strong>Nom et Prénom des enseignants :</strong><br/>\n"; foreach ($Enseignants as $Enseignant_ID) { $NomEnseignant = $client->NomEnseignant($Enseignant_ID); $PrenomEnseignant = $client->PrenomEnseignant($Enseignant_ID); print "$NomEnseignant $PrenomEnseignant<br/>\n"; } ?>
Collez ce code dans le bloc-notes, modifiez les constantes $WSDL, $LOGIN, $PASS et enregistrez le fichier sous le nom SoapClientPHP.php dans votre répertoire root (par défaut www/). Ce répertoire est défini par DocumentRoot dans le fichier httpd.conf.
Lancez le fichier depuis votre navigateur internet : http://localhost/SoapClientPHP.php
Ce script affiche le nombre d'enseignants ainsi que leur nom et prénom.
Voici un exemple de script en python qui permet d'interroger HYPERPLANNING Service web :
from requests import Session from requests.auth import HTTPBasicAuth from zeep import Client from zeep.transports import Transport session = Session() session.auth = HTTPBasicAuth("MyLogin", "MyPassword") lPrefixeWsdl='http://monserveur/hpsw/wsdl/' # Interfaces utilisées Matiere = Client(lPrefixeWsdl + 'IHpSvcWMatieres', transport=Transport(session=session)) Admin = Client(lPrefixeWsdl + 'IHpSvcWAdmin', transport=Transport(session=session)) # Affichage de la version print ('Connecté à ' + Admin.service.Version()); # Affichage du nombre de matières print ('Il y a ' + str(Matiere.service.NombreMatieres()) + ' matières dans la base '); # Affichage de la liste des matières lCles = Matiere.service.TrierTableauDeMatieresParLibelleEtCode ({'THpSvcWCleMatiere' : Matiere.service.ToutesLesMatieres()}); lClesIn = {'THpSvcWCleMatiere' : lCles}; lCodes = Matiere.service.CodesTableauDeMatieres(lClesIn); lLibelles = Matiere.service.LibellesTableauDeMatieres(lClesIn); lLibellesLongs = Matiere.service.LibellesLongsTableauDeMatieres(lClesIn); for i in range (len (lCles)): print (str(lCles[i]) + ' ' + str(lCodes[i] if lCodes[i] is not None else ' ') + ' ' + str(lLibelles[i]) + ' : ' + str(lLibellesLongs[i] if lLibellesLongs[i] is not None else '-'))
Pour exécuter ce script, collez ce code dans le bloc-notes, modifiez 'MyLogin', 'MyPassword', 'http://monserveur/hpsw/wsdl/' et enregistrez le fichier sous le nom ExempleHpSvcW.py :
L'ouvrir avec IDLE Python et l'exécuter (F5) ou saisir sur une ligne de commande DOS la commande
ExempleHpSvcW.py
En plus de Python 3.6, il est nécessaire d'installer le module Zeep. Pour installer Zeep, saisir sur une console DOS la commande
pip install zeep
Ce script affiche les matières présentes dans la base (clé, code, libellé et libellé long).
Il existe des outils commerciaux et des outils gratuits de bonne qualité pour déboguer un programme consommant un service web, toutefois ils demandent une bonne connaissance du protocole SOAP pour être utilisés.
Certains de ces outils agissent comme un proxy et permettent d'analyser le trafic entre votre programme et le service web. C'est très bien mais attention, ces outils ne vous montrent pas toujours tout. Par exemple ils peuvent masquer la demande de document WSDL au serveur, voire renvoyer un document WSDL modifié, ou masquer les entêtes HTTP alors que ce sont eux qui contiennent les informations d'authentification.
Sachez que si vous recevez une erreur HTTP 401, c'est que l'identifiant et le mot de passe n'ont pas été transmis au service web. Si vous recevez une erreur HTTP 403, c'est que l'identifiant et le mot de passe ont été transmis au service web mais ne sont pas ceux attendus.
Il est important que l'accès au service web reste protégé par un identifiant et un mot de passe. Si votre langage de programmation ne gère pas l'authentification HTTP "basic" vous pouvez spécifier l'identifiant et le mot de passe dans un document WSDL local. Voici la marche à suivre :
<soap:address location="http://TT:TTTTTTTT@monserveur/hpsw/Matieres" />Remarque pour les utilisateurs Windows : Depuis la mise à jour MS04-004 Cumulative Security Update for Internet Explorer (832894), la syntaxe http://TT:TTTTTTTT@monserveur/hpsw/Matieres est rejetée par défaut. Vous pouvez être amené à autoriser cette syntaxe pour un programme particulier en insérant une clef dans le registre Windows de votre ordinateur.
Il existait sous Windows XP un composant nommé MSSOAP (Microsoft Soap Toolkit) qui permettait d'invoquer des services web depuis VBA. Cela n'existe plus pour les versions plus récentes de Windows.
Maintenant vous devez utiliser Visual Studio pour produire du code qui sera exécuté dans vos documents Microsoft Office. Voici quelques ressources :
WS-I est une organisation qui propose une autre norme appelée Basic Profile pour les services web que celle du World Wide Web Consortium.
HYPERPLANNING Service web n'est pas compatible WS-I et ce pour plusieurs raisons :
wsi:Claim, wsi="http://ws-i.org/schemas/conformanceClaim/") dans les éléments wsdl:documentation alors que ces derniers, tels des commentaires, devraient être ignorés par les programmes. Les éléments wsdl:documentation fournissent en effet des informations à usage de celui qui écrit le programme qui va consommer le service web.