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 $tableauBilanGraphique;
    private $htmlBilan;
    private $graphique;
    private $bilanReference;
    
    public function init()
    {
	    ((!Zend_Registry::isRegistered('WsScores'))?Zend_Registry::set('WsScores', $this->ws = new WsScores()):$this->ws = Zend_Registry::get('WsScores'));
        ((!Zend_Registry::isRegistered('WDate'))?Zend_Registry::set('WDate', $this->dateFunction = new WDate()):$this->dateFunction = Zend_Registry::get('WDate'));
        ((!Zend_Registry::isRegistered('SessionEntreprise'))?Zend_Registry::set('SessionEntreprise', $entreprise = new SessionEntreprise($this->getRequest()->getParam('siret'), $this->getRequest()->getParam('id')))
                                                           :$entreprise = Zend_Registry::get('SessionEntreprise'));
        $request = $this->getRequest();
        $this->entreprise->id	 = $entreprise->getId();
        $this->entreprise->nom   = $entreprise->getRaisonSociale();
        $this->entreprise->siret = $entreprise->getSiret();
        $this->entreprise->idSC  = $entreprise->getId();
        $this->entreprise->siren = substr($this->entreprise->siret,0,9);
        (empty($this->entreprise->siren))?$this->entreprise->siren = substr($request->getParam('siret'), 0, 9):EOF;
        $this->entreprise->naf   = $entreprise->getNaf();
        $this->imageCachePath    = APPLICATION_PATH . '/../cache/pages/imgcache/';
        ((!Zend_Registry::isRegistered('graphique'))?Zend_Registry::set('graphique', $this->graphique = new Graphique($this->imageCachePath)):$this->graphique = Zend_Registry::get('graphique'));
  
        $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');
			
	    $this->view->assign('isChecked', 'checked="ckecket"');
	    $this->view->assign('isNotChecked', 'false');
    }

/* --------------------------------------------------------------------------------------------------- */
/*                                Fonction génériques       				                           */
/* ----------------------------------------------------------------------------------------------------*/    
    private function maskNameImg($action, $siret, $others = EOF)
    {
        $name = $action.'-'.$siret;
        if($others != EOF) {
            foreach($others as $other) {
                $name .= '-'.$other;
            }
        }
        $name .= '.png';
        return ($name);
    }
    
    public function lignegraphAction()
    {
        $request = $this->getRequest();
        $action  = $request->getParam('actionName');
        
        
        switch ($action) {
            case 'synthese':
                self::setSyntheseReference();
                $id        = $request->getParam('id');
                $typeBilan = $request->getParam('typeBilan');
                $parametres= array('bilanReference' => array($id => $this->bilanReference[$id]),
                                   'siret' => $request->siret,
                                   'otherView' => $request->getParam('idGraph'),
                                   'typeBilan' => $typeBilan);
                
                $this->view->assign('actionName', $action);
                $this->view->assign('parametres', $parametres);
            break;
            case 'ratios':
                
            break;
        }
        
        
        self::setSyntheseReference();

        
    }
    
    public function array_key_existValeur($array, $key, $valeur)
    {
        foreach ($array as $arrayValeur) {
            foreach($arrayValeur as $arrayKey => $val) {
                if($arrayKey == $key)
                    if($val == $valeur)
                        return (true);
            }
        }
        return (false);
    }
    
/* --------------------------------------------------------------------------------------------------- */
/*                                Gestion de la synthése avec les graphiques                           */
/* ----------------------------------------------------------------------------------------------------*/
    
    public function getReference($valeur, $reference, $annee, $synthese)
    {
        foreach ($synthese->BilansInfos->item as $item) {
            if(substr($item->dateCloture, 0, 4) == $annee) {
                foreach ($item->RatiosEntrep->item as $RatiosEntrep) {
                    if ($RatiosEntrep->id == $reference) {
                        return (round(($valeur/$RatiosEntrep->val)*100,2));
                    }
                }
            }
        }
    }
    
    /**
     * @todo faire le setLog.
     * 
     */
    public function rsyntheseAction()
    {
        $final    = array();
        $request  = $this->getRequest();
        $idsReference = $request->getParam('idsReference');
        $synthese = $this->ws->getRatios(substr($request->getParam('siret'), 0, 9), 'synthese');
        self::setSyntheseReference();
        
        foreach ($synthese->BilansInfos->item as $item) {
            $annee = substr($item->dateCloture, 0, 4);
            if( $annee >= substr($synthese->BilansInfos->item[0]->dateCloture, 0, 4)-2) {
                $tabAnnee[$this->dateFunction->dateT('Ymd', 'd/m/Y', $item->dateCloture)] = $item->duree;
                foreach ($item->RatiosEntrep->item as $RatiosEntrep) {
                    foreach($idsReference as $id => $elements) {
                        if ($RatiosEntrep->id == $id) {
                           $final[$id.':'.$elements['titre']][$item->dateCloture] = 
                               array('Valeur' => $RatiosEntrep->val/1000,
                                     'percent' => self::getReference($RatiosEntrep->val, $elements['total'], $annee, $synthese), 'id' => $id);
                           ksort($final[$id.':'.$elements['titre']]);
                        }
                    }
                }
            }
        }
        ksort($tabAnnee);
        $this->view->assign('commentaires', $this->bilanReference);
        $this->view->assign('annees', $tabAnnee);
        $this->view->assign('synthese', $final);
    }
    
    private function setSyntheseReference()
    {
        $this->bilanReference = array('r5'   => array('evolution' => 'r6'  , 'unite' => 'EUR',   'operateur' => 1000, 'name' => 'CHIFFRE D\'AFFAIRES',
    	                            'commentaires' => 'Montant total des ventes hors taxe tant sur le territoire français que hors de France.'),
    	    						'r7'   => array('evolution' => 'r8'  , 'unite' => 'EUR',   'operateur' => 1000, 'name' => 'RESULTAT COURANT AVANT IMPOTS',
    	                            'commentaires' =>  'Bénéfice ou perte constaté avant affectation des produits ou charges exceptionnelles, déduction des impôts et participation au bénéfice. Il est égal aux :
                                                        produits d\'exploitation (notamment les sommes reçues qui relèvent de l\'activité de l\'entreprise, soit les ventes de biens, prestations de services etc..)
                                                        + quotes-parts de résultats sur opérations faites en commun(par exemple, résultat des opérations faites par l\'intermédiaire d\'une société en participation)
                                                        + produits financiers (intérêts courus, gains de change, revenus tirés des comptes en banque)
                                                        - charges d\'exploitation
                                                        - quotes-parts de charges sur opérations en commun
                                                        - charges financières.)'),
    	                            'r10'  => array('evolution' => 'r11' , 'unite' => 'EUR',   'operateur' => 1000, 'name' => 'RESULTAT NET',
    	                            'commentaires' => 'Le résultat net comptable correspond au bénéfice ou perte de la période, mesuré par la différence entre les produits et les charges (au sens comptable) de l\'exercice. Il s\'agit du résultat courant, corrigé du résultat exceptionnel, déduction faite de l\'impôt sur le résultat et de l\'éventuelle participation des salariés. Il mesure les ressources nettes restant à l\'entreprise à l\'issue de l\'exercice.'),
    	                            'r18'  => array('evolution' => 'r19' , 'unite' => 'EUR',   'operateur' => 1000, 'name' => 'FONDS PROPRES',
    	                            'commentaires' => 'La situation nette ou Fonds propres ou bien encore, capitaux propres représentent l\'argent apporté par les actionnaires à la constitution de la société ou ultérieurement, ou laissés à la disposition de la société en tant que bénéfices non distribués sous forme de dividendes. Ils courent le risque total de l\'entreprise : si celle-ci va mal, ils ne seront pas rémunérés (aucun dividende ne sera versé) ; si elle dépose son bilan, les porteurs de capitaux propres ne seront remboursés qu\'après que les créanciers l\'aient été intégralement. Si elle va très bien au contraire, tous les profits leur reviennent.'),
    	                            'r22'  => array('evolution' => 'r23' , 'unite' => 'EUR',   'operateur' => 1000, 'name' => 'TOTAL BILAN',
    	                            'commentaires' => 'Le total du bilan est la somme de tous les actifs ainsi que des passifs, il caractérise la taille de l\'entreprise.
                                                        Selon le décret n° 2008-1354 du 18 décembre 2008, les critères désormais retenus pour les besoins de l\'analyse statistique et économique sont les suivants :
                                                        La catégorie des micro entreprises est constituée des entreprises qui :
                                                            * d\'une part occupent moins de 10 personnes ;
                                                            * d\'autre part ont un chiffre d\'affaires annuel ou un total de bilan n\'excédant pas 2 millions d\'euros.
                                                        La catégorie des petites et moyennes entreprises (PME) est constituée des entreprises qui :
                                                            * d\'une part occupent moins de 250 personnes ;
                                                            * d\'autre part ont un chiffre d\'affaires annuel n\'excédant pas 50 millions d\'euros ou un total de bilan n\'excédant pas 43 millions d\'euros.
                                                        La catégorie des entreprises de taille intermédiaire (ETI) est constituée des entreprises qui n\'appartiennent pas à la catégorie des petites et moyennes entreprises, et qui :
                                                            * d\'une part occupent moins de 5 000 personnes ;
                                                            * d\'autre part ont un chiffre d\'affaires annuel n\'excédant pas 1 500 millions d\'euros ou un total de bilan n\'excédant pas 2 000 millions d\'euros.
                                                        La catégorie des grandes entreprises (GE) est constituée des entreprises qui ne sont pas classées dans les catégories précédentes.'),
    	                            'r231' => array('evolution' => 'r235', 'unite' => 'EUR',   'operateur' => 1000, 'name' => 'FONDS DE ROULEMENT',
    	                            'commentaires' => 'Le fonds de roulement représente la différence entre l\'actif à court terme et le passif à court terme (dont l\'échéance est de moins de douze mois). Un fonds de roulement positif indique qu\'une entreprise a suffisamment d\'actifs liquides pour régler ses dettes et engagements à court terme (12 mois). Dans certains cas particuliers, le FDR peut être négatif et l\'entreprise viable : GSA ou autre Hypermarchés par exemple. Cette situation devenant risquée en cas de baisse du CA.'),
    	                            'r232' => array('evolution' => 'r236', 'unite' => 'EUR',   'operateur' => 1000, 'name' => 'BESOIN EN FONDS DE ROULEMENT',
    	                            'commentaires' => 'Pour les comptables, le BFR correspond aux actifs d\'exploitation (hors immobilisations et actifs financiers) diminués du montant des dettes d\'exploitation (cad  aux fonds indéfiniment mobilisés). Ainsi, une entreprise dont le BFR s\'élève à 15 % de son chiffre d\'affaires requiert un besoin permanent de trésorerie représentant 15 % de son activité uniquement pour assurer la pérennité de son cycle d\'exploitation. Plus le niveau de BFR est faible (ou bien plus sa rotation est forte), plus le dégagement de liquidités est important dès lors que les marges sont positives.'),
    	                            'r249' => array('evolution' => 'r254', 'unite' => 'EUR',   'operateur' => 1000, 'name' => 'TRESORERIE',
    	                            'commentaires' => 'Trésorerie nette (FR-BFR)'),
    	                            'r24'  => array('evolution' => 'r24' , 'unite' => 'Pers.', 'operateur' => 1,    'name' => 'EFFECTIF',
    	                            'commentaires' =>  'La définition exacte de l\'effectif peut varier selon les sources :
                                                        DADS : effectif salarié instantané au 30 juin ;
                                                        SIRENE : effectif salarié au 31 décembre n (ou au 1er janvier n+1) ; cet effectif fait l\'objet d\'une mise à jour « de masse » au premier semestre à partir des données DADS, l\'effectif d\'une entreprise est alors la somme des effectifs de ses établissements au 31 décembre;
                                                        SUSE-FICUS : moyenne annuelle de l\'effectif salarié.
                                                        Dans un bilan c\'est la moyenne de l\'effectif de l\'exercice.')
    	    );
    }
    /**
     * 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()
	{
	    $request        = $this->getRequest();
	    $bilan          = array();
	    $exist          = $request->getParam('bilanReference');
	    $synthese       = $this->ws->getRatios(substr($request->getParam('siret'), 0, 9), 'synthese');
	    $typeBilan      = $this->getRequest()->getParam('typeBilan');
	    
        if(empty($typeBilan))$typeBilan = 'N';    
        // Dans le cas ou ont veut des id(s) spécifique(s).
	    if(empty($exist)){
    	    self::setSyntheseReference();
    	    $bilanReference = $this->bilanReference;}
    	else $bilanReference = $request->getParam('bilanReference');

	    foreach ($synthese->BilansInfos->item as $item) {
	        if ($item->typeBilan == $typeBilan) {
                foreach ($item->RatiosEntrep->item as $RatiosEntrep) {
                    foreach ($bilanReference as $id => $params) {
                        if ($RatiosEntrep->id == $id) {
                            $bilan[$id]['name'] = $params['name'];
                            $bilan[$id]['unite'] = $params['unite'];
                            $bilan[$id]['commentaires'] = $params['commentaires'];
                            if (count($bilan[$id]['item']) <= 2) {
                                if (is_numeric($RatiosEntrep->val))
                                    $valeur = number_format(($RatiosEntrep->val / $params['operateur']), 0, '', ' ');
                                $bilan[$id]['item'][$item->dateCloture]['ValEntrep'] = $valeur;}
                                self::GraphiqueSyntheseLine($id, $synthese,
                                    $item->typeBilan, self::maskNameImg('synthese', $this->entreprise->siret, array($id,$item->typeBilan))); } } }
                foreach ($item->RatiosEntrepEvol->item as $RatiosEntrepEvol) {
                    foreach ($bilanReference as $id => $params) {
                        if ($RatiosEntrepEvol->id == $params['evolution']) {
                            if (array_key_exists($item->dateCloture, $bilan[$id]['item'])) {
                                $bilan[$id]['item'][$item->dateCloture]['duree'] = $item->duree;
                                $bilan[$id]['item'][$item->dateCloture]['ValEntrepEvol'] = $RatiosEntrepEvol->val; } } } }
	        }
	    }
      foreach ($bilan as $id => $val)
          ksort($bilan[$id]['item']);

      $this->view->assign('affFormNormal', self::array_key_existValeur($synthese->BilansInfos->item, 'typeBilan', 'N'));
      $this->view->assign('affFormConsolide', self::array_key_existValeur($synthese->BilansInfos->item, 'typeBilan', 'C'));
      $this->view->assign('idSC', $this->entreprise->id);
      $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', $bilan);
      $this->view->assign('nameForGraphique', $bilanReference);
      if(empty($this->bilanReference))
          $this->view->assign('otherView', $request->getParam('otherView'));
      self::GraphiqueSyntheseAnalyse($synthese->BilansInfos->item, $typeBilan, $this->entreprise->siret);
	}
	
	/**
	 * Création des elements servant au graphique les données 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 GraphiqueSyntheseLine($id, $synthese, $type, $name)
	{
	    $labelX                = array();
	    $parametres            = new stdClass();
	    $parametres->nom       = $name;
	    $parametres->datas     = array(self::createAbscisseSynthese($synthese,$id, $labelX, $type));
	    $parametres->TitlesY   = array(array("Keuros"));
	    $parametres->TitlesX   = array(array("Années"));
	    $parametres->LineLayer = array("Entreprise");
	    $parametres->labelsY   = array();
	    $parametres->labelsX   = $labelX;
	    
	    $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);
	    }
	}
	
	public function trieType($data, $idType)
	{
	    $type = array();
	    
	    foreach($data as $item)
	    {
	        if($item->typeBilan == 'N')
	           $type['N'][] = $item;
	        else if($item->typeBilan == 'C')
	            $type['C'][] = $item;
	    }
	    return ($type[$idType]);
	}
	
	/**
	 * En cours de developement
	 *
	 * @param unknown_type $synthese
	 * @param unknown_type $bilanReference
	 */
	protected function GraphiqueSyntheseAnalyse($data, $type, $siret)
	{
	    
	    //Définition des valeurs pour le graph
		$dataBFR     = array();
		$dataFR      = array();
		$dataCA      = array();
		$BFR         = array();
		$i           = 0;
		$nbAnnees    = 0;
	    $data        = self::trieType($data, $type);
	        
	    //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);
        if(count($data)>5)
		    $data        = array_slice($data, count($data)-5, null, true);
		
		//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
			$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
			$dataBFR['y'][$i] = $dataBFR['y'][$i+1] = self::getValFromKey($item->RatiosEntrep->item, 'r236');
			$dataFR['y'][$i]  = $dataFR['y'][$i+1] = self::getValFromKey($item->RatiosEntrep->item, 'r235');
			$dataCA['y'][$i]  = $dataCA['y'][$i+1] = self::getValFromKey($item->RatiosEntrep->item, 'r6');
			$dataEBE['y'][$i] = $dataEBE['y'][$i+1] = self::getValFromKey($item->RatiosEntrep->item, 'r146');
    		$i+=2;
		}
		
		$parametres                    = new stdClass();
		$parametres->nom               = self::maskNameImg('synthese', $this->entreprise->siret, array('graphiqueSynthses', $type));
		$parametres->width             = 660;
		$parametres->height            = 350;
		$parametres->bgColor           = 0xcccccc;
		$parametres->edgeColor         = 0x000000;
		$parametres->raisedEffect      = 1;
		$parametres->addTitle          = array("Synthèse *", "timesbi.ttf", 15, 0x000000);
		$parametres->addText           = array(array(60, 320, "* Elements financier rapportés à 12 mois"));
		$parametres->setPlotArea       = array(100, 80, 500, 200, 0xffffff, -1, -1, 0xcccccc, 0xcccccc);
		$parametres->TitlesY           = array(array("KEUROS","timesbi.ttf", 10));
		$parametres->TitlesX           = array(array("<*block,valign=absmiddle*>Années<*/*>"));
		$parametres->yAxisWidth        = 2;
		$parametres->xAxisWidth        = 2;
		$parametres->legendeParams     = array(55, 30, false, "times.ttf", 9);
		$parametres->addStepLineLayer  = array('layer1' => array($dataFR['y'], 0x0000ff, "FONDS DE ROULEMENT", $dataFR['x']),
		                                       'layer0'  => array($dataBFR['y'], 0xff0000, "BESOIN EN FONDS DE ROULEMENT", $dataBFR['x']),
		                                       'layer2'  => array($dataCA['y'], 0x00ff00, "CHIFFRE D'AFFAIRES", $dataCA['x']),
		                    				   'layer3'  => array($dataEBE['y'], 0x000000, "EXCEDENT BRUT D'EXPLOITATION", $dataEBE['x'])
		);
		$parametres->dashLineColor     = 'layer3';
		$parametres->addInterLineLayer = array('layer0:layer1' => array(0xff0000, Transparent),
		                                 	   'layer0:layer1' => array(Transparent, 0x8044ff44)
		);
		$this->graphique->GraphiqueLineXY($parametres);
	}
	
/* --------------------------------------------------------------------------------------------------- */
/*                                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);
	}
	
	/**
	 * Permet d'afficher la version imprimable d'un graphique de ligne des bilans.
	 * Passages des infos par url + protection htmlentites et url_encode.
	 * 
	 * Enter description here ...
	 */
	public function onelinebilanAction()
	{
	    $request = $this->getRequest();
	    $datas = $request->getParam('data');
	    $dates = $request->getParam('dates');
	    $name  = $request->getParam('name');
	    $image = $request->getParam('image');
	    
	    $datas = explode('|', $datas);
	    $dates = explode('|', $dates);
        
	    $this->view->assign('idSC', $this->entreprise->idSC);
	    $this->view->assign('siret', $this->entreprise->siret);
	    $this->view->assign('raisonSociale', $this->entreprise->nom);
	    $this->view->assign('image',$image);
	    $this->view->assign('datas', $datas);
	    $this->view->assign('dates', $dates);
	    $this->view->assign('name', $name);
	}
	
	private function referenceBilan($reference)
	{
	    switch ($reference)
	    {
	        case 'actif':
    	       $reference  = 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'
                );       
            break; 
	        case 'passif':
        	    $reference = 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'
        	    );
        	break;
	        case 'sig':
        	    $reference    = 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'
        	    );
        	break;
	    }
	    return ($reference);
	}
	
	/**
	 * 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');
	    $persoActif      = $request->getParam('referenceActif');
	    $persoPassif     = $request->getParam('referencePassif');
	    $persoSig        = $request->getParam('referenceSig');
	    
	    $bilan           = array();
	    $typeBilan       = ($this->getRequest()->isPost())?$this->getRequest()->getParam('typeBilan'):'N';
	    $bilan           = $this->ws->getRatios($this->entreprise->siren, 'ratios');

	    $referenceActif = self::referenceBilan('actif');
	    $referencePassif = self::referenceBilan('passif');
	    $referenceSIG = self::referenceBilan('sig');
	    
	    
	    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('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 GraphiqueBilan($type, $data, $i, $filename, $date, $count, $labels)
    {
        $parametres               = new stdClass();
        $parametres->nom          = self::maskNameImg('bilan', $this->entreprise->siret, array($i, 'graph', $type));
        $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::GraphiqueBilan('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::GraphiqueBilan('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::GraphiqueBilan('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 GraphiqueLineBilan($data, $name, $date)
    {
        $parametres            = new stdClass();
	    $parametres->nom       = $name;
	    $parametres->datas     = array($data);
	    $parametres->TitlesY   = array(array("Keuros"));
	    $parametres->TitlesX   = array(array("Années"));
	    $parametres->LineLayer = array("Entreprise");
	    $parametres->labelsY   = array();
	    $parametres->labelsX   = $date;
	    
	    $this->graphique->GraphiqueLineXY($parametres, true);
	    return($parametres->nom);
    }
    
    /**
     * 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 chaque 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, $siren, $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>';
    	    $image = self::GraphiqueLineBilan($GraphLine, self::maskNameImg('bilan', $this->entreprise->siret, array($id)), $Graphdate);
    	    $html .= '<td>';
    	    $datas = implode('|', $GraphLine);
    	    $dates = implode('|', $Graphdate);
    			$html .= '<a name="Actif Immobilisé Net" class="rTip" rel="'.$url.'" href="'.$this->_helper->url(
    																					   'onelinebilan','finance', null, 
    			                                                                           array('data'=> $datas, 
    			                                                                           		 'name' => urlencode($name),
    			                                                                                 'dates' => $dates,
    			                                                                                 'image' => $image)).'">
                    		 <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');
        $siren     = $this->getRequest()->getParam('siren');
        
        foreach ($referenceForeach as $id => $valeur) {
	        self::LineBilan($id, $Graphdate, $partial, $reference, $valeur,
	        					  '/finance/printgraph/idGraph/bilan-'.$this->entreprise->siret.'-'.$id.'.png',$siren , $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);
	    }
	}
	
	/**
	 * 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 < $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, $type)
	{
    	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) {
                	                    self::createGraphique($ratios, $liste->id, $item->unite, $type);
            	                        $html .= '<tr class="ratiosTr">';
            	                        $html .= '<td class="tooltip" style="cursor:help;" title="'.$item->commentaires.'"><span id="help">'.$item->libelle.'</span></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' => 'ratios'.'-'.$this->entreprise->siren.'-'.$liste->id.'-'.$type.'.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);
	    }
	}
	
	/**
	 * Compte le nombre de bilan celon le type C ou N
	 * 
	 * @param unknown_type $ratios
	 * @param unknown_type $typeBilan
	 */
	private function countTypeBilan($ratios, $typeBilan)
	{
	    $type = 0;

        foreach($ratios->BilansInfos->item as $item) {
    	        if($item->typeBilan == $typeBilan) 
    	            $type++;
        }
	    return ($type);
	}
	
	/**
	 * 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, $typeBilan = 'N', &$labelX = null, $nbResult = 5)
	{
	    $i = 0;
	    
	    $dataX = array();
	    if ($type == 'RatiosEntrep') {
    	    foreach ($ratio->BilansInfos->item as $element) {
    	        if($element->typeBilan == $typeBilan) {
        	        if ($i >= self::countTypeBilan($ratio, $typeBilan))
        	            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 >= self::countTypeBilan($ratio, $typeBilan))
	                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, $type)
	{
	    $Annees                               = array();
	    $parametres                           = new stdClass();
	    $parametres->nom                      = self::maskNameImg('ratios', $this->entreprise->siren, array($id,$type));
	    $parametres->datas                    = array(self::createAbscisse('RatiosEntrep', $unite, $ratio, $id, $type, $Annees),
	                                               self::createAbscisse('RatiosSecteur', $unite, $ratio, $id, $type));
	    $parametres->TitlesY                  = array(array($unite));
	    $parametres->TitlesX                  = array(array("Années"));
	    $parametres->colorLegende->Secteur    = 0x008C00;
	    $parametres->colorLegende->Entreprise = 0x0000ff;
	    $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('r244' => '<', '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, $type);
	            }
	        }
	    }
	    
        /** 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()
	{
	    $request = $this->getRequest(); 

	    $bourse = $this->ws->getInfosBourse($this->entreprise->siren);
	    
	    $this->view->assign('bourse', $bourse);
        $this->view->assign('graphique', self::bourseGraphique('test')); // utiliser le mask part la suite
	}

/* --------------------------------------------------------------------------------------------------- */
/*                                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);
	}
}