Développement Web, Javascript

Base de données en Javascript avec TaffyDB

Posté par seiyar81 le 6 octobre 2014 | Laisser un commentaire (0)
TaffyDB

Lors de mes développements, une tâche qui revient quasiment à chaque fois est l’implémentation de la gestion de collection en Javascript. Faire une recherche dans une collection, ajouter/supprimer des éléments etc …

Si la gestion de ces opérations n’est pas compliquée il n’en reste pas moins que le plus simple est d’utiliser une librairie dédiée à cette gestion.

C’est alors qu’intervient TaffyDB, une librairie de gestion de base de données en Javascript.
Elle gère les opérations de type CRUD, est facilement extensible et est aussi bien utilisable en front avec jQuery et compagnie qu’en back via NodeJS par exemple.

Sans tarder voici ci dessous un exemple complet de ce qu’il est possible de faire avec la librairie :

	// Déclaration de la table employés
	var employees = new TAFFY([
		{"id":1,"gender":"M","first":"John","last":"Smith","branch":"Seattle, WA","department":1},
		{"id":2,"gender":"F","first":"Kelly","last":"Ruth","branch":"Seattle, TX","department":2},
		{"id":3,"gender":"M","first":"Jeff","last":"Stevenson","branch":"Washington, D.C.","department":1},
		{"id":4,"gender":"F","first":"Jennifer","last":"Gill","branch":"Seattle, WA","department":3}	
	]);
		
	// Déclaration de la table départements
	var departments = TAFFY([
	  {id: 1, name: 'Sales', abbreviation: 'SA'},
	  {id: 2, name: 'Accounting', abbreviation: 'AC'},
	  {id: 3, name: 'Human Resources', abbreviation: 'HR'}
	]);

Vous pouvez donc initialiser vos bases de données en récupérant le contenu d’une requête AJAX.

	
	// Tri sur la colonne last et récupération du premier de la liste
	employees.order("last").first().name;

	// Select sur la colonne branch et count
	employees({branch:"Seattle"}).count();

	// Update de la colonne branch
	employees({id:"1"}).update({ branch: "Washington, D.C." });

	// Delete
	employees({id:"4"}).remove();
	
	// Insert d'un nouveau département
	departments.insert({id: 4, name:"IT Support", abbreviation:"IT"});

Enfin sachez que les jointures sont gérées :


	// Jointure sur la table departments et récupération du nom du premier élément : Sales
	employees().join( departments, [ 'department', 'id' ]).first().name;

Attention si les deux tables jointes ont des noms de colonnes en commun alors le nom de colonne de la table jointe sera préfixé avec right_.

Et voilà il n’y a plus qu’à se servir des multiples fonctions de TaffyDB pour gérer au mieux ses jeux de données.

Catégorie: Développement Web, Javascript | Laisser un commentaire (0)

Java : créer une archive Zip en mémoire avec ZipOutputStream

Posté par seiyar81 le 3 avril 2014 | Laisser un commentaire (0)

Une petite class utilitaire pour générer des archives Zip en mémoire, sans rien écrire sur le disque, le tout aussi bien à partir de fichiers physiques ou de texte brut.

package fr.yriase.tools;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

import javax.servlet.ServletOutputStream;

public class ZipFileWriter {

  /**
  * Flux de l'archive zip
  */
  private ZipOutputStream zos;
  
  /**
  * Constructor: creation d'une nouvelle archive directement dans le stream passé en paramètre
  * @param OutputStream out
  * @throws FileNotFoundException
  */
  public ZipFileWriter(OutputStream out) throws FileNotFoundException {
  	this.zos = new ZipOutputStream(out);
  }
  
  public ZipOutputStream getOutputStream()
  {
  	return this.zos;
  }
  
  /**
  * Ajouter un fichier depuis le disque dur au zip
  * @param String fileName
  * @throws FileNotFoundException
  * @throws IOException
  */
  public void addFile(String fileName) throws FileNotFoundException, IOException {
    FileInputStream fis = new FileInputStream(fileName);
    int size = 0;
    byte[] buffer = new byte[1024];
    
    //Ajouter une entree à l'archive zip
    File file = new File(fileName);
    ZipEntry zipEntry = new ZipEntry(file.getName());
    this.zos.putNextEntry(zipEntry);
    
    //copier et compresser les données
    while ((size = fis.read(buffer, 0, buffer.length)) > 0) {
    	this.zos.write(buffer, 0, size);
  	}
  
  	this.zos.closeEntry();
  	fis.close();
  }
  
  /**
  * Ajouter un fichier depuis un array de bytes au zip
	* @param 
  * @param fileName
  * @throws IOException
  */
  public void addFile(byte[] bytes, String fileName) throws IOException {
    //Ajouter une entree à l'archive zip
    ZipEntry zipEntry = new ZipEntry(fileName);
    this.zos.putNextEntry(zipEntry);
    
    //Copier et compresser les données
    this.zos.write(bytes, 0, bytes.length);
    
    this.zos.closeEntry();
  }
  
  /**
  * Fermer le fichier zip
  * @throws IOException
  */
  public void close() throws IOException {
  	this.zos.finish();
  	this.zos.close();
  }
}

A utiliser comme ceci dans une action Struts par exemple :

public class DownloadZipAction extends Action {

	public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
	
		ServletOutputStream out = response.getOutputStream();

		response.setHeader("Content-Type","application/zip");
		response.setHeader("Content-Disposition", "attachment; filename=\"test.zip\"");

		ZipFileWriter zip = new ZipFileWriter(out);

		zip.addFile("<?xml version=\"1.0\" encoding=\"UTF-8\"?><test>var1</test>", "test.xml");
		zip.addFile("C:/test.xml");
		
		zip.close();

	}

}

A garder sous le coude, ça peut toujours servir.

Catégorie: Développement Web, Java | Laisser un commentaire (0)

Prestashop Advanced Sitemap: v1.5 et sitemaps multiples

Posté par seiyar81 le 26 février 2014 | Laisser un commentaire (21)

Une petite news rapide pour informer de la nouvelle version du module qui passe en 1.5 avec au menu une fonctionnalité demandée depuis quelques temps :

  • Génération de sitemaps multiples
  • Compression gzip des sitemaps générés
  • Sauvegarde des paramètres sans regénérer le sitemap
  • Stabilité du code

Cette fonctionnalité permet d’éviter un refus du sitemap par Google si le nombre d’URLs dépasse 50 000 ou si la taille est supérieure à 50 Mo.
Le module fonctionne maintenant ainsi :

  • vous définissez une limite à ne pas dépasser par sitemap (10 000 par défaut, car il faut tenir compte des images)
  • une fois cette limite atteinte lors de la génération, le module sauvegarde un premier fichier et passe au second
  • et ainsi de suite jusqu’à avoir traité toutes les URLs
  • une fois la génération terminée, le module génère un Sitemap Index qui regroupe tous les sitemaps générés et le transmet aux moteurs de recherche
  • si la limite définie n’est pas atteinte, un fichier sitemap simple est généré.

Vous pouvez ensuite choisir de compresser ou non tous les fichiers générés.

La prochaine étape sera maintenant de proposer une génération par langage !

Tout ça se récupère sur GitHub.


MAJ v1.5.1 : version mineure pour corriger 2 petits bugs
– Ajout forcé d’un ‘/’ à la fin des URLs personnalisées (si non présent) pour éviter les URLs malformées
– Correction de la génération du sitemap XML pour la validation XSD

La prochaine version vera l’ajout des fournisseurs/marques et éventuellement la sélection du type d’image à ajouter et/ou la possibilité de ne pas les ajouter au sitemap.

Catégorie: Développement Web, Internet, PHP | Laisser un commentaire (21)

Développer en ligne avec Koding

Posté par seiyar81 le 30 janvier 2014 | Laisser un commentaire (0)
Koding

Une petite news rapide pour préciser que le site Koding offre à tout nouvel inscrit un espace de 4Go pour développer ses applications en ligne (dans la limite de 100 To pour tout le monde).

Pour information Koding est un service qui offre une VM accessible via une interface Web et avec tout ce qui va avec : terminal, explorateur de fichiers, applications etc …

Idéal lorsqu’on travaille sur plusieurs machines en même temps ou que l’on souhaite tester un bout de code rapidement.

Plus intéressant encore, Koding permet de travailler en collaboration avec d’autres utilisateurs ! Voir la vidéo ci-dessous :

Un outil à tester d’urgence car le tout est plutôt fluide et simple à utiliser !

Catégorie: Développement Web, Geek, Internet | Laisser un commentaire (0)

jQuery UI DatePicker : désactiver certains jours de la semaine

Posté par seiyar81 le 28 janvier 2014 | Laisser un commentaire (3)
jQuery UI DatePicker

jQuery UI propose bon nombre de widgets très utiles lorsqu’on développe des applications Web dynamiques.
Parmis ces derniers le DatePicker, ou calendrier, qui propose plusieurs options de configuration très précises.

Prenons par exemple le cas suivant : le client pour qui vous développez une application de réservation de restaurants vous informe que tous les réservations ne sont pas possibles les lundis et jeudis.

Et bien pas de problèmes, la fonction beforeShowDay permet de pré-filtrer chaque date et de définir si elle est sélectionnable ou pas.
Ce qui donne dans notre cas :


	jQuery(document).ready(function() {
		jQuery("#calendar").datepicker({
			beforeShowDay: function (date) {
				if (date.getDay() == 1 || date.getDay() == 4) { // La semaine commence à 0 = Dimanche
					return [false, ''];
				} else {
					return [true, ''];
				}
			}
		});
	});

Et voilà c’est tout simple.

On peut également utiliser la même méthode pour supprimer certaines semaines ou mois de l’année (vacances par exemple) :


	jQuery(document).ready(function() {
		jQuery("#calendar").datepicker({
			beforeShowDay: function (date) {
				if (date.getMonth() == 6 || date.getMonth() == 7) { // Mois Juillet et Août
					return [false, ''];
				} else {
					return [true, ''];
				}
			}
		});
	});

Si vous souhaitez par contre mettre une date minimum, utilisez plutôt l’option minDate :


	jQuery(document).ready(function() {
		jQuery("#calendar").datepicker({
			minDate: new Date(2014, 1 - 1, 1)
		});
	});

A vos claviers !

Catégorie: Développement Web, Javascript | Laisser un commentaire (3)

Java : sérialisation personnalisée de ses objets en JSON avec Flexjson

Posté par seiyar81 le 16 janvier 2014 | Laisser un commentaire (0)
JSON - Flexjson

Si vous travaillez sur des applis Web et Java et que vous vous retrouvez à devoir sérialiser vos données en JSON, il y a de fortes chances pour que vous utilisiez la bibliothèque Flexjson.

Les fonctionnalités de sérialisation sont puissantes et permettent par exemple de sériliaser un objet en profondeur.

Un exemple plutôt simple :


public class Yriase {
	
	private String name;

	public Yriase {
	}

	public String getName() {
		return this.name;
	}

	public void setName(String name) {
		this.name = name;
	}

}


public static void main(String[] args) {

	Yriase y = new Yriase();
	y.setName( "yriase" );

	System.out.println( new JSONSerializer().exclude("*.class").serialize(yriase) );

}

Devrait vous renvoyer la chaîne suivante :

{
	name: "yriase"
}

Imaginons maintenant un cas un peu plus complexe. Vous avez créé une classe, et vous vous attendez à ce que les objets soient formattés d’une façon bien définie.
Pas de chance vous tombez dans le cas où le formattage par défaut de Flexjson ne vous convient pas.

Aucun problème, la bibliothèque vous offre la possibilité de définir vos propres Transformer pour vos données.

Prenons la classe template suivante :


public class Pair<String, Integer> {
	private String key;
	private Integer value;
    
	public Pair() {
	}
    
	public Pair(String k, Integer v) {
		this.key = k;
		this.value = v;
	}
    
	public String getKey() {
		return key;
	}
	public void setKey(String key) {
		this.key = key;
	}
	public Integer getValue() {
		return value;
	}
	public void setValue(Integer value) {
		this.value = value;
	}
}

Le formattage par défaut donnera ceci :

{
	key: "keyname",
	value: 10
}

Or on préfèrerait avoir le formattage suivant :

[ "keyname", 10 ]

Et bien il suffit d’implémenter une classe qui étends AbstractTransformer.
Voici donc la solution au problème :


public class PairTransformer extends AbstractTransformer {
	
	@Override
	public void transform(Object object) {
		Pair<String, Integer> p = (Pair<String, Integer>) object;
		
		getContext().writeOpenArray();
		
		getContext().writeQuoted( p.getKey());
		
		getContext().writeComma();
		
		getContext().write( String.valueOf(p.getValue()) );
		
		getContext().writeCloseArray();
	}
	
}

Et pour terminer il nous faut précisier lors de la sérialisation que l’on a un Transformer customisé :


JSONSerializer serializer = new JSONSerializer();
serializer.transform(new PairTransformer(), 	new Pair<String,Integer>().getClass());

Le tour est joué !

Catégorie: Développement Web, Java | Laisser un commentaire (0)

Remplir un formulaire avec jQuery

Posté par seiyar81 le 7 janvier 2014 | Laisser un commentaire (0)
jQuery Populate

Lorsque vous developpez une application Web, disons en PHP par exemple et que vous devez assigner vous-même les valeurs aux champs d’un formulaire, le mélange HTML/PHP peut vite s’avérer indigeste.

Si vous disposez de données JSON, ou de la possibilité de formater des données dans ce format, pour remplir votre formulaire, alors le plugin jQuery Populate devrait répondre à tous vos besoins.

Imaginons le formulaire HTML suivant :

	

Vous récupérez un jeu de données JSON via une requête AJAX ou bien directement formaté dans la page du type :

  var data = {

		name: "Yriase",

		type: ["0","2"],

		valider: false,

		comment: "Commentaire plus long"

	}

Grâce à Populate vous n’avez plus qu’à réaliser l’appel suivant :


	$('form["myform"]').populate(data);

Et le tour est joué !

Catégorie: Développement Web, Javascript | Laisser un commentaire (0)

FullCalendar : chargement et mise à jour des évènements dans une base de données

Posté par seiyar81 le 7 août 2013 | Laisser un commentaire (7)

Pour faire suite au précédent article présentant le plugin FullCalendar, nous allons voir comment charger des évènements depuis une base de données pour peupler notre calendrier et ensuite comment les mettre à jour.

Nous allons pour cela mettre en place un calendrier avec affichage simple (mois/semaine/jour) sur notre page web :


<html>
<head>
<link href='fullcalendar/fullcalendar/fullcalendar.css' rel='stylesheet' />
<link href='fullcalendar/fullcalendar/fullcalendar.print.css' rel='stylesheet' media='print' />
<script src='fullcalendar/jquery/jquery.min.js'></script>
<script src='fullcalendar/jquery/jquery-ui.min.js'></script>
<script src='fullcalendar/fullcalendar/fullcalendar.js'></script>

<style>

	body {
		margin-top: 40px;
		text-align: center;
		font-size: 14px;
		font-family: "Lucida Grande",Helvetica,Arial,Verdana,sans-serif;
		}

	#calendar {
		width: 900px;
		margin: 0 auto;
		}

</style>
</head>
<body>
<div id='calendar'></div>
</body>
</html>

Côté serveur, il va nous falloir une base de données, forcément, avec une table pour stocker les évènements pouvant ressembler à ceci :



--
-- Table structure for table `event`
--

CREATE TABLE IF NOT EXISTS `event` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `title` varchar(55) NOT NULL,
  `start` datetime NOT NULL,
  `end` datetime DEFAULT NULL,
  `allDay` tinyint(1) DEFAULT NULL,
  `url` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB  DEFAULT CHARSET=latin1 AUTO_INCREMENT=2 ;

On va ensuite ajouter le code Javascript pour charger et mettre à jour les évènements :


    $(document).ready(function() {
	
        function updateEvent(event,dayDelta,minuteDelta,allDay)
        {
            $.ajax({ 'url': 'ajax.php?action=update', 'type': 'POST', 
                'data': {'id':event.id, 'dayDelta': dayDelta, 'minuteDelta': minuteDelta, 'allDay': allDay},
                success: function(data) {
                    if(data.error)
                        alert(data.error);
                },
                error: function(data) {
                   alert('Une erreur est survenue.'); 
                }
            });
        }
		
				$('#calendar').fullCalendar({
            header: {
    					left: 'prev,next today',
							center: 'title',
							right: 'month,agendaWeek,agendaDay'
						},
            editable: true,
            eventSources: [
                'ajax.php?action=get'
            ],
            eventDrop: function(event,dayDelta,minuteDelta,allDay,revertFunc) {    
                if (!confirm("Valider la modification ?")) {
                    revertFunc();
                } else {
                    updateEvent(event,dayDelta,minuteDelta,allDay);
                }
            },
            eventResize: function(event,dayDelta,minuteDelta,revertFunc) {
                if (!confirm("Valider la modification ?")) {
                    revertFunc();
                } else {
                    updateEvent(event,dayDelta,minuteDelta,0);
                }
            }
		});
		
	});

On note donc que le paramètre d’initialisation eventSources indique au calendrier une (ou plusieurs) url à interroger pour charger les évènements.
Le résultat attendu étant un tableau au format JSON.
Les callbacks eventDrop et eventResize sont appellés dès qu’un évènement est modifié sur le calendrier.
Si l’utilisateur valide l’action, alors on appelle la fonction updateEvent qui enverra la requête d’update au serveur.
Les paramètres dayDelta, minuteDelta et allDay correspondent aux modifications apportées à l’évènement.

Pour fournir ce tableau c’est très simple.
On va créer une page PHP pour recevoir et traiter les requêtes AJAX :


    $dsn = 'mysql:dbname=fullcalendar;host=127.0.0.1';
    $user = 'root';
    $password = 'root';

    if(isset($_GET['action']))
    {
        switch($_GET['action'])
        {
            case 'get':
                try {
                    $db = new PDO($dsn, $user, $password);
                    
                    $sql = 'SELECT * FROM event';
                    $events = array();
                    
                    foreach ($db->query($sql) as $row) {
                        $events[] = $row;
                    }
                    
                    echo json_encode($events);
                    
                } catch (PDOException $e) {
                    echo json_encode(array('error' => 'Connection failed: ' . $e->getMessage()));
                }                
                break;
            default:
                break;
        }
    }
    

Très simple donc, on contrôle l’action reçue en paramètre, si c’est get alors on renvoit un tableau contenant les évènement stockés dans la base de données.
Un simple json_encode des évènements suffit.

Avec ce code on possède donc un calendrier affichant nos évènements.
Pour maintenant mettre à jour nos évènements en base de données, il faut juste ajouter l’action update côté serveur :


case 'update':
  try {
    $db = new PDO($dsn, $user, $password);
    
    $query = $db->query('SELECT * FROM event WHERE id = ' . $_POST['id']);
    $event = $query->fetch(PDO::FETCH_ASSOC);
    
    // Mise a jour de la date
    $diff = calculateDiff($_POST['dayDelta'], $_POST['minuteDelta']);
    
    $newStart = DateTime::createFromFormat('Y-m-d H:i:s', $event['start']);
    $newStart->modify($diff);
    
    $newEnd = DateTime::createFromFormat('Y-m-d H:i:s', $event['end']);
    $newEnd->modify($diff);
    
    $sql = 'UPDATE event SET start = "'.$newStart->format('Y-m-d H:i:s').'",
    end = "'.$newEnd->format('Y-m-d H:i:s').'",
    allDay = "'.$_POST['allDay'].'"
    WHERE id = ' . $_POST['id'];
    $row = $db->query($sql);
    
    echo json_encode(array('updated' => true));
  
  } catch (PDOException $e) {
    echo json_encode(array('error' => 'Db error : ' . $e->getMessage()));
  } catch (Exception $e) {
    echo json_encode(array('error' => $e->getMessage()));
  }       
break;

Le traitement est assez simple, on utilise la classe DateTime pour calculer les changements de dates avec sa méthode modify et deux fonctions que l’on va utiliser pour transformer les dayDelta et minuteDelta en chaîne compréhensible par DateTime :


	function pluralize($string) 
  {
      preg_match("|^([0-9]+)(.*)|",$string,$matched);
      if($matched[1] > 1) {
          return number_format($matched[1]) . $matched[2] . 's';
      }
      return $string;
  }

  function calculateDiff($dayDelta, $minuteDelta)
  {
      if($dayDelta != 'null' && $dayDelta != '0') {
          if($dayDelta < 0)
              $diff = "-".pluralize(abs(intval($dayDelta))." day");
          else if($dayDelta > 0)
              $diff = "+".pluralize(intval($dayDelta)." day");
      }
      else
          $diff = "";

			if($minuteDelta != 'null' && $minuteDelta != '0') {
          if($minuteDelta < 0)
              $diff .= "-".pluralize(abs(intval($minuteDelta))." minute");
          else
              $diff .= "+".pluralize(intval($minuteDelta)." minute");
      }
        
      return $diff;
  }

Ces fonctions vont par exemple transformer dayDelta = +2 : +30 en la chaîne "+2 days"

Et voilà on a maintenant un calendrier affichant nos propres évènements et les enregistrant en base de données.

Catégorie: Développement Web, Javascript | Laisser un commentaire (7)

Prestashop Advanced Sitemap : mises à jours GitHub

Posté par seiyar81 le 31 juillet 2013 | Laisser un commentaire (5)

Une news rapide pour signaler que le module est passé en version 1.4.5.2 suite à quelques mises à jour.
S’il n’y a pas de grosses nouvelles fonctionnalités, il y a toutefois une nouvelle présentation et mise en page, mais surtout un bloc affichant les dernières versions disponibles au téléchargement ainsi que les dernières mises à jour du module sur GitHub.
Le meilleur moyen donc de se tenir informé des modifications apportées au module et de voir si’ l’on est à jour.

N’hésitez donc pas à soumettre vos idées pour les prochaines versions du module.

Pour télécharger le module direction GitHub.

Catégorie: Développement Web, PHP | Laisser un commentaire (5)

Des div toujours visibles avec Sticky, un plugin jQuery

Posté par seiyar81 le 5 juillet 2013 | Laisser un commentaire (1)
Sticky

Lorsqu’on développe des sites ou applications Web, on peut être amenés à vouloir garder une partie de la page toujours visible lorsqu’on scroll.
Que ce soit pour un effet esthétique ou pour une question de praticité comme avec une barre d’actions ou un menu de navigation par exemple.

Plusieurs manières existent pour réaliser cet effet, mais je parlerai ici d’un plugin jQuery : Sticky.

Ci-dessous un petit exemple d’un header toujours visible :

  Sticky
  
  
  
  

  
  

Une première div qui va disparaître.

Une deuxième div qui va disparaître.

Une troisième div qui va disparaître.

Nous centrons donc notre header en CSS et nous indiquons ensuite à Sticky via la propriété center:true que l’on souhaite qu’il reste centré une fois collé en haut de la page.

Sticky est léger et configurable via 5 options :

  • topSpacing: Pixels entre le haut de la page et le haut de l’élément
  • bottomSpacing: Pixels entre le bas de la page et le bas de l’élément
  • className: Classe CSS ajouté à l’élément et à son wrapper quand il est collé
  • wrapperClassName: Classe CSS ajouté au wrapper
  • getWidthFrom: Sélecteur d’un élément utilisé pour régler la largeur fixe de l’élément collé

Libre à vous d’utiliser le CSS que vous souhaitez pour placer/dessiner votre élément.

Pour récupérer le plugin ou y contribuer, direction Github.

Catégorie: Développement Web, Javascript | Laisser un commentaire (1)