Subversion Repositories Applications.gtt

Compare Revisions

Ignore whitespace Rev 160 → Rev 161

/tags/v1.1-thales/actions/GttCtrlActionPreferences.class.php
New file
0,0 → 1,76
<?php
class GttCtrlActionPreferences extends aControlleurAction {
 
public function __construct(Registre $Registre)
{
$Registre->ajouterEspace('Preferences', 'preferences');
}
 
public function executer()
{
$aso_preferences = array();
$this->getRegistre()->setTitre('Modifier mes préférences');
$Projet = new Projet();
$tab_projets = $Projet->consulter(Projet::GP_TOUS);
 
if (false == $tab_projets) {
$aso_preferences['messages'][] = "Veuillez commencer par ajouter des catégories de projet et des projets !";
$aso_preferences['preferences'] = false;
} else {
$aso_preferences['nbre_projets'] = count($tab_projets);
// Parcourt du tableau de projets
foreach ($tab_projets as $Projet) {
// Vérification de la présence du projet dans les préférences de l'utilisateur
$UtilisateurAProjet = new UtilisateurAProjet();
$cmd = UtilisateurAProjet::GUAP_ID;
$param = array($GLOBALS['_GTT_']['Utilisateur']->getIdUtilisateur(), $Projet->getIdProjet());
$coche = false;
if ($present = $UtilisateurAProjet->consulter($cmd, $param)) {
$coche = true;
}
// Récupération de la catégorie du projet
$ProjetCategorie = new ProjetCategorie();
$Categorie = current($ProjetCategorie->consulter(ProjetCategorie::GPC_ID, $Projet->getCeCategorie()));
// Récupération de toutes les infos
$aso_preferences['preferences'][$Categorie->getLibelle()][] = array(
'id' => $Projet->getIdProjet(),
'valeur' => $Projet->getIdProjet(),
'no' => $Projet->getNom(),
'de' => $Projet->getDescription(),
'dade' => $Projet->getDateDebut(),
'dafi' => $Projet->getDateFin(),
'dupr' => $Projet->getDureePrevue(),
'dufi' => $Projet->getDureeFinance(),
'av' => $Projet->getAvancement(),
'coche' => $coche);
}
ksort($aso_preferences['preferences']);
}
//echo '<pre>'.print_r($aso_preferences, true).'</pre>';
$this->getRegistre()->ajouterDonnee('preferences', $aso_preferences);
}
 
public function executerValider()
{
// Mise à jour des Préférences
$UtilisateurAProjet = new UtilisateurAProjet();
$UtilisateurAProjet->setIdUtilisateur($GLOBALS['_GTT_']['Utilisateur']->getIdUtilisateur());
$UtilisateurAProjet->supprimer();
//echo '<pre>'.print_r($_POST, true).'</pre>';
if (isset($_POST['pr'])) {
foreach ($_POST['pr'] as $pr_id) {
$UtilisateurAProjet = new UtilisateurAProjet();
$UtilisateurAProjet->setIdUtilisateur($GLOBALS['_GTT_']['Utilisateur']->getIdUtilisateur());
$UtilisateurAProjet->setIdProjet($pr_id);
$UtilisateurAProjet->ajouter();
}
}
// Action suivante
$this->setSuivant('__defaut__');
}
}
?>
/tags/v1.1-thales/actions/GttCtrlActionAdminUtilisateur.class.php
New file
0,0 → 1,313
<?php
class GttCtrlActionAdminUtilisateur extends aControlleurAction {
 
public function __construct(Registre $Registre)
{
$Registre->ajouterEspace('AdminUtilisateur', 'admin_utilisateur');
$Registre->setTitre('Administrer les utilisateurs');
}
 
public function executer()
{
$aso_admin_utilisateur = array();
// Ajout du mode
$aso_admin_utilisateur['mode'] = 'A';// Ajout
 
// Récupération des utilisateur
$Utilisateur = new Utilisateur();
 
// Vérification si l'utilisateur est admin
$aso_admin_utilisateur['bool_mark_admin'] = false;
if ($Utilisateur->getMarkAdmin() == 1) {
$aso_admin_utilisateur['bool_mark_admin'] = true;
}
// Vérification si l'utilisateur doit apparaître dans le récapitulatif
$aso_admin_utilisateur['bool_mark_recapitulatif'] = false;
if ($Utilisateur->getMarkRecapitulatif() == 1) {
$aso_admin_utilisateur['bool_mark_recapitulatif'] = true;
}
 
// Utilisateur vide par défaut
$aso_admin_utilisateur['Utilisateur'] = clone $Utilisateur;
 
// Recherche des utilisateurs existant
$tab_u = $Utilisateur->consulter(Utilisateur::GU_TOUS);
foreach ($tab_u as $u) {
// Nous récupérons tous les statuts sauf le null (=0)
if ($u->getIdUtilisateur() != 0) {
$aso_utilisateur['id'] = $u->getIdUtilisateur();
$aso_utilisateur['libelle'] = $u->getNom().' '.$u->getPrenom();
$aso_admin_utilisateur['utilisateurs'][] = $aso_utilisateur;
}
}
 
// Recherche des statuts des utilisateurs
$UtilisateurStatut = new UtilisateurStatut();
$tab_us = $UtilisateurStatut->consulter(UtilisateurStatut::GUS_TOUS);
foreach ($tab_us as $us) {
// Nous récupérons tous les statuts sauf le null (=0)
if ($us->getIdUtilisateurStatut() != 0) {
$aso_us['id'] = $us->getIdUtilisateurStatut();
$aso_us['libelle'] = $us->getLibelle();
$aso_admin_utilisateur['utilisateur_statuts'][] = $aso_us;
}
}
 
// Modification des titres, légendes et bouton
$aso_admin_utilisateur['form_legend'] = 'Ajouter un utilisateur';
$aso_admin_utilisateur['form_bouton_value'] = 'Ajouter';
$aso_admin_utilisateur['form_bouton_id'] = 'btn_utilisateur_ajouter';
$aso_admin_utilisateur['form_url'] = 'index.php?action=admin-utilisateur_valider-ajouter';
 
//echo '<pre>'.print_r($aso_admin_utilisateur, true).'</pre>';
$this->getRegistre()->ajouterDonnee('admin_utilisateur', $aso_admin_utilisateur);
}
 
public function executerValiderAjouter()
{
if (isset($_POST['btn_utilisateur_annuler'])) {
// Action suivante
$this->setSuivant('__defaut__');
} else if (isset($_POST['btn_utilisateur_ajouter'])) {
// Vérification de l'utilisateur à ajouter
$bool_ajouter = true;
$Utilisateur = new Utilisateur();
$UtMail = $Utilisateur->consulter(Utilisateur::GU_MAIL, array($_POST['ut_email']));
if ((is_array($UtMail) && count($UtMail) > 1) || $UtMail instanceof Utilisateur) {
$aso_admin_utilisateur['messages'][] = 'Un utilisateur avec le même courriel existe déjà !';
$bool_ajouter = false;
}
$this->verifierChampsCommuns($aso_admin_utilisateur, $bool_ajouter, 'A');
if ($bool_ajouter) {
// Action suivante
$this->setSuivant('ajouter');
} else {
// Action suivante
$this->setSuivant('__defaut__');
$this->getRegistre()->ajouterDonnee('admin_utilisateur', $aso_admin_utilisateur);
}
}
}
 
public function executerValiderModifier()
{
if (isset($_POST['btn_utilisateur_annuler'])) {
// Action suivante
$this->setSuivant('__defaut__');
} else if (isset($_POST['btn_utilisateur_modifier'])) {
// Vérification de l'utilisateur à modifier
$bool_modifier = true;
$Utilisateur = new Utilisateur();
$UtMail = $Utilisateur->consulter(Utilisateur::GU_MAIL, array($_POST['ut_email']));
if ((is_array($UtMail) && count($UtMail) > 1) || ($UtMail instanceof Utilisateur && $UtMail->getIdUtilisateur() != $_POST['ut_id_utilisateur'])) {
$aso_admin_utilisateur['messages'][] = 'Un utilisateur avec le même courriel existe déjà !';
$bool_modifier = false;
}
$this->verifierChampsCommuns($aso_admin_utilisateur, $bool_modifier, 'M');
if ($bool_modifier) {
// Action suivante
$this->setSuivant('modifier');
} else {
// Action suivante
$_POST['btn_utilisateur_modifier'] = 'btn_utilisateur_modifier';
$_POST['utsu_id'] = $_POST['ut_id_utilisateur'];
$this->setSuivant('editer');
$this->getRegistre()->ajouterDonnee('admin_utilisateur', $aso_admin_utilisateur);
}
}
}
 
public function verifierChampsCommuns(&$aso_admin_utilisateur, &$bool, $mode)
{
// En modifcation, si le mot de passe est vide, on ne fait pas de changement dans la base de données
if ($mode == 'A' || ($mode == 'M' && (!empty($_POST['ut_mot_de_passe']) || !empty($_POST['ut_mot_de_passe_confirmation'])))) {
if (mb_strlen($_POST['ut_mot_de_passe']) < 6) {
$aso_admin_utilisateur['messages'][] = 'Le mot de passe doit contenir au moins 6 caractères !';
$bool = false;
}
if ($_POST['ut_mot_de_passe'] != $_POST['ut_mot_de_passe_confirmation']) {
$aso_admin_utilisateur['messages'][] = 'Les mots de passe saisies ne sont pas identique !';
$bool = false;
}
}
if ($_POST['ut_temps_de_travail_jour'] > 24) {
$aso_admin_utilisateur['messages'][] = 'Il est impossible que le temps de travail soit supérieur à 24h !';
$bool = false;
}
$aso_champs_tdt = array('ut_tdt_lundi' => 'Lundi', 'ut_tdt_mardi' => 'Mardi', 'ut_tdt_mercredi' => 'Mercredi',
'ut_tdt_jeudi' => 'Jeudi', 'ut_tdt_vendredi' => 'Vendredi', 'ut_tdt_samedi' => 'Samedi',
'ut_tdt_dimanche' => 'Dimanche');
foreach ($aso_champs_tdt as $champ_id => $libelle) {
if ($_POST[$champ_id] > $_POST['ut_temps_de_travail_jour']) {
$aso_admin_utilisateur['messages'][] = "Le champ temps de travail du $libelle ne doit pas être supérieur à la durée maximum du temps de travail journalier !";
$bool = false;
}
}
$aso_champs_obligatoires = array('ut_nom' => 'Nom', 'ut_prenom' => 'Prénom', 'ut_email' => 'Courriel');
// En modifcation, si le mot de passe est vide cela peut être normal
if ($mode == 'A' || ($mode == 'M' && (!empty($_POST['ut_mot_de_passe']) || !empty($_POST['ut_mot_de_passe_confirmation'])))) {
$aso_champs_obligatoires['ut_mot_de_passe'] = 'Mot de passe';
}
foreach ($aso_champs_obligatoires as $champ_id => $libelle) {
if (empty($_POST[$champ_id])) {
$aso_admin_utilisateur['messages'][] = "Le champ $libelle ne doit pas être vide !";
$bool = false;
}
}
}
 
public function executerEditer()
{
// Ajout du statut d'utilisateur
if (isset($_POST['btn_utilisateur_modifier'])) {
// Ajout du mode
$aso_admin_utilisateur['mode'] = 'M';// Modifier
 
// Récupération des données de l'utilisateur à modifier
$Utilisateur = new Utilisateur();
$Utilisateur->consulter(Utilisateur::GU_ID, $_POST['utsu_id'], true);
$aso_admin_utilisateur['Utilisateur'] = $Utilisateur;
// Vérification si l'utilisateur est admin
$aso_admin_utilisateur['bool_mark_admin'] = false;
if ($Utilisateur->getMarkAdmin() == 1) {
$aso_admin_utilisateur['bool_mark_admin'] = true;
}
// Vérification si l'utilisateur doit apparaître dans le récapitulatif
$aso_admin_utilisateur['bool_mark_recapitulatif'] = false;
if ($Utilisateur->getMarkRecapitulatif() == 1) {
$aso_admin_utilisateur['bool_mark_recapitulatif'] = true;
}
// Modification des titres, légendes et bouton
$aso_admin_utilisateur['form_legend'] = 'Modifier un utilisateur';
$aso_admin_utilisateur['form_bouton_value'] = 'Modifier';
$aso_admin_utilisateur['form_bouton_id'] = 'btn_utilisateur_modifier';
$aso_admin_utilisateur['form_url'] = 'index.php?action=admin-utilisateur_valider-modifier';
 
$this->getRegistre()->ajouterDonnee('admin_utilisateur', $aso_admin_utilisateur);
} else if (isset($_POST['btn_utilisateur_supprimer'])) {
// Action suivante
$this->setSuivant('supprimer');
}
}
 
public function executerAjouter()
{
$Utilisateur = new Utilisateur();
$Utilisateur->setNom($_POST['ut_nom']);
$Utilisateur->setPrenom($_POST['ut_prenom']);
$Utilisateur->setAdresse($_POST['ut_adresse']);
$Utilisateur->setVille($_POST['ut_ville']);
$Utilisateur->setCodePostal($_POST['ut_code_postal']);
$Utilisateur->setTelephone($_POST['ut_telephone']);
$Utilisateur->setEmail($_POST['ut_email']);
$Utilisateur->setPassword($_POST['ut_mot_de_passe']);
//$Utilisateur->setCeStatut($_POST['ut_statut']);
$Utilisateur->setCongesPayes($_POST['ut_conges_payes']);
$Utilisateur->setTempsDeTravailJour($_POST['ut_temps_de_travail_jour']);
$Utilisateur->setTempsDeTravailMois($_POST['ut_temps_de_travail_mois']);
$Utilisateur->setTdtLundi($_POST['ut_tdt_lundi']);
$Utilisateur->setTdtMardi($_POST['ut_tdt_mardi']);
$Utilisateur->setTdtMercredi($_POST['ut_tdt_mercredi']);
$Utilisateur->setTdtJeudi($_POST['ut_tdt_jeudi']);
$Utilisateur->setTdtVendredi($_POST['ut_tdt_vendredi']);
$Utilisateur->setTdtSamedi($_POST['ut_tdt_samedi']);
$Utilisateur->setTdtDimanche($_POST['ut_tdt_dimanche']);
$Utilisateur->setQuotaHeuresSupp($_POST['ut_quota_heures_supp']);
if (!isset($_POST['ut_mark_admin'])) {
$_POST['ut_mark_admin'] = 0;
}
$Utilisateur->setMarkAdmin($_POST['ut_mark_admin']);
if (!isset($_POST['ut_mark_recapitulatif'])) {
$_POST['ut_mark_recapitulatif'] = 0;
}
$Utilisateur->setMarkRecapitulatif($_POST['ut_mark_recapitulatif']);
$Utilisateur->ajouter();
// Action suivante
$this->setSuivant('__defaut__');
}
 
 
public function executerModifier()
{
$Utilisateur = new Utilisateur();
$Utilisateur->setIdUtilisateur($_POST['ut_id_utilisateur']);
$Utilisateur->setNom($_POST['ut_nom']);
$Utilisateur->setPrenom($_POST['ut_prenom']);
$Utilisateur->setAdresse($_POST['ut_adresse']);
$Utilisateur->setVille($_POST['ut_ville']);
$Utilisateur->setCodePostal($_POST['ut_code_postal']);
$Utilisateur->setTelephone($_POST['ut_telephone']);
$Utilisateur->setEmail($_POST['ut_email']);
if (isset($_POST['ut_mot_de_passe']) && !empty($_POST['ut_mot_de_passe'])) {
$Utilisateur->setPassword($_POST['ut_mot_de_passe']);
}
//$Utilisateur->setCeStatut($_POST['ut_statut']);
$Utilisateur->setCongesPayes($_POST['ut_conges_payes']);
$Utilisateur->setTempsDeTravailJour($_POST['ut_temps_de_travail_jour']);
$Utilisateur->setTempsDeTravailMois($_POST['ut_temps_de_travail_mois']);
$Utilisateur->setTdtLundi($_POST['ut_tdt_lundi']);
$Utilisateur->setTdtMardi($_POST['ut_tdt_mardi']);
$Utilisateur->setTdtMercredi($_POST['ut_tdt_mercredi']);
$Utilisateur->setTdtJeudi($_POST['ut_tdt_jeudi']);
$Utilisateur->setTdtVendredi($_POST['ut_tdt_vendredi']);
$Utilisateur->setTdtSamedi($_POST['ut_tdt_samedi']);
$Utilisateur->setTdtDimanche($_POST['ut_tdt_dimanche']);
 
$Utilisateur->setQuotaHeuresSupp($_POST['ut_quota_heures_supp']);
if (!isset($_POST['ut_mark_admin'])) {
$_POST['ut_mark_admin'] = 0;
}
$Utilisateur->setMarkAdmin($_POST['ut_mark_admin']);
if (!isset($_POST['ut_mark_recapitulatif'])) {
$_POST['ut_mark_recapitulatif'] = 0;
}
$Utilisateur->setMarkRecapitulatif($_POST['ut_mark_recapitulatif']);
 
$Utilisateur->modifier();
// Action suivante
$this->setSuivant('__defaut__');
}
 
public function executerSupprimer()
{
$aso_admin_utilisateur = array();
// Vérif du nombre d'utilisateur admin (doit être supérieur à 1)
$Utilisateur = new Utilisateur();
$nbre_admin = $Utilisateur->consulter(Utilisateur::GU_ADMIN);
if (count($nbre_admin) > 1) {
trigger_error('Utilisateur admin > 1 -> OK', E_USER_NOTICE);
// Vérif des travail_projets
$TravailProjet = new TravailProjet();
$bool_existe = $TravailProjet->consulter(TravailProjet::GTP_UTILISATEUR, array($_POST['utsu_id']));
if ($bool_existe == false) {
trigger_error('TravailProjet -> OK', E_USER_NOTICE);
// Vérif des absences
$Absence = new Absence();
$bool_existe = $Absence->consulter(Absence::GA_ID_UTILISATEUR, array($_POST['utsu_id']));
if ($bool_existe == false) {
trigger_error('Absence -> OK', E_USER_NOTICE);
// Suppression de l'utilisateur
$Utilisateur = new Utilisateur();
$Utilisateur->setIdUtilisateur($_POST['utsu_id']);
if ($Utilisateur->supprimer()) {
$aso_admin_utilisateur['messages'][] = "L'utilisateur a été supprimé.";
}
}
}
} else {
$aso_admin_utilisateur['messages'][] = "Il n'est pas possible de supprimer le seul administrateur!";
}
 
// Message d'erreur si l'utilisateur contient des données
if (isset($bool_existe) && $bool_existe != false) {
$aso_admin_utilisateur['messages'][] = "Il n'est pas possible de supprimer un utilisateur contenant des données!";
}
 
// Enregistrement du message
$this->getRegistre()->ajouterDonnee('admin_utilisateur', $aso_admin_utilisateur);
 
// Action suivante
$this->setSuivant('__defaut__');
}
}
?>
/tags/v1.1-thales/actions/GttCtrlActionStatTableauCharge.class.php
New file
0,0 → 1,254
<?php
class GttCtrlActionStatTableauCharge extends aControlleurAction {
 
public function __construct(Registre $Registre)
{
$Registre->ajouterEspace('StatTableauCharge', 'stat_tableau_charge');
}
 
public function executer()
{
//+-------------------------------------------------------------------------------------------------+
// GESTION D'INFO GLOBALES
//+-------------------------------------------------------------------------------------------------+
$aso_stat = array('total_w' => 0,'total_a' => 0, 'total' => 0);
$this->getRegistre()->setTitre('Plan de charge');
 
//+-------------------------------------------------------------------------------------------------+
// GESTION DES PARAMÊTRE de l'URL
//+-------------------------------------------------------------------------------------------------+
// Initialisation des variables
if (!isset($_GET['annee'])) {
$_GET['annee'] = date('Y');
}
if (!isset($_GET['mois'])) {
$_GET['mois'] = date('m');
}
if (!isset($_GET['uid'])) {// ID de l'utilisateur à afficher
$_GET['uid'] = null;
}
//+-------------------------------------------------------------------------------------------------+
// GESTION DES UTILISATEURS
//+-------------------------------------------------------------------------------------------------+
$DaoUtilsateur = new Utilisateur();
$utilisateurs = $DaoUtilsateur->consulter(Utilisateur::GU_TOUS);
$UtilisateurCourant = null;
foreach ($utilisateurs as $Utilisateur) {
// Récupération des infos sur l'utilisateur
$aso_stat['utilisateurs'][$Utilisateur->getIdUtilisateur()]['courant'] = false;
$aso_stat['utilisateurs'][$Utilisateur->getIdUtilisateur()]['nom'] = $Utilisateur->getNom().' '.$Utilisateur->getPrenom();
if ( (!is_null($_GET['uid']) && $Utilisateur->getIdUtilisateur() == $_GET['uid'])
|| (is_null($_GET['uid']) && $Utilisateur->getIdUtilisateur() == $GLOBALS['_GTT_']['Utilisateur']->getIdUtilisateur()) ) {
$UtilisateurCourant = clone $Utilisateur;
$aso_stat['utilisateurs'][$Utilisateur->getIdUtilisateur()]['courant'] = true;
$aso_stat['utilisateur_courant'] = $Utilisateur->getNom().' '.$Utilisateur->getPrenom();
$_GET['uid'] = $Utilisateur->getIdUtilisateur();
}
}
$aso_stat['etre_admin'] = $GLOBALS['_GTT_']['Utilisateur']->getMarkAdmin();
$Utilisateur = $UtilisateurCourant;
//+-------------------------------------------------------------------------------------------------+
// GESTION DES CALENDRIERS
//+-------------------------------------------------------------------------------------------------+
// Construction du Calendrier
$Calendrier = new Calendrier();
$tab_jours_feries = $Calendrier->getListeFeries();
// Construction de l'objet mois
$Month = new Calendar_Month_Weeks($_GET['annee'], $_GET['mois']);
$Month->build();
// Récupération des jours du mois
while ($Week = $Month->fetch()) {
$Week->build();
//echo '<pre>'.print_r($Month, true).'</pre>';
$tab_semaine_jours = $Week->fetchAll();
foreach ($tab_semaine_jours as $num => $Day) {
// Nous prenons en compte uniquement les jours du mois courant
if ($Day->thisMonth() == $_GET['mois']) {
$element = array('travail' => 0, 'absence' => 0, 'w_et_a' => 0);
$element['jour'] = $Day->thisDay();
$element['jour_nom'] = $Calendrier->getNomJours($num);
$element['class'] = 'jour';
// Nous vérifions le type de jour
// Jour courrant
if ($Day->isSelected()) {
$element['class'] .= ' jour_courrant';
}
// Jour n'appartenant pas au moins courrant
if ($Day->isEmpty()) {
$element['class'] .= ' jour_vide';
}
// Jour férié
foreach ($tab_jours_feries as $jour_ferie) {
if ($Day->thisDay(true) == $jour_ferie) {
$element['class'] .= ' jour_ferie';
}
}
// Jour de week-end
if ($element['jour_nom'] == GESTION_DIM_L || $element['jour_nom'] == GESTION_SAM_L) {
$element['class'] .= ' jour_we';
}
$id = date('Y-m-d', mktime(0, 0, 0, $Day->thisMonth(), $Day->thisDay(), $Day->thisYear()));
$aso_stat['elements'][$id] = $element;
}
}
}
// Construction de l'url pour les mois précédent/suivant/courant et paramêtres pour le formulaire utilisateur
$aso_stat['form_url'] = 'index.php';
$aso_stat['form_param']['action'] = GTT_ACTION_STAT_TAB_CHARGE;
$aso_stat['form_param']['annee'] = $Month->thisYear();
$aso_stat['form_param']['mois'] = $Month->thisMonth();
$aso_stat['url_mois_courant'] = 'index.php?action='.GTT_ACTION_STAT_TAB_CHARGE.'&amp;annee='.$Month->thisYear().'&amp;mois='.$Month->thisMonth().'&amp;uid='.$_GET['uid'];
$PMonth = $Month->prevMonth('object');
$aso_stat['url_mois_precedent'] = 'index.php?action='.GTT_ACTION_STAT_TAB_CHARGE.'&amp;annee='.$PMonth->thisYear().'&amp;mois='.$PMonth->thisMonth().'&amp;uid='.$_GET['uid'];
$NMonth = $Month->nextMonth('object');
$aso_stat['url_mois_suivant'] = 'index.php?action='.GTT_ACTION_STAT_TAB_CHARGE.'&amp;annee='.$NMonth->thisYear().'&amp;mois='.$NMonth->thisMonth().'&amp;uid='.$_GET['uid'];
$aso_stat['mois']['mois'] = $Calendrier->getNomMois($Month->thisMonth());
$aso_stat['mois']['annee'] = $Month->thisYear();
$mois_courant_j1 = $Month->thisYear().'-'.sprintf("%02s", $Month->thisMonth()).'-'.sprintf("%02s", $Month->thisDay()).' 00:00:00';
$mois_courant_j36 = date('Y-m-d H:i:s', mktime(0, 0, 0, $NMonth->thisMonth(), 0, $NMonth->thisYear()));
//+-------------------------------------------------------------------------------------------------+
// GESTION DES PROJETS
//+-------------------------------------------------------------------------------------------------+
// Récupération du temps de travail pour un utilisateur pour le mois donné
$TravailProjet = new TravailProjet();
$cmd = TravailProjet::GTP_ID_UTILISATEUR_DATE_DEB_FIN;
$param = array($Utilisateur->getIdUtilisateur(), $mois_courant_j1, $mois_courant_j36);
$tab_tp = $TravailProjet->consulter($cmd, $param);
if ($tab_tp != false) {
$tab_projet_id = array();
foreach ($tab_tp as $utp) {
$tab_projet_id[] = $utp->getIdProjet();
}
// Nous vérifions qu'il y a des données pour l'utilisateur courant pour le mois donné
// Récupération des infos sur les projets de l'utilisateur
$Projet = new Projet();
$tab_p = $Projet->consulter(Projet::GP_ID_LIST, array(implode(',', $tab_projet_id)));
foreach ($tab_p as $Projet) {
// Récupération de la catégorie du projet
$ProjetCategorie = new ProjetCategorie();
$cmd = ProjetCategorie::GPC_ID;
$param = $Projet->getCeCategorie();
$Categorie = current($ProjetCategorie->consulter($cmd, $param));
// Nous vérifions le temps de travail pour ce projet
$aso_tps_w = 0;
if ($tab_tp) {
foreach ($tab_tp as $TP) {
$j = date('Y-m-d', strtotime($TP->getIdDateTravail()));
if ($TP->getIdProjet() == $Projet->getIdProjet()) {
// Récupération des infos sur les catégories
if (!isset($aso_stat['categories'][$Categorie->getLibelle()])) {
$aso_stat['categories'][$Categorie->getLibelle()] = array(
'total' => 0,
'abreviation' => $Categorie->getAbreviation());
}
if (!isset($aso_stat['categories'][$Categorie->getLibelle()][$j])) {
$aso_stat['categories'][$Categorie->getLibelle()][$j] = 0;
}
$aso_stat['categories'][$Categorie->getLibelle()][$j] += $TP->getDuree();
$aso_stat['categories'][$Categorie->getLibelle()]['total'] += $TP->getDuree();
// Récupération du total de travail
$aso_stat['total_w'] += $TP->getDuree();
// Récupération du total de temps global (travail+absence)
$aso_stat['total'] += $TP->getDuree();
// Récupération d'info sur le temps travaillé
$aso_stat['elements'][$j]['travail'] += $TP->getDuree();
 
// Récupération du total travail + absence par jour
$aso_stat['elements'][$j]['w_et_a'] += $TP->getDuree();
// Récupération des infos sur les projets
if (!isset($aso_stat['projets'][$Categorie->getLibelle()][$Projet->getIdProjet()])) {
$aso_stat['projets'][$Categorie->getLibelle()][$Projet->getIdProjet()] = array(
'id' => $Projet->getIdProjet(),
'nom' => $Projet->getNom(),
'desc' => $Projet->getDescription(),
'duree' => array(),
'total' => 0);
}
$aso_stat['projets'][$Categorie->getLibelle()][$Projet->getIdProjet()]['duree'][$j] = $TP->getDuree();
$aso_stat['projets'][$Categorie->getLibelle()][$Projet->getIdProjet()]['total'] += $TP->getDuree();
}
}
}
}
} else {
$aso_stat['messages'][] = 'Aucune information sur le travail en '.$aso_stat['mois']['mois'].' '.$aso_stat['mois']['annee'];
}
//+-------------------------------------------------------------------------------------------------+
// GESTION DES ABSENCES
//+-------------------------------------------------------------------------------------------------+
// Récupération des motifs d'absence
$AbsenceMotif = new AbsenceMotif();
$cmd = AbsenceMotif::GAM_TOUS;
$tab_am = $AbsenceMotif->consulter($cmd);
 
// Récupération des absences pour un utilisateur à une date donnée
$Absence = new Absence();
$cmd = Absence::GA_ID_UTILISATEUR_DATE_DEB_FIN;
$param = array($Utilisateur->getIdUtilisateur(), $mois_courant_j1, $mois_courant_j36);
$tab_a = $Absence->consulter($cmd, $param);
if ($tab_a != false) {
$aso_stat['ab_total'] = '';
if ($tab_am) {
foreach ($tab_am as $AM) {
// Initialisation du tableau des types d'absences
$aso_stat['absences'][$AM->getIdAbsenceMotif()]['nom'] = $AM->getLibelle();
if (!isset($aso_stat['absences'][$AM->getIdAbsenceMotif()]['total'])) {
$aso_stat['absences'][$AM->getIdAbsenceMotif()]['total'] = 0;
}
 
if ($tab_a) {
foreach ($tab_a as $A) {
if ($A->getIdAbsenceMotif() == $AM->getIdAbsenceMotif() && $A->getDuree() != 0) {
$j = date('Y-m-d', strtotime($A->getIdDateAbsence()));
 
// Récupération des infos sur les absences
$aso_stat['ab'][$AM->getIdAbsenceMotif()][$j] = $A->getDuree();
// Récupération du total des absences par jour
$aso_stat['elements'][$j]['absence'] += $A->getDuree();
// Récupération du total travail + absence par jour
$aso_stat['elements'][$j]['w_et_a'] += $A->getDuree();
 
// Récupération du total pour chaque type d'absence
$aso_stat['absences'][$AM->getIdAbsenceMotif()]['total'] += $A->getDuree();
 
// Récupération du total des absences
$aso_stat['total_a'] += $A->getDuree();
// Récupération du total de temps global (travail+absence)
$aso_stat['total'] += $A->getDuree();
}
}
}
}
}
} else {
$aso_stat['messages'][] = 'Aucune absence de mentionnée en '.$aso_stat['mois']['mois'].' '.$aso_stat['mois']['annee'];
}
// Post-traitement des nombre pour l'affichage
$formatage = array('ab', 'elements','absences', 'total_a', 'total_w', 'total', 'categories', 'projets');
foreach ($formatage as $cle) {
$aso_stat[$cle] = Nombre::formaterNbre($aso_stat[$cle], GTT_LANGUE);
}
// Sortie
//trigger_error(print_r($aso_stat, true), E_USER_NOTICE);
$this->getRegistre()->ajouterDonnee('stat_tableau_charge', $aso_stat);
}
}
?>
/tags/v1.1-thales/actions/GttCtrlActionMenu.class.php
New file
0,0 → 1,24
<?php
class GttCtrlActionMenu extends aControlleurAction {
 
public function __construct(Registre $Registre)
{
$Registre->ajouterEspace('Menu', 'zone_menu');
$Registre->ajouterSquelette('zone_menu', 'menu');
}
 
public function executer()
{
$aso_menu = array();
 
// Nous vérifions les droits de l'utilisateur.
$aso_menu['bool_admin'] = false;
if ($GLOBALS['_GTT_']['Utilisateur']->getMarkAdmin()) {
$aso_menu['bool_admin'] = true;
}
 
//echo '<pre>'.print_r($aso_menu, true).'</pre>';
$this->getRegistre()->ajouterDonnee('zone_menu', $aso_menu);
}
}
?>
/tags/v1.1-thales/actions/GttCtrlActionAdminAbsenceMotif.class.php
New file
0,0 → 1,214
<?php
class GttCtrlActionAdminAbsenceMotif extends aControlleurAction {
 
public function __construct(Registre $Registre)
{
$Registre->ajouterEspace('AdminAbsenceMotif', 'admin_absence_motif');
$Registre->setTitre("Administrer les motifs d'absence");
}
 
public function executer()
{
$aso_admin_absence_motif = array();
 
// Récupération des catégories
$AbsenceMotif = new AbsenceMotif();
 
// Utilisateur vide par défaut
$aso_admin_absence_motif['AbsenceMotif'] = clone $AbsenceMotif;
$tab_am = $AbsenceMotif->consulter(AbsenceMotif::GAM_TOUS);
if ($tab_am) {
if ($tab_am instanceof AbsenceMotif) {
$tab_am = array($tab_am);
}
foreach ($tab_am as $am) {
if ($am->getIdAbsenceMotif() != 0) {
$aso_motif['id'] = $am->getIdAbsenceMotif();
$aso_motif['libelle'] = $am->getLibelle();
$aso_admin_absence_motif['motifs'][] = $aso_motif;
}
}
}
// Modification des titres, légendes et bouton
$aso_admin_absence_motif['form_legend'] = "Ajouter un motif d'abscence";
$aso_admin_absence_motif['form_bouton_value'] = 'Ajouter';
$aso_admin_absence_motif['form_bouton_id'] = 'btn_absence_motif_ajouter';
$aso_admin_absence_motif['form_url'] = 'index.php?action=admin-absence-motif_valider-ajouter';
//echo '<pre>'.print_r($aso_admin_absence_motif, true).'</pre>';
$this->getRegistre()->ajouterDonnee('admin_absence_motif', $aso_admin_absence_motif);
}
public function executerEditer()
{
// Initialisation de variable
$aso_admin_absence_motif = array();
 
// Récupération d'info en fonction du bouton selectionné
if (isset($_POST['btn_absence_motif_modifier'])) {
// Récupération des données du motif à modifier
$AbsenceMotif = new AbsenceMotif();
$AbsenceMotif ->consulter(AbsenceMotif::GAM_ID, $_POST['amsu_id'], true);
$aso_admin_absence_motif['AbsenceMotif'] = $AbsenceMotif;
 
// Modification des titres, légendes et bouton
$aso_admin_absence_motif['form_legend'] = "Modifier un motif d'absence";
$aso_admin_absence_motif['form_bouton_value'] = 'Modifier';
$aso_admin_absence_motif['form_bouton_id'] = 'btn_absence_motif_modifier';
$aso_admin_absence_motif['form_url'] = 'index.php?action=admin-absence-motif_valider-modifier';
 
$this->getRegistre()->ajouterDonnee('admin_absence_motif', $aso_admin_absence_motif);
} else if (isset($_POST['btn_absence_motif_supprimer'])) {
// Action suivante
$this->setSuivant('ValiderSupprimer');
}
}
public function executerValiderAjouter()
{
if (isset($_POST['btn_absence_motif_annuler'])) {
// Action suivante
$this->setSuivant('__defaut__');
} else if (isset($_POST['btn_absence_motif_ajouter'])) {
// Vérification du motif à ajouter
$bool_modifier = true;
$AbsenceMotif = new AbsenceMotif();
$AmLibelle = $AbsenceMotif->consulter(AbsenceMotif::GAM_LIBELLE, array($_POST['amaj_libelle']));
if ((is_array($AmLibelle) && count($AmLibelle) > 1) || ($AmLibelle instanceof AbsenceMotif && $AmLibelle->getIdAbsenceMotif() != $_POST['amaj_id_absence_motif'])) {
$aso_admin_absence_motif['messages'][] = "Un motif d'absence avec le même libellé existe déjà !";
$bool_modifier = false;
}
//$this->verifierChampsCommuns(&$aso_admin_absence_motif, &$bool_modifier);
if ($bool_modifier) {
// Action suivante
$this->setSuivant('ajouter');
} else {
// Action suivante
$this->setSuivant('__defaut__');
$this->getRegistre()->ajouterDonnee('admin_absence_motif', $aso_admin_absence_motif);
}
}
}
 
public function executerAjouter()
{
// Initialisation de variable
$aso_admin_motif = array();
// Création de l'objet AbsenceMotif à ajouter
$AbsenceMotif = new AbsenceMotif();
$AbsenceMotif->setLibelle($_POST['amaj_libelle']);
if (!isset($_POST['amaj_mark_cp_diminuer'])) {
$_POST['amaj_mark_cp_diminuer'] = 0;
}
$AbsenceMotif->setMarkCpDiminuer($_POST['amaj_mark_cp_diminuer']);
if (!isset($_POST['amaj_mark_hs_diminuer'])) {
$_POST['amaj_mark_hs_diminuer'] = 0;
}
$AbsenceMotif->setMarkHsDiminuer($_POST['amaj_mark_hs_diminuer']);
if ($AbsenceMotif->ajouter()) {
$aso_admin_motif['messages'][] = "Le motif d'absence ${_POST['amaj_libelle']} a été ajouté.";
}
// Ajout du message d'information
$this->getRegistre()->ajouterDonnee('admin_absence_motif', $aso_admin_motif);
// Action suivante
$this->setSuivant('__defaut__');
}
 
public function executerValiderModifier()
{
if (isset($_POST['btn_absence_motif_annuler'])) {
// Action suivante
$this->setSuivant('__defaut__');
} else if (isset($_POST['btn_absence_motif_modifier'])) {
// Initialisation de variable
$aso_admin_motif = array();
// Vérification du motif à modifier
$bool_modifier = true;
$AbsenceMotif = new AbsenceMotif();
$AmLibelle = $AbsenceMotif->consulter(AbsenceMotif::GAM_LIBELLE, array($_POST['amaj_libelle']));
if ((is_array($AmLibelle) && count($AmLibelle) > 1) || ($AmLibelle instanceof AbsenceMotif && $AmLibelle->getIdAbsenceMotif() != $_POST['amaj_id_absence_motif'])) {
$aso_admin_motif['messages'][] = "Un motif d'absence avec le même libellé existe déjà !";
$bool_modifier = false;
}
//$this->verifierChampsCommuns(&$aso_admin_absence_motif, &$bool_modifier);
if ($bool_modifier) {
// Action suivante
$this->setSuivant('modifier');
} else {
// Action suivante
$_POST['btn_motif_absence_modifier'] = 'btn_absence_motif_modifier';
$_POST['amsu_id'] = $_POST['amaj_id_absence_motif'];
$this->setSuivant('editer');
$this->getRegistre()->ajouterDonnee('admin_absence_motif', $aso_admin_motif);
}
}
}
 
public function executerModifier()
{
// Initialisation de variable
$aso_admin_motif = array();
// Création de l'objet AbsenceMotif à modifier
$AbsenceMotif = new AbsenceMotif();
$AbsenceMotif->setIdAbsenceMotif($_POST['amaj_id_absence_motif']);
$AbsenceMotif->setLibelle($_POST['amaj_libelle']);
if (!isset($_POST['amaj_mark_cp_diminuer'])) {
$_POST['amaj_mark_cp_diminuer'] = 0;
}
$AbsenceMotif->setMarkCpDiminuer($_POST['amaj_mark_cp_diminuer']);
if (!isset($_POST['amaj_mark_hs_diminuer'])) {
$_POST['amaj_mark_hs_diminuer'] = 0;
}
$AbsenceMotif->setMarkHsDiminuer($_POST['amaj_mark_hs_diminuer']);
 
if ($AbsenceMotif->modifier()) {
$aso_admin_motif['messages'][] = "Le motif d'absence ${_POST['amaj_libelle']} a été modifié.";
}
// Ajout du message d'information
$this->getRegistre()->ajouterDonnee('admin_absence_motif', $aso_admin_motif);
// Action suivante
$this->setSuivant('__defaut__');
}
 
public function executerValiderSupprimer()
{
// Initialisation des variables
$aso_admin_motif = array();
 
// Vérif des absences
$Absence = new Absence();
$bool_existe = $Absence->consulter(Absence::GA_ID_ABSENCE_MOTIF, array($_POST['amsu_id']));
if ($bool_existe == false) {
trigger_error('Absence -> OK', E_USER_NOTICE);
// Suppression du motif d'absence
$AbsenceMotif = new AbsenceMotif();
$AbsenceMotif->setIdAbsenceMotif($_POST['amsu_id']);
if ($AbsenceMotif->supprimer()) {
$aso_admin_motif['messages'][] = "Le motif d'absence a été supprimé.";
}
}
// Message d'erreur si le motif d'absence est utilisé
if ($bool_existe != false) {
$aso_admin_motif['messages'][ ] = "Il n'est pas possible de supprimer un motif d'absence contenant des données!";
}
 
// Enregistrement du message
$this->getRegistre()->ajouterDonnee('admin_absence_motif', $aso_admin_motif);
// Action suivante
$this->setSuivant('__defaut__');
}
}
?>
/tags/v1.1-thales/actions/GttCtrlActionAdminUtilisateurStatut.class.php
New file
0,0 → 1,69
<?php
class GttCtrlActionAdminUtilisateurStatut extends aControlleurAction {
 
public function __construct(Registre $Registre)
{
$Registre->ajouterEspace('AdminUtilisateurStatut', 'admin_utilisateur_statut');
$Registre->setTitre('Administrer les statuts des utilisateurs');
}
 
public function executer()
{
$aso_admin_us = array();
 
// Récupération des statuts d'utilisateur
$UtilisateurStatut = new UtilisateurStatut();
$tab_us = $UtilisateurStatut->consulter(UtilisateurStatut::GUS_TOUS);
foreach ($tab_us as $us) {
// Nous récupérons tous les statuts sauf le null (=0)
if ($us->getIdUtilisateurStatut() != 0) {
$aso_us['id'] = $us->getIdUtilisateurStatut();
$aso_us['libelle'] = $us->getLibelle();
$aso_admin_us['statuts'][] = $aso_us;
}
}
 
//echo '<pre>'.print_r($aso_admin_us, true).'</pre>';
$this->getRegistre()->ajouterDonnee('admin_utilisateur_statut', $aso_admin_us);
}
 
public function executerValiderAjouter()
{
// Ajout du statut d'utilisateur
$UtilisateurStatut = new UtilisateurStatut();
$bool_existe = $UtilisateurStatut->consulter(UtilisateurStatut::GUS_LIBELLE, array($_POST['usaj_libelle']));
if ($bool_existe == false) {
$UtilisateurStatut->setLibelle($_POST['usaj_libelle']);
$UtilisateurStatut->ajouter();
} else {
$aso_admin_us['message'] = 'Ce statut d\'utilisateur existe déjà !';
$this->getRegistre()->ajouterDonnee('admin_utilisateur_statut', $aso_admin_us);
}
 
// Action suivante
$this->setSuivant('__defaut__');
}
 
public function executerValiderSupprimer()
{
// Suppression du statut d'utilisateur
$UtilisateurStatut = new UtilisateurStatut();
$UtilisateurStatut->setIdUtilisateurStatut($_POST['ussu_id']);
$UtilisateurStatut->supprimer();
 
// Mise à jour des utilisateurs possédant ce statut
$Utilisateur = new Utilisateur();
$tab_u = $Utilisateur->consulter(Utilisateur::GU_CE_STATUT, $_POST['ussu_id']);
if ($tab_u != false) {
foreach ($tab_u as $u) {
$Ancien = clone $u;
$u->setCeStatut(0);
$u->modifier($Ancien);
}
}
 
// Action suivante
$this->setSuivant('__defaut__');
}
}
?>
/tags/v1.1-thales/actions/GttCtrlActionGestion.class.php
New file
0,0 → 1,472
<?php
class GttCtrlActionGestion extends aControlleurAction {
 
public function __construct(Registre $Registre)
{
$Registre->ajouterEspace('Gestion', 'gestion');
$Registre->ajouterEspace('ZoneCalendrier', 'zone_calendrier');
$Registre->ajouterSquelette('zone_calendrier', 'calendrier_mini');
}
 
public function executer()
{
$aso_gestion = array();
$this->getRegistre()->setTitre('Gérer son temps');
 
//+-------------------------------------------------------------------------------------------------+
// GESTION DES CALENDRIERS
//+-------------------------------------------------------------------------------------------------+
// Initialisation des variables pour le calendrier
if (!isset($_GET['annee'])) {
$_GET['annee'] = date('Y');
}
if (!isset($_GET['mois'])) {
$_GET['mois'] = date('m');
}
if (!isset($_GET['semaine'])) {
$_GET['semaine'] = date('W');
}
if (!isset($_GET['jour'])) {
$_GET['jour'] = date('d');
}
// Instanciation de la classe Calendrier France
$Calendrier = new Calendrier($_GET['jour'], $_GET['semaine'], $_GET['mois'], $_GET['annee']);
$tab_jours_feries = $Calendrier->getListeFeries();
 
// Create an array of days which are "selected"
// Used for Week::build() below
$CalendrierJourCourrant = new Calendar_Week(date('Y'), date('m'), date('d'));
$aso_gestion['jc']['jour'] = $CalendrierJourCourrant->thisDay();
$aso_gestion['jc']['semaine'] = $CalendrierJourCourrant->thisWeek('n_in_year');
$aso_gestion['jc']['mois'] = $CalendrierJourCourrant->thisMonth();
$aso_gestion['jc']['mois_nom'] = $Calendrier->getNomMois($CalendrierJourCourrant->thisMonth());
$aso_gestion['jc']['annee'] = $CalendrierJourCourrant->thisYear();
$aso_gestion['jc_url'] = 'index.php?action='.GTT_ACTION_GESTION.'&amp;annee='.$aso_gestion['jc']['annee'].'&amp;mois='.$aso_gestion['jc']['mois'].'&amp;semaine='.$aso_gestion['jc']['semaine'].'&amp;jour='.$aso_gestion['jc']['jour'];
 
$CalendrierJourCourrant->build();
$CalendrierSemaineCourrante = $CalendrierJourCourrant->thisWeek('object');
$CalendrierSemaineCourrante->build();
$tab_jours = $CalendrierSemaineCourrante->fetchAll();
$aso_gestion['sjc_1']['jour'] = $tab_jours[1]->thisDay();
$aso_gestion['sjc_1']['mois'] = $Calendrier->getNomMois($tab_jours[1]->thisMonth());
$aso_gestion['sjc_1']['annee'] = $tab_jours[1]->thisYear();
$aso_gestion['sjc_7']['jour'] = $tab_jours[7]->thisDay();
$aso_gestion['sjc_7']['mois'] = $Calendrier->getNomMois($tab_jours[7]->thisMonth());
$aso_gestion['sjc_7']['annee'] = $tab_jours[7]->thisYear();
 
$aso_gestion['selectedDays'] = array ($CalendrierJourCourrant);
 
// Instruct month to build Week objects
// Construction de l'objet mois
$Month = new Calendar_Month_Weeks($_GET['annee'], $_GET['mois']);
$Month->build();
 
while ($Week = $Month->fetch()) {
$Week->build($aso_gestion['selectedDays']);
//echo '<pre>'.print_r($Month, true).'</pre>';
$tab_semaine_jours = $Week->fetchAll();
foreach ($tab_semaine_jours as $num => $Day) {
$element = array();
$element['annee'] = $Day->thisYear();
$element['mois'] = $Day->thisMonth();
$element['jour'] = $Day->thisDay();
$element['jour_nom'] = $Calendrier->getNomJours($num);
$element['url'] = 'index.php?action='.GTT_ACTION_GESTION.'&amp;annee='.$Day->thisYear().'&amp;mois='.$Day->thisMonth().'&amp;jour='.$Day->thisDay();
// Check to see if day is selected
if ($Day->isSelected()) {
$element['class'] = 'jour_courrant';
} else if ($Day->isEmpty()) {
$element['class'] = 'jour_vide';
} else {
$element['class'] = 'jour';
}
foreach ($tab_jours_feries as $jour_ferie) {
if ($Day->thisDay(true) == $jour_ferie) {
$element['class'] = 'jour_ferie';
}
}
$aso_gestion['elements'][$Week->thisWeek('n_in_year')][$num] = $element;
}
}
 
// Construction de l'url pour les mois précédent/suivant
$PMonth = $Month->prevMonth('object');
$aso_gestion['url_mois_precedent'] = 'index.php?action='.GTT_ACTION_GESTION.'&amp;annee='.$PMonth->thisYear().'&amp;mois='.$PMonth->thisMonth().'&amp;jour='.$PMonth->thisDay();
$NMonth = $Month->nextMonth('object');
$aso_gestion['url_mois_suivant'] = 'index.php?action='.GTT_ACTION_GESTION.'&amp;annee='.$NMonth->thisYear().'&amp;mois='.$NMonth->thisMonth().'&amp;jour='.$NMonth->thisDay();
$aso_gestion['mois']['mois'] = $Calendrier->getNomMois($Month->thisMonth());
$aso_gestion['mois']['annee'] = $Month->thisYear();
 
// Construction de l'url pour les semaines précédente/suivante
$Week = new Calendar_Week($_GET['annee'], $_GET['mois'], $_GET['jour']);
$aso_gestion['s'] = $Week->thisWeek('n_in_year');
 
$PWeek = $Week->prevWeek('object');
$aso_gestion['url_semaine_precedente'] = 'index.php?action='.GTT_ACTION_GESTION.'&amp;annee='.$PWeek->thisYear().'&amp;mois='.$PWeek->thisMonth().'&amp;jour='.$PWeek->thisDay();
 
$url_sc_param_date = '&amp;annee='.$Week->thisYear().'&amp;mois='.$Week->thisMonth().'&amp;jour='.$Week->thisDay();
$aso_gestion['url_semaine_courante'] = 'index.php?action='.GTT_ACTION_GESTION.$url_sc_param_date;
 
$NWeek = $Week->nextWeek('object');
$aso_gestion['url_semaine_suivante'] = 'index.php?action='.GTT_ACTION_GESTION.'&amp;annee='.$NWeek->thisYear().'&amp;mois='.$NWeek->thisMonth().'&amp;jour='.$NWeek->thisDay();
 
$Week->build();
$aso_jours = array();
foreach($Week->fetchAll() as $num => $j) {
$aso_gestion['sj_'.$num]['jour'] = $j->thisDay();
$aso_gestion['sj_'.$num]['mois'] = $Calendrier->getNomMois($j->thisMonth());
$aso_gestion['sj_'.$num]['annee'] = $j->thisYear();
$aso_gestion['sj_'.$num]['mysql'] = $aso_gestion['sj_'.$num]['annee'].'-'.sprintf("%02s", $j->thisMonth()).'-'.sprintf("%02s", $aso_gestion['sj_'.$num]['jour']);
$aso_jours[$aso_gestion['sj_'.$num]['mysql']] = $num;
$aso_tps_w_vide[$num] = '';
$aso_abscence_initial[$num] = array(
'duree' => '',
'duree_defaut' => $GLOBALS['_GTT_']['Utilisateur']->getTdtParNumJour($num));
}
 
//+-------------------------------------------------------------------------------------------------+
// GESTION DES PROJETS
//+-------------------------------------------------------------------------------------------------+
// Récupération des projets sur lesquels l'utilisateur travaille
$UtilsateurAProjet = new UtilisateurAProjet();
$tab_uap = $UtilsateurAProjet->consulter(UtilisateurAProjet::GUAP_UTILISATEUR, $GLOBALS['_GTT_']['Utilisateur']->getIdUtilisateur());
// Si nous avons des données...
$aso_gestion['bool_projets'] = false;
if ($tab_uap && count($tab_uap) >= 1) {
$aso_gestion['bool_projets'] = true;
$tab_projet_id = array();
foreach ($tab_uap as $uap) {
$tab_projet_id[] = $uap->getIdProjet();
}
 
// Récupération du temps de travail pour un utilisateur à une date donnée
$TravailProjet = new TravailProjet();
$cmd = TravailProjet::GTP_ID_UTILISATEUR_DATE_DEB_FIN;
$param = array($GLOBALS['_GTT_']['Utilisateur']->getIdUtilisateur(), $aso_gestion['sj_1']['mysql'], $aso_gestion['sj_7']['mysql']);
$tab_tp = $TravailProjet->consulter($cmd, $param);
 
// Récupération des infos sur les projets de l'utilisateur
$aso_gestion['totaux'] = $aso_tps_w_vide;
$Projet = new Projet();
$tab_p = $Projet->consulter(Projet::GP_ID_LIST, array(implode(',', $tab_projet_id)));
foreach ($tab_p as $Projet) {
 
// Récupération de la catégorie du projet
$ProjetCategorie = new ProjetCategorie();
$Categorie = current($ProjetCategorie->consulter(ProjetCategorie::GPC_ID, $Projet->getCeCategorie()));
 
// Nous vérifions le temps de travail pour ce projet pour la semaine courrante
$aso_tps_w = $aso_tps_w_vide;
if (!isset($aso_gestion['categorie_totaux'][$Categorie->getLibelle()])) {
$aso_gestion['categorie_totaux'][$Categorie->getLibelle()] = $aso_tps_w_vide;
}
if ($tab_tp) {
foreach ($tab_tp as $TP) {
if ($TP->getIdProjet() == $Projet->getIdProjet()) {
$num = $aso_jours[$TP->getIdDateTravail()];
$aso_tps_w[$num] = $TP->getDuree();
$aso_gestion['categorie_totaux'][$Categorie->getLibelle()][$num] += $TP->getDuree();
$aso_gestion['totaux'][$num] += $TP->getDuree();
}
}
}
 
// Stockage des infos nécessaire pour l'affichage
$aso_gestion['preferences'][$Categorie->getLibelle()][] = array(
'id' => $Projet->getIdProjet(),
'valeur' => $Projet->getIdProjet(),
'nom' => $Projet->getNom(),
'desc' => $Projet->getDescription(),
'date' => $aso_tps_w);
 
 
}
}
// Trie par odre alphabétique des catégories...
ksort($aso_gestion['preferences']);
 
//+-------------------------------------------------------------------------------------------------+
// GESTION DES ABSENCES
//+-------------------------------------------------------------------------------------------------+
// Récupération des motifs d'absence
$AbsenceMotif = new AbsenceMotif();
$cmd = AbsenceMotif::GAM_TOUS;
$tab_am = $AbsenceMotif->consulter($cmd);
 
// Récupération des absences pour un utilisateur à une date donnée
$Absence = new Absence();
$cmd = Absence::GA_ID_UTILISATEUR_DATE_DEB_FIN;
$param = array($GLOBALS['_GTT_']['Utilisateur']->getIdUtilisateur(), $aso_gestion['sj_1']['mysql'], $aso_gestion['sj_7']['mysql']);
$tab_a = $Absence->consulter($cmd, $param);
// Si nous avons des absences...
 
$aso_gestion['ab_total'] = $aso_tps_w_vide;
if ($tab_am) {
foreach ($tab_am as $AM) {
$aso_gestion['ab_libelle'][$AM->getIdAbsenceMotif()] = $AM->getLibelle();
$aso_gestion['ab'][$AM->getIdAbsenceMotif()] = $aso_abscence_initial;
if ($tab_a) {
foreach ($tab_a as $A) {
if ($A->getIdAbsenceMotif() == $AM->getIdAbsenceMotif()) {
$num = $aso_jours[$A->getIdDateAbsence()];
if ($A->getDuree() < 0) {
$A->setDuree(0);
}
$aso_gestion['ab'][$AM->getIdAbsenceMotif()][$num]['duree'] = $A->getDuree();
$aso_gestion['ab_total'][$num] += $A->getDuree();
$aso_gestion['totaux'][$num] += $A->getDuree();
}
}
}
}
}
 
// Création de l'url de réponse du formulaire
$aso_gestion['url_gestion_valider'] = 'index.php?action='.GTT_ACTION_GESTION_VALIDER.$url_sc_param_date;
 
//echo '<pre>ici '.print_r($aso_gestion['ab'], true).'la</pre>';
$this->getRegistre()->ajouterDonnee('gestion', $aso_gestion);
$this->getRegistre()->ajouterDonnee('zone_calendrier', $aso_gestion);
}
 
public function verifierValider()
{
 
}
 
public function executerValider()
{
// Création du Calendrier
$Calendrier = new Calendrier($_GET['jour'], null, $_GET['mois'], $_GET['annee']);
 
// Récupération des info sur la semaine courrante
$Week = new Calendar_Week($_GET['annee'], $_GET['mois'], $_GET['jour']);
$Week->build();
$aso_jours = array();
$aso_semaine = array();
$jours_w_semaine = array();
foreach($Week->fetchAll() as $num => $j) {
$aso_semaine[$num]['mysql'] = $j->thisYear().'-'.sprintf("%02s", $j->thisMonth()).'-'.sprintf("%02s", $j->thisDay());
$aso_jours[$aso_semaine[$num]['mysql']] = $num;
 
// Initialisation de la variable pour la gestion des heures sup
$methode = 'getTdt'.$Calendrier->getNomJoursLong($num);
$jours_w_semaine[$num] = array( 'act' => 0,
'pre' => 0,
'act_a' => 0,
'pre_a' => 0,
'mod' => false,
'tdt' => $GLOBALS['_GTT_']['Utilisateur']->$methode());
// Vérification des jours fériés pour modification du temps de travail automatique
if ($Calendrier->etreFerie($j->getTimestamp())) {
// Nous passons automatiquement le temps de travail à 0
$jours_w_semaine[$num]['tdt'] = 0;
}
}
 
// Récupération du temps de travail pour un utilisateur à une date donnée
$TravailProjet = new TravailProjet();
$cmd = TravailProjet::GTP_ID_UTILISATEUR_DATE_DEB_FIN;
$param = array($GLOBALS['_GTT_']['Utilisateur']->getIdUtilisateur(), $aso_semaine[1]['mysql'], $aso_semaine[7]['mysql']);
$tab_tp = $TravailProjet->consulter($cmd, $param);
 
// Création d'un utilisateur pour les mises à jour des CP et RTT
$Utilisateur = new Utilisateur();
$Utilisateur->initialiser();
$Utilisateur->setIdUtilisateur($GLOBALS['_GTT_']['Utilisateur']->getIdUtilisateur());
$Utilisateur->setQuotaHeuresSupp($GLOBALS['_GTT_']['Utilisateur']->getQuotaHeuresSupp());
$Utilisateur->setCongesPayes($GLOBALS['_GTT_']['Utilisateur']->getCongesPayes());
 
// Ajout ou Mise à jour des durées de travail
if (isset($_POST['pr'])) {
foreach($_POST['pr'] as $projet_id => $jours) {
foreach($jours as $jour_num => $nbr_heure) {
if (isset($jours_w_semaine[$jour_num])) {
$jours_w_semaine[$jour_num]['act'] += $nbr_heure;
}
$bool_ajouter = true;
if (!empty($tab_tp)) {
foreach ($tab_tp as $TP) {
if ($TP->getIdDateTravail() == $aso_semaine[$jour_num]['mysql']) {
if ($TP->getIdProjet() == $projet_id) {
$bool_ajouter = false;
$jours_w_semaine[$jour_num]['pre'] += $TP->getDuree();
$jours_w_semaine[$jour_num]['mod'] = true;
if ($TP->getDuree() != $nbr_heure) {
if (empty($nbr_heure)) {
// Si un temps de travail est mis à 0, on le supprime.
// Les heures sup sont réinitialisés ci-dessous.
$TP->supprimer();
} else {
$TP->setDuree($nbr_heure);
$TP->modifier();
}
}
}
}
}
}
if ($bool_ajouter && !empty($nbr_heure)) {
$TP = new TravailProjet();
$TP->setDuree((float)$nbr_heure);
$TP->setIdUtilisateur($GLOBALS['_GTT_']['Utilisateur']->getIdUtilisateur());
$TP->setIdProjet($projet_id);
$TP->setIdDateTravail((string)$aso_semaine[$jour_num]['mysql']);
$TP->ajouter();
}
}
}
}
 
// Récupération des absences pour un utilisateur à une date donnée
$Absence = new Absence();
$cmd = Absence::GA_ID_UTILISATEUR_DATE_DEB_FIN;
$param = array($GLOBALS['_GTT_']['Utilisateur']->getIdUtilisateur(), $aso_semaine[1]['mysql'], $aso_semaine[7]['mysql']);
$tab_a = $Absence->consulter($cmd, $param);
//echo '<pre>'.print_r($tab_a, true).'</pre>';
// Ajout ou Mise à jour des durées d'absences pour congés payés
$cp_h_modif = 0;
$hs_h_modif = 0;
$abscences_a_supprimer = $tab_a;
//echo '<pre>'.print_r($_POST['ab'], true).'</pre>';
if (isset($_POST['ab'])) {
echo '<pre>'.print_r($_POST['ab'], true).'</pre>';
foreach($_POST['ab'] as $num_j => $tab_ab_id_duree) {
if (isset($tab_ab_id_duree)) {
list($ab_id, $ab_duree) = explode(':', $tab_ab_id_duree);
 
// Création du motif d'absence pour voir si on doit diminuer les congés payés
$AbsenceMotif = new AbsenceMotif();
$AbsenceMotif->consulter(AbsenceMotif::GAM_ID, $ab_id, true);
 
// Gestion des heures sup en fonction du type d'absence
if (isset($jours_w_semaine[$num_j])) {
if ($AbsenceMotif->getMarkHsDiminuer()) {
$jours_w_semaine[$num_j]['act_a'] += $ab_duree;
} else {
$jours_w_semaine[$num_j]['act'] += $ab_duree;
}
}
$bool_ajouter = true;
if (!empty($tab_a)) {
foreach ($tab_a as $id => $A) {
if ($A->getIdDateAbsence() == $aso_semaine[$num_j]['mysql']) {
if ($A->getIdAbsenceMotif() == $ab_id) {
unset($abscences_a_supprimer[$id]);
$bool_ajouter = false;
$jours_w_semaine[$num_j]['mod'] = true;
// Gestion des heures sup en fonction du type d'absence
if ($AbsenceMotif->getMarkHsDiminuer()) {
$jours_w_semaine[$num_j]['pre_a'] += $A->getDuree();
} else {
$jours_w_semaine[$num_j]['pre'] += $A->getDuree();
}
if ($A->getDuree() != $ab_duree) {
if (empty($ab_duree)) {
if ($AbsenceMotif->getMarkCpDiminuer()) {
$Utilisateur->augmenterCongesPayes($A->getDuree());
}
// Une fois des données saisie dans un jour, on ne supprime pas la ligne mais
// on met la durée 0
$A->setDuree(0);
$A->modifier();
} else {
$ab_duree_tmp = $A->getDuree();
$A->setDuree($ab_duree);
$A->modifier();
if ($AbsenceMotif->getMarkCpDiminuer()) {
$Utilisateur->augmenterCongesPayes(($ab_duree_tmp - $ab_duree));
}
}
}
}
}
}
}
// Ajout de nouvelle abscences
if ($bool_ajouter && !empty($ab_duree)) {
$A = new Absence();
$A->setDuree((float)$ab_duree);
$A->setIdUtilisateur($GLOBALS['_GTT_']['Utilisateur']->getIdUtilisateur());
$A->setIdAbsenceMotif($ab_id);
$A->setIdDateAbsence((string)$aso_semaine[$num_j]['mysql']);
$A->ajouter();
if ($AbsenceMotif->getMarkCpDiminuer()) {
$Utilisateur->diminuerCongesPayes($ab_duree);
}
}
}
}
}
// Suppression des abscences décochées
//echo '<pre>'.print_r($abscences_a_supprimer, true).'</pre>';
if (count($abscences_a_supprimer) > 0) {
foreach ($abscences_a_supprimer as $A) {
$num_jour_ab = $aso_jours[$A->getIdDateAbsence()];
$AbsenceMotif = new AbsenceMotif();
$AbsenceMotif->consulter(AbsenceMotif::GAM_ID, $A->getIdAbsenceMotif(), true);
if ($AbsenceMotif->getMarkHsDiminuer()) {
$jours_w_semaine[$num_jour_ab]['pre_a'] = $A->getDuree();
$jours_w_semaine[$num_jour_ab]['act_a'] = 0;
$jours_w_semaine[$num_jour_ab]['mod'] = true;
}
$A->supprimer();
}
}
 
// Gestion de la mise à jour des heures sup
//echo '<pre>'.print_r($jours_w_semaine, true).'</pre>';
foreach ($jours_w_semaine as $c => $j) {
// Modifications existantes pour le jour courant
if (($j['pre'] != 0 || $j['act'] != 0) || ($j['act_a'] != 0 || $j['pre_a'] != 0)) {
if ($j['mod'] == false) {// Première fois que l'on modifie le jour
if ($j['act_a'] == 0 && $j['act'] != 0) {// Journée de travail
$heure_sup_act = $j['act'] - $j['tdt'];
if ($heure_sup_act > 0) {
$Utilisateur->augmenterQuotaHeuresSup($heure_sup_act);
}
if ($heure_sup_act < 0) {
$Utilisateur->diminuerQuotaHeuresSup($heure_sup_act);
}
} else {// Journée d'abscence
$Utilisateur->diminuerQuotaHeuresSup($j['act_a']);
}
} else {// Les heures sup ont déjà été comptabilisées, réinitialisation nécessaire
// Nous restaurons les heures sup précédement ajoutées ou décomptées
if ($j['pre_a'] == 0 && $j['pre'] != 0) {// Journée de travail
$heure_sup_pre = $j['pre'] - $j['tdt'];
if ($heure_sup_pre > 0) {
$Utilisateur->diminuerQuotaHeuresSup($heure_sup_pre);
} else if ($heure_sup_pre < 0) {
$Utilisateur->augmenterQuotaHeuresSup($heure_sup_pre);
}
} else {// Journée d'abscence
$Utilisateur->augmenterQuotaHeuresSup($j['pre_a']);
}
// Nous ajoutons ou décomptons les heures sup actuelles
if ($j['act_a'] == 0 && $j['act'] != 0) {// Journée de travail
$heure_sup_act = $j['act'] - $j['tdt'];
if ($heure_sup_act > 0) {
$Utilisateur->augmenterQuotaHeuresSup($heure_sup_act);
}
if ($heure_sup_act < 0) {
$Utilisateur->diminuerQuotaHeuresSup($heure_sup_act);
}
} else {// Journée d'abscence
$Utilisateur->diminuerQuotaHeuresSup($j['act_a']);
}
}
}
}
$Utilisateur->modifier();
 
// Mise à jour de la vue Identité pour les congés payés et RTT
$GttCtrlActionIdentification = new GttCtrlActionIdentification($this->getRegistre());
$GttCtrlActionIdentification->setSuivant('__defaut__');
$this->setSuivant($GttCtrlActionIdentification);
 
// Action suivante
$this->setSuivant('__defaut__');
}
}
?>
/tags/v1.1-thales/actions/GttCtrlActionIdentification.class.php
New file
0,0 → 1,61
<?php
 
class GttCtrlActionIdentification extends aControlleurAction {
 
public function __construct(Registre $Registre)
{
$Registre->ajouterEspace('Identification', 'identification');
}
 
public function executer()
{
$aso_identification = array();
$params = array('dsn' => GTT_BDD_DSN,
'table' => 'gestion_utilisateur',
'usernamecol' => 'gu_email',
'passwordcol' => 'gu_password',
'cryptype' => 'md5',
'db_fields' => '*');
// Création de l'objet auth
$GLOBALS['_GTT_']['identification'] = new Auth('DB', $params, null, false);
$GLOBALS['_GTT_']['identification']->setSessionname(GTT_AUTH_SESSION_NOM);
$GLOBALS['_GTT_']['identification']->setExpire(time()+(int)GTT_AUTH_SESSION_DUREE);
$GLOBALS['_GTT_']['identification']->start();
setcookie(session_name(),session_id(), time()+(int)GTT_AUTH_SESSION_DUREE, "/");
if ($GLOBALS['_GTT_']['identification']->getAuth()) {
require_once GTT_CHEMIN_METIER.'Utilisateur.class.php';
$GLOBALS['_GTT_']['Utilisateur'] = new Utilisateur(Utilisateur::GU_MAIL, array($GLOBALS['_GTT_']['identification']->getUserName()));
$aso_identification['nom'] = $GLOBALS['_GTT_']['Utilisateur']->getNom();
$aso_identification['prenom'] = $GLOBALS['_GTT_']['Utilisateur']->getPrenom();
// Récupération des infos sur l'utilisateur
$aso_identification['cp'] = $GLOBALS['_GTT_']['Utilisateur']->getCongesPayes();
$cp = $aso_identification['cp'] / $GLOBALS['_GTT_']['Utilisateur']->getTempsDeTravailJour();
$aso_identification['cp_j'] = round($cp, 1);
$aso_identification['rtt'] = $GLOBALS['_GTT_']['Utilisateur']->getQuotaHeuresSupp();
$rtt = $aso_identification['rtt'] / $GLOBALS['_GTT_']['Utilisateur']->getTempsDeTravailJour();
$aso_identification['rtt_j'] = round($rtt, 1);
$aso_identification['tps_w'] = $GLOBALS['_GTT_']['Utilisateur']->getTempsDeTravailJour();
 
$this->getRegistre()->ajouterSquelette('identification', 'identite');
//echo '<pre>'.print_r($aso_identification, true).'</pre>';
$this->getRegistre()->ajouterDonnee('identification', $aso_identification);
} else {
$this->setSuivant('Deconnexion', 1);
}
}
 
public function executerDeconnexion()
{
$aso_connexion = array();
$this->getRegistre()->setTitre('Bienvenue sur GTT!');
$this->getRegistre()->ajouterSquelette('identification', 'connexion');
// Création de l'url de réponse du formulaire
$aso_connexion['url'] = 'index.php?action='.GTT_ACTION_CONNEXION;
$GLOBALS['_GTT_']['identification']->logout();
 
//echo '<pre>'.print_r($aso_connexion, true).'</pre>';
$this->getRegistre()->ajouterDonnee('identification', $aso_connexion);
$this->getRegistre()->set('action_finale', true);
}
}
?>
/tags/v1.1-thales/actions/GttCtrlActionStatTableauGlobal.class.php
New file
0,0 → 1,199
<?php
class GttCtrlActionStatTableauGlobal extends aControlleurAction {
 
public function __construct(Registre $Registre)
{
$Registre->ajouterEspace('StatTableauGlobal', 'stat_tableau_global');
}
 
public function executer()
{
$aso_stat = array();
$this->getRegistre()->setTitre('Tableau récapitulatif');
 
//+-------------------------------------------------------------------------------------------------+
// GESTION DES CALENDRIERS
//+-------------------------------------------------------------------------------------------------+
// Initialisation des variables pour le calendrier
if (!isset($_GET['annee'])) {
$_GET['annee'] = date('Y');
}
if (!isset($_GET['mois'])) {
$_GET['mois'] = date('m');
}
 
// Construction de l'objet mois
$Month = new Calendar_Month_Weeks($_GET['annee'], $_GET['mois']);
$Month->build();
 
// Construction du Calendrier
$Calendrier = new Calendrier();
// Construction de l'url pour les mois précédent/suivant
$aso_stat['url_mois_courant'] = 'index.php?action='.GTT_ACTION_STAT_TAB_GLOB.'&amp;annee='.$Month->thisYear().'&amp;mois='.$Month->thisMonth();
$PMonth = $Month->prevMonth('object');
$aso_stat['url_mois_precedent'] = 'index.php?action='.GTT_ACTION_STAT_TAB_GLOB.'&amp;annee='.$PMonth->thisYear().'&amp;mois='.$PMonth->thisMonth();
$NMonth = $Month->nextMonth('object');
$aso_stat['url_mois_suivant'] = 'index.php?action='.GTT_ACTION_STAT_TAB_GLOB.'&amp;annee='.$NMonth->thisYear().'&amp;mois='.$NMonth->thisMonth();
$aso_stat['mois']['mois'] = $Calendrier->getNomMois($Month->thisMonth());
$aso_stat['mois']['annee'] = $Month->thisYear();
$mois_courant_j1 = $Month->thisYear().'-'.sprintf("%02s", $Month->thisMonth()).'-'.sprintf("%02s", $Month->thisDay()).' 00:00:00';
$mois_courant_j36 = date('Y-m-d H:i:s', mktime(0, 0, 0, $NMonth->thisMonth(), 0, $NMonth->thisYear()));
 
//+-------------------------------------------------------------------------------------------------+
// GESTION D'INFO GLOBALES
//+-------------------------------------------------------------------------------------------------+
// Initialisation de variables
$aso_stat['absences'] = false;
$aso_stat['categories'] = false;
// Récupération des infos sur les utilisateurs
$DaoUtilsateur = new Utilisateur();
$utilisateurs = $DaoUtilsateur->consulter(Utilisateur::GU_TOUS_AFFICHABLE);
if (false == $utilisateurs) {
$aso_stat['messages'][] = "Aucun utilisateur affichable de disponible...";
} else {
// Initialisation de variables communes à la gestion des projets et des absences
$aso_stat['total_absences_projets'] = 0;
// Initialisation de variables propre aux absences
$aso_stat['total_absences'] = 0;
// Initialisation de variables propre aux absences
$aso_stat['total_projets'] = 0;
 
// Récupération des motifs d'absence
$AbsenceMotif = new AbsenceMotif();
$cmd = AbsenceMotif::GAM_TOUS;
$tab_am = $AbsenceMotif->consulter($cmd);
if (false == $tab_am) {
$aso_stat['messages'][] = "Aucun motif d'absence de renseigné";
}
// Pour chaque utilisateur nous récupérons les infos
foreach ($utilisateurs as $Utilisateur) {
// Initialisation du talbeau des infos sur l'utilisateur
$aso_gestion = array( 'prenom_nom' => $Utilisateur->getPrenom().' '.$Utilisateur->getNom(),
'total_w' => 0,
'total_a' => 0,
'total' => 0);
//+-------------------------------------------------------------------------------------------------+
// GESTION DES PROJETS
//+-------------------------------------------------------------------------------------------------+
// Récupération du temps de travail pour un utilisateur à une date donnée
$TravailProjet = new TravailProjet();
$cmd = TravailProjet::GTP_ID_UTILISATEUR_DATE_DEB_FIN;
$param = array($Utilisateur->getIdUtilisateur(), $mois_courant_j1, $mois_courant_j36);
$tab_tp = $TravailProjet->consulter($cmd, $param);
if (false == $tab_tp) {
$aso_stat['messages'][] = "Aucune information sur le travail de ${aso_gestion['prenom_nom']}";
} else {
// Récupération des identifiants des projets
$tab_projet_id = array('');
foreach ($tab_tp as $tp) {
$tab_projet_id[0] .= $tp->getIdProjet().',';
}
$tab_projet_id[0] = rtrim($tab_projet_id[0], ',');
// Récupération des infos sur les projets de l'utilisateur
$Projet = new Projet();
$tab_p = $Projet->consulter(Projet::GP_ID_LIST, $tab_projet_id);
foreach ($tab_p as $Projet) {
// Récupération de la catégorie du projet
$ProjetCategorie = new ProjetCategorie();
$cmd = ProjetCategorie::GPC_ID;
$param = $Projet->getCeCategorie();
$Categorie = current($ProjetCategorie->consulter($cmd, $param));
// Info trans utilisateur sur les catégories
if (!isset($aso_stat['categories'][$Categorie->getIdCategorie()])) {
$aso_stat['categories'][$Categorie->getIdCategorie()] = array( 'projets' => array(),
'nom' => $Categorie->getLibelle(),
'abreviation' => $Categorie->getAbreviation(),
'total' => 0);
}
foreach ($tab_tp as $TP) {
if ($TP->getIdProjet() == $Projet->getIdProjet()) {
// Info trans utilisateur sur les catégories
if (!isset($aso_stat['categories'][$Categorie->getIdCategorie()]['projets'][$Projet->getIdProjet()])) {
$aso_stat['categories'][$Categorie->getIdCategorie()]['projets'][$Projet->getIdProjet()] =
array( 'nom' => $Projet->getNom(),
'desc' => $Projet->getDescription(),
'total' => 0);
}
$aso_stat['categories'][$Categorie->getIdCategorie()]['projets'][$Projet->getIdProjet()]['total'] += $TP->getDuree();
$aso_stat['categories'][$Categorie->getIdCategorie()]['total'] += $TP->getDuree();
// Stockage des infos nécessaire pour l'affichage d'un utilisateur
if (!isset($aso_gestion['projets'][$Categorie->getIdCategorie()][$Projet->getIdProjet()])) {
$aso_gestion['projets'][$Categorie->getIdCategorie()][$Projet->getIdProjet()] = array(
'id' => $Projet->getIdProjet(),
'nom' => $Projet->getNom(),
'duree' => 0);
}
$aso_gestion['projets'][$Categorie->getIdCategorie()][$Projet->getIdProjet()]['duree'] += $TP->getDuree();
if (!isset($aso_gestion['projets'][$Categorie->getIdCategorie()]['total'])) {
$aso_gestion['projets'][$Categorie->getIdCategorie()]['total'] = 0;
}
$aso_gestion['projets'][$Categorie->getIdCategorie()]['total'] += $TP->getDuree();
$aso_gestion['total_w'] += $TP->getDuree();
}
}
}
}
$aso_gestion['total'] = $aso_gestion['total_w'];
$aso_stat['total_projets'] += $aso_gestion['total_w'];
//+-------------------------------------------------------------------------------------------------+
// GESTION DES ABSENCES
//+-------------------------------------------------------------------------------------------------+
// Récupération des absences pour un utilisateur à une date donnée
$Absence = new Absence();
$cmd = Absence::GA_ID_UTILISATEUR_DATE_DEB_FIN;
$param = array($Utilisateur->getIdUtilisateur(), $mois_courant_j1, $mois_courant_j36);
$tab_a = $Absence->consulter($cmd, $param);
 
if (false == $tab_a) {
$aso_stat['messages'][] = "Aucune information sur les absences de ${aso_gestion['prenom_nom']}";
} else {
if (false != $tab_am) {
foreach ($tab_am as $AM) {
if (!isset($aso_stat['absences'][$AM->getIdAbsenceMotif()])) {
$aso_stat['absences'][$AM->getIdAbsenceMotif()] =
array( 'nom' => $AM->getLibelle(),
'total' => 0);
}
foreach ($tab_a as $A) {
if ($A->getIdAbsenceMotif() == $AM->getIdAbsenceMotif() && $A->getDuree() != 0) {
$aso_stat['absences'][$AM->getIdAbsenceMotif()]['total'] += $A->getDuree();
$aso_stat['total_absences'] += $A->getDuree();
if (!isset($aso_gestion['ab'][$AM->getIdAbsenceMotif()])) {
$aso_gestion['ab'][$AM->getIdAbsenceMotif()] = 0;
}
$aso_gestion['ab'][$AM->getIdAbsenceMotif()] += $A->getDuree();
$aso_gestion['total_a'] += $A->getDuree();
$aso_gestion['total'] += $A->getDuree();
}
}
}
}
}
$aso_stat['total_absences_projets'] += $aso_gestion['total'];
$aso_stat['utilisateurs'][] = $aso_gestion;
}
}
// Post-traitement des nombre pour l'affichage
$formatage = array('total_projets', 'total_absences','total_absences_projets', 'utilisateurs', 'categories', 'projets', 'absences');
foreach ($formatage as $cle) {
$aso_stat[$cle] = Nombre::formaterNbre($aso_stat[$cle], GTT_LANGUE);
}
// Sortie
//trigger_error(print_r($aso_stat, true), E_USER_NOTICE);
$this->getRegistre()->ajouterDonnee('stat_tableau_global', $aso_stat);
}
}
?>
/tags/v1.1-thales/actions/GttCtrlActionAdminCategorie.class.php
New file
0,0 → 1,119
<?php
class GttCtrlActionAdminCategorie extends aControlleurAction {
 
public function __construct(Registre $Registre)
{
$Registre->ajouterEspace('AdminCategorie', 'admin_categorie');
$Registre->setTitre('Administrer les catégories des projets');
}
 
public function executer()
{
$aso_admin_categ = array();
 
// Récupération des catégories
$ProjetCategorie = new ProjetCategorie();
 
// Ajout de la catégorie par défaut
$aso_admin_categ['ProjetCategorie'] = $ProjetCategorie;
// Récupération des infos sur les categories existantes
$tab_pc = $ProjetCategorie->consulter(ProjetCategorie::GPC_TOUS);
if (false == $tab_pc) {
$aso_admin_categ['categories'] = false;
} else {
foreach ($tab_pc as $pc) {
if ($pc->getIdCategorie() != 0) {
$aso_categ['id'] = $pc->getIdCategorie();
$aso_categ['libelle'] = $pc->getLibelle();
$aso_admin_categ['categories'][] = $aso_categ;
}
}
}
// Modification des titres, légendes et bouton
$aso_admin_categ['form_legend'] = 'Ajouter une categorie';
$aso_admin_categ['form_bouton_value'] = 'Ajouter';
$aso_admin_categ['form_bouton_id'] = 'btn_categorie_ajouter';
$aso_admin_categ['form_url'] = 'index.php?action=admin-categorie_valider-ajouter';
//echo '<pre>'.print_r($aso_admin_categ, true).'</pre>';
$this->getRegistre()->ajouterDonnee('admin_categorie', $aso_admin_categ);
}
 
public function executerEditer()
{
// Ajout du statut d'utilisateur
if (isset($_POST['btn_categorie_modifier'])) {
// Récupération des données de la categorie à modifier
$ProjetCategorie = new ProjetCategorie();
$ProjetCategorie->consulter(ProjetCategorie::GPC_ID, $_POST['casu_id'], true);
$aso_admin_categ['ProjetCategorie'] = $ProjetCategorie;
 
// Modification des titres, légendes et bouton
$aso_admin_categ['form_legend'] = 'Modifier une categorie';
$aso_admin_categ['form_bouton_value'] = 'Modifier';
$aso_admin_categ['form_bouton_id'] = 'btn_categorie_modifier';
$aso_admin_categ['form_url'] = 'index.php?action=admin-categorie_valider-modifier';
 
$this->getRegistre()->ajouterDonnee('admin_categorie', $aso_admin_categ);
} else if (isset($_POST['btn_categorie_supprimer'])) {
// Action suivante
$this->setSuivant('ValiderSupprimer');
}
}
 
public function executerValiderModifier()
{
if (isset($_POST['btn_categorie_annuler'])) {
// Action suivante
$this->setSuivant('__defaut__');
} else if (isset($_POST['btn_categorie_modifier'])) {
$ProjetCategorie = new ProjetCategorie();
$ProjetCategorie->setIdCategorie($_POST['caaj_id_categorie']);
$ProjetCategorie->setLibelle($_POST['caaj_libelle']);
$ProjetCategorie->setAbreviation($_POST['caaj_abreviation']);
$ProjetCategorie->modifier();
}
}
public function executerValiderAjouter()
{
// Ajout de la catégorie
$ProjetCategorie = new ProjetCategorie();
$bool_existe = $ProjetCategorie->consulter(ProjetCategorie::GPC_LIBELLE, array($_POST['caaj_libelle']));
if ($bool_existe == false) {
$ProjetCategorie->setLibelle($_POST['caaj_libelle']);
$ProjetCategorie->setAbreviation($_POST['caaj_abreviation']);
$ProjetCategorie->ajouter();
} else {
$aso_admin_categ['message'] = 'Cette catégorie existe déjà !';
$this->getRegistre()->ajouterDonnee('admin_categorie', $aso_admin_categ);
}
 
// Action suivante
$this->setSuivant('__defaut__');
}
 
public function executerValiderSupprimer()
{
// Suppression de la catégorie
$ProjetCategorie = new ProjetCategorie();
$ProjetCategorie->setIdCategorie($_POST['casu_id']);
$ProjetCategorie->supprimer();
 
// Mise à jour des projets appartenant à la catégorie
$Projet = new Projet();
$tab_p = $Projet->consulter(Projet::GP_CE_CATEGORIE, $_POST['casu_id']);
if ($tab_p != false) {
foreach ($tab_p as $p) {
$Ancien = clone $p;
$p->setCeCategorie(0);
$p->modifier($Ancien);
}
}
 
// Action suivante
$this->setSuivant('__defaut__');
}
}
?>
/tags/v1.1-thales/actions/GttCtrlActionAdminProjet.class.php
New file
0,0 → 1,208
<?php
class GttCtrlActionAdminProjet extends aControlleurAction {
 
public function __construct(Registre $Registre)
{
$Registre->ajouterEspace('AdminProjet', 'admin_projet');
$Registre->setTitre('Administrer les projets');
}
 
public function executer()
{
$aso_admin_projet = array();
// Récupération des projet
$Projet = new Projet();
// Ajout du projet par défaut
$aso_admin_projet['Projet'] = $Projet;
 
// Récupération des catégories
$ProjetCategorie = new ProjetCategorie();
$aso_admin_projet['categories'] = $ProjetCategorie->consulter(ProjetCategorie::GPC_TOUS);
// Récupération des projets
$tab_p = $Projet->consulter(Projet::GP_TOUS);
if (false == $tab_p) {
$aso_admin_projet['projets'] = false;
} else {
foreach ($tab_p as $Pr) {
$aso_projet['id'] = $Pr->getIdProjet();
$aso_projet['nom'] = $Pr->getNom();
$aso_admin_projet['projets'][] = $aso_projet;
}
}
// Modification des titres, légendes et bouton
$aso_admin_projet['form_legend'] = 'Ajouter un projet';
$aso_admin_projet['form_bouton_value'] = 'Ajouter';
$aso_admin_projet['form_bouton_id'] = 'btn_projet_ajouter';
$aso_admin_projet['form_url'] = 'index.php?action=admin-projet_valider-ajouter';
//echo '<pre>'.print_r($aso_admin_projet, true).'</pre>';
$this->getRegistre()->ajouterDonnee('admin_projet', $aso_admin_projet);
}
 
public function executerEditer()
{
if (isset($_POST['btn_projet_modifier'])) {
// Récupération des données du projet à modifier
$Projet = new Projet();
$Projet->consulter(Projet::GP_ID, $_POST['prsu_id'], true);
$aso_admin_projet['Projet'] = $Projet;
// Récupération des catégories
$ProjetCategorie = new ProjetCategorie();
$aso_admin_projet['categories'] = $ProjetCategorie->consulter(ProjetCategorie::GPC_TOUS);
 
// Ajout de la catégorie par défaut
$ProjetCategorie->consulter(ProjetCategorie::GPC_ID, $Projet->getCeCategorie(), true);
$aso_admin_projet['CategorieDefaut'] = $ProjetCategorie;
//echo '<hr>'.print_r($aso_admin_projet['CategorieDefaut'],true);
// Modification des titres, légendes et bouton
$aso_admin_projet['form_legend'] = 'Modifier une projet';
$aso_admin_projet['form_bouton_value'] = 'Modifier';
$aso_admin_projet['form_bouton_id'] = 'btn_projet_modifier';
$aso_admin_projet['form_url'] = 'index.php?action=admin-projet_valider-modifier';
 
$this->getRegistre()->ajouterDonnee('admin_projet', $aso_admin_projet);
} else if (isset($_POST['btn_projet_supprimer'])) {
// Action suivante
$this->setSuivant('ValiderSupprimer');
}
}
 
public function executerValiderModifier()
{
if (isset($_POST['btn_utilisateur_annuler'])) {
// Action suivante
$this->setSuivant('__defaut__');
} else if (isset($_POST['btn_projet_modifier'])) {
$aso_admin_projet = array();
$bool_modifier = true;
$this->verifierChampsCommuns($aso_admin_projet, $bool_modifier);
if ($bool_modifier) {
// Action suivante
$this->setSuivant('modifier');
} else {
$this->getRegistre()->ajouterDonnee('admin_projet', $aso_admin_projet);
// Action suivante
$this->setSuivant('__defaut__');
}
}
}
public function executerModifier()
{
$Projet = new Projet();
//$Projet->setIdCategorie($_POST['caaj_id_categorie']);
$Projet->setIdProjet($_POST['praj_id_projet']);
$Projet->setCeCategorie($_POST['praj_ce_categorie']);
$Projet->setNom($_POST['praj_nom']);
$Projet->setDescription($_POST['praj_description']);
$Projet->setDateDebut($_POST['praj_date_debut']);
$Projet->setDateFin($_POST['praj_date_fin']);
$Projet->setDureePrevue($_POST['praj_duree_prevue']);
$Projet->setDureeFinance($_POST['praj_duree_finance']);
$Projet->setAvancement($_POST['praj_avancement']);
if ($Projet->modifier()) {
$aso_admin_projet['messages'][] = "Le projet ${_POST['praj_nom']} a été modifié.";
}
// Ajout du message d'information
$this->getRegistre()->ajouterDonnee('admin_projet', $aso_admin_projet);
// Action suivante
$this->setSuivant('__defaut__');
}
public function executerValiderAjouter()
{
$aso_admin_projet = array();
if (isset($_POST['btn_projet_annuler'])) {
// Action suivante
$this->setSuivant('__defaut__');
} else if (isset($_POST['btn_projet_ajouter'])) {
$bool_ajouter = true;
// Vérification de l'existance d'un projet avec le même nom
$Projet = new Projet();
$bool_existe = $Projet->consulter(Projet::GP_NOM, array($_POST['praj_nom']));
if (true == $bool_existe) {
$aso_admin_projet['messages'][] = "Un projet avec un nom identique existe déjà !";
$bool_ajouter = false;
}
$this->verifierChampsCommuns($aso_admin_projet, $bool_ajouter);
$this->getRegistre()->ajouterDonnee('admin_projet', $aso_admin_projet);
if ($bool_ajouter) {
// Action suivante
$this->setSuivant('ajouter');
} else {
// Action suivante
$this->setSuivant('__defaut__');
}
}
}
public function executerAjouter()
{
$aso_admin_projet = array();
$Projet = new Projet();
$Projet->setCeCategorie($_POST['praj_ce_categorie']);
$Projet->setNom($_POST['praj_nom']);
$Projet->setDescription($_POST['praj_description']);
$Projet->setDateDebut($_POST['praj_date_debut']);
$Projet->setDateFin($_POST['praj_date_fin']);
$Projet->setDureePrevue($_POST['praj_duree_prevue']);
$Projet->setDureeFinance($_POST['praj_duree_finance']);
$Projet->setAvancement($_POST['praj_avancement']);
if ($Projet->ajouter()) {
$aso_admin_projet['messages'][] = "Le projet ${_POST['praj_nom']} a été ajouté.";
}
// Ajout du message d'information
$this->getRegistre()->ajouterDonnee('admin_projet', $aso_admin_projet);
// Action suivante
$this->setSuivant('__defaut__');
}
public function verifierChampsCommuns(&$aso_admin_projet, &$bool)
{
if (empty($_POST['praj_nom'])) {
$aso_admin_projet['messages'][] = 'Le nom du projet ne doit pas être vide !';
$bool = false;
}
}
 
public function executerValiderSupprimer()
{
$aso_admin_projet = array();
// Vérif des utilisateur_a_projets
$UtilisateurAProjet = new UtilisateurAProjet();
$bool_existe = $UtilisateurAProjet->consulter(UtilisateurAProjet::GUAP_PROJET, array($_POST['prsu_id']));
if ($bool_existe == false) {
trigger_error('UtilisateurAProjet -> OK', E_USER_NOTICE);
// Vérif des travail_projets
$TravailProjet = new TravailProjet();
$bool_existe = $TravailProjet->consulter(TravailProjet::GTP_PROJET, array($_POST['prsu_id']));
if ($bool_existe == false) {
trigger_error('TravailProjet -> OK', E_USER_NOTICE);
// Suppression du projet
$Projet = new Projet();
$Projet->setIdProjet($_POST['prsu_id']);
if ($Projet->supprimer()) {
$aso_admin_projet['messages'][] = "Le projet a été supprimé.";
}
}
}
// Message d'erreur si le projet contient des données
if ($bool_existe != false) {
$aso_admin_projet['messages'][] = "Il n'est pas possible de supprimer un projet contenant des données!";
}
 
// Enregistrement du message
$this->getRegistre()->ajouterDonnee('admin_projet', $aso_admin_projet);
// Action suivante
$this->setSuivant('__defaut__');
}
}
?>