1332 lines
53 KiB
PHP
1332 lines
53 KiB
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);
|
|
}
|
|
} |