extranet/application/controllers/FinanceController.php

<?php
require_once ('common/dates.php');
require_once ('Scores/SessionEntreprise.php');
require_once ('Scores/Utilisateur.php');
require_once ('finance/synthese.lib.php');
require_once ('Scores/WsScores.php');
require_once ('ChartDirector/phpchartdir.php');
require_once ('ChartDirector/FinanceChart.php');
require_once ('Graphique/Graphique.lib.php');

/**
 * La Classe finance gére les actions concernant la partie element financiés du menu
 *
 * Les Bilans.
 * La Synthese.
 * Les Ratios.
 * Les Etablissements bancaires.
 * Les Liasses fiscales.
 * Les cotations en bourses.
 *
 * @author Damien Lasserre
 *
 */
class FinanceController extends Zend_Controller_Action
{
    private $ws; // L'objet WSScores pour les requetes.
    private $entreprise; // Un stdClass pour quelques info sur la société.
    private $dateFunction; // Objet qui gére les dates.
    private $imageCachePath; // Chemin des images de graphique en cache.
    private $idSC; // Id unique Scores-et-decision ( URL ).
    private $tableauBilanGraphique;
    private $htmlBilan;
    private $graphique;
    
    public function init()
    {
        define('FIRST_POSITION',  0);
	    define('SECOND_POSITION', 1);
	    define('THREE_POSITION',  2);
	    
        $this->entreprise        = new stdClass();
        $this->dateFunction      = new WDate();
        $this->ws                = new WsScores();
        $entreprise              = new SessionEntreprise($this->getRequest()->getParam('siret'), $this->getRequest()->getParam('id'));
        $this->entreprise->id	 = $entreprise->getId();
        $this->entreprise->nom   = $entreprise->getRaisonSociale();
        $this->entreprise->siret = $this->getRequest()->getParam('siret');
        $this->entreprise->siren = substr($this->entreprise->siret,0,9);
        $this->entreprise->naf   = $entreprise->getNaf();
        $this->imageCachePath    = APPLICATION_PATH. '/../cache/pages/imgcache/';
        $this->graphique         = new Graphique($this->imageCachePath);
       
        $this->entreprise->siren = substr($this->getRequest()->getParam('siret'), 0, 9);
        
        $this->view->assign('isChecked', 'checked="ckecket"');
	    $this->view->assign('isNotChecked', 'false');
        $this->view->assign('dateFunction', $this->dateFunction);
        $this->view->headLink()
            ->appendStylesheet('/themes/default/styles/finance.css', 'all');
        $this->view->headScript()
			->appendFile('/themes/default/scripts/finance.js', 'text/javascript');
    }

/* --------------------------------------------------------------------------------------------------- */
/*                                Gestion de la synthése avec les graphiques                           */
/* ----------------------------------------------------------------------------------------------------*/
    
    /**
     * cette fonction gére l'affichage des données pour la synthése avec les différents graphiques.
     * Il est possible de rajouter des champs dans le tableau bilanReference en respectant la synthaxe.
     */
	public function syntheseAction()
	{
	    $bilanN         = array();
	    $bilanReference = array('r5'   => array('evolution' => 'r6'  , 'unite' => 'EUR',   'operateur' => 1000, 'name' => 'CHIFFRE D\'AFFAIRES'),
	    						'r7'   => array('evolution' => 'r8'  , 'unite' => 'EUR',   'operateur' => 1000, 'name' => 'RESULTAT COURANT AVANT IMPOTS'),
	                            'r10'  => array('evolution' => 'r11' , 'unite' => 'EUR',   'operateur' => 1000, 'name' => 'RESULTAT NET'),
	                            'r18'  => array('evolution' => 'r19' , 'unite' => 'EUR',   'operateur' => 1000, 'name' => 'FONDS PROPRES'),
	                            'r22'  => array('evolution' => 'r23' , 'unite' => 'EUR',   'operateur' => 1000, 'name' => 'TOTAL BILAN'),
	                            'r231' => array('evolution' => 'r235', 'unite' => 'EUR',   'operateur' => 1000, 'name' => 'FONDS DE ROULEMENT'),
	                            'r232' => array('evolution' => 'r236', 'unite' => 'EUR',   'operateur' => 1000, 'name' => 'BESOIN EN FONDS DE ROULEMENT'),
	                            'r249' => array('evolution' => 'r254', 'unite' => 'EUR',   'operateur' => 1000, 'name' => 'TRESORERIE'),
	                            'r24'  => array('evolution' => 'r24' , 'unite' => 'Pers.', 'operateur' => 1,    'name' => 'EFFECTIF')
	    );
	    $request        = $this->getRequest();
	    $synthese       = $this->ws->getRatios(substr($request->getParam('siret'), 0, 9), 'synthese');
	    
	    foreach ($synthese->BilansInfos->item as $item) {
	        if ($item->typeBilan == self::getTypeSynthese()) {
                foreach ($item->RatiosEntrep->item as $RatiosEntrep) {
                    foreach ($bilanReference as $id => $params) {
                        if ($RatiosEntrep->id == $id) {
                            $bilanN[$id]['name'] = $params['name'];
                            $bilanN[$id]['unite'] = $params['unite'];
                            if (count($bilanN[$id]['item']) <= 2) {
                                if (is_numeric($RatiosEntrep->val))
                                    $valeur = number_format(($RatiosEntrep->val/$params['operateur']), 0, '', ' ');
                                $bilanN[$id]['item'][$item->dateCloture]['ValEntrep'] = $valeur;
                            }
                            if (!self::checkIfImageExist(self::getTypeSynthese().'-'.$id))
                                self::createGraphiqueSynthes($id, $synthese, self::getTypeSynthese());
                        }
                    }
                }
                foreach ($item->RatiosEntrepEvol->item as $RatiosEntrepEvol) {
                    foreach ($bilanReference as $id => $params) {
                        if ($RatiosEntrepEvol->id == $params['evolution']) {
                            if (array_key_exists($item->dateCloture, $bilanN[$id]['item']))
                                $bilanN[$id]['item'][$item->dateCloture]['ValEntrepEvol'] = $RatiosEntrepEvol->val;
                        }
                    }
                }
	        }
	    }
      foreach ($bilanN as $id => $val)
          ksort($bilanN[$id]['item']);

      if ($this->getRequest()->isPost())
          $typeBilan = $this->getRequest()->getParam('typeBilan');
      else
          $typeBilan = 'N';
      $this->view->assign('typeBilan', $typeBilan);
      $this->view->assign('raisonSociale', $this->entreprise->nom);
      $this->view->assign('siret', $this->entreprise->siret);
      $this->view->assign('siren', $this->entreprise->siren);
      $this->view->assign('synthese', $bilanN);
      $this->view->assign('nameForGraphique', $bilanReference);
      self::analyseSyntheseGraphique($synthese->BilansInfos->item);
	}
	
	/**
	 * Permet de determiner le type de bilan choise
	 * par default c'est le type N
	 *
	 */
	protected function getTypeSynthese()
	{
	    $typeBilan = $this->getRequest()->getParam('typeBilan');
	    
	    switch($this->getRequest()->getParam('typeBilan')) {
	        case 'C':
	            return ($typeBilan);
	        case 'N':
	        	return ($typeBilan);
	        default:
	            return ('N');
	    }
	    return ('N');
	}
	
	/**
	 * Création des elements servant au graphique les donnée entreprise sur toutes les années.
	 *
	 * @param L'objet $synthese
	 * @param id courrent $id
	 * @param l'adresse du label $labelX
	 * @param le type de bilan C/N $type
	 */
	protected function createAbscisseSynthese($synthese, $id, &$labelX, $type)
	{
	    $dataX1 = array();
	    
        foreach ($synthese->BilansInfos->item as $item) {
            if ($item->typeBilan == $type) {
                $labelX[] = substr($item->dateCloture, 0, 4);
                foreach ($item->RatiosEntrep->item as $RatiosEntrep) {
                    if ($RatiosEntrep->id == $id) {
                        if (is_numeric($RatiosEntrep->val))
                            $dataX1[] = ($RatiosEntrep->val / 1000);
                    }
                }
            }
        }
        $labelX = array_reverse($labelX);
        $dataX1 = array_reverse($dataX1);
        return ($dataX1);
	}
	
	/**
	 * Création des graphiques pour chaque lignes de la synthése.
	 *
	 * @param id courrent $id
	 * @param l'objet $synthese
	 * @param le type de bilan C/N $type
	 */
	protected function createGraphiqueSynthes($id, $synthese, $type)
	{
	    $parametres            = new stdClass();
	    $parametres->nom       = $type.'-'.$id.'.png';
	    $parametres->datas     = array(self::createAbscisseSynthese($synthese,$id, $labelX, $type));
	    $parametres->TitlesY   = array("Keuros");
	    $parametres->TitlesX   = array("Années");
	    $parametres->LineLayer = array("Entreprise");
	    $parametres->labelsY   = array();
	    $parametres->labelsX   = array();
	    
	    $this->graphique->GraphiqueLineXY($parametres, true);
	}
	
	/**
	 * En cours de developement
	 *
	 * @param unknown_type $id
	 * @param unknown_type $dataX
	 * @param unknown_type $synthese
	 */
	protected function getVal($id, &$dataX, $synthese)
	{
	    $dataX = array();

	    foreach ($synthese->BilansInfos->item as $element){
	        foreach($element->RatiosEntrepEvol->item as $RatiosEntrepEvol){
	            if ($RatiosEntrepEvol->id == $id) {
	                $dataX[] = ($RatiosEntrepEvol->val == 'NS')?0:$RatiosEntrepEvol->val;
	            }
	        }
	    }
	}
	
	private function getValFromKey($stdClass, $key)
	{
	    foreach($stdClass as $element) {
	        if ($element->id == $key)
	            return ($element->val/1000);
	    }
	}
	
	/**
	 * En cours de developement
	 *
	 * @param unknown_type $synthese
	 * @param unknown_type $bilanReference
	 */
	protected function analyseSyntheseGraphique($data)
	{
	    $filename = "test.png";
	    
	    //Tri des données par date et par ordre croissant
		foreach ($data as $key => $row) { $date[$key]  = $row->dateCloture; }
		array_multisort($date, SORT_ASC, $data);

		//Définition des valeurs pour le graph
		$dataBFR = array();
		$dataFR = array();
		$dataCA = array();
		$BFR = array();
		$i=0;
		$nbAnnees = 0;
		
		//Parcourir les années
		foreach($data as $item) {
			$anneeFin = substr($item->dateCloture,0,4);
			$moisFin  = substr($item->dateCloture,4,2);
			$jourFin  = substr($item->dateCloture,6,2);
			//Calcul de la date de début
			$dateDebut  = date("Ymd", mktime(0, 0, 0, $moisFin-$item->duree, $jourFin, $anneeFin));
			$anneeDebut = substr($dateDebut,0,4);
			$moisDebut  = substr($dateDebut,4,2);
			$jourDebut  = substr($dateDebut,6,2);
			//Affectation des abscisses
			if(count($dataBFR['x']) < 5) {
    			$dataBFR['x'][$i]   = $dataFR['x'][$i] = $dataCA['x'][$i] = $dataEBE['x'][$i] = chartTime((int)$anneeDebut, (int)$moisDebut, (int)$jourDebut);
    			$dataBFR['x'][$i+1] = $dataFR['x'][$i+1] = $dataCA['x'][$i+1] = $dataEBE['x'][$i+1] = chartTime((int)$anneeFin, (int)$moisFin, (int)$jourFin);
			}
    			//Affectation des ordonnées
    		if(count($dataBFR['y']) < 5)
    			$dataBFR['y'][$i] = $dataBFR['y'][$i+1] = self::getValFromKey($item->RatiosEntrep->item, 'r236');
    		if(count($dataFR['y']) < 5)
    			$dataFR['y'][$i]  = $dataFR['y'][$i+1] = self::getValFromKey($item->RatiosEntrep->item, 'r235');
    		if(count($dataCA['y']) < 5)
    			$dataCA['y'][$i]  = $dataCA['y'][$i+1] = self::getValFromKey($item->RatiosEntrep->item, 'r6');
    		if(count($dataEBE['y']) < 5)
    			$dataEBE['y'][$i] = $dataEBE['y'][$i+1] = self::getValFromKey($item->RatiosEntrep->item, 'r146');
    			
    		$i+=2;
		}
		
		$c = new XYChart(660, 350, 0xcccccc, 0x000000, 1);
		$c->addTitle("Synthèse *", "timesbi.ttf", 15, 0x000000);
		$c->addText(60, 320, "* Elements financier rapportés à 12 mois" );
		$c->setPlotArea(60, 80, 500, 200, 0xffffff, -1, -1, 0xcccccc, 0xcccccc);
		$c->yAxis->setTitle("KEUROS","timesbi.ttf",10);
		$c->xAxis->setTitle( "<*block,valign=absmiddle*>Années<*/*>");
		$c->xAxis->setWidth(2);
		$c->yAxis->setWidth(2);

		// Add a legend box at (55, 32) (top of the chart) with horizontal layout. Use 9 pts
		// Arial Bold font. Set the background and border color to Transparent.
		$legendObj = $c->addLegend(55, 30, false, "times.ttf", 9);
		$legendObj->setBackground(Transparent);

		// Add a blue (0000ff) step line layer to the chart and set the line width to 2 pixels
		$layer1 = $c->addStepLineLayer($dataFR['y'], 0x0000ff, "FONDS DE ROULEMENT");
		$layer1->setXData($dataFR['x']);
		$layer1->setLineWidth(2);

		// Add a red (ff0000) step line layer to the chart and set the line width to 2 pixels
		$layer0 = $c->addStepLineLayer($dataBFR['y'], 0xff0000, "BESOIN EN FONDS DE ROULEMENT");
		$layer0->setXData($dataBFR['x']);
		$layer0->setLineWidth(2);

		// Add a green (00ff00) step line layer to the chart and set the line width to 2 pixels
		$layer2 = $c->addStepLineLayer($dataCA['y'], 0x00ff00, "CHIFFRE D'AFFAIRES");
		$layer2->setXData($dataCA['x']);
		$layer2->setLineWidth(2);

		// Add a black (000000) step line layer style dash to the chart and set the line width to 2 pixels
		$layer3 = $c->addStepLineLayer($dataEBE['y'], $c->dashLineColor(0x000000, DashLine), "EXCEDENT BRUT D'EXPLOITATION");
		$layer3->setXData($dataEBE['x']);
		$layer3->setLineWidth(2);

		# If the FR line gets above the BFR line, color to area between the lines red (ff0000)
		$c->addInterLineLayer($layer0->getLine(0), $layer1->getLine(0), 0xff0000, Transparent);

		# If the FR line gets below the lower BFR line, color to area between the lines light green (8099ff99)
		$c->addInterLineLayer($layer0->getLine(0), $layer1->getLine(0), Transparent, 0x8044ff44);

		if($c->makeChart($this->imageCachePath.$filename) === TRUE){
			$return = '<img src="./fichier/imgcache/'.$filename.'"/>';
		}else{
			$return = 'Impossible de générer le graphique';
		}
	    return $return;
	}
	
/* --------------------------------------------------------------------------------------------------- */
/*                                Gestion des bilans ACTIF/PASSIF/CR                                   */
/* ----------------------------------------------------------------------------------------------------*/

	/**
	 * Construit les elements des bilan en particulié les valeurs.
	 *
	 * @param objet $bilan
	 * @param le tableau de reference $tableauDeReference
	 * @param type de bilan $type
	 * @param date $date
	 * @param duree 12Mois/... $duree
	 * @param consolidé ou Normale (formulaire) $typebilan
	 */
	protected function constructElementForBilan($bilan, $tableauDeReference, &$type, &$date, &$duree, $typebilan)
	{
    	foreach($bilan->BilansInfos->item as $element) {
    	    if($element->typeBilan == $typebilan)
    	    {
        	    if($duree == EOF)
        	        $duree = $element->duree;
        	    if (@count($date) < 5) {
        	        if(!in_array($element->dateCloture, $date))
        	            $date[] = $element->dateCloture;
        	    }
                foreach($element->RatiosEntrep->item as $item) {
                    foreach($tableauDeReference as $id => $valeur) {
        	             if ($item->id == $id) {
                             if (count($type[$id]['item']) < 5) {
                                 if ($item->val > 0) {
                                     $type[$id]['item'][$element->dateCloture] = $item->val / 1000;
                                 }
                                 else
                                     $type[$id]['item'][$element->dateCloture] = 'NS';
                             }
        	             }
                    }
                }
    	    }
    	}
	    foreach ($type as $id => $valeur) {
	        $type[$id]['item'] = array_reverse($valeur['item']);
	    }
    	$date = array_reverse($date);
	}
	
	/**
	 * Fonction qui affiche les bilan (actif, passif, SIG).
	 * Le principe est d'utiliser le mapping de données.
	 *
	 */
	public function bilanAction()
	{
	    $actif           = array();
	    $passif          = array();
	    $SIG             = array();
	    $date            = array();
	    $duree           = EOF;
	    $request         = $this->getRequest();
	    $listeBilan      = array('actif', 'passif', 'sig');
	    $referenceActif  = array('r59' => 'Actif Immobilisé Net','r51' => 'Incorporelles',
	                             'r52' => 'Corporelles', 'r53' => 'Financières',
	                             'r69' => 'Actif Circulant Net', 'r60' => 'Stock et encours',
	                             'r61' => 'Créances Clients', 'r62' => 'Autres Créances',
                  		  	     'r63' => 'Trésorerie Active', 'r22' => 'TOTAL ACTIF'
        );
                 
	    $referencePassif = array('r79' => 'Ressources Propres', 	 'r70' => 'Fonds Propres',
                                 'r71' => 'Provisions Risques',  'r72' => 'Comptes Courants',
                                 'r90' => 'Ressources Externes', 'r83' => 'Dettes Financières',
                                 'r84' => 'Dettes Fournisseurs', 'r85' => 'Dettes Fiscales',
                                 'r86' => 'Autres Dettes', 	  	 'r87' => 'Trésorerie Passive',
                                 'r22' => 'TOTAL PASSIF'
	    );
	    $referenceSIG    = array('r101' => 'CHIFFRE D\'AFFAIRES HORS TAXE', 	 					  'r102' => '-Achat de marchandises, de matières premières',
	    						 'r110' => 'MARGE COMMERCIALE', 				 					  'r111' => '+Production vendue',
                                 'r112' => '+Production immobilisée et stockée',
                                 'r120' => 'PRODUCTION DE L\'EXERCICE',
                                 'r121' => 'Variation de stock de marchandises et matières premières',
                                 'r122' => 'MARGE BRUTE',
                                 'r123' => '-Autres charges externes',
                                 'r130' => 'VALEUR AJOUTÉE', 										  'r132' => 'Charges de personnel',
								 'r133' => '-Impôts, taxes & versements assimilés',					  'r131' => '+Subventions d\'exploitation',
                                 'r140' => 'EXCÉDENT BRUT D\'EXPLOITATION (EBE)', 					  'r141' => '+Autres produits d\'exploitation',
                                 'r142' => '-Autres charges d\'exploitation', 						  'r143' => '+Reprise sur dotations & transferts de charges',
                                 'r144' => '+70% Loyer de crédit bail', 							  'r145' => '-Dotations d\'exploitation & provisions d\'exploitation',
                                 'r150' => 'RÉSULTAT D\'EXPLOITATION', 								  'r151' => '+Produits financiers',
                                 'r152' => '+30% Loyer de crédit bail', 							  'r153' => '+Charges financières',
                                 'r170' => 'RÉSULTAT COURANT AVANT IMPOTS', 						  'r171' => '+Produits exceptionnels',
                                 'r172' => '-Charges exceptionnelles', 								  'r181' => '-Impôts sur les bénéfices',
                                 'r182' => '-Participation salariale',
                                 'r199' => 'RÉSULTAT NET'
	    );
	    
	    $bilan           = array();
	    $typeBilan       = ($this->getRequest()->isPost())?$this->getRequest()->getParam('typeBilan'):'N';
	    $bilan           = $this->ws->getRatios($this->entreprise->siren, 'ratios');

	    self::constructElementForBilan($bilan, $referenceActif, $actif, $date, $duree, $typeBilan);
	    self::constructElementForBilan($bilan, $referencePassif, $passif, $date, $duree, $typeBilan);
	    self::constructElementForBilan($bilan, $referenceSIG, $SIG, $date, $duree, $typeBilan);
	   
	    $this->view->assign('referenceactif', $referenceActif);
	    $this->view->assign('referencepassif', $referencePassif);
	    $this->view->assign('referencesig', $referenceSIG);
	    
	    $this->view->assign('typeBilan', $typeBilan);
	    $this->view->assign('typeBilan', $typeBilan);
	    $this->view->assign('siren', $this->entreprise->siren);
	    $this->view->assign('raisonSociale', $this->entreprise->nom);
	    $this->view->assign('listeBilan', $listeBilan);
	    $this->view->assign('date', $date);
	    $this->view->assign('duree', $duree);
	    $this->view->assign('actif', $actif);
	    $this->view->assign('passif', $passif);
	    $this->view->assign('sig', $SIG);
	}
	
	private function formatElementForGraphiqueBilan($bilan)
	{
	    $tb = array();
	    
	    foreach ($bilan as $id => $item) {
	        foreach($bilan[$id]['item'] as $element) {
	            $tb[] = round($element*100/$bilan[$id]['item'][key($bilan['r22']['item'])],2);
	        }
	    }
	    return ($tb);
	}
	
	/**
	 * Retourne le bon titre pour les différents graphiques.
	 *
	 * @param unknown_type $type
	 */
	protected function selectTitleGraphique($type)
	{
	    switch($type) {
	        case 'actif' :
	            return ('Composition de l\'actif pour la période de : ');
	        case 'passif':
	            return ('Composition du passif pour la période de : ');
	        case 'sig'   :
	            return ('Sole Intermédiaire de Gestion pour la période de : ');
	    }
	}
	
	/**
	 * Fonction générique qui fabrique l'image pour les différents graphiques Actif, Passif, SIG
	 * (Les parametres parlent d'eux mêmes...)
	 *
	 * @param unknown_type $type
	 * @param unknown_type $data
	 * @param unknown_type $i
	 * @param unknown_type $filename
	 * @param unknown_type $date
	 * @param unknown_type $count
	 * @param unknown_type $labels
	 */
    protected function makeGraphiqueBilan($type, $data, $i, $filename, $date, $count, $labels)
    {
        $parametres               = new stdClass();
        $parametres->nom          = $i.'-'.$filename.'-graph-'.$type.'.png';
        $parametres->title->texte = self::selectTitleGraphique($type).' '.$date;
        $parametres->datas        = $data;
        $parametres->labels       = $labels;
        $parametres->makeSession  = 'chart_'.$type.$i;
        $retour                   = $this->graphique->GraphiquePieChart($parametres, true);
        
        $this->view->assign('file', $parametres->nom);
        $this->view->assign('chartID', $retour->chartID);
        $this->view->assign('imageMap', $retour->imageMap);
        $this->view->assign('i', 'passif'.$i);
        $this->view->assign('hide', $i);
        ($i == $count)?$this->view->assign('hide', false):$this->view->assign('hide', true);

        $this->render('printgraphbilan');
    }
	
    /**
     * Permet de construire le graphique Actif
     * les parametre viennent de $this->getRequest();
     */
    public function actifgraphAction()
    {
        $data     = $this->getRequest()->getParam('valeur');
        $i        = $this->getRequest()->getParam('i');
        $filename = $this->getRequest()->getParam('siren');
        $date     = $this->getRequest()->getParam('date');
        $count    = $this->getRequest()->getParam('count');
        $labels   = array('Immo. incorporelles', 'Immo. corporelles',
						  'Immo. financières', 'Stock et encours',
						  'Créances Clients', 'Autres créances',
						  'Trésorerie Active'
		);
        self::makeGraphiqueBilan('actif', $data, $i, $filename, $date, $count, $labels);
    }
    
    /**
     * Permet de construire le graphique Passif
     * les parametre viennent de $this->getRequest();
     */
    public function passifgraphAction()
    {
        $data     = $this->getRequest()->getParam('valeur');
        $i        = $this->getRequest()->getParam('i');
        $filename = $this->getRequest()->getParam('siren');
        $date     = $this->getRequest()->getParam('date');
        $count    = $this->getRequest()->getParam('count');
        $labels   = array('Fonds propres',
						'Provisions Risques',
						'Compte Courant',
						'Dettes Financières',
						'Dettes Fournisseurs',
						'Dettes fiscales',
						'Autres Dettes',
						'Trésorerie Passive'
		);
		self::makeGraphiqueBilan('passif', $data, $i, $filename, $date, $count, $labels);
    }
	
    /**
     * Construit le graphique SIG
     * les parametre viennent de $this->getRequest();
     */
    public function siggraphAction()
    {
        $data     = $this->getRequest()->getParam('valeur');
        $i        = $this->getRequest()->getParam('i');
        $filename = $this->getRequest()->getParam('siren');
        $date     = $this->getRequest()->getParam('date');
        $count    = $this->getRequest()->getParam('count');
        $labels   = array('Achats de marchandises.',
						'Autres achats externes',
						'Charges de fonctionnement',
						'Amortissement et provisions',
						'Perte financière',
						'Impôts sociétés',
						'RÉSULTAT NET',
		);
		self::makeGraphiqueBilan('sig', $data, $i, $filename, $date, $count, $labels);
    }
    
    /**
     * Permet de retourner le pourcentage par rapport a sa reference.
     *
     * @param unknown_type $element
     * @param unknown_type $reference
     */
    public function Tb($element, $reference)
    {
        if($element != 'NS') {
            if ($element != 0 and $reference != 0) {
                return (round(($element * 100) / $reference, 2));
            } else {
                return($element);
            }
        }
        return (false);
    }
    
    /**
     * Construit les elements graphique des bilans pour chaque ligne.
     * Permet de visualiser l'evolution de la ligne pour chaque années.
     *
     * @param unknown_type $data
     * @param unknown_type $name
     * @param unknown_type $date
     */
    public function GraphLineBilan($data, $name, $date)
    {
        $parametres            = new stdClass();
	    $parametres->nom       = $name.'.png';
	    $parametres->datas     = array($data);
	    $parametres->TitlesY   = array("Keuros");
	    $parametres->TitlesX   = array("Années");
	    $parametres->LineLayer = array("Entreprise");
	    $parametres->labelsY   = array();
	    $parametres->labelsX   = $date;
	    
	    $this->graphique->GraphiqueLineXY($parametres, true);
    }
    
    /**
     * permet de definir les grand titre des tableaux 'subhead' en CSS.
     * Verifie les balise heads pour la couleur.
     *
     * @param unknown_type $id
     */
    public function ifIsHead($id)
    {
        $head = array('r59', 'r69', 'r22','r79', 'r90', 'r101',
        			  'r110', 'r120', 'r122', 'r130', 'r140',
        			  'r150', 'r170', 'r199'
        );
        
        if (in_array($id, $head))
            return (true);
        return (false);
    }
    
    /**
     * Selectionne les elements servant pour construire les graphiques pour Actif et Passif seulement.
     *
     * @param unknown_type $id
     */
    public function createlementForGraphique($id)
    {
        $element = array('r51', 'r52', 'r53', 'r60', 'r61', 'r62', 'r63',
                         'r70', 'r71', 'r72', 'r83', 'r84', 'r85', 'r86', 'r87',
                         '');
        
        if (in_array($id, $element))
            return (true);
        return (false);
    }
    
    /**
     * Permet de selectionner les sommes a calculer en pourcentage pour la génération des données du graphique SIG
     * Le SIG est un graphique particulié ou les sommes sont imbriquées les une dans les autre.
     * A savoir par exemple que Achat de marchandise = chiffre d'affaire - marge brut donc le calcule est :
     * (AM*100/AM) - (MB*100/AM) = (la valeur du graphique).
     *
     * @param unknown_type $id
     * @param unknown_type $element
     * @param unknown_type $partial
     * @param unknown_type $count
     */
    public function specialSIG($id, $element, $partial, $count)
    {
        if($element != 'NS') {
            if ($id == 'r101')
                return self::Tb($element, $element) - self::Tb($partial['r122']['item'][$count], $partial['r101']['item'][$count]);
            else if ($id == 'r122')
                return self::Tb($element, $partial['r101']['item'][$count]) - self::Tb($partial['r130']['item'][$count], $partial['r101']['item'][$count]);
            else if ($id == 'r130')
                return self::Tb($element, $partial['r101']['item'][$count]) - self::Tb($partial['r140']['item'][$count], $partial['r101']['item'][$count]);
            else if ($id == 'r140')
                return self::Tb($element, $partial['r101']['item'][$count]) - self::Tb($partial['r150']['item'][$count], $partial['r101']['item'][$count]);
            else if ($id == 'r150')
                return self::Tb($element, $partial['r101']['item'][$count]) - self::Tb($partial['r170']['item'][$count], $partial['r101']['item'][$count]);
            else if ($id == 'r170')
                return self::Tb($element, $partial['r101']['item'][$count]) - self::Tb($partial['r199']['item'][$count], $partial['r101']['item'][$count]);
            else if ($id == 'r199')
                return self::Tb($element, $partial['r101']['item'][$count]);
        } else
            return (null);
    }
    
    /**
     * Ont va selectionnez chaque valeur dans caque tableau pour construire les données pour le graphique
     * exemple :
     * [0]
     *   --[0] : 1000 (indirectement premiere valeur de la premiere année)
     *   --[1] : 2000
     *   --[2] : 3000
     * [1]
     *   --[0] : 4000
     *   --[1] : 5000
     *   etc...
     *
     * le retour sera
     *  [0]
     *    --[0] : 1000
     *    --[1] : 4000
     *
     * @param unknown_type $tb
     */
    protected function formatElementGraphiquebilan($tb)
    {
        $valeur = array();
        $case   = 0;
        
        for ($i =0; $i < count($tb); $i++) {
            foreach ($tb as $tableau) {
                while($case < count($tableau)) {
                    $valeur[$i][] = $tableau[$case];
                    break;
                }
            }
            $case++;
        }
        return ($valeur);
    }
    
    /**
     * Permet d'enregistrer les données pour le graphique dans un premiere temps
     * Puis dans un deuxieme temps ont affiche les données ent les enregistrants dans $this->htmlBilan
     * qui sera envoyé a la vue plus tard.
     *
     * @param unknown_type $id
     * @param unknown_type $Graphdate
     * @param unknown_type $partial
     * @param unknown_type $reference
     * @param unknown_type $name
     * @param unknown_type $url
     * @param unknown_type $sig
     */
    protected function LineBilan($id, $Graphdate, $partial, $reference, $name, $url, $sig = false)
    {
        $i            = 0;
        $this->column = 0;
        $GraphLine    = array();
        /** Ont enregistre les données (premié temps) **/
        foreach($partial[$id]['item'] as $element) {
            if($element != 'NS'){ $GraphLine[] = $number = $element; }else{$number = 0; $GraphLine[] = 0;};
            if($sig) {
			    $result = self::specialSIG($id, $element, $partial, $i);
		        if(is_numeric($result))
		            $gr[] = ($result < 0)?0:$result;
			}
			else
			    if(self::createlementForGraphique($id))$gr[] = $number;
        }
        ($gr != 0)?$this->tableauBilanGraphique = $gr:$this->tableauBilanGraphique = false;

        /** Ont affiche les données (deuxiéme temps) **/
        $html .= '<tr '.((self::ifIsHead($id))?'class="subhead"':'class="bilanDatas"').'>';
    		$html .= '<td>'.$name.'</td>';
    		foreach($partial[$id]['item'] as $element) {
    			$html .= '<td align="right">' . (($element != 'NS') ? number_format($element, 0, '', ' ') . ' K€':$element).'</td>';
    		}
            $html .= '<td align="right">'.self::Tb(end($partial[$id]['item']), end($partial[$reference]['item'])).'</td>';
    	    self::GraphLineBilan($GraphLine, $id.'-'.$this->entreprise->siren, $Graphdate);
    	    $html .= '<td>';
    			$html .= '<a name="Actif Immobilisé Net" class="rTip" rel="'.$url.'">
                    		 <img src="/themes/default/images/finance/char_bar.png" />
        				 </a>';
    	    $html .= '</td>';
	    $html .= '</tr>';
	    $this->htmlBilan .= $html;
    }
    
    /**
     * Construit et format les données puis envoie les info a la vue.
     * Fonction mére.
     */
    public function linebilanAction()
    {
        $tb        = array();
        $type      = $this->getRequest()->getParam('type');
        $Graphdate = $this->getRequest()->getParam('Graphdate');
        $partial   = $this->getRequest()->getParam('data');
        $reference = $this->getRequest()->getParam('reference');
        $referenceForeach = $this->getRequest()->getParam('referenceForeach');
        $sig       = $this->getRequest()->getParam('sig');
        
        foreach ($referenceForeach as $id => $valeur) {
	        self::LineBilan($id, $Graphdate, $partial, $reference, $valeur,
	        					  '/finance/printgraph/idGraph/'.$id.'-'.$this->entreprise->siren.'.png', $sig);
	        if($this->tableauBilanGraphique)$tb[] = $this->tableauBilanGraphique;
        }
        $this->view->assign('type', $type);
        $this->view->assign('html', $this->htmlBilan);
        $this->view->assign('valeur', $this->formatElementGraphiquebilan($tb));
        $this->view->assign('Graphdate', $Graphdate);
    }
    
/* --------------------------------------------------------------------------------------------------- */
/*                                Gestion des ratios avec les graphiques                               */
/* ----------------------------------------------------------------------------------------------------*/
	/**
	 * Permet de formater correctement les données.
	 *
	 * @param type d'unite $unite
	 * @param la valeur a transcrire $valeur
	 */
	protected function parseUnite($unite, $valeur)
	{
	    switch ($unite)
	    {
	        case 'EUR':
	            return (number_format((round($valeur)/1000), 0, '', ' '));
	        case '%' :
	        	return (round($valeur));
	        case 'Jours':
	            return ($valeur);
	        default:
	            return ($valeur);
	    }
	}
	
	/**
	 * Permet de determiner si ont crée l'image ou s'il elle existe daja dans une periode de 8 heures MAX.
	 *
	 * @param nom de l'image $name
	 */
	protected function checkIfImageExist($name)
	{
	    $path = $this->imageCachePath;
	    
	    if (file_exists($path.$name.'.png')) {
	        $date = date('Ymdh', filemtime($path.$name.'.png'));
	        if($date + 8 > date('Ymdh'))
	            return (false);
	        else
	            return (true);
	    }
	    return (false);
	}
	
	/**
	 * Cette fonction permet de comparer les donnée entre elles pour determiner l'evolution
	 * positive ou négative, ( j'ai respecté les consigne apppliqué préalablement sur l'ancien Extranet.
	 *
	 * @param Objet $valeurEnt
	 * @param Objet $valeurSec
	 * @param string (le signe de comparaison) $compare
	 */
	protected function compareValeur($valeurEnt, $valeurSec, $compare)
	{
	    $ecart = 1/100;
	    
	    if( $valeurSec=='NS' || $valeurEnt == 'NS' || $valeurSec==NULL || $valeurEnt==NULL) {
	        return ('-');
	    } else if ($compare == '>') {
	        if (($valeurEnt + $ecart) > $valeurSec) {
	           $return = '<img src="/themes/default/images/finance/ratios_bon.png" />';
	        } elseif( ($valeurSec - ($valeurSec * $ecart)) < $valeurEnt && ($valeurSec + ($valeurSec * $ecart)) > $valeurEnt) {
	            $return = '-';
	        } else {
	           $return = '<img src="/themes/default/images/finance/ratios_mauvais.png" />';
	        }
	    } else if ($compare == '<') {
	    if (($valeurEnt + $ecart) > $valeurSec) {
	           $return = '<img src="/themes/default/images/finance/ratios_bon.png" />';
	        } elseif( ($valeurSec - ($valeurSec * $ecart)) < $valeurEnt && ($valeurSec + ($valeurSec * $ecart)) > $valeurEnt) {
	            $return = '-';
	        } else {
	           $return = '<img src="/themes/default/images/finance/ratios_mauvais.png" />';
	        }
	    }
	    return ($return);
	}
	
	/**
	 * Permet d'afficher les elements par block avec un titre.
	 *
	 * @param Le tableau de reference des ID a afficher $tableau
	 * @param Le nom du block en traitement $name
	 * @param Les elements de Ratios $element
	 * @param L'adresse de la variable $html
	 * @param l'object ratio $ratios
	 * @param la date du block $date
	 */
	protected function printElementRatio($tableau, $name, $element, &$html, $ratios, $date)
	{
    	foreach($tableau[$name] as $row => $val) {
            if ($row == $element->id) {
                foreach ($ratios->RatiosInfos->item as $item) {
                    if ($item->id == $element->id) {
                        foreach ($ratios->RatiosSecteur->item as $Secteur) {
        	                if (substr($date, 0, 4) == $Secteur->annee) {
        	                    foreach ($Secteur->liste->item as $liste) {
                	                if ($item->id == $liste->id) {
                	                    if (!self::checkIfImageExist($liste->id))
                	                        self::createGraphique($ratios, $liste->id, $item->unite, $liste->id);
            	                        $html .= '<tr>';
            	                        $html .= '<td>'.$item->libelle.'</td>';
            	                        $html .= '<td class="right">'.self::parseUnite($item->unite, $element->val).' '.$item->unite.'</td>';
            	                        $html .= '<td class="right">'.self::parseUnite($item->unite, $liste->val).' '.$item->unite.'</td>';
            	                        $html .= '<td align="center">';
            	                        $html .= '<a name="'.$item->libelle.'" class="rTip" rel="'.$this->view->url(array('controller' => 'finance',
            	                                                                                            'action' => 'printgraph',
            	                                                                                            'idGraph' => $liste->id.'-'.$this->entreprise->siren.'.png')).'" >'.self::compareValeur($element->val, $liste->val, $val).'</a>';
            	                        $html .= '</td>';
            	                        $html .= '</tr>';
            	                    }
            	                }
        	                }
    	                }
                    }
                }
            }
        }
	}
	
	/**
	 * Apelle la view avec la balise image, j'ai désactivé le layout pour un affichage spécial.
	 */
	public function printgraphAction()
	{
	    $this->_helper->layout()->disableLayout();
	    $filename = $this->getRequest()->getParam('idGraph');
	    $this->view->assign('filename', $filename);
	}
	
	/**
	 * Permet de mettres les clefs du tableau sous forme indexé pour ChartDirector
	 * @param array $tableau
	 */
	protected function initTableau($tableau)
	{
	    $i = 0;
	    
	    foreach($tableau as $date => $valeur){
	        $tableau[$i] = $valeur;
	        unset($tableau[$date]);
	        $i++;
	    }
	    return ($tableau);
	}
	
	/**
	 * Permet de calculer avec les unité fournies ( exemple 1 000 000 = 1 000 000 / 1000 (EUR) )
	 *
	 * @param la valeur $valeur
	 * @param l'unité $unite
	 */
	protected function setUnite($valeur, $unite)
	{
	    switch ($unite) {
	        case 'EUR':
	            return ($valeur = $valeur / 1000);
	    default:
	            return ($valeur);
	    }
	}
	
	/**
	 * Cette fonction permet de créer les abscisses pour les données, en l'ocurence elle gére Entreprise et Secteur
	 *
	 * @param le type de courbe $type
	 * @param l'unité de l'information $unite
	 * @param l'object ratio $ratio
	 * @param le tableau a formater $dataX
	 * @param id de l'element courant $id
	 * @param l'adresse du tableau de label $labelX
	 */
	protected function createAbscisse($type, $unite, $ratio, $id, &$labelX = null)
	{
	    $i = 0;
	    $dataX = array();
	    if ($type == 'RatiosEntrep') {
    	    foreach ($ratio->BilansInfos->item as $element) {
    	        if ($i >= 5)
    	            break;
    	        if (is_array($labelX))
    	            $labelX[] = substr($element->dateCloture, 0, 4);
                foreach ($element->RatiosEntrep->item as $ratioEntre) {
                    if ($ratioEntre->id == $id) {
                        $dataX[substr($element->dateCloture, 0, 4)] = self::setUnite($ratioEntre->val, $unite);$i++;
                    }
                }
    	    }
	    }
	    if ($type == 'RatiosSecteur') {
	        foreach ($ratio->RatiosSecteur->item as $element) {
	            if($i >= 5)
	                break;
	            foreach($element->liste->item as $item) {
	                if ($item->id == $id) {
	                    $dataX[$element->annee] = self::setUnite($item->val, $unite);$i++;
	                }
	            }
	        }
	    }
	    
	    if (is_array($labelX))
	        sort($labelX);
	    ksort($dataX);
	    $dataX = self::initTableau($dataX);
	    
	    return ($dataX);
	}
	
	/**
	 * Cette fonction crée le graphique et le stock dans cache/imgcache.
	 *
	 * @param l'objet ratio $ratio
	 * @param id de l'element courant $id
	 * @param l'unité courante $unite
	 * @param l'id qui servira de nom pour l'image $filename
	 */
	protected function createGraphique($ratio, $id, $unite, $filename)
	{
	    $Annees                            = array();
	    $parametres                        = new stdClass();
	    $parametres->nom                   = $filename.'-'.$this->entreprise->siren.'.png';
	    $parametres->datas                 = array(self::createAbscisse('RatiosEntrep', $unite, $ratio, $id, $Annees),
	                                               self::createAbscisse('RatiosSecteur', $unite, $ratio, $id));
	    $parametres->TitlesY               = array($unite);
	    $parametres->TitlesX               = array("Années");
	    $parametres->colorLegende->Secteur = 0x008C00;
	    $parametres->LineLayer             = array("Entreprise", "Secteur");
	    $parametres->labelsY               = array();
	    $parametres->labelsX               = $Annees;
	    
	    return ($this->graphique->GraphiqueLineXY($parametres, true));
	}
	
	/**
	 * Permet de gerer les date pour les switch de formulaire.
	 *
	 * @param unknown_type $ratio
	 * @param unknown_type $type
	 * @param unknown_type $date
	 */
	private function getSwitchFormRatios($ratio, $type, $date = false)
	{
	    $change = false;
	    
	    if(!$date) {
    	    foreach($ratio->BilansInfos->item as $valeur) {
        	        if ($valeur->typeBilan == $type)
        	            return ($valeur);
    	    }
	    } else {
	        foreach($ratio->BilansInfos->item as $valeur) {
    	        if ($valeur->typeBilan == $type and $valeur->dateCloture == $date)
    	            return ($valeur);
    	        else
    	            $change = true;
	        }
	    }
	    if($change) {
	        foreach($ratio->BilansInfos->item as $valeur) {
        	        if ($valeur->typeBilan == $type)
        	            return ($valeur);
    	    }
	    }
	}
	
	/**
	 * Gestion de l'affichage des ratios.
	 */
	public function ratiosAction()
	{
	    /**
	     * Ont ajoute de nouveaux ratios a cette endroit
	     * @var unknown_type
	     */
	    $tableau     = array('EquilibreFinancier' => array('r233' => '>', 'r234' => '>', 'r237' => '>', 'r238' => '>', 'r239' => '>', 'r240' => '>'),
	                     'Profitabilite'      => array('r262' => '>', 'r263' => '>', 'r264' => '>', 'r265' => '>', 'r266' => '>'),
	                     'Liquidite'          => array('r250' => '>', 'r251' => '>', 'r252' => '>'),
	                     'Endetement'         => array('r241' => '<', 'r247' => '<', 'r248' => '<'),
	                     'Productivite'       => array('r271' => '>', 'r278' => '<', 'r279' => '<', 'r281' => '<', 'r261' => '>', 'r267' => '>')
	    );
	    $tab         = array();
	    $siret       = $this->getRequest()->getParam('siret');
        $id          = $this->getRequest()->getParam('id');
        $i           = 0;
        $i_view      = 0;
        $listeDate   = array();
        $request     = $this->getRequest();
        $html        = '';
	    $ratios      = $this->ws->getRatios($this->entreprise->siren, 'ratios');
	    $type        = ($request->isPost())?$request->getParam('typeBilan'):'N';
        $date        = self::getSwitchFormRatios($ratios, $type, $request->getParam('Date'))->dateCloture;

        foreach($ratios->BilansInfos->item as $elements) {
	        $tab[$elements->dateCloture][$elements->typeBilan] = $elements;
	        $i++;
	    }
	    
	    foreach ($tab as $champDate => $valeur)
	        $listeDate[] = $champDate;
	           
	    if (isset($date)) {
	        if (!empty($date)) {
	            foreach ($tableau as $name => $valeur) {
	                $html .= '<tr class="subhead">
	                			<td align="center">'.$name.'</td>
	                			<td>Entreprise</td>
	                			<td>Secteur</td>
	                			<td>Position</td>
	                		 </tr>';
    	            foreach ($tab[$date][$type]->RatiosEntrep->item as $element)
                            self::printElementRatio($tableau, $name, $element, $html, $ratios, $date);
	            }
	        }
	    }
	    
        /** Gestion de la vue **/
	    $this->view->assign('typeBilan', $type);
	    $this->view->assign('Date', $date);
	    $this->view->assign('i', $i_view);
	    $this->view->assign('html', $html);
	    $this->view->assign('raisonSociale', $this->entreprise->nom);
	    $this->view->assign('siret', $siret);
	    $this->view->assign('id', $id);
	    $this->view->assign('ratios', $tab);
	    $this->view->assign('naf', $this->entreprise->naf);
	}
	
/* --------------------------------------------------------------------------------------------------- */
/*                                Gestion des liasses fiscales                                         */
/* ----------------------------------------------------------------------------------------------------*/
	
	/**
	 * Selectionne les Unité pour l'affichage des valeurs dans les liasses
	 *
	 * @param unknown_type $tab
	 * @param unknown_type $unite
	 */
	private function selectInUnit($tab, $unite)
	{
	    foreach($tab as $champ => $val) {
	        if($val == $unite)
	            return ($champ);
	    }
	    return (false);
	}
	
	/**
	 * Export d'une liasse au format XLS
	 */
	public function liassexlsAction()
	{
		//@todo : Gestion des unités dans l'export XLS
		
		$this->_helper->layout()->disableLayout();
		
		$request = $this->getRequest();
		$unite = $request->getParam('unit', '€');
		$type = $request->getParam('type', '');
		$date = $request->getParam('date', '');
		
		switch($type) {
			case 'C':
			case 'N':
				$model = 'liasse_2050';
				break;
			case 'S':
				$model = 'liasse_2033';
				break;
			}
		
		$liasses = $this->ws->getBilan($this->entreprise->siren, $date, $type, '');
	 	$data = array();
		$data['DATE_CLOTURE'] = $liasses->DATE_CLOTURE;
	    $data['DATE_CLOTURE_PRE'] = $liasses->DATE_CLOTURE_PRE;
	    $data['DUREE_MOIS'] = $liasses->DUREE_MOIS;
	    $data['DUREE_MOIS_PRE'] = $liasses->DUREE_MOIS_PRE;
		foreach ($liasses->POSTES->item as $element) {
    		$data[$element->id] =$element->val;
		}
		$path = APPLICATION_PATH . '/../cache/liasse/';
		$file = 'liasse-'.$this->entreprise->siren.'-'.$this->entreprise->id.'-'.$type.$date.'.xls';
		
		require_once 'finance/LiasseXLS.php';
		$liasse = new LiasseXLS($model);
		$liasse->dataModel($this->entreprise->siren, $this->entreprise->nom, $data);
		$liasse->dataFile($file);
		
		if( file_exists($path.$file) ){
			//$client->setLog('liassexls', $siren, 0, '');
			$this->view->assign('file', $file);
		}
		
	}
	
	/**
	 * Affichage des liasses.
	 * @todo :
	 * 	ATTENTION LES BILANS SIMPLIFIES ONT ETE RETIRE ALORS QU'IL FAUT LES TRAITER
	 *	NE PAS FAIRE COMME DANS LES RATIOS
	 */
	public function liasseAction()
	{
	    /** Les ancres pour les liens **/
	    $ancres      = array(
	    	'C' => array('actif', 'passif', 'compteDeResultat'),
	        'N' => array('actif', 'passif', 'compteDeResultat', 'immobilisations',
	        				'amortissements', 'provisions', 'creancesDettes', 'affectation'),
			'A' => array('actif', 'passif', 'compteDeResultat'),
	        'B' => array('actif', 'passif', 'compteDeResultat')
	     );
	     
        /** La liste des type de bilan existant **/
	    $liste = array (
	    	'N' => array(),
	    	'S' => array(),
            'C' => array(),
            'B' => array(),
            'A' => array());
        
        /** Le nom des type pour le select */
        $type = array (
        	'A' => 'Assurance',
        	'B' => 'Banque',
			'C' => 'Consolidé',
			'N' => ''
        );
        
        /** Liste des unités que l'ont proposent **/
        $unit = array (
        	'€' => 1,
        	'K€' => 1000,
            'M€' => 1000000
        );
        $liasse      = array ();
        $request     = $this->getRequest();
        $siret       = $this->getRequest()->getParam('siret');
        $id          = $this->getRequest()->getParam('id');
        $listBilan   = $this->ws->getListeBilans($this->entreprise->siren);
        $date   	 = ($request->isPost())? $request->getParam('date') :
        				$listBilan->result->item[0]->dateExercice.':'.$listBilan->result->item[0]->typeBilan;
        $unite       = ($request->isPost())?$request->getParam('unit'):'€';

        foreach ($listBilan->result->item as $item)
            $liste[$item->typeBilan][] = $item->dateExercice;
            
        /** ont transforme les bilan de type S en N => !!!! ERREUR !!!! **/
        $NandS      = array_merge($liste['N'], $liste['S']);
        $liste['N'] = $NandS;unset($liste['S']);
        /**
         * Utiliser un système de masque pour mapper les données sur le rapport normal.
         * Exemple : DL => 142
         */
        
	    if (!empty($date)) {
	        $dateAndType = explode(':', $date);
    	    $liasses     = $this->ws->getBilan($this->entreprise->siren, $dateAndType[0], $dateAndType[1], true);
    	    $this->view->assign('dateCloture', $liasses->DATE_CLOTURE);
	        $this->view->assign('dateCloturePre', $liasses->DATE_CLOTURE_PRE);
	        $this->view->assign('dureesMois', $liasses->DUREE_MOIS);
	        $this->view->assign('dureesMoisPre', $liasses->DUREE_MOIS_PRE);

	        foreach ($liasses->POSTES->item as $element) {
    	        $liasse[$element->id] =$element->val;
    	            //number_format(($element->val > 0)?$element->val / $unite:$element->val, 0, '', ' ') .' '.self::selectInUnit($unit, $unite);
	        }

	        $this->view->assign('date', $dateAndType[0]);
	        $this->view->assign('champType', $dateAndType[1]);
    	    $this->view->assign('liasse', $liasse);
    	    
    	    //Gestion export de la liasse au format XLS
    	    $user = new Utilisateur();
    	    if (in_array($user->getIdClient(), array(1,86))
    	    	&& in_array($dateAndType[1],array('C', 'N', 'S')) ) {
    	    	$this->view->assign('exportxls', true);
    	    }
    	    
	    }
	    
	    /** Partie vue **/
	    $this->view->assign('ancres', $ancres);
	    $this->view->assign('liste', $liste);
	    $this->view->assign('raisonSociale', $this->entreprise->nom);
	    $this->view->assign('siren',  $this->entreprise->siren);
	    $this->view->assign('siret', $siret);
	    $this->view->assign('id', $id);
	    $this->view->assign('type', $type);
	    $this->view->assign('unit', $unit);
	}

/* --------------------------------------------------------------------------------------------------- */
/*                                Gestion des bourses                                                  */
/* ----------------------------------------------------------------------------------------------------*/
	public function bourseGraphique($filename)
	{
	    $file      = $filename.'.png';
        $noOfDays  = 30;
        $extraDays = 30; 
        $rantable  = new RanTable(9, 6, $noOfDays + $extraDays);
        $rantable->setDateCol(0, chartTime(2002, 9, 4), 86400, true);
        $rantable->setHLOCCols(1, 100, -5, 5);
        $rantable->setCol(5, 50000000, 250000000);
        
        $timeStamps = $rantable->getCol(0); // Les date
        $highData   = $rantable->getCol(1); // les données les plus hautes
        $lowData    = $rantable->getCol(2);  // Les données les plus basses
        $openData   = $rantable->getCol(3); // Les donnée d'ouverture
        $closeData  = $rantable->getCol(4); // Les donnée de fermeture
        $volData    = $rantable->getCol(5); // Volume de data
        
        $parametres = new stdClass();
        $parametres->nom = $file;
        $parametres->makeSession = "chart1";
        $parametres->timeStamps  = $timeStamps;
        $parametres->highData    = $highData;
        $parametres->lowData     = $lowData;
        $parametres->openData    = $openData;
        $parametres->closeData   = $closeData;
        $parametres->volData     = $volData;
        $parametres->extraDays   = $extraDays;
        
        $retour                  = $this->graphique->GraphiqueFinance($parametres, true);
        return ('<img src="/fichier/imgcache/'.$file.'?'.$retour->chartID.'" border="1" usemap="#map1"><map name="map1">'.$retour->imageMap.'</map>');
	}
	
	/**
	 * Fonction qui gére la cotation en bourse.
	 * Enter description here ...
	 */
	public function bourseAction()
	{
        $this->view->assign('graphique', self::bourseGraphique('test'));
	}

/* --------------------------------------------------------------------------------------------------- */
/*                                Gestion des etablissements bancaires                                 */
/* ----------------------------------------------------------------------------------------------------*/
	/**
	 * Fonction qui gére les etablissements bancaires.
	 */
	public function banqueAction()
	{
	    $banque = $this->ws->getBanques($this->entreprise->siren);
	    $this->view->assign('banques', $banque->result->item);
	    
	    $this->view->assign('raisonSociale', $this->entreprise->nom);
	    $this->view->assign('siren',  $this->entreprise->siren);
	}
}