**
  * Cette méthode permet de télécharger un fichier depuis une URL
  * @param urlPath chemin du fichier source (site web)
  * @param destination chemin de destination
  */
 private void downloadFile(String urlPath, String destination) { 
  try { 
   //On crée l'URL
          URL url = new URL(urlPath);
 
   //On crée une connection vers cet URL
   URLConnection connection = url.openConnection( );
 
   //On récupère la taille du fichier
   int length = connection.getContentLength();
 
   //Si le fichier est inexestant, on lance une exception
   if(length == -1){
    throw new IOException("Fichier vide");
         }
 
   //On récupère le flux du fichier
   InputStream is = new BufferedInputStream(connection.getInputStream());
 
   //On prépare le tableau de bits pour les données du fichier
   byte[] data = new byte[length];
 
   //On déclare les variables pour se retrouver dans la lecture du fichier
   int currentBit = 0;
   int deplacement = 0;
 
   //Tant que l'on n'est pas à la fin du fichier, on récupère des données
   while(deplacement < length){
    currentBit = is.read(data, deplacement, data.length-deplacement); 
    if(currentBit == -1)break; 
    deplacement += currentBit;
   }
 
   //On ferme le stream
   is.close();
 
   //Si on est pas arrivé à la fin du fichier, on lance une exception
   if(deplacement != length){
    throw new IOException("Le fichier n'a pas été lu en entier (seulement "
 + deplacement + " sur " + length + ")");
   }  
 
   //On crée un flux sortant vers la destination
   FileOutputStream destinationFile = new FileOutputStream(destination); 
 
   //On écrit les données du fichier dans ce flux
   destinationFile.write(data);
 
   //On vide le tampon et on ferme le stream
   destinationFile.flush();
   destinationFile.close();
 
       } catch (MalformedURLException e) { 
         System.err.println("Problème avec l'URL : " + urlPath); 
       } catch (IOException e) { 
         e.printStackTrace();
       }   
 }

	downloadFile("www.XXX.com/XXX/XXX.xxx", "C:\\XXX\XXX.xxx");

/**
* Cette méthode permet de récupérer la source d'une page WEB sous forme de String
*/
publig String getSourceOfWebPage(String page){
	URLConnection urlConnection = new URL(page).openConnection();
	urlConnection.setUseCaches(false);
	urlConnection.connect();
				
	Scanner scanner = new Scanner(urlConnection.getInputStream());
	StringBuffer source = new StringBuffer();
	
	while(scanner.hasNextLine()){
		source.append(scanner.nextLine());
	}
	
	return source.toString();
}

package models;
import java.io.File;
import java.util.ArrayList;
import java.util.StringTokenizer;
import javax.swing.filechooser.FileFilter;
 
/**
* Classe de filtre pour JFileChooser, permet de selectionner différents 
types de fichier. On peut passer plusieurs extensions de fichiers en 
paramètres, mais il faut les séparer par des virgules
* @author Wichtounet
*
*/
public class FiltreMultiple extends FileFilter{//Description et extension acceptée par le filtre
	private String description;
	private String extension;
	private ArrayList<String> acceptedExtensions = new ArrayList<String>();
	
	/**
	* Constructeur du filtre
	* @param description Description du filtre
	* @param extensions Extensions valides donc à afficher
	*/
	public FiltreMultiple(String description, String extensions){
		if(description == null || extensions ==null){
			throw new NullPointerException("La description (ou extension) ne peut être null.");
		}
		
		this.description = description;
		this.extension = extensions;
		 
		StringTokenizer token = new StringTokenizer(extension,",");
		 
		while(token.hasMoreTokens()){
			acceptedExtensions.add(token.nextToken());
		}
	}
 
	/**
	* Méthode qui dit si un fichier doit etre affiché ou pas en fonction de son extension
	* @param file Fichier qui demande à etre accepté ou pas
	*/
	public boolean accept(File file){String nomFichier = file.getName().toLowerCase(); 
		if(file.isDirectory()) { 
			return true; 
		} 
			else{for(short i = 0; i < acceptedExtensions.size();i++){
				if(nomFichier.endsWith(acceptedExtensions.get(i)))return true;
			}
		}
		
		return nomFichier.endsWith(acceptedExtensions.get(acceptedExtensions.size()-1));
	}
 
	/**
	* Méthode qui retourne la description du filtre
	*/
	public String getDescription(){
		return description;
	}
}

FiltreMultiple filtre = new FiltreMultiple("Images","bmp,jpg,gif,png");
fileChooser.setFilter(filtre);

import java.util.ArrayList;
import java.util.Iterator;

/**
 * Cette classe permet la gestion d'une liste de couple clé-valeur. On peut récupérer soit la valeur soit 
 * l'id via l'autre partie du couple et récupérer le valeur en fonction de sa place dans la liste.
 * @author Wichtounet
 *
 */
public class Stock<T> implements Iterable<T>{
	/* Listes contentants les ids et les objets*/
	private ArrayList<T> datas = null;
	private ArrayList<Integer> ids = null;
	
	//Position actuelle de lecture
	private int position = -1;
	
	/**
	 * Constructeur de la classe, il initialise les deux listes de données
	 *
	 */
	public Stock(){
		super();
		
		ids = new ArrayList<Integer>();
		datas = new ArrayList<T>();
	}
	
	/**
	 * Méthode pour ajouter un nouveau couple dans la collection
	 * @param id, l'id du couple
	 * @param value, la valeur du couple
	 */
	public void put(int id, T value){
		ids.add(id);
      	datas.add(value);
	}
	
	/**
	 * Cette méthode permet de récupérer une valeur à partir d'un id
	 * @param id, id de la valeur à récupérer
	 * @return La valeur correspondant à l'id
	 */
	public T getValueOf(int id){
		int index = ids.indexOf(id);
		
		if (index >= 0){
			return (T)datas.get(index);          
		}
		
		return null;
	}
	
	/**
	 * Cette méthode permet de récupérer un id à partir d'une valeur
	 * @param value, valeur dont on recherche l'id
	 * @return L'id
	 */
	public Integer getIdOf(T value){
		int index = datas.indexOf(value);
		
		if(index > 0){
			return (Integer)ids.get(index);
		}
		
		return null;
	}
	
	/**
	 * Méthode qui retourne le nombre d'éléments du tableau
	 * @return Le nombre d'éléments de la collection
	 */
	public int getItemCount(){
		return datas.size();
	}
	
	/**
	 * Méthode qui dit s'l reste encore des éléments avant la fin du parcous
	 * @return true ou false
	 */
	public boolean hasNext(){		
		return position < datas.size() -1;
	}
	
	/**
	 * Méthode qui retourne l'élément suivant dans la collection
	 * @return La valeur de l'élément
	 */
	public T next(){
		position++;
		return datas.get(position);
	}
	
	/**
	 * Méthode qui retourne l'id de l'élément courant
	 * @return id de l'élément courant
	 */
	public int getCurrentId(){
		return ids.get(position);
	}
	
	/**
	 * Méthode qui revient au début de la collection pour permettre un deuxième parcours
	 *
	 */
	public void first(){
		position = -1;
	}
	
	/**
	 * Cette méthode permet de vérifier si un id est déja contenu ou non dans la liste
	 * @param id L'id à rechercher
	 * @return true si l'id est trouvé et false s'il ne l'est pas
	 */
	public boolean containsID(Integer id){
		return ids.contains(id);
	}
	
	/**
	 * Cette méthode permet de vérifier si une valeur est déja contenu ou non dans la liste
	 * @param value La valeur à rechercher
	 * @return true si la valeur est trouvée et false s'elle ne l'est pas
	 */
	public boolean containsValue(T value){
		return datas.contains(value);
	}
	
	/**
	 * Cette méthode permet de générer un itérateur des données contenues dans le classe
	 */
	public Iterator<T> iterator() {
		return datas.iterator();
	}
}

/**
	 * Cette méthode permet d'encrypter un password avec l'algorythme de cryptage SHA-256
	 * @param password à encrypter
	 * @return le password encrypté
	 */
	private static String encryptPassword(String password){
		String passwordEncoded = "";
		MessageDigest md = null;
		try {
			md = MessageDigest.getInstance("SHA-256");
			
			md.update(password.getBytes());
			
			passwordEncoded = new String(md.digest());
			
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} finally{
			md.reset();
		}
		
		return passwordEncoded;
	}

import java.io.File;
import java.io.IOException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.FileHandler;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.logging.SimpleFormatter;

/**
 * Cette classe permet de gérer le log des erreurs, des requêtes et des messages dans des fichiers, elle fonctionne
 * en verrouillage à double tour. 
 * @author Wichtounet
 *
 */
public class SimpleLogger{
	
	private static MyLogger instance = null;
	private Logger logger = null;
	private Handler handler = null;
	private DateFormat dateFormat = new SimpleDateFormat("ddMMyy");
	//private String logsFolder = System.getProperty("user.dir") + File.separator + "Logs" + File.separator;
	private String logsFolder = "C:\\Documents and Settings\\Propriétaire\\Bureau\\JTheque V4" + File.separator + "Logs" + File.separator;
	
	/**
	 * Construcuteur du loggeur, il est privé pour permettre le verrouillage
	 *
	 */
	private MyLogger(){
		super();
		
		logger = Logger.getLogger("utils.MyLogger");
		logger.setLevel(Level.FINER);
		
		String date = dateFormat.format(new Date());
		
		try {
			File logFile = new File(logsFolder + date + ".log");
			
			if(logFile.exists()){
				handler = new FileHandler(logFile.getAbsolutePath(), true);
			}else{
				logFile.createNewFile();
				handler = new FileHandler(logFile.getAbsolutePath());
			}
			
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		handler.setFormatter(new SimpleFormatter());
		
		logger.addHandler(handler);
	}
	
	/**
	 * Cette méthode permet de charger instance en tant que nouvelle instance de Language, il est synchronisé
	 * pour ne pas avoir de problèmes avec le multi-thread
	 *
	 */
	private static synchronized void syncInstance(){
		if(instance == null){
			instance = new MyLogger();
		}
	}
	
	/**
	 * Cette méthode retourne l'instance unique du logger
	 * @return L'instance de logger
	 */
	public static MyLogger getInstance(){
		if(instance == null){
			syncInstance();
		}
		
		return instance;
	}
	
	/**
	 * Cette méthode logge un nouveau message
	 * @param message le message à logger
	 */
	public void message(String message){
		logger.info(message);
	}
	
	/**
	 * Cette méthode logge une nouvelle requête
	 * @param request la requête à logger
	 */
	public void request(String request){
		logger.info(request);
	}
	
	/**
	 * Cette méthode logge une nouvelle exception
	 * @param classe la classe d'ou vient l'exception
	 * @param methode la méthode d'ou vient l'exception
	 * @param exception l'exception qui a été levée
	 */
	public void exception(String classe, String methode, Throwable exception){
		logger.throwing(classe, methode, exception);
	}
	
	/**
	 * Cette méthode permet de fermer proprement le fichier de log
	 *
	 */
	public void closeHandler(){
		handler.close();
	}
}

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Locale;

/*
 *     This file is part of JTheque.
 * 	   
 * 	   JTheque is free software; you can redistribute it and/or modify
 * 	   it under the terms of the GNU General Public License as published by
 * 	   the Free Software Foundation; either version 2 of the License, or
 * 	   (at your option) any later version.
 * 	   
 * 	   JTheque is distributed in the hope that it will be useful,
 * 	   but WITHOUT ANY WARRANTY; without even the implied warranty of
 * 	   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * 	   GNU General Public License for more details.
 * 	   
 * 	   You should have received a copy of the GNU General Public License
 * 	   along with ExtendedFrame; if not, write to the Free Software
 * 	   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 * 	   
 */

/**
 * Cette classe permet de gérer une date int (yyyymmdd) de manière simplifiée
 * @author Baptiste Wicht
 *
 */
public class IntDate {
	public static final class Fields {
		public static final int MONTH = Calendar.MONTH;
		public static final int DAY = Calendar.DAY_OF_MONTH;
		public static final int YEAR = Calendar.YEAR;
		
		/**
		 * Permet de tester la validité d'un champ
		 * @param field Le champ à tester
		 * @return true si le champ est un champ accepté sinon false
		 */
		public static boolean isValid(int field){
			return field == MONTH || field == DAY || field == YEAR;
		}
	}
	
	private static IntDate today = null;
	
	private final SimpleDateFormat formatter = new SimpleDateFormat("dd.MM.yyyy", Locale.getDefault());
	private final Calendar calendar;
	
	/**
	 * Constructeur de la date, il construit les différentes propriétés de la date
	 * @param date La date sous forme de int
	 */
	public IntDate(int date){
		super();
		
		String dateString = Integer.toString(date);
		
		calendar = Calendar.getInstance();
		calendar.clear();
		
		int day = Integer.parseInt(dateString.substring(6, 8));
		int month = Integer.parseInt(dateString.substring(4, 6)) - 1;
		int year = Integer.parseInt(dateString.substring(0, 4));
		
		calendar.set(year, month, day);
	}
	
	/**
	 * Construit un objet IntDate à partir d'un objet Calendar
	 * @param calendar Le calendar de la date à représenter
	 */
	public IntDate(Calendar calendar){
		super();
		
		this.calendar = calendar;
	}
	
	/**
	 * Retourne le jour de la date
	 * @return Le jour
	 */
	public int getDay(){
		return calendar.get(Calendar.DAY_OF_MONTH);
	}
	
	/**
	 * Retourne l'année de la date
	 * @return L'année
	 */
	public int getYear(){
		return calendar.get(Calendar.YEAR);
	}
	
	/**
	 * Retourne le mois de la date 
	 * @return Le mois
	 */
	public int getMonth(){
		return calendar.get(Calendar.MONTH);
	}
	
	/**
	 * Cette méthode permet de récupérer la date en int
	 * @return La date
	 */
	public int getDate(){
		return Integer.parseInt(getStrDate());
	}
	
	/**
	 * Cette méthode permet d'ajouter quelque chose à la date
	 * @param field Le champ en question
	 * @param toAdd Ce qu'il faut lui ajouter
	 */
	public void add(int field, int toAdd){
		if(Fields.isValid(field)){
			calendar.add(field, toAdd);
		} else {
			throw new IllegalArgumentException();
		}
	}
	
	/**
	 * Cette méthode permet de modifier quelque chose à la date
	 * @param field Le champ en question
	 * @param value La nouvelle valeur qu'il faut lui attribuer
	 */
	public void set(int field, int value){
		if(Fields.isValid(field)){
			calendar.set(field, value);
		} else {
			throw new IllegalArgumentException();
		}
	}
	
	/**
	 * Retourne la date sous forme de chaîne de caractères
	 * @return Une chaîne de caractères représentant la date
	 */
	public String getStrDate(){
		StringBuilder builder = new StringBuilder();
		
		builder.append(getYear());
		
		String strMonth = getMonth() < 10 ? "0" + getMonth() : Integer.toString(getMonth());
		builder.append(strMonth);
		
		String strDay = getDay() < 10 ? "0" + getDay() : Integer.toString(getDay());
		builder.append(strDay);
		
		return builder.toString();
	}
	
	public static IntDate today(){
		if(today == null){
			Calendar calendar = Calendar.getInstance();
			
			today = new IntDate(calendar);
		}
		
		return today;
	}
	
	public int intValue(){
		return getDate();
	}
	
	@Override
	public String toString(){
		return formatter.format(calendar.getTime());
	}
}