Récupération des données client via l'Api Magento

java logo   magento

- Environnement Java, String, Maven.
- IHM : Eplipse Neon
- Source Magento : http://devdocs.magento.com/guides/m1x/api/soap/introduction.html

Les Apis Magento sont développées et proposées pour un environnement php. Les informations pour un developpement en Java sont plus disparate. C'est pour cela que je vous propose quelques tutos sur l'utilisation des Apis proposées par Magento en Java.

Magento propose des Apis pour récupérer des informations concernant les clients, les produits, les commandes, les livraisons, les facturations, etc.
Ce tuto va nous permettre de se connecter à la base de donnée Magento par un appel XmlRpc puis d'effectuer l'appel à l'Api Magento customer.info pour répupérer des informations client dans une HashMap.
Attention, pour que votre projet puisse fonctionner, veuillez mettre en place un service REST sur votre projet.

Classe d'implémentation du sercvice REST : ClientRestControlleur.java

//--------------------------

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.evolutis.synchro.odoo.magento.WSCommon.SynchroResponse;
import com.evolutis.synchro.odoo.magento.services.customer.UpdateCustomerService;

@RestController
public class ClientRestController {

    @Autowired
    private UpdateCustomerService updateClientService;
    
    @RequestMapping("/clientUpdate/{cId}")
    public SynchroResponse update(@PathVariable(value="cId") String cId ) {

        try {
            updateClientService.updateClient(cId);
            return new SynchroResponse("ok");
        } catch (Exception e) {
            e.printStackTrace();
            return new SynchroResponse("nok");
        }
    }
}

//--------------------------

Classe : UpdateCustomerService.java

Cette classe est primordiale pour recevoir l'id du client et le renvoyer dans la méthode de répupération des informations clients.

//---------------

import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class UpdateCustomerService {
    
    @Autowired
    private GetMagentoCustomerService getMagentoClientService;
    
    @Autowired
    private UpdateOdooCustomerService updateOdooClientService;
    
    public void updateClient(String id_client) throws Exception {
        
        //Récupération de l'Id Client depuis Magento
        Map<String,Object> client_magento = getMagentoClientService.getClient(id_client);
    }
}

//---------------


Dans votre Projet, créer un fichier 'project.properties' vous permettant de définir:
- url,
- base de donnée,
- nom d'utilisateur,
- Mot de passe

//-------------

wsmagento.url = http://magento.######.localhost
wsmagento.api_key = ######
wsmagento.api_username = ######
wsmagento.apixmlrpc = /api/xmlrpc/

//---------------

N'oubliez pas de le définir dans votre fichier principal 'Application.java'.

// -----------------

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.PropertySource;
import org.springframework.scheduling.annotation.EnableAsync;

@SpringBootApplication
@EnableAsync
@PropertySource({"project.properties"})

public class Application {
    
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

//--------------


Classe : GetMagentoCustomerService.java

Cette classe va se charger de récupérer les informations clients via l'appel de connexion puis l'appel via l'Api.

// ----------------


import java.util.Arrays;
import java.util.Map;

import org.apache.xmlrpc.client.XmlRpcClient;
import org.apache.xmlrpc.client.XmlRpcClientConfigImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Component;

import com.evolutis.synchro.odoo.magento.services.XmlRpcMagentoConnexion;

@Component
public class GetMagentoCustomerService {

    @Autowired
    private Environment environment;
    
    @Autowired
    private XmlRpcMagentoConnexion xmlRpcMagentoConnexion;
    
    public Map<String,Object> getClient(String customerId) throws Exception {

        
        final String url = environment.getRequiredProperty("wsmagento.url"),
                api_key = environment.getRequiredProperty("wsmagento.api_key"),
                api_username = environment.getRequiredProperty("wsmagento.api_username"),
                api_xml_rpc = environment.getRequiredProperty("wsmagento.apixmlrpc");
                    
        //Connexion XmlRpc du Pont vers Magento
        final XmlRpcClient client = xmlRpcMagentoConnexion.addValueClient(url, api_key, api_username, api_xml_rpc);
        final XmlRpcClientConfigImpl common_config = xmlRpcMagentoConnexion.addValueConfig(url, api_xml_rpc);
        String sessionId = xmlRpcMagentoConnexion.addValueSession(client, common_config, api_username, api_key);
      

       return null;
}

}


// --------------
Cette classe permet l'appel les identifiants indispensables pour la connexion. Mais la connexion proprement dite ne sera effectuée que dans la prochaine classe : XmlRpcMagentoConnexion.java

Un détail :

- Spring gère les dépendances (Component + Environnement),

- customerId est définis dans la méthode UpdateClient dans GetMagentoCustomerService.java et elle même définit dans la classe Controleur du Service REST.


La  classe XmlRpcMagentoConnexion déploie le coeur même de la connexion XmlRpc.
// ------------------


import java.net.URL;
import java.util.Arrays;

import org.apache.xmlrpc.client.XmlRpcClient;
import org.apache.xmlrpc.client.XmlRpcClientConfigImpl;
import org.springframework.stereotype.Component;

@Component
public class XmlRpcMagentoConnexion {

    public XmlRpcClient addValueClient(String url, String api_key, String api_username, String api_xml_rpc) {
        
        final XmlRpcClient client = new XmlRpcClient();
        
        //Source : https://zugiart.com/2011/07/apache-xml-rpc-handle-null-nil/
        client.setTypeFactory(new XmlRpcTypeNil(client));
        
        return client;
    }

    public XmlRpcClientConfigImpl addValueConfig(String url, String api_xml_rpc) throws Exception {
        
        final XmlRpcClientConfigImpl common_config = new XmlRpcClientConfigImpl();
        common_config.setServerURL(new URL(url+api_xml_rpc));
        common_config.setEnabledForExceptions(true);
        
        return common_config;
    }

    public String addValueSession(XmlRpcClient client, XmlRpcClientConfigImpl common_config, String api_username,
            String api_key) throws Exception {
        
        String sessionId = (String)client.execute(
                common_config, "login", Arrays.asList(
                    api_username, api_key));
        
        return sessionId;
    }
}

// ----------------------


Enfin, la classe XmlRpcTypeNil permet de gérer le type 'nil' qui représente 'null'.
Source : https://zugiart.com/2011/07/apache-xml-rpc-handle-null-nil/

//------------------

import org.apache.ws.commons.util.NamespaceContextImpl;
import org.apache.xmlrpc.common.TypeFactoryImpl;
import org.apache.xmlrpc.common.XmlRpcController;
import org.apache.xmlrpc.common.XmlRpcStreamConfig;
import org.apache.xmlrpc.parser.NullParser;
import org.apache.xmlrpc.parser.TypeParser;
import org.apache.xmlrpc.serializer.NullSerializer;
import org.apache.xmlrpc.serializer.TypeSerializer;
import org.xml.sax.SAXException;

public class XmlRpcTypeNil extends TypeFactoryImpl {
    
    public XmlRpcTypeNil(XmlRpcController pController) {
        super(pController);
    }
 
    public TypeParser getParser(XmlRpcStreamConfig pConfig, NamespaceContextImpl pContext, String pURI, String pLocalName) {
        if (NullSerializer.NIL_TAG.equals(pLocalName) || NullSerializer.EX_NIL_TAG.equals(pLocalName) )return new NullParser();
        else return super.getParser(pConfig, pContext, pURI, pLocalName);
    }
 
    public TypeSerializer getSerializer(XmlRpcStreamConfig pConfig, Object pObject) throws SAXException {
        if (pObject instanceof XmlRpcTypeNil) return new NullSerializer();
        else return super.getSerializer(pConfig, pObject);
    }
}

//--------------------

Voila pour la connexion. Maintenant, il est possible de récupérer les informations du client.

//-----------------

début de la classe GetMagentoCustomerService.java

Map<String,Object> mapCustomer = null;
        
        //Récupération des informations Client de Magento       
        Object customerInfo = client.execute(common_config,"call",Arrays.asList(
                sessionId ,"customer.info",Arrays.asList(
                        customerId, Arrays.asList()
            ));
        
        client.execute(common_config,"endSession",Arrays.asList(
            sessionId )
        );
        
        if(customerInfo == null) {
            throw new Exception("The client Magento id is invalid.");
        }
        else if (((Map<String, Object>) customerInfo).isEmpty()) {
            throw new Exception("The client Magento id is empty.");
        }
        else {
            mapCustomer = ((Map<String,Object>) customerInfo);
        }
    return mapCustomer;
    }    
}

// ------------------

Grâce à l'Api customer.info (lien : http://devdocs.magento.com/guides/m1x/api/soap/customer/customer.info.html ) nous pouvons répupérer les informations liées à un identifiant client.

L'identifiant client (customerId) est obligatoire mais les attributs définis dans un tableau (Arrays.asList()) sont optionnels.

Si vous faite un System.out.println de mapCustomer, vous pourrez apprécier les différents couples clés/valeurs des informations clients.

J'espère que cet article vous aura aidé dans vos recherches.

@JonathanC

Tags :
Java
magento
XmlRpc
Base de Donnée
Api
customer.info