Exemple #1
0
 public function save(PropelPDO $con = null)
 {
     $query = DomainQuery::create()->filterByName($this->getName());
     if ($this->getId()) {
         $query->add(DomainPeer::ID, $this->getId(), Criteria::NOT_EQUAL);
     }
     if (!$this->getAccountId()) {
         throw new Exception('A Domain must belong to an Account.');
     }
     if ($query->findOneByAccountId($this->getAccountId())) {
         throw new Exception('A Domain must have a unique name.', self::ERROR_NOT_UNIQUE);
     }
     return parent::save($con);
 }
Exemple #2
0
 private function import()
 {
     session_write_close();
     $SOURCE_DB = 'groupion_new';
     $USERNAME = '******';
     $PASSWORD = '';
     set_time_limit(0);
     $status = new Status();
     print '<br><br><br><br><br><div style="margin-left: 3em">';
     print '<p>Starting database migration</p>';
     flush();
     try {
         $con = Propel::getConnection();
         $status->start('Connecting to database');
         $dbh = new PDO('mysql:host=localhost;dbname=' . $SOURCE_DB, $USERNAME, $PASSWORD);
         $dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
         $dbh->exec('SET NAMES utf8');
         $status->done();
         $debugUser = UserQuery::create()->findOneByFQN('cms/test', $con);
         if ($debugUser === null) {
             throw new Exception('Could not find debug user "cms/test".');
         }
         $status->start('Clearing tables');
         // Mark transactions created by old system as deleted
         TransactionQuery::create()->filterByCreatorId(null, Criteria::NOT_EQUAL)->filterById(5814, Criteria::LESS_EQUAL)->filterByCreationdate(1347446069, Criteria::LESS_EQUAL)->update(array('Deleted' => 1), $con);
         // Clockings created by old system => max. clocking ID = 365913
         // Transactions created by new system with old clockings
         // SELECT distinct min(tc.clocking_id) FROM transaction t join transaction_clocking tc on t.id=tc.transaction_id where tc.clocking_id<=365913 and ;
         // => min clocking ID
         /*
         			// Delete clockings without new system transactions
         			ClockingQuery::create()
         				->joinTransactionClocking()
         				->join('TransactionClocking.Transaction')
         				->filterByCreatorId(null, Criteria::NOT_EQUAL)
         				->add(TransactionPeer::ID, 5814, Criteria::LESS_EQUAL)
         				->add(TransactionPeer::CREATOR_ID, null, Criteria::NOT_EQUAL)
         				->update(array('Deleted' => 1), $con);
         */
         // Mark clockings with new system transactions as deleted
         ClockingQuery::create()->filterById(365913, Criteria::LESS_EQUAL)->filterByCreatorId(null)->update(array('Deleted' => 1), $con);
         /*
         			TransactionClockingQuery::create()->deleteAll($con);
         			TransactionQuery::create()->deleteAll($con);
         
         			ClockingQuery::create()
         				->filterByUserRelatedByUserId($debugUser, Criteria::NOT_EQUAL)
         				->delete($con);
         			HolidayQuery::create()->deleteAll($con);
         			UserQuery::create()
         				->filterByName('test', Criteria::NOT_EQUAL)
         				->delete($con);
         */
         /*
         			TransactionClockingQuery::create()->deleteAll();
         			TransactionQuery::create()->deleteAll();
         			ClockingQuery::create()->deleteAll();
         			DomainQuery::create()->deleteAll();
         			AccountQuery::create()->deleteAll();
         
         			$status->done();
         
         			$status->start('Create default Account');
         
         			$account = new Account();
         			$account->setName('Default account');
         			$account->save();
         
         			$status->done();
         
         			$status->start('Create default domain');
         
         			$domain = new Domain();
         			$domain->setName('default');
         			$domain->setDescription('Default domain created while migrating to the new system.');
         			$domain->setAccount($account);
         			$domain->save();
         
         			$status->done();
         */
         $account = AccountQuery::create()->findOneByIdentifier('cms', $con);
         $domain = DomainQuery::create();
         /*
         			$status->start('Create holidays');
         
         			$holidaysUrl = \Xily\Config::get('migration.holidays_url', 'string', 'http://10.10.10.5/groupion/data/holidays');
         
         			$filenames = array('Bayern2009', 'Bayern2010', 'Bayern2011', 'Bayern2012', 'Bayern2013', 'Bayern2014');
         			foreach ($filenames as $filename) {
         				$file = fopen($holidaysUrl.'/'.$filename.'.csv', 'r');
         				if ( !is_resource($file) )
         					throw new Exception('Could not open file');
         
         				while ( is_array($row = fgetcsv($file, 1000, ';')) ) {
         					$date  = strtotime($row[0]);
         					$name  = $row[1];
         					$state = $row[2];
         					if ( $date ) {
         						$holidayDomain = new HolidayDomain();
         						$holidayDomain->setDomain($domain);
         
         						$holiday = new Holiday();
         						$holiday
         							->setAccount($account)
         							->setDate($date)
         							->setName(trim($name))
         							->addHolidayDomain($holidayDomain)
         							->save();
         					}
         				}
         			}
         
         			$status->done();
         
         			$status->start('Migrating Users');
         			$this->importUsers($status, $account, $domain, $dbh, $con);
         			$status->done();
         */
         $usersByName = $this->getUsers($account, $con);
         $clockingTypeMap = $this->getClockingTypes($account, $con);
         $status->start('Migrating Clockings');
         $clockingDataByOldID = $this->importClockings($status, $clockingTypeMap, $usersByName, $dbh, $con);
         $status->done();
         $bookingTypesByIdentifier = $this->getBookingTypes($account, $con);
         $status->start('Migrating Transactions');
         $this->importTransactions($status, $clockingTypeMap, $bookingTypesByIdentifier, $usersByName, $clockingDataByOldID, $dbh, $con);
         $status->done();
         echo '#INCONSISTENCIES: ' . $this->inconsistencies;
         $dbh = null;
     } catch (Exception $e) {
         echo 'Error: ' . nl2br(htmlspecialchars($e->getMessage())) . '<br/>';
         $status->showNotes($e->getMessage());
         die;
     }
     print '<p>Finished migration!</p></div>';
     $status->showNotes();
 }
Exemple #3
0
 /**
  * If this collection has already been initialized with
  * an identical criteria, it returns the collection.
  * Otherwise if this Account is new, it will return
  * an empty collection; or if this Account has previously
  * been saved, it will retrieve related Domains from storage.
  *
  * This method is protected by default in order to keep the public
  * api reasonable.  You can provide public methods for those you
  * actually need in Account.
  *
  * @param Criteria $criteria optional Criteria object to narrow the query
  * @param PropelPDO $con optional connection object
  * @param string $join_behavior optional join type to use (defaults to Criteria::LEFT_JOIN)
  * @return PropelObjectCollection|Domain[] List of Domain objects
  */
 public function getDomainsJoinAddress($criteria = null, $con = null, $join_behavior = Criteria::LEFT_JOIN)
 {
     $query = DomainQuery::create(null, $criteria);
     $query->joinWith('Address', $join_behavior);
     return $this->getDomains($query, $con);
 }
Exemple #4
0
 /**
  * Get the associated Domain object
  *
  * @param PropelPDO $con Optional Connection object.
  * @param $doQuery Executes a query to get the object if required
  * @return Domain The associated Domain object.
  * @throws PropelException
  */
 public function getDomain(PropelPDO $con = null, $doQuery = true)
 {
     if ($this->aDomain === null && $this->domain_id !== null && $doQuery) {
         $this->aDomain = DomainQuery::create()->findPk($this->domain_id, $con);
         /* The following can be used additionally to
               guarantee the related object contains a reference
               to this object.  This level of coupling may, however, be
               undesirable since it could result in an only partially populated collection
               in the referenced object.
               $this->aDomain->addHolidayDomains($this);
            */
     }
     return $this->aDomain;
 }
Exemple #5
0
 /**
  * Lists users of a domain.
  *
  * For non-administrative users, the list will contain the authenticated user only.
  *
  * @param string $strSearch Search query
  * @param string $intDomain Filter by domain
  * @param bool $showDeleted Show deleted users
  * @param string $strOrderby OrderBy Column
  * @param string $strOrderMode Order mode (asc or desc)
  * @return array
  */
 public function do_list($strSearch = false, $intDomain = false, $showDeleted = false, $strOrderby = 'Name', $strOrderMode = 'asc')
 {
     $user = $this->requireUser();
     $account = $user->getAccount();
     $query = UserQuery::create()->joinWith('Domain')->joinWith('Domain.Account')->add(AccountPeer::ID, $account->getId());
     if (!$user->getIsAdmin()) {
         $query->filterById($user->getId());
     }
     Search::addSearchCriteria($query, $strSearch, array(UserPeer::NAME, UserPeer::FIRSTNAME, UserPeer::LASTNAME, UserPeer::PHONE, UserPeer::EMAIL));
     if ($intDomain) {
         if ($domain = DomainQuery::create()->findOneById($intDomain)) {
             $query->filterByDomain($domain);
         } else {
             throw new Exception('Domain ID "' . $intDomain . '" not found!');
         }
     }
     if ($strOrderMode != 'asc') {
         $strOrderMode = 'desc';
     }
     switch ($strOrderby) {
         case 'Firstname':
             $query->orderByFirstname($strOrderMode);
             break;
         case 'Lastname':
             $query->orderByLastname($strOrderMode);
             break;
         case 'Domain':
             $query->orderBy(DomainPeer::NAME, $strOrderMode);
             break;
         case 'Email':
             $query->orderByEmail($strOrderMode);
             break;
         default:
             // Name
             $query->orderByName($strOrderMode);
             break;
     }
     if (!$showDeleted) {
         $query->filterByDeleted(0);
     }
     $res = array();
     foreach ($query->find() as $user) {
         $domain = $user->getDomain();
         $item = EntityArray::from($user) + array('Domain' => array('Name' => $domain->getName(), 'Id' => $domain->getId())) + array('Account' => array('Name' => $domain->getAccount()->getName(), 'Id' => $domain->getAccountId()));
         $res[] = $item;
     }
     return $res;
 }
Exemple #6
0
 /**
  * Updates a domain
  *
  * @param int $intId
  * @param array $arrData
  * @return int The domain ID
  */
 public function do_update($intId, $arrData)
 {
     $domain = null;
     $con = Propel::getConnection();
     if (!$con->beginTransaction()) {
         throw new Exception('Could not start transaction.');
     }
     try {
         $user = $this->requireUser();
         $account = $user->getAccount($con);
         // Validate input data
         $validator = new KickstartValidator();
         $locale = Localizer::getInstance();
         $warnings = $validator->filterErrors($arrData, $this->initFilter($this->filter_basic, $locale));
         if ($warnings) {
             $con->rollBack();
             return array('result' => false, 'warnings' => $warnings);
         }
         $query = DomainQuery::create()->filterByAccount($account);
         if ($intId !== null) {
             $domain = DomainQuery::create()->filterByAccount($account)->findOneById($intId, $con);
             if ($domain === null) {
                 throw new Exception('Domain not found; ID: ' . $intId);
             }
             $query->filterById($intId, Criteria::NOT_EQUAL);
         } else {
             $domain = new Domain();
             $domain->setAccount($account);
         }
         // Check for duplicates
         if ($query->findOneByName($arrData['Name'], $con)) {
             throw new Exception($locale->insert('error.taken', array('value' => '"' . $arrData['Name'] . '"')));
         }
         $domain->fromArray(array_intersect_key($arrData, array('AddressId' => true, 'Name' => true, 'Description' => true, 'Number' => true)));
         $domain->save($con);
         if (!empty($arrData['Properties'])) {
             $domain->setProperties($arrData['Properties'], $con);
         }
     } catch (Exception $e) {
         $con->rollBack();
         throw $e;
     }
     if (!$con->commit()) {
         throw new Exception('Could not commit transaction.');
     }
     return $domain->getId();
 }
Exemple #7
0
 /**
  * Returns a new DomainQuery object.
  *
  * @param     string $modelAlias The alias of a model in the query
  * @param   DomainQuery|Criteria $criteria Optional Criteria to build the query from
  *
  * @return DomainQuery
  */
 public static function create($modelAlias = null, $criteria = null)
 {
     if ($criteria instanceof DomainQuery) {
         return $criteria;
     }
     $query = new DomainQuery();
     if (null !== $modelAlias) {
         $query->setModelAlias($modelAlias);
     }
     if ($criteria instanceof Criteria) {
         $query->mergeWith($criteria);
     }
     return $query;
 }
Exemple #8
0
 /**
  * Gets another domain from the same account.
  *
  * @param int $domainId
  * @param PropelPDO $con Optional. The database connection to use.
  *     Default is NULL.
  * @return Domain
  * @throws Exception
  */
 public function getOtherDomain($domainId, PropelPDO $con = null)
 {
     $domain = DomainQuery::create()->findOneById($domainId, $con);
     if ($domain === null) {
         throw new Exception('Domain with ID ' . $domainId . ' not found!');
     }
     $account = $this->getAccount($con);
     if ($account === null or $domain->getAccountId() != $account->getId()) {
         throw new Exception('The domain does not belong to our account!');
     }
     return $domain;
 }
Exemple #9
0
 /**
  * Updates a holiday
  *
  * @param int $intId The holiday ID
  * @param array $arrData
  * @return int The holiday ID
  */
 public function do_update($intId, $arrData)
 {
     $user = $this->requireUser();
     // Validate input data
     $validator = new KickstartValidator();
     $locale = Localizer::getInstance();
     $warnings = $validator->filterErrors($arrData, $this->initFilter($this->filter_basic, $locale));
     if ($warnings) {
         return array('result' => false, 'warnings' => $warnings);
     }
     if ($intId) {
         if (!($holiday = HolidayQuery::create()->findOneById($intId))) {
             throw new Exception('Holiday with ID ' . $intId . ' not found!');
         }
     } else {
         $holiday = new Holiday();
     }
     $con = Propel::getConnection(HolidayPeer::DATABASE_NAME);
     $con->beginTransaction();
     try {
         $holiday->setName($arrData['Name'])->setDate($arrData['Date'])->setAccount($user->getAccount())->save($con);
         // Assign the domains
         if (!(isset($arrData['Domains']) && is_array($arrData['Domains']))) {
             $arrData['Domains'] = array();
         }
         $sub = array();
         foreach (HolidayDomainQuery::create()->filterByHoliday($holiday)->find() as $link) {
             if (in_array($link->getDomainId(), $arrData['Domains'])) {
                 $sub[] = $link->getDomainId();
             } else {
                 $link->delete($con);
             }
         }
         $diff = array_diff($arrData['Domains'], $sub);
         if (sizeof($diff) > 0) {
             // Get the account's domains
             $domainFilter = DomainQuery::create()->filterByAccount($user->getAccount())->add(DomainPeer::ID, $arrData['Domains'], Criteria::IN)->find();
             if (sizeof($domainFilter) != sizeof($arrData['Domains'])) {
                 // Obviously there are some domains the user does not belong to
             }
             foreach (array_diff($arrData['Domains'], $sub) as $domainId) {
                 $link = new HolidayDomain();
                 $link->setHoliday($holiday)->setDomainId($domainId)->save($con);
             }
         }
         $con->commit();
     } catch (Exception $e) {
         $con->rollBack();
         throw $e;
     }
     return array('result' => $holiday->getId(), 'test' => $diff);
     // return $holiday->getId();
 }
Exemple #10
0
 /**
  * Removes this object from datastore and sets delete attribute.
  *
  * @param PropelPDO $con
  * @return void
  * @throws PropelException
  * @throws Exception
  * @see        BaseObject::setDeleted()
  * @see        BaseObject::isDeleted()
  */
 public function delete(PropelPDO $con = null)
 {
     if ($this->isDeleted()) {
         throw new PropelException("This object has already been deleted.");
     }
     if ($con === null) {
         $con = Propel::getConnection(DomainPeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
     }
     $con->beginTransaction();
     try {
         $deleteQuery = DomainQuery::create()->filterByPrimaryKey($this->getPrimaryKey());
         $ret = $this->preDelete($con);
         if ($ret) {
             $deleteQuery->delete($con);
             $this->postDelete($con);
             $con->commit();
             $this->setDeleted(true);
         } else {
             $con->commit();
         }
     } catch (Exception $e) {
         $con->rollBack();
         throw $e;
     }
 }