lindev.fr

Aller au contenu | Aller au menu | Aller à la recherche

Mot-clé - commande

Fil des billets - Fil des commentaires

06 déc. 2015

Réference commande dans prestashop [1.6.x]

Prestashop et ses bizarreries

presta.png Je travaille quotidiennement sur Prestashop, car à mon grand regret, il n’existe pas aujourd'hui, beaucoup d'alternatives qui proposent un produit :

  • libre
  • fonctionnel et évolutif
  • supporté par une communauté active
  • avec une documentation complète ( pour l'utilisateur et le développeur )
  • développé en python sous Django par exemple .... humm ce dernier point sent le troll ;)

Bref dans ma grande frustration personnel, je dois tout de même admettre que Pretashop offre une solution complète performante et fonctionnelle pour l'utilisateur final, mais dés qu'il s'agit de mettre les mains dans le code, la documentation et plus que maigre !! Et il faut investiguer, poser des questions qui bien souvent dés que ces dernières sont un peu techniques, restent sans réponse sur le forum officiel :( !!
Nous ( développeurs ) sommes doc seuls devant le code et devons faire preuve de patience pour apprivoiser le code sans documentation approfondie. Ce manque d'information est selon moi voulu pour pousser le système économique qui tourne autour de Prestashop ( modules payants pour ajouter des fonctionnalités qui parfois devraient être disponibles par défaut dans la solution ).

D'autant que certains choix fait par Prestashop semblent parfois peu efficaces, voir illogiques.
Prenons le cas de la référence commande, qui est sous la forme d'une chaine de caractères aléatoire et unique .
Pour une boutique qui n'a que quelques commandes / jour cela ne pose aucun problème (quoique), mais pour un flux plus important, cette référence qui sera utilisée par vous et vos clients n'est absolument pas pratique.

Prenons un exemple. Si je vous donne la référence : QRFRUMBMF vous êtes bien avancé, ce n'est pas mnémotechnique et ne vous apprend rien sur la commande.

Alors que ( par exemple ) une référence comme : 20151206-225 qui est la concaténation de :

  • 2015 : L'année de la commande
  • 12 : le mois de la commande
  • 06 : le jour de la commande
  • 225 : id unique de la commande

Aurait était un choix beaucoup plus pertinent pour tout le monde ( client et marchand ).

Posez la questions sur le forum et vous aurez avec un peu de chance, une âme charitable qui va vous guider pour effectuer ce changement. Dans le cas contraire, votre demande tombera dans les abîmes avec les autres messages du genre restés sans réponse .

Aller au boulot, voyons comment faire ce changement dans le code.

La surcharge

Je ne vais pas détailler comment surcharger les différents éléments de Prestashop mais utiliser cette technique pour deux fichiers.

Comme expliqué pus haut, prestashop est bien fini et permet de tout "surcharger" pour vous permettre de modeler/modifier les fonctionnalités de base de l'outil à volonté.

Nous allons donc surcharger dans un premier temps les fichiers suivants :

  1. classes/order/OrderHistory.php
  2. classes/PaymentModule.php

OrderHistory.php

Cette classe gère l'historique des commandes et de ce fait, gère également l’expédition des emails liés à ces états. Mails dans lesquels est rappelé la référence de la commande.

Nous allons donc créer le fichier de surcharge override/classes/order/OrderHistory.php , copier la méthode d'origine addWithemail et enfin le modeler à notre sauce.

ce qui donne :

<?php
class OrderHistory extends OrderHistoryCore{
    
    /**
     * @param bool $autodate Optional
     * @param array $template_vars Optional
     * @param Context $context Optional
     * @return bool
     */

	public function addWithemail($autodate = true, $template_vars = false, Context $context = null){
            if (!$context)
                $context = Context::getContext();

            $order = new Order( (int)$this->id_order );
            $date = new DateTime($order->date_add);

            $data = array(
                '{id_order}' => $date->format('Ymd').'-'.$this->id_order
            );

            if ($template_vars){
                $data = array_merge($data, $template_vars);
            }

            return parent::addWithemail($autodate, $data, $context);
    }
}

Ne vous reste plus qu'à remplacer dans vos mails la balise {order_name} par {id_order}

PaymentModule.php

Cette classe est utilisée à la confirmation de commande et s'occupe également de l'expédition du mail de confirmation de commande ( pourquoi avoir séparé ce mails des autres ? ). Bref, nous allons donc également surcharger cette classe et plus précisément la méthode validateOrder.

Nous allons donc créer le fichier de surcharge override/classes/PaymentModule.php , copier la méthode d'origine validateOrder() et enfin le modeler à notre sauce.

class PaymentModule extends PaymentModuleCore{
    
        /**
     * Validate an order in database
     * Function called from a payment module
     *
     * @param int $id_cart
     * @param int $id_order_state
     * @param float   $amount_paid    Amount really paid by customer (in the default currency)
     * @param string  $payment_method Payment method (eg. 'Credit card')
     * @param null    $message        Message to attach to order
     * @param array   $extra_vars
     * @param null    $currency_special
     * @param bool    $dont_touch_amount
     * @param bool    $secure_key
     * @param Shop    $shop
     *
     * @return bool
     * @throws PrestaShopException
     */
    public function validateOrder($id_cart, $id_order_state, $amount_paid, $payment_method = 'Unknown',
        $message = null, $extra_vars = array(), $currency_special = null, $dont_touch_amount = false,
        $secure_key = false, Shop $shop = null)
    {

        ...
        ...
        ...
        //contenu de la méthode d'origine ( copier - coller de la methode validateOrder dans le fichier classes/PaymentModule.php )
        ...
        ...
        ...
        // Avant la liste des paramétres, o va formater la date de la commande
        $dateOrder = new DateTime($order->date_add);
        ....
        //Vers la ligne 622 dans la liste des paramètres balancés au template du mail, ajouter la ligne 
        ...
        '{id_order}' => $dateOrder->format('Ymd').'-'.$order->id
        ...
        ...
        ...
    }
}

Voilà , ne vous reste plus qu'à mettre à jour le mail orderConf pour remplacer {order_name} par {idorder}

vider le cache

Afin que les surcharges soient bien prises en compte, vous devez supprimer le fichier de cache suivant :

cache/class_index.php

Conclusion

Voilà comment changer une partie de prestashop sans toucher au code d'origine.
Si ce que vous avez fait ne fonctionne pas ou casse quelque chose, il vous suffit alors de supprimer ces fichiers ( dans le répertoire Override ) et remettre les balises dans les mails.
Pas d'inquiétude donc lancez-vous.

07 sept. 2009

Talbette Graphique wacom Bamboo

La tablette

55509.jpg

La tablette graphique que je vais tenter d'apprivoiser est la suivante : WACOM BAMBOO - A6 - en USB pour Mac et Pc

Bien entendu , l'installation se fera sous linux , et pour être plus précis , sous ubuntu jaunty.

Premier branchement

Aller on y crois , premier branchement , on allume le pc et là .. bonne surprise , la tablette est reconnue , le stylet remplace le mulot habituel ... vraiment le pied pour une première ..

Bon aller assez joué .. Aprés quelques dessins ratés , et tentatives de signatures , je me décide d'aller plus loin , et de configurer les raccourcies présents sur la tablette .

A installer

En cherchant un peut sur le net , l'on trouve déjà pas mal d'infos sur le sujet , plus ou moins à jour ... Une chose est certaine , vous devrez installer le paquet wacom-tools

sudo apt-get install wacom-tools

Rien de plus ..

A configurer

Maintenant , mettons les mains dans le cambouis , wacom-tools , nous donne l'outil xsetwacom pour configurer les touches de notre tablette .

Avant d'écrire note script , regardons les possibilités de cette commande , qui nous offre de nombreuses infos , à savoir :

xsetwacom list dev => liste des périphériques xsetwacom list param => liste des paramètres xsetwacom list mod => liste des modificateurs de touches

La commande qui nous intéresse principalement ici , est la dernière , je laisse les plus expérimentés aller plus loin avec les autres configurations possibles .

une documentation est disponible , à l'installation du paquet wacom-tools ,

file:///usr/share/doc/wacom-tools/howto.html

Cette documentation reprends l'installation , si la tablette n'est pas bien reconnue , ainsi que sa configuration .

Il faut décider à quoi vont bien pouvoir servir les boutons de la tablette , personnellement , j'ai opté pour la configuration suivante :

A : bouton 1 ( en haut à gauche) => basculer ver l'écran de gauche
B : bouton 2 ( en bas à gauche) => ouvrir un terminal
C : bouton 3 ( en haut à droite ) => basculer vers l'écran de droite
D : bouton 4 ( en bas à droite ) => minimiser la fenêtre courante
E : Et pour la zone tactile du milieu , remplace touche haut et touche bas

Voici les ligne de commande correspondantes à chaque bouton :

A : xsetwacom set Wacom Bamboo pad button1 "core key CONTROL alt Left" #bureau de gauche
B : xsetwacom set Wacom Bamboo pad button2 "core key CONTROL alt t" #ouverture d'un terminal
C : xsetwacom set Wacom Bamboo pad button3 "core key CONTROL alt Right" #bureau de droite
D : xsetwacom set Wacom Bamboo pad button4 "core key ALT F9" #minimize windows
E : xsetwacom set Wacom Bamboo pad AbsWDn "core key Up" #curseur haut

    xsetwacom set Wacom Bamboo pad AbsWUp "core key Down" #curseur bas


Vous pouvez bien entendu modifier ce script pour effectuer des actions que vous jugez plus utiles , il suffit juste de remplacer les raccourcies utilisés , à savoir :

  • CONTROL alt Left
  • CONTROL alt t
  • CONTROL alt Right
  • ALT F9
  • Up
  • Down

Le script

Assez tourné autour du pot , faisons notre script afin que les raccourcies soient actifs au démarrage .

création du script

cd /etc/init.d/
vim wacomkeys

le code

#!/bin/sh
#
### BEGIN INIT INFO
# Provides:          wacomexpresskeys
# Required-Start:
# Required-Stop:
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: Démarre les raccourcies de la tablette graphique wacom
# Description:
### END INIT INFO

ARGV="[email protected]"

ERROR=0
if [ "x$ARGV" = "x" ] ; then
    ARGV="restart"
fi

case $ARGV in
start|stop|restart)

        WACOM_PAD=`xinput list --short | grep -i "Wacom.*Pad" | cut -f 1 | sed -e 's/"//g'`
        if [ "x${WACOM_PAD}y" != "xy" ]
        then
          echo "Wacom pad found: ${WACOM_PAD}"
          xsetwacom set "${WACOM_PAD}" AbsWDn "core key Up" #curseur haut
          xsetwacom set "${WACOM_PAD}" AbsWUp "core key Down" #curseur bas
          xsetwacom set "${WACOM_PAD}" button1 "core key CONTROL alt Left" #bureau de gauche
          xsetwacom set "${WACOM_PAD}" button2 "core key CONTROL alt t" #ouverture d'un terminal
          xsetwacom set "${WACOM_PAD}" button3 "core key CONTROL alt Right" #bureau de droite
          xsetwacom set "${WACOM_PAD}" button4 "core key ALT F9" #minimize windows
        else
          echo "Cannot find Wacom pad"
        fi

    ERROR=0
    ;;
*)
    $HTTPD $ARGV
    ERROR=$?
esac

exit $ERROR

Le script est téléchargeable wacomkeys.sh

Rendons exécutable

chmod 777 wacomkeys

Mettons le dans les process de demarrage

update-rc.d wacomkeys defaults

Fin

Et voilà , les raccourcies sont maintenant effectifs à chaque démarrage de votre système . Reste à lier cette tablette à gimp ... peut être dans un prochain billet .. en attendant , amusez vous bien .

Ch.

20 janv. 2009

Exemple d'utilisation du module SSH

sshphp.jpeg

Exemple d'utilisation du module ssh2 via php

N'ayant jamais moi même utilisé ssh via php , je me suis permis de creer un petit bout de code pour compléter l'article précédent ...

Nous allons donc utiliser quelques fonctions Sell2 dont la liste se trouve ici

Note : le code ci-dessous n'est qu'un exemple , loin d'être complet , mais il peut permettre de servir pour la compréhension des bases d'utilisation des fonctions ssh2

Dans un premier temps , la connexion :

Elle se fait via la finction ssh2_connect . Simple à comprendre , elle doit avoir deux paramétres obligatoires , à savoir : Host: qui correspond à l'hôte auquel nous souhaitons nous connecter port: Bien évidemment le numéro du port à utiliser

Ensuite , vient des paramètres facultatifs , méthods qui est un tableau dans lequel , nous allons pouvoir spécifier des méthodes de connexions , ici , nous n'allons pas entrer dans ces détails , les valeurs par défaut fonctionnent trés bien pour ce que nous souhaitons faire .

Un autre paramètre intéressant , ( le dernier ) est callbacks qui comme methods est un tableau associatif , qui permet d'appeler votre propre méthode pour un type de paquet SSH reçu . Encore une fois , nous n'allons pas l'utiliser ici , mais il est important de savoir que cela existe .

L'identification :

Une fois connecté , il faut s'identifier , pour celà , il existe plusieurs méthodes , à savoir :

ssh2_auth_password pour l'identification pas mot de passe ( ce que nous allons utiliser ici )

ssh2_auth_pubkey_file identification par clef publique

ssh2_auth_none identification en tant que "none"

ssh2_auth_hostbased_file identification par clef d'hôte publique

NOTE: Pour des raisons de sécurité , il peut être intéressant d'utiliser une identification par clef d'hôte publique

La fonction ssh2_auth_password est simple , elle demande trois paramétres , la ressource qu'a retourné la fonction précédente ssh2_connect , suivi , de l'utilisateur , et du mot de passe ...

A savoir , le tout est en clair !!

Ouverture d'un terminal

Une fois connecté et identifié , nous allons ouvrir un terminale pour y entrer des commandes à exécuter sur le serveur distant . Il existe encore une fois plusieurs façons de le faire , par la méthode ssh2_exec et ssh2_shell

La différence , est mince , via ssh2_exec , un terminal est ouvert , la commande passé en paramètre est exécuté , et un flux est retourné en cas de succès , alors qu'avec ssh2_shell , on ne fait qu'ouvrir un terminale , sans lui passer de commande , celui-ci renvoie un flux dans lequel nous allons écrire et lire dans un second temps .

Pour utiliser ssh2_shell , seuls deux paramètres sont encore nécessaires , à savoir , la ressource de connection , suivie du type de terminal à utiliser .. ici xterm

Écriture et lecture commandes

Voici venu le temps d'envoyer une commande à notre hôte ... Pour ce faire , il suffit d'utiliser la fonction fwrite() pour écrire dans un flux , nous allons l'utiliser comme ceci :

fwrite(ressource,commande);

Et pour récupérer ce qui s'affiche sur la sortie standard , nous allons utiliser fgets() comme ceci :

while($line = fgets(ressource)) { echo nl2br($line);}

Et voilà pour les explications de bases sur une utilisation simplifié du protocole ssh via php ... Et pour finir , je vais donc vous donner une classe exemple , qui vous permettra de tester tout ça .. ( classe qui peut être complété sans problème )

Code source

class ssh2{
	
	private $handle;
	private $std_out;
	
	public $host;
	public $port;
	public $term;
	public $user;
	public $pass;
	public $cmd_line; 
	
	
	public function __construct($user='', $pass='', $host='127.0.0.1', $port=22){
		
		
		if(!empty($user) && !empty($pass)){
			$this->user	=	$user;
			$this->pass	=	$pass;
			$this->host	=	$host;
			$this->port	=	$port;
				
		
			try {
				
				$this->handle	=	ssh2_connect($this->host, $this->port);
				
				if(!$this->handle){
					throw new Exception('Exception n°1: erreur à la connection ssh !', 1);
				}
				
				if(!ssh2_auth_password( $this->handle, $this->user, $this->pass )){
							throw new Exception('Exception n°2: erreur à l\'identification ssh !', 2);
				}
				
			}catch (Exception $e){
				echo $e->getCode().PHP_EOL;
				echo $e->getMessage().PHP_EOL;
			}
			
		}//end if
	}
	
	/*
	 * Fermeture de la ressource si elle est encoe active
	 */
	public function __destruct(){
	
		if(is_resource($this->std_out))
		{
			fclose($this->std_out);
		}
		
	}
	
	
	public function __get(string $name){
		
		return $this->$name;
	}
	public function __set(string $name, $value){
		
		$this->$name	=	$value;
	}
	
	public function __call(string $name,array $args){
		
		if(function_exists($name)){
			return $this->$name(implode(',',$args));
		}
	}
	
	
	
	
	/*
	 * Ouvre un terminal Par defaut et retourne le flux
	 */
	public function terminal(){
		
		//ouverture d'un terminal
		$this->std_out	=	ssh2_shell($this->handle,$this->term);
		//retourne la sortie 
		while($line = fgets($this->std_out)) { flush(); echo nl2br($line);}
	}

	
	/*
	 * Execute une commande , en supprimant le flux 
	 * Cette commande s'effectue donc de façon invisible
	 */	
	public function exec_secret_cmd($cmd=''){
		
		if(!empty($cmd)){
			$this->cmd_line	=	$cmd;
		}
		
		//Si la ressource n'hexiste pas encore
		if(!is_resource($this->std_out)){
			$this->terminal();
		}
		
		ob_start();
	
		fwrite($this->std_out,$this->cmd_line.PHP_EOL);
		sleep(1);
		
		while($line = fgets($this->std_out)) { echo nl2br($line);}
		
		ob_end_clean();
		
		//efface les traces
		$this->cmd_line	=	'';
	
	}
	
	
	/*
	 * Execute une commande et retourne le flux
	 */
	public function exec_cmd($cmd=''){
		
		if(!empty($cmd)){
			$this->cmd_line	=	$cmd;
		}
		
		//Si la ressource n'hexiste pas encore
		if(!is_resource($this->std_out)){
			$this->terminal();
		}
		
		fwrite($this->std_out,$this->cmd_line.PHP_EOL);
		sleep(1);
		
		while($line = fgets($this->std_out)) { flush(); echo nl2br($line)."\n";}
		
	}
}


/*
*
*Exemple d'utilisation de la classe ssh2
*
* Ici la connexion se fait en local , l'interet est donc limité 
* Mais cela permet par exemple de lancer des scripts d'un autre 
* utilisateur que www-data , sans changer la configuration 
* du php.ini ou apache 
*/

$P	=	new ssh2("user", "password");

$P->term	=	"xtrem";

$P->terminal();

$P->exec_secret_cmd("sudo -s");
$P->exec_secret_cmd("password");

$P->exec_cmd("apt-get upgrade");