protected function setUp()
 {
     TestDataService::truncateSpecificTables(array('Employee', 'Leave', 'LeaveRequest', 'LeaveType', 'EmployeeLeaveEntitlement', 'LeavePeriod'));
     // Save leave type
     $leaveTypeData = sfYaml::load(sfConfig::get('sf_plugins_dir') . '/orangehrmCoreLeavePlugin/test/fixtures/leaveType.yml');
     $leaveTypeDao = new LeaveTypeDao();
     $leaveType = new LeaveType();
     $leaveType->setLeaveTypeName($leaveTypeData['leaveType']['LT_001']['name']);
     //                $leaveType->setLeaveRules($leaveTypeData['leaveType']['LT_001']['rule']);
     $leaveTypeDao->saveLeaveType($leaveType);
     $this->leaveType = $leaveType;
     $this->leaveTypeId = $leaveType->getLeaveTypeId();
     // Save leave Period
     $leavePeriodData = sfYaml::load(sfConfig::get('sf_plugins_dir') . '/orangehrmCoreLeavePlugin/test/fixtures/leavePeriod.yml');
     $leavePeriodService = new LeavePeriodService();
     $leavePeriodService->setLeavePeriodDao(new LeavePeriodDao());
     $leavePeriod = new LeavePeriod();
     $leavePeriod->setStartDate($leavePeriodData['leavePeriod']['1']['startDate']);
     $leavePeriod->setEndDate($leavePeriodData['leavePeriod']['1']['endDate']);
     $leavePeriodService->saveLeavePeriod($leavePeriod);
     $this->leavePeriod = $leavePeriod;
     $this->leavePeriodId = $leavePeriod->getLeavePeriodId();
     // Save Employee
     $employeeservice = new EmployeeService();
     $this->employee = new Employee();
     $employeeservice->saveEmployee($this->employee);
     $this->empNumber = $this->employee->getEmpNumber();
     // save leave quota
     $this->leaveEntitlement = sfYaml::load(sfConfig::get('sf_plugins_dir') . '/orangehrmCoreLeavePlugin/test/fixtures/leaveEntitlement.yml');
     $this->leaveEntitlementDao = new LeaveEntitlementDao();
 }
 public function validateSave($obj)
 {
     $leavePeriod = new LeavePeriod();
     $leavePeriods = $leavePeriod->Find("1=1");
     if (strtotime($obj->date_end) <= strtotime($obj->date_start)) {
         return new IceResponse(IceResponse::ERROR, "Start date should be less than end date");
     }
     foreach ($leavePeriods as $lp) {
         if (!empty($obj->id) && $obj->id == $lp->id) {
             continue;
         }
         if (strtotime($lp->date_end) >= strtotime($obj->date_end) && strtotime($lp->date_start) <= strtotime($obj->date_end)) {
             //-1---0---1---0 || ---0--1---1---0
             return new IceResponse(IceResponse::ERROR, "Leave period is overlapping with an existing one");
         } else {
             if (strtotime($lp->date_end) >= strtotime($obj->date_start) && strtotime($lp->date_start) <= strtotime($obj->date_start)) {
                 //---0---1---0---1 || ---0--1---1---0
                 return new IceResponse(IceResponse::ERROR, "Leave period is overlapping with an existing one");
             } else {
                 if (strtotime($lp->date_end) <= strtotime($obj->date_end) && strtotime($lp->date_start) >= strtotime($obj->date_start)) {
                     //--1--0---0--1--
                     return new IceResponse(IceResponse::ERROR, "Leave period is overlapping with an existing one");
                 }
             }
         }
     }
     return new IceResponse(IceResponse::SUCCESS, "");
 }
 public function testSaveLeavePeriodWithNoId()
 {
     TestDataService::truncateTables(array('LeavePeriod'));
     $leavePeriod = new LeavePeriod();
     $leavePeriod->setStartDate("2010-01-31");
     $leavePeriod->setEndDate("2011-01-31");
     $this->assertTrue($this->leavePeriodDao->saveLeavePeriod($leavePeriod));
     $savedLeavePeriod = TestDataService::fetchObject('LeavePeriod', 1);
     $this->assertEquals($leavePeriod->getLeavePeriodId(), $savedLeavePeriod->getLeavePeriodId());
     $this->assertEquals($leavePeriod->getStartDate(), $savedLeavePeriod->getStartDate());
     $this->assertEquals($leavePeriod->getEndDate(), $savedLeavePeriod->getEndDate());
 }
Example #4
0
 /**
  * Saves the leave period
  *
  * @param LeavePeriod $leavePeriod
  * @return boolean
  */
 public function saveLeavePeriod(LeavePeriod $leavePeriod)
 {
     try {
         if ($leavePeriod->getLeavePeriodId() == '') {
             $idGenService = new IDGeneratorService();
             $idGenService->setEntity($leavePeriod);
             $leavePeriod->setLeavePeriodId($idGenService->getNextID());
         }
         $leavePeriod->save();
         return true;
     } catch (Exception $e) {
         throw new DaoException($e->getMessage());
     }
 }
 public function testReadLeavePeriod()
 {
     //mocking LeavePeriodDao
     $lastLeavePeriod = new LeavePeriod();
     $lastLeavePeriod->setStartDate("2010-01-01");
     $lastLeavePeriod->setEndDate("2010-12-31");
     $lastLeavePeriod->setLeavePeriodId(1);
     $leavePeriodDao = $this->getMock('LeavePeriodDao', array('readLeavePeriod'));
     $leavePeriodDao->expects($this->once())->method('readLeavePeriod')->will($this->returnValue($lastLeavePeriod));
     $this->leavePeriodService->setLeavePeriodDao($leavePeriodDao);
     $retrievedLeavePeriod = $this->leavePeriodService->readLeavePeriod(1);
     $this->assertTrue($retrievedLeavePeriod instanceof LeavePeriod);
 }
 public function getCurrentLeavePeriod($startDate, $endDate)
 {
     $leavePeriod = new LeavePeriod();
     $leavePeriod->Load("date_start <= ? and date_end >= ?", array($startDate, $endDate));
     if (empty($leavePeriod->id)) {
         $leavePeriod1 = new LeavePeriod();
         $leavePeriod1->Load("date_start <= ? and date_end >= ?", array($startDate, $startDate));
         $leavePeriod2 = new LeavePeriod();
         $leavePeriod2->Load("date_start <= ? and date_end >= ?", array($endDate, $endDate));
         if (!empty($leavePeriod1->id) && !empty($leavePeriod2->id)) {
             return new IceResponse(IceResponse::ERROR, "You are trying to apply leaves in two leave periods. You may apply leaves til {$leavePeriod1->date_end}. Rest you have to apply seperately");
         } else {
             return new IceResponse(IceResponse::ERROR, "The leave period for your leave application is not defined. Please inform administrator");
         }
     } else {
         return new IceResponse(IceResponse::SUCCESS, $leavePeriod);
     }
 }
Example #7
0
	private function getCurrentLeavePeriod($startDate,$endDate){
	
		$leavePeriod = new LeavePeriod();
		$leavePeriod->Load("date_start <= ? and date_end >= ?",array($startDate,$endDate));
		if(empty($leavePeriod->id)){
			return new IceResponse(IceResponse::ERROR,"Error in leave period" );
		}else{
			return new IceResponse(IceResponse::SUCCESS,$leavePeriod);
		}
	}
 private function getCurrentLeavePeriod()
 {
     $leavePeriod = new LeavePeriod();
     $leavePeriod->Load("status = ?", array('Active'));
     if ($leavePeriod->status == 'Active') {
         return $leavePeriod;
     }
     return null;
 }
 public function xtestIsEmployeeHavingLeaveBalanceErrorCases()
 {
     $empId = 1;
     $leaveTypeId = "LT001";
     $leaveRequest = "";
     $leavePeriodId = 11;
     $dateApplied = '2010-09-11';
     $applyDays = 2;
     $leaveRequest = new LeaveRequest();
     $leaveRequest->setDateApplied($dateApplied);
     $leaveRequest->setLeavePeriodId($leavePeriodId);
     $entitledDays = 5;
     $availableLeave = 3;
     $leaveEntitlement = new EmployeeLeaveEntitlement();
     $leaveEntitlement->setLeaveBroughtForward(2);
     $leaveBalance = 0;
     $currentLeavePeriod = new LeavePeriod();
     $currentLeavePeriod->setStartDate('2010-01-01');
     $currentLeavePeriod->setEndDate('2010-12-31');
     $nextLeavePeriod = new LeavePeriod();
     $nextLeavePeriod->setStartDate('2011-01-01');
     $nextLeavePeriod->setEndDate('2011-12-31');
     $leaveEntitlementService = $this->getMock('OldLeaveEntitlementService', array('getEmployeeLeaveEntitlementDays', 'readEmployeeLeaveEntitlement', 'getLeaveBalance'));
     $leaveEntitlementService->expects($this->any())->method('getEmployeeLeaveEntitlementDays')->with($empId, $leaveTypeId, $leavePeriodId)->will($this->returnValue($entitledDays));
     $leaveEntitlementService->expects($this->any())->method('readEmployeeLeaveEntitlement')->with($empId, $leaveTypeId, $leavePeriodId)->will($this->returnValue($leaveEntitlement));
     $leaveEntitlementService->expects($this->any())->method('getLeaveBalance')->will($this->returnValue($leaveBalance));
     $this->leaveRequestService->setLeaveEntitlementService($leaveEntitlementService);
     $leaveRequestDao = $this->getMock('LeaveRequestDao', array('getNumOfAvaliableLeave'));
     $leaveRequestDao->expects($this->any())->method('getNumOfAvaliableLeave')->with($empId, $leaveTypeId)->will($this->returnValue($availableLeave));
     $this->leaveRequestService->setLeaveRequestDao($leaveRequestDao);
     $leavePeriodService = $this->getMock('LeavePeriodService', array('getLeavePeriod', 'createNextLeavePeriod', 'getCurrentLeavePeriod'));
     $leavePeriodService->expects($this->any())->method('getLeavePeriod')->with(strtotime($leaveRequest->getDateApplied()))->will($this->returnValue($currentLeavePeriod));
     $leavePeriodService->expects($this->any())->method('createNextLeavePeriod')->with(date('Y-m-d', strtotime('2010-09-13')))->will($this->returnValue($nextLeavePeriod));
     $leavePeriodService->expects($this->any())->method('getCurrentLeavePeriod')->will($this->returnValue($currentLeavePeriod));
     $this->leaveRequestService->setLeavePeriodService($leavePeriodService);
     // Trigger leave balance exceeded
     try {
         $retVal = $this->leaveRequestService->isEmployeeHavingLeaveBalance($empId, $leaveTypeId, $leaveRequest, $applyDays);
         $this->fail("Exception expected");
     } catch (LeaveServiceException $e) {
         // expected - check code thrown in LeaveRequestService
     }
 }
 /**
  * 
  * @param LeavePeriod $leavePeriod
  * @return unknown_type
  */
 public function xgetLeavePeriodOverlapLeaves(LeavePeriod $leavePeriod)
 {
     try {
         $q = Doctrine_Query::create()->from('Leave l')->andWhere('l.leave_date > ?', $leavePeriod->getEndDate())->groupBy('l.leave_request_id');
         $leaveList = $q->execute();
         return $leaveList;
     } catch (Exception $e) {
         throw new DaoException($e->getMessage());
     }
 }
 /**
  * This test checks for the success scenario in case if an employee assigned a leave
  */
 public function testAssignLeaveFailsOnHolidays()
 {
     // Set post parameters
     $parameters = array('txtFromDate' => '2010-11-23', 'txtToDate' => '2010-11-24', 'txtEmpID' => '0001', 'txtLeaveType' => 'LT001');
     $request = $this->context->request;
     $request->setPostParameters($parameters);
     // Set request to POST method
     $request->setMethod(sfRequest::POST);
     //mocking LeaveRequestService
     $leaveRequestService = $this->getMock('LeaveRequestService', array('getOverlappingLeave'));
     $leaveTypes = TestDataService::loadObjectList('LeaveType', $this->fixture, 'LeaveTypes');
     $leaveRequestService->expects($this->once())->method('getOverlappingLeave')->will($this->returnValue(array()));
     //mocking LeaveTypeService
     $leaveTypeService = $this->getMock('LeaveTypeService', array('readLeaveType', 'getLeaveTypeList'));
     $leaveTypeService->expects($this->once())->method('readLeaveType')->will($this->returnValue($leaveTypes[0]));
     $leaveTypeService->expects($this->once())->method('getLeaveTypeList')->will($this->returnValue($leaveTypes));
     //mocking leave period service
     $leavePeriod = new LeavePeriod();
     $leavePeriod->setStartDate("2010-01-01");
     $leavePeriod->setEndDate("2010-12-31");
     $leavePeriod->setLeavePeriodId(2);
     $leavePeriodService = $this->getMock('LeavePeriodService', array('isWithinNextLeavePeriod', 'createNextLeavePeriod'));
     $leavePeriodService->expects($this->once())->method('isWithinNextLeavePeriod')->will($this->returnValue(true));
     $leavePeriodService->expects($this->once())->method('createNextLeavePeriod')->will($this->returnValue($leavePeriod));
     $assignLeaveAction = new assignLeaveAction($this->context, "leave", "execute");
     $assignLeaveAction->setLeaveRequestService($leaveRequestService);
     $assignLeaveAction->setLeaveTypeService($leaveTypeService);
     $assignLeaveAction->setLeavePeriodService($leavePeriodService);
     //mocking the form
     $form = $this->getMock('AssignLeaveForm', array('isValid', 'createLeaveObjectListForAppliedRange'));
     $form->expects($this->once())->method('isValid')->will($this->returnValue(true));
     $leaves = TestDataService::loadObjectList('Leave', $this->fixture, 'Leave');
     //making all leaves to holidays
     foreach ($leaves as $k => $obj) {
         $leaves[$k]->setLeaveStatus(Leave::LEAVE_STATUS_LEAVE_HOLIDAY);
     }
     $form->expects($this->once())->method('createLeaveObjectListForAppliedRange')->will($this->returnValue($leaves));
     $assignLeaveAction->setForm($form);
     try {
         $assignLeaveAction->execute($request);
         $this->assertTrue(isset($assignLeaveAction->templateMessage['SUCCESS']));
     } catch (Exception $e) {
     }
 }
Example #12
0
 /**
  * Creates the next leave period
  *
  * @return LeavePeriod Newly create leave period object
  */
 public function createNextLeavePeriod($date = null)
 {
     $lastLeavePeriod = $this->getLeavePeriodDao()->findLastLeavePeriod($date);
     if (!is_null($lastLeavePeriod)) {
         $newLeavePeriod = $this->getNextLeavePeriodByCurrentEndDate($lastLeavePeriod->getEndDate());
         if (!empty($newLeavePeriod)) {
             return $newLeavePeriod;
         } else {
             $lastEndDateTimestamp = strtotime($lastLeavePeriod->getEndDate());
             $dateInNextLeavePeriodTimestamp = strtotime('+1 day', $lastEndDateTimestamp);
             $dateInNextLeavePeriod = date('Y-m-d', $dateInNextLeavePeriodTimestamp);
             $leavePeriodDataHolder = $this->_getPopulatedLeavePeriodDataHolder();
             $leavePeriodDataHolder->setCurrentDate($dateInNextLeavePeriod);
             $nextStartDate = $this->generateStartDate($leavePeriodDataHolder);
             $leavePeriodDataHolder->setLeavePeriodStartDate($nextStartDate);
             $nextEndDate = $this->generateEndDate($leavePeriodDataHolder);
             $newLeavePeriod = new LeavePeriod();
             $newLeavePeriod->setStartDate($nextStartDate);
             $newLeavePeriod->setEndDate($nextEndDate);
             try {
                 $this->getLeavePeriodDao()->saveLeavePeriod($newLeavePeriod);
             } catch (Exception $e) {
                 // TODO: Warn
             }
             return $newLeavePeriod;
         }
     }
     return null;
 }
Education::SetDatabaseAdapter($dbLocal);
Certification::SetDatabaseAdapter($dbLocal);
Language::SetDatabaseAdapter($dbLocal);
Nationality::SetDatabaseAdapter($dbLocal);
Employee::SetDatabaseAdapter($dbLocal);
User::SetDatabaseAdapter($dbLocal);
EmployeeSkill::SetDatabaseAdapter($dbLocal);
EmployeeEducation::SetDatabaseAdapter($dbLocal);
EmployeeCertification::SetDatabaseAdapter($dbLocal);
EmployeeLanguage::SetDatabaseAdapter($dbLocal);
EmergencyContact::SetDatabaseAdapter($dbLocal);
EmployeeDependent::SetDatabaseAdapter($dbLocal);
EmployeeImmigration::SetDatabaseAdapter($dbLocal);
EmployeeSalary::SetDatabaseAdapter($dbLocal);
LeaveType::SetDatabaseAdapter($dbLocal);
LeavePeriod::SetDatabaseAdapter($dbLocal);
WorkDay::SetDatabaseAdapter($dbLocal);
HoliDay::SetDatabaseAdapter($dbLocal);
LeaveRule::SetDatabaseAdapter($dbLocal);
EmployeeLeave::SetDatabaseAdapter($dbLocal);
EmployeeLeaveDay::SetDatabaseAdapter($dbLocal);
File::SetDatabaseAdapter($dbLocal);
Client::SetDatabaseAdapter($dbLocal);
Project::SetDatabaseAdapter($dbLocal);
EmployeeTimeSheet::SetDatabaseAdapter($dbLocal);
EmployeeTimeEntry::SetDatabaseAdapter($dbLocal);
EmployeeProject::SetDatabaseAdapter($dbLocal);
Document::SetDatabaseAdapter($dbLocal);
EmployeeDocument::SetDatabaseAdapter($dbLocal);
CompanyLoan::SetDatabaseAdapter($dbLocal);
EmployeeCompanyLoan::SetDatabaseAdapter($dbLocal);
 public function execute($request)
 {
     if (!Auth::instance()->hasRole(Auth::ADMIN_ROLE)) {
         $this->forward('leave', 'showLeavePeriodNotDefinedWarning');
     }
     $this->setForm(new LeavePeriodForm(array(), array(), true));
     $this->isLeavePeriodDefined = OrangeConfig::getInstance()->getAppConfValue(ConfigService::KEY_LEAVE_PERIOD_DEFINED);
     $this->currentLeavePeriod = $this->getLeavePeriodService()->getCurrentLeavePeriod();
     if ($this->isLeavePeriodDefined) {
         $endDateElements = explode(' ', $this->currentLeavePeriod->getEndDateFormatted('F d'));
         $endDate = __($endDateElements[0]) . ' ' . $endDateElements[1];
         $nextPeriodStartDateTimestamp = strtotime('+1 day', strtotime($this->currentLeavePeriod->getEndDate()));
         $startMonthValue = (int) date('m', $nextPeriodStartDateTimestamp);
         $startDateValue = (int) date('d', $nextPeriodStartDateTimestamp);
     } else {
         $endDate = '-';
         $startMonthValue = 0;
         $startDateValue = 0;
     }
     $this->endDate = $endDate;
     $this->startMonthValue = $startMonthValue;
     $this->startDateValue = $startDateValue;
     if ($this->getUser()->hasFlash('templateMessage')) {
         list($this->messageType, $this->message) = $this->getUser()->getFlash('templateMessage');
     }
     // this section is for saving leave period
     if ($request->isMethod('post')) {
         $leavePeriodService = $this->getLeavePeriodService();
         $this->form->bind($request->getParameter($this->form->getName()));
         if ($this->form->isValid()) {
             $this->_setLeapYearLeavePeriodDetails($this->form);
             $leavePeriodDataHolder = $this->_getPopulatedLeavePeriodDataHolder();
             $fullStartDate = $leavePeriodService->generateStartDate($leavePeriodDataHolder);
             $leavePeriodDataHolder->setLeavePeriodStartDate($fullStartDate);
             $fullEndDate = $leavePeriodService->generateEndDate($leavePeriodDataHolder);
             $currentLeavePeriod = $leavePeriodService->getCurrentLeavePeriod();
             $this->getUser()->setFlash('templateMessage', array('success', __(TopLevelMessages::SAVE_SUCCESS)));
             if (!is_null($currentLeavePeriod)) {
                 $leavePeriodService->adjustCurrentLeavePeriod($fullEndDate);
             } else {
                 $leavePeriod = new LeavePeriod();
                 $leavePeriod->setStartDate($fullStartDate);
                 $leavePeriod->setEndDate($fullEndDate);
                 $leavePeriodService->saveLeavePeriod($leavePeriod);
             }
             $this->redirect('leave/defineLeavePeriod');
         }
     }
 }