absences_Entry

Complexity

Total Complexity

282

Size/Duplication

Total Lines	2393
Duplicated Lines	12.95 %

Coupling/Cohesion

Components	1
Dependencies	19

Test Coverage

Coverage

37.69%

Importance

Changes	8
Bugs	4	Features	2

84 Methods

Rating	Name	Duplication	Size	Complexity
A	getElements()	0	4	1
A	addPeriod()	0	4	1
A	getPlannedPeriods()	0	4	1
A	sortElements()	0	4	1
A	addElement()	0	4	1
A	getTotalDays()	17	17	4
A	getTotalHours()	17	17	4
A	requireApproval()	0	17	4
A	getById()	0	7	1
A	getRow()	0	16	3
A	getRequestType()	0	15	3
A	getApprobationId()	0	9	2
A	getElementsIterator()	0	7	1
A	getPlannedPeriodsIterator()	0	7	1
A	getFolderEntriesIterator()	12	12	2
A	addElementsMovements()	0	8	2
A	loadElements()	0	15	3
A	loadPlannedPeriods()	0	21	4
A	getPlannedDurationHours()	14	14	3
A	sortElem()	0	18	3
B	checkElementsDates()	0	14	6
B	getNextValidDate()	0	23	5
A	getFutureDate()	0	8	2
B	getWorkingPeriodsFromDate()	0	23	5
B	getFutureDate_Seconds()	0	30	4
A	getFutureDate_Hours()	0	6	1
C	getWorkingTimeByDay()	6	51	10
B	getSecondsToAdd()	0	30	5
B	getFutureDate_Days_Old()	0	45	6
A	createPlannedPeriods()	0	17	2
B	getPeriodQuantity()	0	27	6
A	getDayDurationInHours()	0	18	3
B	getPeriodType()	0	19	7
B	saveElements()	0	26	3
A	savePlannedPeriods()	0	21	3
A	applyDynamicRight()	0	13	2
A	removeElement()	0	13	3
A	setWorkingPeriodIndex()	0	5	1
B	getWorkingPeriodIndex()	0	25	4
B	loadDurations()	0	27	4
A	getWorkingPeriods()	0	8	2
A	getDayWorkingPeriods()	0	11	3
A	getDayPlannedPeriods()	0	11	3
A	getDurationDays()	0	9	2
A	getDurationHours()	0	9	2
A	daysToHours()	12	12	2
A	hoursToDays()	10	10	2
B	loadedElementsTotal()	0	32	5
A	addQUantityInCache()	0	15	3
B	getPlannedDaysBetween()	30	30	6
B	getPlannedHoursBetween()	30	30	6
A	containsHours()	0	12	3
C	getElement()	0	48	7
A	getPlannedDurationDays()	18	18	3
F	loadDefaultValues()	0	40	10
B	save()	37	82	4
C	setElementsDates()	0	45	7
A	getElementEndGap()	0	15	3
D	getFutureDate_Days()	0	109	14
A	checkAvailable()	0	10	3
A	checkElementsValidity()	0	16	3
A	checkOtherEntriesValidity()	6	21	3
C	checkValidity()	14	105	8
A	modifiedOn()	0	4	1
A	isFixed()	0	5	1
A	isPrevisonal()	0	4	1
A	isFolderPrevisonal()	0	13	2
A	getFolderFirst()	17	17	3
A	onReject()	0	4	1
A	onConfirm()	0	4	1
B	updateCalendar()	0	29	2
A	getTitle()	0	8	3
A	getNotifyFields()	8	8	1
A	getYear()	11	11	2
A	getArchiveYear()	20	20	3
A	archive()	11	11	1
A	setNotified()	16	16	2
A	getManagerEditUrl()	0	6	1
A	getManagerDeleteUrl()	0	9	1
A	getManagerFrame()	0	15	2
C	getCardFrame()	4	74	9
A	getEditUrl()	0	17	3
B	delete()	0	57	8
A	notifyOwner()	0	19	3

<?php
/************************************************************************
 * OVIDENTIA http://www.ovidentia.org                                   *
 ************************************************************************
 * Copyright (c) 2003 by CANTICO ( http://www.cantico.fr )              *
 *                                                                      *
 * This file is part of Ovidentia.                                      *
 *                                                                      *
 * Ovidentia is free software; you can redistribute it and/or modify    *
 * it under the terms of the GNU General Public License as published by *
 * the Free Software Foundation; either version 2, or (at your option)  *
 * any later version.													*
 *																		*
 * This program is distributed in the hope that it will be useful, but  *
 * WITHOUT ANY WARRANTY; without even the implied warranty of			*
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.					*
 * See the  GNU General Public License for more details.				*
 *																		*
 * You should have received a copy of the GNU General Public License	*
 * along with this program; if not, write to the Free Software			*
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,*
 * USA.																	*
************************************************************************/


require_once dirname(__FILE__).'/vacincl.php';
require_once dirname(__FILE__).'/request.class.php';
require_once $GLOBALS['babInstallPath'].'utilit/urlincl.php';


/**
 * Vacation request
 *
 *
 * @property int	$id_user
 * @property string $createdOn
 * @property int	$createdBy
 * @property string	$date_begin
 * @property string	$date_end
 * @property int	$idfai
 * @property string	$comment
 * @property string	$date			Last modification date or approbation date (last action)
 * @property string	$status			'' : unconfirmed ; 'Y' : confirmed ; 'P' : previsional
 * @property string	$comment2		Commentaire approbateur
 * @property int	$id_approver
 * @property int	$folder
 * @property int	$creation_type
 * @property int	$archived
 * 
 *
 */
class absences_Entry extends absences_Request
{

	const CREATION_USER = 0;
	const CREATION_FIXED = 1;




	/**
	 * Memory for saved or unsaved elements of a vacation request
	 * @var array
	 */
	private $elements = array();


	/**
	 * Memory for working periods of a vacation request
	 * they are the working periods saved with the entry at the creation of the request
	 * the periods will remain event after a workschedule modification for the user
	 * @var array
	 */
	private $plannedPeriods = array();

	/**
	 * @var float
	 */
	private $duration_days = null;

	/**
	 * @var float
	 */
	private $duration_hours = null;


	/**
	 * Cache for actual working periods from calendar
	 * @var bab_CalendarPeriod[]
	 */
	private $working_periods;


	/**
	 * cache for total quantity
	 * @var float
	 */
	private $total_days = null;

	/**
	 * cache for total quantity
	 * @var float
	 */
	private $total_hours = null;


	/**
	 * cache for total quantity per type
	 * @var array
	 */
	private $total_type_days = null;

	/**
	 * cache for total quantity per type
	 * @var float
	 */
	private $total_type_hours = null;



	/**
	 * @var array
	 */
	private $workingPeriodIndex = null;
	
	
	/**
	 * @see absences_EntryPeriod::getDurationDays
	 * @var array
	 */
	public $_getDurationDays_halfDays = array();



	/**
	 * @return absences_Entry
	 */
	public static function getById($id)
	{
		$request = new absences_Entry();
		$request->id = $id;

		return $request;
	}


	/**
	 * (non-PHPdoc)
	 * @see absences_Record::getRow()
	 */
	public function getRow()
	{
		if (null === $this->row)
		{
			if (!isset($this->id))
			{
				throw new Exception('Failed to load entry, missing entry id');
			}

			global $babDB;
			$res = $babDB->db_query('SELECT * FROM absences_entries WHERE id='.$babDB->quote($this->id));
			$this->setRow($babDB->db_fetch_assoc($res));
		}

		return $this->row;
	}


	/**
	 * (non-PHPdoc)
	 * @see absences_Request::getRequestType()
	 *
	 * @return string
	 */
	public function getRequestType()
	{
		switch($this->creation_type)
		{
			case '1':
				return absences_translate('Fixed vacation');

			default:
			case '0':

case '0': return absences_translate('Requested vacation'); does not seem to be reachable.

				return absences_translate('Requested vacation');
		}



	}




	public function getApprobationId()
	{
		if ($agent = $this->getAgent())
		{
			return $agent->getApprobationId();
		}

		return null;
	}





	/**
	 * Get elements stored in database
	 * @return absences_EntryElemIterator
	 */
	public function getElementsIterator()
	{
		$I = new absences_EntryElemIterator;
		$I->entry = $this;

		return $I;
	}


	public function getPlannedPeriodsIterator()
	{
	    $I = new absences_EntryPeriodIterator;
	    $I->entry = $this;

	    return $I;
	}



	/**
	 * Get entries within the same folder
	 * @return absences_EntryIterator
	 */
	public function getFolderEntriesIterator()

This method seems to be duplicated in your project.

	{
		if (!$this->folder)
		{
			return null;
		}

		$I = new absences_EntryIterator;
		$I->folder = $this->folder;

The property $folder was declared of type string, but $this->folder is of type integer. Maybe add a type cast?

		return $I;
	}







	/**
	 *
	 * @param string $message	Generated message
	 * @param string $comment	Author comment
	 */
	public function addElementsMovements($message, $comment = '')
	{
		foreach($this->elements as $elem)
		{
			/*@var $elem absences_EntryElem */
			$elem->addMovement($message, $comment);
		}
	}




	/**
	 * Load elements from database
	 * @throws Exception
	 */
	public function loadElements()
	{
		if (!isset($this->id))
		{
			throw new Exception('Failed to load entry elements, id missing');
		}

		$this->elements = array();

		foreach($this->getElementsIterator() as $entryElem)
		{
			/*@var $entryElem absences_EntryElem */
			$this->addElement($entryElem);
		}
	}

	/**
	 * Get the loaded elements
	 * @return array
	 */
	public function getElements()
	{
		return $this->elements;
	}

	/**
	 * Get element by right from the loaded elements
	 * @param int|absences_Right $right
	 * @return absences_EntryElem
	 */
	public function getElement($right)
	{
	    $id_right = $right;
	    if ($right instanceof absences_Right) {
	        $id_right = $right->id; 
	    }
	    
	    
	    if (empty($this->elements)) {
	        // not loaded
	        
	        require_once dirname(__FILE__).'/entry_elem.class.php';
	        
	        global $babDB;
	        
	        $res = $babDB->db_query('SELECT * 
	            FROM absences_entries_elem 
	            WHERE 
	               id_entry='.$babDB->quote($this->id).' 
	               AND id_right='.$babDB->quote($id_right));
	        
	        $row = $babDB->db_fetch_assoc($res);
	        
	        if (!$row) {
	            return null;
	        }
	        
	        $elem = new absences_EntryElem();
	        $elem->setRow($row);
	        
	        if ($right instanceof absences_Right) {
	           $elem->setRight($right);
	        }
	        
	        return $elem;
	    }

	    
	    // already loaded
	    
	    foreach($this->elements as $element) {
	        if ($element->id_right == $id_right) {
	            return $element;
	        }
	    }

	    return null;
	}
	
	
	
	/**
	 * Add a planned period
	 * @param absences_EntryPeriod $plannedPeriod
	 */
	public function addPeriod(absences_EntryPeriod $plannedPeriod)
	{
	    $this->plannedPeriods[] = $plannedPeriod;
	}




	/**
	 * Load the planned working periods from database
	 * @throws Exception
	 */
	public function loadPlannedPeriods()
	{
	    if (!isset($this->id))
	    {
	        throw new Exception('Failed to load entry periods, id missing');
	    }

	    $this->plannedPeriods = array();

	    $res = $this->getPlannedPeriodsIterator();

	    if (0 === $res->count()) {
	        return $this->createPlannedPeriods();
	    }

	    foreach($res as $plannedPeriod)
	    {
	        /*@var $plannedPeriod absences_EntryPeriod */
	        $this->addPeriod($plannedPeriod);
	    }
	}

	/**
	 * Get the loaded planned working periods
	 * @return absences_EntryPeriod[]
	 */
	public function getPlannedPeriods()
	{
	    return $this->plannedPeriods;
	}


	/**
	 * Get planned duration
	 *
	 * @param string $begin    Optional limit to use for duration
	 * @param string $end      Optional limit to use for duration
	 *
	 * @return float
	 */
	public function getPlannedDurationDays($begin = null, $end = null)

This method seems to be duplicated in your project.

	{
	    if (empty($this->plannedPeriods)) {
	        $this->loadPlannedPeriods();
	    }

	    $total = 0.0;

	    foreach ($this->getPlannedPeriods() as $entryPeriod) {
	        $total += $entryPeriod->getDurationDays($begin, $end);
	    }
	    

	    
	     

	    return $total;
	}


	/**
	 * Get planned duration
	 *
	 * @param string $begin    Optional limit to use for duration
	 * @param string $end      Optional limit to use for duration
	 *
	 * @return float
	 */
	public function getPlannedDurationHours($begin = null, $end = null)

This method seems to be duplicated in your project.

	{
	    if (empty($this->plannedPeriods)) {
	        $this->loadPlannedPeriods();
	    }

	    $total = 0.0;

	    foreach ($this->getPlannedPeriods() as $entryPeriod) {
	        $total += $entryPeriod->getDurationHours($begin, $end);
	    }

	    return $total;
	}

	
	public function loadDefaultValues()
	{
	    
	    if (!isset($this->createdOn)) {
	        $this->createdOn = date('Y-m-d H:i:s');
	    }
	    
	    if (!isset($this->date)) {
	        $this->date = date('Y-m-d H:i:s');
	    }
	    
	    if (!isset($this->comment)) {
	        $this->comment = '';
	    }
	    
	    if (!isset($this->comment2)) {
	        $this->comment2 = '';
	    }
	    
	    if (!isset($this->idfai)) {
	        $this->idfai = '0';
	    }
	    
	    if (!isset($this->status)) {
	        $this->status = 'N';
	    }
	    
	    if (!isset($this->id_approver)) {
	        $this->id_approver = '0';
	    }
	    
	    if (!isset($this->folder)) {
	        $this->folder = '0';
	    }
	    
	    if (!isset($this->creation_type)) {
	        $this->creation_type = '0';
	    }
	    
	}


	/**
	 * Save entry to database
	 * without validity checking
	 *
	 * @return bool
	 */
	public function save()
	{
		// save entry

		global $babDB;

        $this->loadDefaultValues();

		if (isset($this->id))
		{
			$req = "
				UPDATE absences_entries
				SET
					`date`			=".$babDB->quote($this->date).",
					date_begin		=".$babDB->quote($this->date_begin).",
					date_end		=".$babDB->quote($this->date_end).",
					comment			=".$babDB->quote($this->comment).",
					idfai			=".$babDB->quote($this->idfai).",
					status			=".$babDB->quote($this->status).",
					comment2		=".$babDB->quote($this->comment2).",
					id_approver		=".$babDB->quote($this->id_approver).",
					folder			=".$babDB->quote($this->folder).",
					creation_type	=".$babDB->quote($this->creation_type)."
			";
			
			if (isset($this->todelete))
			{
			    $req .= ", todelete=".$babDB->quote($this->todelete);
			}

			if (isset($this->appr_notified))
			{
				$req .= ", appr_notified=".$babDB->quote($this->appr_notified);
			}


			$req .= " WHERE
					id=".$babDB->quote($this->id)." ";

			$babDB->db_query($req);


		} else {

This code seems to be duplicated across your project.

			$babDB->db_query("
				INSERT INTO absences_entries
				(
					id_user,
					date_begin,
					date_end,
					comment,
					`createdOn`,
					`date`,
					idfai,
					status,
					comment2,
					id_approver,
					folder,
					creation_type
				)
				VALUES
				(
					".$babDB->quote($this->id_user).",
					".$babDB->quote($this->date_begin).",
					".$babDB->quote($this->date_end).",
					".$babDB->quote($this->comment).",
					".$babDB->quote($this->createdOn).",
					".$babDB->quote($this->date).",
					".$babDB->quote($this->idfai).",
					".$babDB->quote($this->status).",
					".$babDB->quote($this->comment2).",
					".$babDB->quote($this->id_approver).",
					".$babDB->quote($this->folder).",
					".$babDB->quote($this->creation_type)."
				)
			");

			$this->id = $babDB->db_insert_id();
		}


	}


	/**
	 * Sort the loaded element by right order, type name
	 */
	public function sortElements()
	{
	    usort($this->elements, array('absences_Entry', 'sortElem'));
	}

	private static function sortElem(absences_EntryElem $elem1, absences_EntryElem $elem2)
	{
	    $right1 = $elem1->getRight();
	    $right2 = $elem2->getRight();

	    if ($right1->sortkey > $right2->sortkey) {
	        return 1;
	    }

	    if ($right1->sortkey < $right2->sortkey) {
	        return -1;
	    }

	    $type1 = $right1->getType();
	    $type2 = $right2->getType();

	    return bab_compare(mb_strtolower($type1->name), mb_strtolower($type2->name));
	}
	
	
	/**
	 * Verifier si les dates des elements sont correctement parametres
	 * en cas de modificiation de la quantite, toujours mettre les dates a zero
	 * @return bool
	 */
	public function checkElementsDates()
	{
	    foreach($this->elements as $elem) {
	        if (!isset($elem->date_begin) || '0000-00-00 00:00:00' === $elem->date_begin) {
	            return false;
	        }
	        
	        if (!isset($elem->date_end) || '0000-00-00 00:00:00' === $elem->date_end) {
	            return false;
	        }
	    }
	    
	    return true;
	}


	/**
	 * Add dates to loaded elements using the user calendar
	 */
	public function setElementsDates()
	{
	    include_once $GLOBALS['babInstallPath']."utilit/dateTime.php";

	    if (0 === count($this->elements)) {
	        throw new absences_EntryException('No elements to set dates on, id_entry='.$this->id.', owner='.$this->getUserName());
	    }
	    
	    if ($this->checkElementsDates()) {
	        // dates allready set
	        // calling getFutureDate twice does not work
	        return;
	    }

	    if (1 === count($this->elements)) {
	        $element = reset($this->elements);
	        /*@var $element absences_EntryElem */
	        $element->date_begin = $this->date_begin;
	        $element->date_end = $this->date_end;
	        return;
	    }
	    
	    $this->sortElements();
        
	    $loop = BAB_DateTime::fromIsoDateTime($this->date_begin);

	    foreach($this->elements as $element) {
	        /*@var $element absences_EntryElem */
	        $element->date_begin = $loop->getIsoDateTime();
	        
	        $loop = $this->getFutureDate($loop, (float) $element->quantity, $element->getRight()->quantity_unit);
	        $element->date_end = $loop->getIsoDateTime();
	        
	        if ($element->date_end > $this->date_end) {
	            $element->date_end = $this->date_end;
	        }
	        
	        $loop = $this->getNextValidDate($loop);
	    }
	    
	    // round the last half day to the request period end
	    if ($this->getElementEndGap() <= 3600) {
	        $this->elements[count($this->elements)-1]->date_end = $this->date_end;
	    }
	}
	
	/**
	 * Get the gap beetween the last element end date and the period end date
	 * @return int
	 */
	protected function getElementEndGap()
	{
	    $computedLastDate = bab_mktime($this->elements[count($this->elements)-1]->date_end);
	    $periodEnd = bab_mktime($this->date_end);
	     
	    if ($periodEnd > $computedLastDate) {
	         return ($periodEnd - $computedLastDate);
	    }
	    
	    if ($computedLastDate > $periodEnd) {
	        return ($computedLastDate - $periodEnd);
	    }
	    
	    return 0;
	}


	/**
	 * set the date to the next valid date
	 * @param BAB_DateTime $date
	 * @return BAB_DateTime
	 */
	protected function getNextValidDate(BAB_DateTime $date)
	{
	    $moment = $date->getTimeStamp();

	    foreach ($this->getWorkingPeriods() as $period) {

The expression $this->getWorkingPeriods() of type null|array<integer,object<bab_CalendarPeriod>> is not guaranteed to be traversable. How about adding an additional type check?

	        if ($moment >= $period->ts_end) {
	            continue;
	        }

	        // if the future date (end date of the element) is in a worked period
	        // the future date is valid as a next date
	        if ($moment < $period->ts_end && $moment > $period->ts_begin) {
	            return $date;
	        }


	        return BAB_DateTime::fromTimeStamp($period->ts_begin);
	    }


	    return $date;
	}



	/**
	 * Add quantity to startdate only on working periods
	 *
	 * @param BAB_DateTime $startdate
	 * @param float $quantity
	 * @param string $quantity_unit D|H
	 *
	 * @return BAB_DateTime
	 */
	protected function getFutureDate(BAB_DateTime $startdate, $quantity, $quantity_unit)
	{
	    if ('H' === $quantity_unit) {
	        return $this->getFutureDate_Hours($startdate, $quantity);
	    }

	    return $this->getFutureDate_Days($startdate, $quantity);
	}


	/**
	 * Split working periods
	 * @return array
	 */
	protected function getWorkingPeriodsFromDate(BAB_DateTime $startdate)
	{
	    $periods = array();
	    $start = $startdate->getTimeStamp();

	    foreach ($this->getWorkingPeriods() as $period) {

The expression $this->getWorkingPeriods() of type null|array<integer,object<bab_CalendarPeriod>> is not guaranteed to be traversable. How about adding an additional type check?

	        if ($start >= $period->ts_end) {
	            // continue to the next worked period
	            continue;
	        }

	        if ($start > $period->ts_begin && $start < $period->ts_end) {
	            $period->setBeginDate($startdate);
	            $periods[] = $period;
	            continue;
	        }

	        $periods[] = $period;
	    }

	    return $periods;
	}



	/**
	 * Add quantity to startdate only on working periods
	 *
	 * @param BAB_DateTime $startdate
	 * @param float $seconds_to_add
	 *
	 * @return BAB_DateTime
	 */
	protected function getFutureDate_Seconds(BAB_DateTime $startdate, $seconds_to_add)
	{
	    $worked_total = 0; //seconds


	    foreach ($this->getWorkingPeriodsFromDate($startdate) as $period) {

	        $add_in_period = ($seconds_to_add - $worked_total);
	        $worked_total += $period->getDuration();

	        if ((int) $worked_total === (int) $seconds_to_add) {
	            // la duree de la periode de travail est egale a duree demandee
	            // en tenant compte des periodes de travail precedentes

	            return BAB_DateTime::fromTimeStamp($period->ts_end);
	        }


            if ($worked_total > $seconds_to_add) {
                // la date future se trouve a l'interieur d'une periode travaillee
                $futureDate = $period->ts_begin + $add_in_period;
                return BAB_DateTime::fromTimeStamp($futureDate);
            }

            // continue to the next worked period

	    }

	    return BAB_DateTime::fromIsoDateTime($this->date_end);
	}






	/**
	 * Add quantity to startdate only on working periods
	 *
	 * @param BAB_DateTime $startdate
	 * @param float $quantity  hours
	 *
	 * @return BAB_DateTime
	 */
	protected function getFutureDate_Hours(BAB_DateTime $startdate, $quantity)
	{
	    $seconds_to_add = $quantity * 3600;

	    return $this->getFutureDate_Seconds($startdate, $seconds_to_add);
	}
	
	
	/**
	 * periodes travailles, durees et types a partir d'une date
	 * 
	 * duration: seconds
	 * type: AMPM | AM | PM
	 * dayend: timestamp
	 * 
	 * @param BAB_DateTime $startdate
	 * @return array
	 */
	protected function getWorkingTimeByDay(BAB_DateTime $startdate)
	{
	    $start = $startdate->getTimeStamp();
	    $days = array();
	    foreach ($this->getWorkingPeriods() as $period) {

The expression $this->getWorkingPeriods() of type null|array<integer,object<bab_CalendarPeriod>> is not guaranteed to be traversable. How about adding an additional type check?

	        
	        
	        if ($start >= $period->ts_end) {
	            continue;
	        }
	        
	        
	        
	        $d = date('Y-m-d', $period->ts_begin);
	        
	        if (!isset($days[$d])) {
	            
	            $days[$d] = array(
	                'duration' => 0,
	                'type' => null,
	                'dayend' => null
	            );
	        }
	        
	            
	        $days[$d]['duration'] += $period->getDuration();
	        
	        if ($period->ts_end > $days[$d]['dayend']) {
	            $days[$d]['dayend'] = $period->ts_end;
	        }
	        
	        
	        $type = $this->getPeriodType($period);
	        
	        if ('AM' === $days[$d]['type'] && 'PM' === $type) {

This code seems to be duplicated across your project.

	            $days[$d]['type'] = 'AMPM';
	        }
	        
	        if ('PM' === $days[$d]['type'] && 'AM' === $type) {

This code seems to be duplicated across your project.

	            $days[$d]['type'] = 'AMPM';
	        }
	        
	        if (!isset($days[$d]['type'])) {
	            $days[$d]['type'] = $type;
	        }
	    }
	    
	    
	    
	    return $days;
	}
	
	
	

	
	
	
	
	/**
	 * Add quantity to startdate only on working periods
	 *
	 * @param BAB_DateTime $startdate
	 * @param float $quantity  days
	 *
	 * @return BAB_DateTime
	 */
	protected function getFutureDate_Days(BAB_DateTime $startdate, $quantity)
	{
	    
	    $return = clone $startdate;
	    
	    $morning = clone $startdate;
	    $morning->setIsoTime('00:00:00');
	    
	    $days = $this->getWorkingTimeByDay($morning);
	    
	    
	    $seconds_to_add = 0;

	    
	    // traiter les jours entiers
	    
	    $fulldays = $lastfulldays = (float) floor($quantity);
	    $lastquantity = $quantity;
	    $lastdays = $days;
	    $day = key($days);

$day is not used, you could remove the assignment.

	    
	    $pos = 0;
	    if (0 < $fulldays) {

	        foreach($days as $keyday => $arr) {

	            $dayquantity = 'AMPM' === $arr['type'] ? 1.0 : 0.5;

	            $lastfulldays -= $dayquantity;

	            if ($lastfulldays <= 0) {
	                $lastquantity = $quantity - $fulldays - $lastfulldays;

	                if ($pos > 0) {
	                    $lastdays = array_slice($days, $pos, null, true);
	                    
	                } else {
	                    $lastdays = $days;
	                }

	                $day = $keyday;

$day is not used, you could remove the assignment.

	                
	                break;
	            }

	            $pos++;
	        }
	        
	        
	        

	        
	        if ($fulldays > 0 && $lastquantity <= 0) {
	            
	            
	            
	            // il ne reste pas de temps a appliquer sur la date
	            // on se place donc a la fin d'une periode travaillee

	            reset($days);
	            for($i=0; $i<$fulldays-1; $i++) {
	                next($days);
	            }
	            
	            $newstart = current($days);
	            $return = BAB_DateTime::fromTimeStamp($newstart['dayend']);
	            
	            //echo $fulldays.' '.$startdate->getIsoDateTime().' -> '.$return->getIsoDateTime()."\n";
	            
	        } else {
	            
	            // il reste du temps a ajouter sur la date
	            // on ajoute juste le nombre de jours complets
	            
	            $return->add($fulldays, BAB_DATETIME_DAY);
	        }
	        
	        
	        
	        // si la date de debut est supperieur a la date d'ouverture de la premiere periode travaillee
	        // on considere que la date de debut est sur la prochaine periode travaillee, par exemple commence l'apres-midi
	        $start = reset($days);
	        $fromstart = $this->getWorkingTimeByDay($startdate);
	        $firstday = reset($fromstart);
	        $missing_duration = $start['duration'] - $firstday['duration'];
	        if ($missing_duration > 0) {
	            // var_dump($startdate->getIsoDateTime().' '.($missing_duration/3600).'H');
	            $seconds_to_add = $missing_duration;
	        }
	    }
	    
	    
	    
	    if ($seconds_to_add === 0 && ($lastquantity <= 0 || !isset($lastdays))) {
	        return $return;
	    }
	    
	    $seconds_to_add += $this->getSecondsToAdd($lastdays, $lastquantity);
	    
	    
	    if (0 === $seconds_to_add) {
	        return $return;
	    }

	    
	    $return = $this->getFutureDate_Seconds($return, $seconds_to_add);
	    
	    return $return;
	}
	
	
	/**
	 * Trouver le nombre de secondes a ajouter a une date pour une quantite 
	 * @param array $lastdays      Jours restants sur la periode
	 * @param float $lastquantity  Nombre de jours a ajouter, uniquement les jours incomplets de la fin de periode, les jours complets ont ete traites avant
	 * 
	 */
	protected function getSecondsToAdd(Array $lastdays, $lastquantity)
	{
	    $seconds_to_add = 0;
	    
	    //var_dump('lastquantity: '.$lastquantity);
	    
	    // trouver les heures a partir de la quantite restante
	    
	    foreach($lastdays as $keyday => $arr) {
	        
	        $q = 'AMPM' === $arr['type'] ? 1.0 : 0.5;
	    
	        if ($lastquantity > $q) {
	            $lastquantity -= $q;
	            continue;
	        }
	    
	        //var_dump(($arr['duration']/3600).' '.$lastquantity.' '.$arr['type'].' '.$q);
	        
	        if ($lastquantity == $q) {
	            $seconds_to_add = $arr['duration'];
	            break;
	        }
	    
	        $seconds_to_add = $arr['duration'] * $lastquantity;
	        break;
	    }
	    
	    return $seconds_to_add;
	}
	
	

	/**
	 * Add quantity to startdate only on working periods
	 * 
	 * @deprecated probleme avec les periodes a cheval sur 12:00 conbinne aux quantites inferieurs a 1 jour
	 *
	 * @param BAB_DateTime $startdate
	 * @param float $quantity  days
	 *
	 * @return BAB_DateTime
	 */
	protected function getFutureDate_Days_Old(BAB_DateTime $startdate, $quantity)
	{
	    
	    $start = $startdate->getTimeStamp();

	    $periods_quantity = 0; // days

        // get the number of worked hours from startdate to the end of the day
 
	    foreach ($this->getWorkingPeriods() as $period) {

The expression $this->getWorkingPeriods() of type null|array<integer,object<bab_CalendarPeriod>> is not guaranteed to be traversable. How about adding an additional type check?

	        if ($start >= $period->ts_end) {
	            // continue to the next worked period
	            //var_dump('working period ignored, start='.bab_shortDate($start, true).' >= '.bab_shortDate($period->ts_end, true));
	            continue;
	        }

	        $periods_quantity += $this->getPeriodQuantity($startdate, $period);
	        

	        if ($periods_quantity >= $quantity) {

	            $overhead = $periods_quantity - $quantity;

	            $futureDate = BAB_DateTime::fromTimeStamp($period->ts_end);

	            // var_dump($futureDate->getIsoDateTime().' overhead='.$overhead.' ('.$periods_quantity.' - '.$quantity.')');

	            if ($overhead) {
	                $futureDate->less(
	                    3600 * $this->getDayDurationInHours($futureDate->getIsoDate(), $overhead),
	                    BAB_DATETIME_SECOND
	                );
	            }

	            if ($futureDate->getIsoDateTime() > $this->date_end) {
	                $futureDate = BAB_DateTime::fromIsoDateTime($this->date_end);
	            }

	            return $futureDate;
	        }
	    }

	    return BAB_DateTime::fromIsoDateTime($this->date_end);
	}


	/**
	 * Create the planned periods in the entry boundaries
	 * from the calendar working periods
	 */
	public function createPlannedPeriods()
	{
	    require_once dirname(__FILE__).'/entry_period.class.php';
	    $this->plannedPeriods = array();

	    foreach ($this->getWorkingPeriods() as $workingPeriod) {

The expression $this->getWorkingPeriods() of type null|array<integer,object<bab_CalendarPeriod>> is not guaranteed to be traversable. How about adding an additional type check?

	        /*@var $workingPeriod bab_CalendarPeriod */

	        $plannedPeriod = new absences_EntryPeriod();
	        $plannedPeriod->setEntry($this);
	        $plannedPeriod->date_begin = date('Y-m-d H:i:s', $workingPeriod->ts_begin);
	        $plannedPeriod->date_end = date('Y-m-d H:i:s', $workingPeriod->ts_end);

	        $this->plannedPeriods[] = $plannedPeriod;
	    }
	}


	/**
	 * Get period quantity in days from a datetime
	 *
	 * @param BAB_DateTime         $startdate
	 * @param bab_CalendarPeriod   $p
	 *
	 * @return float
	 */
	protected function getPeriodQuantity(BAB_DateTime $startdate, bab_CalendarPeriod $p)
	{
	    $type = $this->getPeriodType($p);

	    if ('AMPM' === $type) {
	        $period_days = 1.0;
	    }

	    if ('AM' === $type || 'PM' === $type) {
	        $period_days = 0.5;
	    }

	    $moment = $startdate->getTimeStamp();
	    
	    
	    if ($moment > $p->ts_begin && $moment < $p->ts_end) {
	        $period_seconds = $p->getDuration();
	        $new_period = clone $p;
	        $new_period->setBeginDate($startdate);

	        $new_seconds = $new_period->getDuration();

	        $period_days = ($new_seconds * $period_days) / $period_seconds;

The variable $period_days does not seem to be defined for all execution paths leading up to this point.

	    }

	    return $period_days;
	}




	/**
	 * Convert days to hours
	 * using the number of hours in a specified day
	 * the number of days given as parameter should be less than 1
	 *
	 * @param string $date     Must be a date in the entry period
	 * @param float $days
	 *
	 * @return float   Hours
	 */
	protected function getDayDurationInHours($date, $days)
	{
	    $hours_in_day = 0;

        foreach ($this->getWorkingPeriods() as $p) {

The expression $this->getWorkingPeriods() of type null|array<integer,object<bab_CalendarPeriod>> is not guaranteed to be traversable. How about adding an additional type check?

            $pdate = date('Y-m-d', $p->ts_begin);

            if ($pdate !== $date) {
                continue;
            }

            $hours_in_day += ($p->getDuration()/3600);
        }

        $hours = ($days * $hours_in_day);

        return $hours;
	}




	/**
	 *
	 *
	 * @param bab_CalendarPeriod $period
	 *
	 * @return AM | PM | AMPM
	 */
	protected function getPeriodType(bab_CalendarPeriod $period)
	{
	    $endtype = date('A', $period->ts_end);
	    $begintype = date('A', $period->ts_begin);

	    if ('AM' === $endtype || '12:00:00' === date('H:i:s', $period->ts_end)) { //  || 'AM' === $begintype  && '14:00:00' >= date('H:i:s', $period->ts_end)
	        return 'AM';
	    }
	    
	    if ('AM' === $begintype && '14:00:00' >= date('H:i:s', $period->ts_end)) {
	        return 'AM';
	    }

	    if ('PM' === $begintype || '12:00:00' === date('H:i:s', $period->ts_begin)) {
	        return 'PM';
	    }
	    
	    return 'AMPM';
	}




	/**
	 * Save elements of entry to database
	 *
	 */
	public function saveElements()
	{
		$processed_ids = array();

		foreach ($this->elements as $elem)
		{
			/*@var $elem absences_EntryElem */
		    
		    try {
		    
    			$elem->save();
    			$processed_ids[] = $elem->id;
    			
		    } catch(Exception $e) {
		        // fail to save one element, it will be deleted or not created
		        bab_debug($e->getMessage());
		    }
		}

		// delete removed elements

		global $babDB;

		$babDB->db_query('DELETE FROM absences_entries_elem WHERE id_entry='.$babDB->quote($this->id).' AND id NOT IN('.$babDB->quote($processed_ids).')');

	}




	public function savePlannedPeriods()
	{
	    if (empty($this->plannedPeriods)) {
	        throw new Exception('Planned periods where not loaded or set');
	    }

	    $processed_ids = array();

	    foreach ($this->plannedPeriods as $period)
	    {
	        /*@var $elem absences_EntryPeriod */
	        $period->save();

	        $processed_ids[] = $period->id;
	    }

	    global $babDB;

	    $babDB->db_query('DELETE FROM absences_entries_periods WHERE id_entry='.$babDB->quote($this->id).' AND id NOT IN('.$babDB->quote($processed_ids).')');

	}



	/**
	 * Apply dynamic rights for all right involved in the entry
	 */
	public function applyDynamicRight()
	{
		require_once dirname(__FILE__).'/agent_right.class.php';

		$I = new absences_AgentRightManagerIterator();
		$I->setAgent($this->getAgent());

		foreach ($I as $agentRight)
		{
			/*@var $agentRight absences_AgentRight */
			$agentRight->applyDynamicRight();
		}
	}




	/**
	 * Add element to list
	 * @param absences_EntryElem $elem
	 */
	public function addElement(absences_EntryElem $elem)
	{
		$this->elements[] = $elem;
	}

	/**
	 * Remove an element in the list
	 * @param int $id_right
	 *
	 * @return bool
	 */
	public function removeElement($id_right)
	{
		foreach ($this->elements as $key => $elem)
		{
			if ($elem->id_right == $id_right)
			{
				unset($this->elements[$key]);
				return true;
			}
		}

		return false;
	}


	/**
	 * Set the working period index for the entry
	 * Used in unit tests to set differents working periods
	 * if not used, the workingPeriodIndex will be generated from the calendar API
	 *
	 */
	public function setWorkingPeriodIndex(Array $index_working)
	{
	    $this->workingPeriodIndex = $index_working;
	    return $this;
	}

	/**
	 * Get working period index for the user and for the period
	 * @return array
	 */
	private function getWorkingPeriodIndex()
	{
	    if (!isset($this->workingPeriodIndex)) {

	        include_once $GLOBALS['babInstallPath']."utilit/dateTime.php";

	        list($index_working,, $is_free) = absences_getHalfDaysIndex(
	            $this->id_user,
	            BAB_DateTime::fromIsoDateTime($this->date_begin),
	            BAB_DateTime::fromIsoDateTime($this->date_end),
	            true
	        );


	        foreach ($index_working as $key => $period_list) {
	            if (!isset($is_free[$key])) {
	                unset($index_working[$key]);
	            }
	        }

	        $this->workingPeriodIndex = $index_working;
	    }

	    return $this->workingPeriodIndex;
	}



	/**
	 * Number of free days and hours between two dates
	 *
	 */
	private function loadDurations() {

		$this->duration_days 	= 0.0;
		$this->duration_hours 	= 0.0;
		$this->working_periods = array();



		$index_working = $this->getWorkingPeriodIndex();


		foreach ($index_working as $key => $period_list) {

			$this->duration_days += 0.5;

			foreach($period_list as $p)
			{
				/*@var $p bab_CalendarPeriod */

				if ($p->getCollection() instanceof bab_WorkingPeriodCollection)
				{
				    $this->working_periods[] = $p;
					$this->duration_hours 	+= ($p->getDuration() / 3600);
				}
			}
		}
	}


	/**
	 * Get list of working periods of the entry
	 * @return bab_CalendarPeriod[]
	 */
	protected function getWorkingPeriods()
	{
	    if (!isset($this->working_periods)) {
	        $this->loadDurations();
	    }

	    return $this->working_periods;
	}


	/**
	 * List of working periods for one day
	 * @param string $date 10 chars
	 *
	 * @return bab_CalendarPeriod[]
	 */
	public function getDayWorkingPeriods($date)
	{
	    $return = array();
	    foreach ($this->getWorkingPeriods() as $period) {

The expression $this->getWorkingPeriods() of type null|array<integer,object<bab_CalendarPeriod>> is not guaranteed to be traversable. How about adding an additional type check?

	        if ($date === date('Y-m-d', $period->ts_begin)) {
	            $return[] = $period;
	        }
	    }

	    return $return;
	}


	/**
	 * List of working periods for one day
	 * @param string $date 10 chars
	 *
	 * @return absences_EntryPeriod[]
	 */
	public function getDayPlannedPeriods($date)
	{
	    $return = array();
	    foreach ($this->getPlannedPeriodsIterator() as $period) {
	        if ($date === substr($period->date_begin, 0, 10)) {
	            $return[] = $period;
	        }
	    }

	    return $return;
	}




	/**
	 * Get period duration in days
	 * @return float
	 */
	public function getDurationDays()
	{
		if (!isset($this->duration_days))
		{
			$this->loadDurations();
		}

		return $this->duration_days;
	}

	/**
	 * Get period duration in hours
	 * @return float
	 */
	public function getDurationHours()
	{
		if (!isset($this->duration_hours))
		{
			$this->loadDurations();
		}

		return $this->duration_hours;
	}


	/**
	 * Convert a number of days to hours
	 * @param float $days
	 * @return float
	 */
	private function daysToHours($days)

This method seems to be duplicated in your project.

	{
	    
	    
		if (0 === (int) round(100 * $this->getTotalDays()))
		{
			return 0;
		}

		$ratio = $this->getPlannedDurationHours() / $this->getPlannedDurationDays();
		return round(($ratio * $days), 2);
	}

	/**
	 * Convert a number of hours to days
	 * @param float $hours
	 * @return float
	 */
	private function hoursToDays($hours)

This method seems to be duplicated in your project.

	{
		if (0 == $this->getTotalHours())
		{
			return 0;
		}

		$ratio = $this->getPlannedDurationDays() / $this->getPlannedDurationHours();
		return round(($ratio * $hours), 2);
	}



	/**
	 * Compute totals for loaded elements
	 */
	private function loadedElementsTotal()
	{
		if (empty($this->elements))
		{
			$this->loadElements();
		}

		$this->total_days = 0.0;
		$this->total_hours = 0.0;
		$this->total_type_days = array();
		$this->total_type_hours = array();

It seems like array() of type array is incompatible with the declared type double of property $total_type_hours.

		foreach($this->elements as $elem)
		{
			/*@var $elem absences_EntryElem */
			$right = $elem->getRight();

			$quantity = (float) $elem->quantity;

			switch($right->quantity_unit)
			{
				case 'D':
					$hours = $this->daysToHours($quantity);
					$this->addQUantityInCache($right, $quantity, $hours);
					break;
				case 'H':
				    $days = $this->hoursToDays($quantity);
				    $this->addQUantityInCache($right, $days, $quantity);
					break;
			}
		}
	}


	/**
	 * Populate the cache variables for one element
	 *
	 * @param absences_Right $right
	 * @param float $days
	 * @param float $hours
	 */
	private function addQUantityInCache(absences_Right $right, $days, $hours)
	{
	    if (!isset($this->total_type_days[$right->id_type])) {
	        $this->total_type_days[$right->id_type] = 0.0;
	    }

	    if (!isset($this->total_type_hours[$right->id_type])) {
	        $this->total_type_hours[$right->id_type] = 0.0;
	    }

	    $this->total_days += $days;
	    $this->total_hours += $hours;
	    $this->total_type_days[$right->id_type] += $days;
	    $this->total_type_hours[$right->id_type] += $hours;
	}





	/**
	 * Get sum of elements quantity, converted in days
	 *
	 * @param int $id_type Optional filter by type
	 *
	 * @return float
	 */
	public function getTotalDays($id_type = null)

This method seems to be duplicated in your project.

	{
		if (!isset($this->total_days)) {
			$this->loadedElementsTotal();
		}

		if (isset($id_type)) {

		    if (!isset($this->total_type_days[$id_type])) {
		        return 0.0;
		    }

		    return $this->total_type_days[$id_type];
		}

		return $this->total_days;
	}

	/**
	 * Get sum of elements quantity, converted in hours
	 *
	 * @param int $id_type Optional filter by type
	 *
	 * @return float
	 */
	public function getTotalHours($id_type = null)

This method seems to be duplicated in your project.

	{
		if (!isset($this->total_hours)) {
			$this->loadedElementsTotal();
		}

		if (isset($id_type)) {

		    if (!isset($this->total_type_hours[$id_type])) {
		        return 0.0;
		    }

		    return $this->total_type_hours[$id_type];
		}

		return $this->total_hours;
	}




	/**
	 * Number of days on entry between two dates
	 * si les dates de l'element sont a cheval sur la periode demandee
	 * on utlise les heures travailles qui etait en vigeur au moment de la creation
	 * de la demande
	 *
	 * @param string   $begin	Datetime
	 * @param string   $end		Datetime
	 * @param int      $id_type Optional filter by type
	 *
	 * @return float (days)
	 */
	public function getPlannedDaysBetween($begin, $end, $id_type = null)

This method seems to be duplicated in your project.

	{
	    if (empty($this->elements))
	    {
	        $this->loadElements();
	    }

	    $total = 0.0;
	    foreach($this->elements as $elem)
	    {
	        /*@var $elem absences_EntryElem */
	        $right = $elem->getRight();

	        if (isset($id_type) && (int) $id_type !== (int) $right->id_type) {
	            continue;
	        }

	        $quantity = $elem->getPlannedQuantityBetween($begin, $end);

	        if ('H' === $right->quantity_unit) {
	            $days = $this->hoursToDays($quantity);
	        } else {
	            $days = $quantity;
	        }

	        $total += $days;
	    }

	    return $total;
	}




	/**
	 * Number of hours on entry between two dates
	 * si les dates de l'element sont a cheval sur la periode demandee
	 * on utlise les heures travailles qui etait en vigeur au moment de la creation
	 * de la demande
	 *
	 * @param string   $begin	Datetime
	 * @param string   $end		Datetime
	 * @param int      $id_type Optional filter by type
	 *
	 * @return float (hours)
	 */
	public function getPlannedHoursBetween($begin, $end, $id_type = null)

This method seems to be duplicated in your project.

	{
	    if (empty($this->elements))
	    {
	        $this->loadElements();
	    }

	    $total = 0.0;
	    foreach($this->elements as $elem)
	    {
	        /*@var $elem absences_EntryElem */
	        $right = $elem->getRight();

	        if (isset($id_type) && (int) $id_type !== (int) $right->id_type) {
	            continue;
	        }

	        $quantity = $elem->getPlannedQuantityBetween($begin, $end);

	        if ('D' === $right->quantity_unit) {
	            $hours = $this->daysToHours($quantity);
	        } else {
	            $hours = $quantity;
	        }

	        $total += $hours;
	    }

	    return $total;
	}








	/**
	 * Test if the loaded elements in entry contains rights in hours
	 * @return bool
	 */
	public function containsHours()
	{
		foreach($this->elements as $elem)
		{
			if ('H' === $elem->getRight()->quantity_unit)
			{
				return true;
			}
		}

		return false;
	}


	/**
	 * Test if loaded elements in entry require approval
	 *
	 * @return bool
	 */
	public function requireApproval()
	{
		if (empty($this->elements))
		{
			$this->loadElements();
		}

		foreach($this->elements as $elem)
		{
			if (1 === (int) $elem->getRight()->require_approval)
			{
				return true;
			}
		}

		return false;
	}
	
	
	public function checkAvailable()
	{
	    $res = $this->getElementsIterator();
	    foreach ($res as $element) {
	        /*@var $element absences_EntryElem */
	        if (!$element->isQuantityAvailable()) {
	            throw new Exception(sprintf(absences_translate('Failed to submit this request, the quantity for right %s s not available'), $element->getRight()->description));
	        }
	    }
	}

	
	/**
	 * Check elements validity
	 * @throws UnexpectedValueException
	 * 
	 * @return int number of elements with quantity > 0
	 */
	protected function checkElementsValidity()
	{
	    $count = 0;
	    foreach($this->elements as $elem)
	    {
	        $quantity = (int) round(100 * $elem->quantity);
	        if ($quantity > 0)
	        {
	            $count++;
	        }
	    
	        $elem->checkValidity();
	    }
	    
	    return $count;
	}
	
	
	/**
	 * throw an exception if there is another entry in the same period
	 * @throws absences_EntryException
	 */
	protected function checkOtherEntriesValidity()
	{
	    $otherEntries = new absences_EntryIterator();
	    $otherEntries->from = $this->date_begin;
	    $otherEntries->to = $this->date_end;
	    $otherEntries->users = array($this->id_user);
	    
	    
	    foreach ($otherEntries as $otherEntry) {
	    
	        /* @var $otherEntry absences_Entry */
	    
	        if ($this->id != $otherEntry->id) {

This code seems to be duplicated across your project.

	            $e = new absences_EntryException(absences_translate('There is allready an absence request in the period'));
	            $e->entry = $this;
	            $e->blocking = true;
	            throw $e;
	        }
	    }
	    
	}


	/**
	 * Check request validity
	 *
	 * @throws absences_EntryException
	 * @throws UnexpectedValueException
	 * 
	 * @return bool
	 */
	public function checkValidity()
	{
		// verify mandatory data

		if (!isset($this->id_user) || $this->id_user <= 0)
		{
			throw new UnexpectedValueException('Unexpected id_user');
		}


		$count = $this->checkElementsValidity();


		if (0 === $count)

This code seems to be duplicated across your project.

		{
			$e = new absences_EntryException(absences_translate('At least one vacation right must be used'));
			$e->entry = $this;
			$e->blocking = true;
			throw $e;
		}



		// test user validity

		require_once $GLOBALS['babInstallPath'].'utilit/userinfosincl.php';

		$creationdate = bab_userInfos::getCreationDate($this->id_user);

		if ($creationdate >= $this->date_end) {
			$e = new absences_EntryException(sprintf(absences_translate('The vacation request end before user creation date : %s'), bab_shortDate(bab_mktime($creationdate))));
			$e->entry = $this;
			$e->blocking = true;
			throw $e;
		}

		// T8359 : si l'utilisateur est reactive la demande ne sera pas presente, il faudra reenregistrer le droit
		// avant la correction de ce ticket, on creeais les demandes pour eviter ce probleme

		if (!bab_userInfos::isValid($this->id_user)) {

		    /*
		    $e = new absences_EntryException(absences_translate('This user account is disabled'));
		    $e->entry = $this;
		    $e->blocking = true;
		    throw $e;
		    */

		    return false;
		}


		// test quantity / period duration in days

		$total = (int) round(100 * $this->getTotalDays());
		$duration = (int) round(100 * $this->getDurationDays());


		if (0 === $duration)

This code seems to be duplicated across your project.

		{
			$e = new absences_EntryException(absences_translate('The selected period is not available'));
			$e->entry = $this;
			$e->blocking = true;
			throw $e;
		}



		if ($total !== $duration)
		{
			$e = new absences_EntryException(sprintf(absences_translate('The total quantity (%s) does not match the period duration (%s)'), absences_quantity($this->getTotalDays(), 'D'), absences_quantity($this->getDurationDays(), 'D')));
			$e->entry = $this;
			$e->blocking = !((bool) absences_getVacationOption('allow_mismatch'));
			throw $e;
		}

		// test quantity / period duration in hours only if there is one right in hours
		/*
		 *
		 * Pas de verification du nombre d'heure pour le moment, la precision de la verification du nombre de jours devrais suffire a verifier aussi les heures
		 * c'est ce qui a ete fait sur la partie en HTML lorsque les les tests etait fait uniquement cote client (vacuser.html template newvacation)
		 *
		if ($this->containsHours())
		{
			$total = (int) round(100 * $this->getTotalHours());
			$duration = (int) round(100 * $this->getDurationHours());

			if ($total !== $duration)
			{
				$e = new absences_EntryException(absences_translate('The total quantity does not match the period duration in hours'));
				$e->blocking = !((bool) absences_getVacationOption('allow_mismatch'));
				throw $e;
			}
		}

		*/



		// verifier si la periode demandee n'est pas deja occuppe par une autre demande
        $this->checkOtherEntriesValidity();
		

		return true;
	}


	/**
	 * (non-PHPdoc)
	 * @see absences_Request::modifiedOn()
	 *
	 * @return string
	 */
	public function modifiedOn()
	{
		return $this->date;
	}

	/**
	 * Test if the entry is a fixed vacation
	 * @return bool
	 */
	public function isFixed()
	{
		return (1 === (int) $this->creation_type);

	}





	/**
	 * Test if entry is previsonal
	 * @return bool
	 */
	public function isPrevisonal()
	{
		return ($this->status === 'P');
	}

	/**
	 * Test if at least one entry in folder is previsonal
	 * @return boolean
	 */
	public function isFolderPrevisonal()
	{
		if (!$this->folder)
		{
			return false;
		}

		$I = new absences_EntryIterator;
		$I->folder = $this->folder;

It seems like $this->folder can also be of type integer. However, the property $folder is declared as type string. Maybe add an additional type check?

		$I->status = 'P';

		return ($I->count() > 0);
	}

	/**
	 * Get the first entry in folder
	 * @return absences_Entry
	 */
	public function getFolderFirst()

This method seems to be duplicated in your project.

	{
		if (!$this->folder)
		{
			return null;
		}

		$I = new absences_EntryIterator;
		$I->folder = $this->folder;

It seems like $this->folder can also be of type integer. However, the property $folder is declared as type string. Maybe add an additional type check?

		foreach($I as $first)
		{
			return $first;
		}

		return null;
	}


	/**
	 * Process specific code when the request is rejected
	 *
	 */
	protected function onReject()
	{
		$this->updateCalendar();
	}


	/**
	 * Process specific code when the request is confirmed
	 *
	 */
	public function onConfirm()
	{
		$this->updateCalendar();
	}



	/**
	 * Call the user calendar backend to update the event
	 * call the event to notify about calendar event modification
	 */
	public function updateCalendar()
	{
		require_once $GLOBALS['babInstallPath'].'utilit/dateTime.php';

		// try to update event copy in other backend (caldav)

		$begin = BAB_DateTime::fromIsoDateTime($this->date_begin);
		$end = BAB_DateTime::fromIsoDateTime($this->date_end);
		$period = absences_getPeriod($this->id, $this->id_user,  $begin, $end);
		if ($period) {

			// probably set a new description if the event has been approved or rejected
			absences_setPeriodProperties($period, $this);

			// save copy of event to calendar backend (if caldav)
			$period->save();
		}


		// Update calendar data overlapped with event

		$date_begin = bab_mktime($this->date_begin);
		$date_end	= bab_mktime($this->date_end);

		include_once $GLOBALS['babInstallPath']."utilit/eventperiod.php";
		$event = new bab_eventPeriodModified($date_begin, $date_end, $this->id_user);
		$event->types = BAB_PERIOD_VACATION;

The property types cannot be accessed from this context as it is declared private in class bab_eventPeriodModified.

		bab_fireEvent($event);
	}


	public function getTitle()
	{
	    if (isset($this->todelete) && $this->todelete) {
	        return absences_translate('vacation request to delete');
	    }
	    
		return absences_translate('vacation request');
	}


	public function getNotifyFields()

This method seems to be duplicated in your project.

	{
		return array(
			absences_translate('From') 		=> bab_shortDate(bab_mktime($this->date_begin)),
			absences_translate('Until')		=> bab_shortDate(bab_mktime($this->date_end)),
			absences_translate('Quantity') 	=> absences_quantity($this->getTotalDays(), 'D')
		);
	}


	public function getYear()

This method seems to be duplicated in your project.

	{
		$year = (int) substr($this->date_begin, 0, 4);

		if (0 === $year)
		{
			return null;
		}

		return $year;
	}


	public function getArchiveYear()

This method seems to be duplicated in your project.

	{
		require_once $GLOBALS['babInstallPath'].'utilit/dateTime.php';
		$year = (int) substr($this->date_begin, 0, 4);

		if (0 === $year)
		{
			return null;
		}

		$day = absences_getVacationOption('archivage_day');
		$month = absences_getVacationOption('archivage_month');

		$currentYear = new BAB_DateTime($year, $month, $day);
		if($this->date_begin < $currentYear->getIsoDate()){
			$year = $year-1;
		}

		return $year;
	}

	public function archive()

This method seems to be duplicated in your project.

	{
		global $babDB;

		$babDB->db_query("
			UPDATE absences_entries
			SET archived=".$babDB->quote(1)."
			WHERE
				id=".$babDB->quote($this->id)."
		");
	}


	public function setNotified()

This method seems to be duplicated in your project.

	{
		global $babDB;

		if (!$this->id)
		{
			throw new Exception('Missing ID');
		}

		$babDB->db_query("
			UPDATE absences_entries
				SET appr_notified=".$babDB->quote(1)."
			WHERE
				id=".$babDB->quote($this->id)."
		");
	}


	public function getManagerEditUrl()
	{
		$addon = bab_getAddonInfosInstance('absences');
		$ts = bab_mktime($this->date_begin);
		return $addon->getUrl().'vacuser&idx=period&id='.$this->id.'&year='.date('Y', $ts).'&month='.date('n', $ts).'&rfrom=1';
	}


	public function getManagerDeleteUrl()
	{
		$addon = bab_getAddonInfosInstance('absences');
		$url = new bab_url($addon->getUrl().'vacadmb');
		$url->idx = 'delete';
		$url->id_entry = $this->id;
		$url->from = $_SERVER['REQUEST_URI'];
		return $url->toString();
	}


	public function getManagerFrame()
	{
		$W = bab_Widgets();
		$vbox = $W->VBoxLayout();

		if ($this->isFixed())
		{
			$vbox->addItem($W->Icon(absences_translate('Fixed vacation period'), Func_Icons::ACTIONS_VIEW_CALENDAR_DAY));
		} else {
			$vbox->addItem($W->Link($W->Icon(absences_translate('Vacation request'), Func_Icons::ACTIONS_VIEW_LIST_DETAILS), absences_addon()->getUrl()."vacadmb&idx=morvw&id=".$this->id));
		}
		$vbox->addItem($W->Label(absences_DateTimePeriod($this->date_begin, $this->date_end)));

		return $vbox;
	}


	/**
	 *
	 * @param bool 			$display_username	Affiche le nom du demandeur dans la card frame ou non, utile pour les listes contenant plusieurs demandeurs possibles
	 * @param int			$rfrom				si les demandes de la liste sont modifiee par un gestionnaire ou gestionnaire delegue
 	 * @param int			$ide				id entite de l'organigramme >0 si gestionnaire delegue seulement
	 */
	public function getCardFrame($display_username, $rfrom, $ide)
	{
		bab_functionality::includeOriginal('Icons');

		$W = bab_Widgets();
		$layout = $W->HBoxLayout()->setHorizontalSpacing(2,'em')->addClass('widget-full-width');
		$frame = $W->Frame(null, $layout);

		$frame->addClass(Func_Icons::ICON_LEFT_16);
		$frame->addClass('absences-entry-cardframe');
		$layout->addItem($col1 = $W->VBoxLayout()->setVerticalSpacing(.5,'em'));
		$layout->addItem($col2 = $W->VBoxLayout()->setVerticalSpacing(.3,'em'));

		if ($this->isPrevisonal())
		{
			$btn = $W->Link($W->Button()->addItem($W->Label(absences_translate('Submit for approval'))), absences_addon()->getUrl()."vacuser&idx=subprev&id_entry=".$this->id);
			$btn->setSizePolicy('display-opened');
			$layout->addItem($btn);
		}

		if ($this->isFolderPrevisonal())
		{
			$first = $this->getFolderFirst();
			if ($first && $first->id === $this->id)
			{
				$btn = $W->Link($W->Button()->addItem($W->Label(absences_translate('Submit requests for approval'))), absences_addon()->getUrl()."vacuser&idx=subprev&id_entry=".$this->id);
				$btn->setSizePolicy('display-closed');
				$layout->addItem($btn);
			}
		}


		$layout->addItem($col3 = $W->VBoxLayout()->setVerticalSpacing(.5,'em'));

		if ($this->isFixed())
		{
			$col1->addItem($W->Icon(absences_translate('Fixed vacation period'), Func_Icons::ACTIONS_VIEW_CALENDAR_DAY));
			$col1->setCanvasOptions($col1->Options()->width(25,'em'));
		} else {
			$col1->addItem($W->Link($W->Icon(absences_translate('Vacation request'), Func_Icons::ACTIONS_VIEW_LIST_DETAILS), absences_addon()->getUrl()."vacuser&idx=morve&id=".$this->id));
			$col1->setCanvasOptions($col1->Options()->width(25,'em'));

			$col1->addItem($this->getStatusIcon());
		}

		$col2->setSizePolicy(Widget_SizePolicy::MAXIMUM);

		$col2->addItem($W->Title(absences_DateTimePeriod($this->date_begin, $this->date_end), 5));

		if ($display_username)
		{
			$col2->addItem($this->labelledValue(absences_translate('Owner'), $this->getUserName()));
		}

		$col2->addItem($this->labelledValue(absences_translate('Quantity'), absences_vacEntryQuantity($this->id)));




		if ($this->canModify())

This code seems to be duplicated across your project.

		{
			$col3->addItem($W->Link($W->Icon(absences_translate('Modify'), Func_Icons::ACTIONS_DOCUMENT_EDIT), $this->getEditUrl($rfrom, $ide)));
		}

		if ($this->canDelete())
		{
			$urldelete = absences_addon()->getUrl()."vacuser&idx=delete&id_entry=".$this->id;
			$col3->addItem($W->Link($W->Icon(absences_translate('Delete'), Func_Icons::ACTIONS_EDIT_DELETE), $urldelete));
		}

		$frame->setTitle(sprintf(absences_translate('Created the %s'), bab_shortDate(bab_mktime($this->createdOn()))));

		return $frame;
	}





	/**
	 * @return string
	 */
	public function getEditUrl($rfrom, $ide = null)
	{
		$begin_ts = bab_mktime($this->date_begin);
		$url = absences_addon()->getUrl()."vacuser&idx=period&id=".$this->id."&year=".date('Y',$begin_ts)."&month=".date('n',$begin_ts);

		if (isset($rfrom))
		{
			$url .= '&rfrom='.$rfrom;
		}

		if (isset($ide))
		{
			$url .= '&ide='.$ide;
		}

		return $url;
	}



	/**
	 * Delete the vacation request
	 * @return bool
	 */
	public function delete()
	{



		global $babDB;

		if (!$this->getRow())
		{
			return false;
		}

		parent::delete();
		
		if ('0000-00-00 00:00:00' !== $this->date_begin && '0000-00-00 00:00:00' !== $this->date_end) {
    		include_once $GLOBALS['babInstallPath']."utilit/dateTime.php";
    		$date_begin = BAB_DateTime::fromIsoDateTime($this->date_begin);
    		$date_end	= BAB_DateTime::fromIsoDateTime($this->date_end);
    
    		$period = absences_getPeriod($this->id, $this->id_user, $date_begin, $date_end);
    		if (null !== $period)
    		{
    			$period->delete();
    		}
		}
		$babDB->db_query("DELETE FROM absences_dynamic_rights WHERE id_entry=".$babDB->quote($this->id));
		$babDB->db_query("DELETE FROM ".ABSENCES_ENTRIES_ELEM_TBL." WHERE id_entry=".$babDB->quote($this->id)."");
		$babDB->db_query("DELETE FROM ".ABSENCES_ENTRIES_TBL." WHERE id=".$babDB->quote($this->id));

		$this->applyDynamicRight();
		
		if (isset($date_begin) && isset($date_end)) {
    		$cal_begin = clone $date_begin;
    		$cal_end = clone $date_end;
    
    		$cal_end->add(1, BAB_DATETIME_MONTH);
    
    		while ($cal_begin->getTimeStamp() <= $cal_end->getTimeStamp()) {
    			$month	= $cal_begin->getMonth();
    			$year	= $cal_begin->getYear();
    			absences_updateCalendar($this->id_user, $year, $month);
    			$cal_begin->add(1, BAB_DATETIME_MONTH);
    		}
    		
    		$this->addMovement(
    		        sprintf(
    		                absences_translate('The vacation entry from %s to %s has been deleted'),
    		                $date_begin->shortFormat(true),
    		                $date_end->shortFormat(true)
    		        )
    		);
		}

		

		return true;
	}







	/**
	 * (non-PHPdoc)
	 * @see absences_Request::notifyOwner()
	 */
	public function notifyOwner()
	{
		parent::notifyOwner();

		if ('Y' != $this->status)
		{
			return;
		}

		$agent = $this->getAgent();
		$emails = $agent->getEmails();

		if (empty($emails))
		{
			return;
		}

		absences_notifyEntryOwnerEmails(array($this), $emails);
	}

}




class absences_EntryException extends Exception
{
	/**
	 * Optional entry associated to error (unsaved entry object)
	 * @var absences_Entry
	 */
	public $entry;


	/**
	 * Define if the exception if blocking a save
	 * @var bool
	 */
	public $blocking = true;
}



/**
 * Vacation requests
 * Sorted by creation date
 */
class absences_EntryIterator extends absences_Iterator
{

	/**
	 *
	 * @var string
	 */
	public $orderby = 'createdOn ASC';


	/**
	 *
	 * @var string
	 */
	public $folder;

	/**
	 *
	 * @var array
	 */
	public $users;


	/**
	 *
	 * @var mixed (array|string)
	 */
	public $status;


	/**
	 * Entry to ignore in the folder
	 * @var int
	 */
	public $id_entry_folder;


	/**
	 * Filtrer les demandes necessitant ou pas un email aux approbateurs
	 * @var int
	 */
	public $appr_notified;

	/**
	 * Filtrer les demandes avec unes instance d'approbation
	 * @var bool
	 */
	public $idfai_set;


	/**
	 * Filtrer les demandes avec une liste d'instances d'approbation
	 * @var array
	 */
	public $appr_idfai;


	/**
	 * Search all request created before this date time
	 * @var string
	 */
	public $createdOn;

	/**
	 * Search all request modified before this date
	 * @var string
	 */
	public $modifiedOn;


	/**
	 * Datetime
	 * @var string
	 */
	public $from;


	/**
	 * Datetime
	 * @var string
	 */
	public $to;


	/**
	 * Filtrer les demandes par annee
	 * @var int
	 */
	public $year;


	/**
	 * Filtrer les demandes par organisation
	 * @var int
	 */
	public $organization;


	/**
	 * Filtrer les demandes par statut d'archivage
	 * @var int
	 */
	public $archived = 0;
	
	/**
	 * with at least one element with this right
	 */
	public $id_right;



	public function getObject($data)
	{

		$entry = new absences_Entry;
		$entry->setRow($data);
		return $entry;

	}



	public function executeQuery()
	{
		if(is_null($this->_oResult))
		{
			global $babDB;
			$req = 'SELECT e.* 
				FROM
					absences_entries e 
				';


			$where = array();
			if (isset($this->folder))
			{
				$where[] = 'e.folder='.$babDB->quote($this->folder);

				if (isset($this->id_entry_folder))
				{
					$where[] = 'e.id<>'.$babDB->quote($this->id_entry_folder);
				}
			}

			if (!empty($this->users))
			{
				$where[] = 'e.id_user IN('.$babDB->quote($this->users).')';
			}

			if (isset($this->status))
			{
				$where[] = 'e.status IN('.$babDB->quote($this->status).')';
			}

			if (isset($this->createdOn))
			{
				$where[] = 'e.createdOn<='.$babDB->quote($this->createdOn);
			}

			if (isset($this->modifiedOn))
			{
				$where[] = 'e.`date`<='.$babDB->quote($this->modifiedOn);
			}

			if (isset($this->appr_notified))
			{
				$where[] = 'e.appr_notified='.$babDB->quote($this->appr_notified);
			}

			if (isset($this->idfai_set) && $this->idfai_set)
			{
				$where[] = 'e.idfai>'.$babDB->quote(0);
			}

			if (isset($this->appr_idfai))
			{
				$where[] = 'e.idfai IN('.$babDB->quote($this->appr_idfai).')';
			}

			if (isset($this->from))
			{
				$where[] = 'e.date_end >'.$babDB->quote($this->from);
			}

			if (isset($this->to))
			{
				$where[] = 'e.date_begin <'.$babDB->quote($this->to);
			}

			if (isset($this->startTo))
			{
				$where[] = 'e.date_begin <='.$babDB->quote($this->startTo);

The property startTo does not exist. Did you maybe forget to declare it?

			}

			if (isset($this->startFrom))
			{
				$where[] = 'e.date_begin >='.$babDB->quote($this->startFrom);

The property startFrom does not exist. Did you maybe forget to declare it?

			}

			if (isset($this->year))
			{
				$where[] = 'YEAR(e.date_begin)='.$babDB->quote($this->year);
			}

			if (isset($this->organization) && $this->organization)

This code seems to be duplicated across your project.

			{
				$req .= ', absences_personnel p';
				$where[] = 'e.id_user=p.id_user';
				$where[] = 'p.id_organization='.$babDB->quote($this->organization);
			}

			if (isset($this->archived))
			{
				$where[] = 'e.archived='.$babDB->quote($this->archived);
			}
			
			if (isset($this->id_right))
			{
			    $where[] = 'e.id IN(SELECT id_entry FROM absences_entries_elem WHERE id_right='.$babDB->quote($this->id_right).')';
			}

			if ($where)

The expression $where of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

			{
				$req .= ' WHERE '.implode(' AND ', $where);
			}

			$req .= ' ORDER BY '.$this->orderby;
			
			$this->setMySqlResult($this->getDataBaseAdapter()->db_query($req));
		}
	}
}


/**
 * Entry elements iterator
 */
class absences_EntryElemIterator extends absences_Iterator
{
	/**
	 *
	 * @var absences_Entry
	 */
	public $entry;

	/**
	 * Filter by a list of id vaction types
	 * @var int[]
	 */
	public $types;


	public function getObject($data)
	{
		require_once dirname(__FILE__).'/type.class.php';
		require_once dirname(__FILE__).'/right.class.php';
		require_once dirname(__FILE__).'/entry_elem.class.php';

		$type_row = $this->getRowByPrefix($data, 'type');
		$type = new absences_Type($type_row['id']);
		$type->setRow($type_row);

		$right_row = $this->getRowByPrefix($data, 'right');
		$right = new absences_Right($right_row['id']);
		$right->setRow($right_row);
		$right->setType($type);

		$elem_row = $this->getRowByPrefix($data, 'elem');
		$elem = new absences_EntryElem();
		$elem->setRow($elem_row);
		$elem->setRight($right);
		$elem->setEntry($this->entry);

		return $elem;
	}



	public function executeQuery()
	{
		if(is_null($this->_oResult))
		{
			global $babDB;
			$req = 'SELECT

				ee.id 					elem__id,
				ee.id_entry 			elem__id_entry,
				ee.id_right				elem__id_right,
				ee.quantity				elem__quantity,
			    ee.date_begin           elem__date_begin,
			    ee.date_end             elem__date_end,

				r.id					right__id,
				r.id_creditor			right__id_creditor,
				r.kind					right__kind,
			    r.createdOn			    right__createdOn,
				r.date_entry			right__date_entry,
				r.date_begin			right__date_begin,
				r.date_end				right__date_end,
				r.quantity				right__quantity,
				r.quantity_unit			right__quantity_unit,
				r.quantity_inc_month 	right__quantity_inc_month,
				r.quantity_inc_max 		right__quantity_inc_max,
				r.quantity_inc_last		right__quantity_inc_last,
				r.id_type				right__id_type,
				r.description			right__description,
				r.active				right__active,
				r.cbalance	 			right__cbalance,
				r.date_begin_valid		right__date_begin_valid,
				r.date_end_valid		right__date_end_valid,
				r.date_end_fixed		right__date_end_fixed,
				r.date_begin_fixed		right__date_begin_fixed,
				r.no_distribution 		right__no_distribution,
				r.use_in_cet			right__use_in_cet,
				r.id_rgroup				right__id_rgroup,
				r.earlier				right__earlier,
				r.earlier_begin_valid 	right__earlier_begin_valid,
				r.earlier_end_valid		right__earlier_end_valid,
				r.later					right__later,
				r.later_begin_valid		right__later_begin_valid,
				r.later_end_valid		right__later_end_valid,
				r.delay_before			right__delay_before,
				r.id_report_type		right__id_report_type,
				r.date_end_report		right__date_end_report,
				r.description_report	right__description_report,
				r.id_reported_from		right__id_reported_from,
				r.quantity_alert_days	right__quantity_alert_days,
				r.quantity_alert_types	right__quantity_alert_types,
				r.quantity_alert_begin	right__quantity_alert_begin,
				r.quantity_alert_end	right__quantity_alert_end,
				r.dynconf_types			right__dynconf_types,
				r.dynconf_begin			right__dynconf_begin,
				r.dynconf_end			right__dynconf_end,
				r.sync_status			right__sync_status,
				r.sync_update			right__sync_update,
				r.uuid					right__uuid,
				r.archived				right__archived,
				r.sortkey				right__sortkey,
				r.require_approval		right__require_approval,


				t.id					type__id,
				t.name					type__name,
				t.description			type__description,
				t.color					type__color
			FROM
				absences_entries_elem ee,
				absences_rights r,
				absences_types t

			WHERE
				ee.id_entry='.$babDB->quote($this->entry->id).'
				AND ee.id_right = r.id
				AND r.id_type = t.id';

			if (isset($this->types)) {
			    $req .= ' AND t.id IN('.$babDB->quote($this->types).')';
			}

		    $req .= ' ORDER BY ee.date_begin';

			$this->setMySqlResult($this->getDataBaseAdapter()->db_query($req));
		}
	}


}



/**
 * Entry periods iterator
 */
class absences_EntryPeriodIterator extends absences_Iterator
{
    /**
     *
     * @var absences_Entry
     */
    public $entry;



    public function getObject($data)
    {
        require_once dirname(__FILE__).'/entry_period.class.php';



        $elem_row = $this->getRowByPrefix($data, 'period');
        $elem = new absences_EntryPeriod();
        $elem->setRow($elem_row);
        $elem->setEntry($this->entry);

        return $elem;
    }



    public function executeQuery()
    {
        if(is_null($this->_oResult))
        {
            global $babDB;
            $req = 'SELECT

				ep.id 					period__id,
				ep.id_entry 			period__id_entry,
			    ep.date_begin           period__date_begin,
			    ep.date_end             period__date_end

			FROM
				absences_entries_periods ep
			WHERE
				ep.id_entry='.$babDB->quote($this->entry->id).'';


            $req .= ' ORDER BY ep.date_begin';

            $this->setMySqlResult($this->getDataBaseAdapter()->db_query($req));
        }
    }


}