private function importTransactions(Status $logger, array $clockingTypeMap, array $bookingTypesByIdentifier, array $usersByName, array $clockingDataByOldID, PDO $source, PropelPDO $dest)
{
if (!$dest->beginTransaction()) {
throw new Exception('Could not start transaction.');
}
try {
$statement = $source->query('SELECT * FROM ext_clockings_transactions');
$logger->info($statement->rowCount());
$oldTransactions = $statement->fetchAll(PDO::FETCH_ASSOC);
$statement->closeCursor();
$statement = null;
foreach ($oldTransactions as $rowIndex => $oldTransaction) {
$authUserName = $oldTransaction['creator'];
$userName = $oldTransaction['username'];
if (empty($usersByName[$userName])) {
$logger->info('Transaction #' . $oldTransaction['ID'] . ' references unknown user "' . $userName . '".');
continue;
}
$transaction = new Transaction();
$dataItems = $this->getTransactionClockingDataItems($logger, $oldTransaction, $clockingDataByOldID, $source);
$clockings = $this->getClockings($dataItems);
if (empty($clockings)) {
$date = (int) $oldTransaction['date'];
$start = $date;
$end = $date;
} else {
list($start, $end) = $this->getClockingRange($clockings);
foreach ($clockings as $clocking) {
$transactionClocking = new TransactionClocking();
$transaction->addTransactionClocking($transactionClocking->setTransaction($transaction)->setClocking($clocking));
}
}
// Check transaction / booking consistency
$logger->start('Checking consistency of new transactions & bookings');
$worktimeId = $bookingTypesByIdentifier['regular']->getId();
$flexitimeId = $bookingTypesByIdentifier['flexitime']->getId();
$overtimeId = $bookingTypesByIdentifier['overtime']->getId();
$vacationId = $bookingTypesByIdentifier['vacation']->getId();
$sickLeaveId = $bookingTypesByIdentifier['sick_leave']->getId();
$educationId = $bookingTypesByIdentifier['education']->getId();
$actualTimes = array($worktimeId => 0.0, $flexitimeId => 0.0, -$flexitimeId => 0.0, $overtimeId => 0.0, $vacationId => 0.0, $sickLeaveId => 0.0, $educationId => 0.0);
//$actualDenied = 0;
$bookings = $this->createBookings($logger, $dataItems, $bookingTypesByIdentifier, $dest);
foreach ($bookings as $booking) {
$bookingTypeId = $booking->getBookingTypeId();
if (!isset($actualTimes[$bookingTypeId])) {
throw new Exception('Unknown booking type #' . $bookingTypeId . ' specified for booking #' . $booking->getId() . '.');
}
$value = $booking->getValue();
if ($bookingTypeId === $flexitimeId and $value < 0) {
$actualTimes[-$bookingTypeId] += $value;
} else {
$actualTimes[$bookingTypeId] += $value;
}
$transaction->addBooking($booking);
}
$transaction->setUserRelatedByCreatorId($usersByName[$authUserName])->setUserRelatedByUserId($usersByName[$userName])->setStart($start)->setEnd($end)->setCreationdate((int) $oldTransaction['creationdate'])->setComment($oldTransaction['comment'])->setDeleted($oldTransaction['visibility'])->save($dest);
// Cross-check times of bookings and transaction
#$this->failTimeDelta($logger, $oldTransaction, 'time', $actualTimes[$worktimeId] + $actualTimes[$flexitimeId] + $actualTimes[$overtimeId], $bookings);
#$this->failTimeDelta($logger, $oldTransaction, 'time', $actualTimes[$worktimeId], $bookings);
$this->failTimeDelta($logger, $oldTransaction, 'flexitime', $actualTimes[$flexitimeId] + $actualTimes[-$flexitimeId], $bookings);
$this->failTimeDelta($logger, $oldTransaction, 'overtime', $actualTimes[$overtimeId], $bookings);
//$this->failTimeDelta($logger, $oldTransaction, 'denied', $actualDenied, $bookings);
$logger->done();
}
} catch (Exception $e) {
$dest->rollBack();
throw $e;
}
if (!$dest->commit()) {
throw new Exception('Could not commit transaction.');
}
}
/**
* Exclude object from result
*
* @param TransactionClocking $transactionClocking Object to remove from the list of results
*
* @return TransactionClockingQuery The current query, for fluid interface
*/
public function prune($transactionClocking = null)
{
if ($transactionClocking) {
$this->addCond('pruneCond0', $this->getAliasedColName(TransactionClockingPeer::TRANSACTION_ID), $transactionClocking->getTransactionId(), Criteria::NOT_EQUAL);
$this->addCond('pruneCond1', $this->getAliasedColName(TransactionClockingPeer::CLOCKING_ID), $transactionClocking->getClockingId(), Criteria::NOT_EQUAL);
$this->combine(array('pruneCond0', 'pruneCond1'), Criteria::LOGICAL_OR);
}
return $this;
}
/**
* Links a transaction with the specified clockings.
*
* @return void
*/
private function linkTransactionClockings(Transaction $transaction, $clockings, PropelPDO $con)
{
foreach ($clockings as $clocking) {
/*
$approvalStatus = $clocking->getApprovalStatus();
switch ( $approvalStatus ) {
case ClockingPeer::APPROVAL_STATUS_PRELIMINARY:
case ClockingPeer::APPROVAL_STATUS_REQUIRED:
$clocking->setApprovalStatus(ClockingPeer::APPROVAL_STATUS_CONFIRMED);
break;
case ClockingPeer::APPROVAL_STATUS_CONFIRMED:
case ClockingPeer::APPROVAL_STATUS_AS_IS:
break;
case ClockingPeer::APPROVAL_STATUS_DENIED:
throw new Exception($clocking->__toString().' has been denied and therefore cannot be used in a transaction.');
default:
throw new Exception($clocking->__toString().' has an invalid approval status '.$approvalStatus.'.');
}
*/
$transactionClocking = new TransactionClocking();
$transactionClocking->setTransaction($transaction)->setClocking($clocking)->save($con);
}
}
/**
* Filter the query by a related TransactionClocking object
*
* @param TransactionClocking|PropelObjectCollection $transactionClocking the related object to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ClockingQuery The current query, for fluid interface
* @throws PropelException - if the provided filter is invalid.
*/
public function filterByTransactionClocking($transactionClocking, $comparison = null)
{
if ($transactionClocking instanceof TransactionClocking) {
return $this->addUsingAlias(ClockingPeer::ID, $transactionClocking->getClockingId(), $comparison);
} elseif ($transactionClocking instanceof PropelObjectCollection) {
return $this->useTransactionClockingQuery()->filterByPrimaryKeys($transactionClocking->getPrimaryKeys())->endUse();
} else {
throw new PropelException('filterByTransactionClocking() only accepts arguments of type TransactionClocking or PropelCollection');
}
}
/**
* @param TransactionClocking $transactionClocking The transactionClocking object to add.
*/
protected function doAddTransactionClocking($transactionClocking)
{
$this->collTransactionClockings[] = $transactionClocking;
$transactionClocking->setTransaction($this);
}
/**
* Adds an object to the instance pool.
*
* Propel keeps cached copies of objects in an instance pool when they are retrieved
* from the database. In some cases -- especially when you override doSelect*()
* methods in your stub classes -- you may need to explicitly add objects
* to the cache in order to ensure that the same objects are always returned by doSelect*()
* and retrieveByPK*() calls.
*
* @param TransactionClocking $obj A TransactionClocking object.
* @param string $key (optional) key to use for instance map (for performance boost if key was already calculated externally).
*/
public static function addInstanceToPool($obj, $key = null)
{
if (Propel::isInstancePoolingEnabled()) {
if ($key === null) {
$key = serialize(array((string) $obj->getTransactionId(), (string) $obj->getClockingId()));
}
// if key === null
TransactionClockingPeer::$instances[$key] = $obj;
}
}
