PHP PropelObjectCollection::append方法代码示例

 public static function addProductWhenAjaxChangeActive($arg)
 {
     /* @var $model SProducts */
     $models = $arg['model'];
     /* @var $ci MY_Controller */
     $ci =& get_instance();
     if (!$models instanceof \PropelObjectCollection) {
         $model = $models;
         $models = new \PropelObjectCollection();
         $models->append($model);
     }
     foreach ($models as $model) {
         if ($model->getActive()) {
             $ci->db->where('trash_url', 'shop/product/' . $model->getUrl())->delete('trash');
         } else {
             $array = array('trash_id' => $model->getCategoryId(), 'trash_url' => 'shop/product/' . $model->getUrl(), 'trash_redirect_type' => 'category', 'trash_type' => '302', 'trash_redirect' => shop_url('category/' . $model->getMainCategory()->getFullPath()));
             $ci->db->insert('trash', $array);
         }
     }
 }

 /**
  * When a relation PK is a composite, replacing the list of relations will flag some of them to be deleted.
  * We primary keys on the "To be deleted" opinions must not be blanked (null) because we need to values to be able to delete the entry.
  */
 public function testReplace_RelationWithCompositePK()
 {
     BookReaderQuery::create()->deleteAll();
     BookQuery::create()->deleteAll();
     BookOpinionQuery::create()->deleteAll();
     $br1 = new BookReader();
     $br1->setName("TestReader");
     $br1->save();
     $br2 = new BookReader();
     $br2->setName("TestReader2");
     $br2->save();
     $b = new Book();
     $b->setTitle("TestBook");
     $b->setISBN("XX-XX-XX-XX");
     $b->save();
     $op1 = new BookOpinion();
     $op1->setBookReader($br1);
     $op1->setBook($b);
     $op1->setRating(10);
     $op1->setRecommendToFriend(true);
     $op1->save();
     // make sure everything is loaded correctly (and their relation too)
     $br1->reload(true);
     $b->reload(true);
     $op1->reload(true);
     $br2->reload(true);
     $op2 = new BookOpinion();
     $op2->setBookReader($br2);
     $op2->setRating(8);
     $op2->setRecommendToFriend(false);
     // the setBookOpinions function expect a PropelCollection
     $pc = new PropelObjectCollection();
     $pc->setModel('BookOpinion');
     $pc->append($op2);
     $br1->getBookOpinions();
     // load the relation
     $b->setBookOpinions($pc);
     // this will flag to be deleted the currently assigned opinion and will add the new opinion so it will can be saved
     $b->save();
     // this will delete $op1 and insert $op2
     $this->assertEquals(2, BookReaderQuery::create()->count(), '2 BookReader');
     $this->assertEquals(1, BookQuery::create()->count(), '1 Book');
     $this->assertEquals(1, BookOpinionQuery::create()->count(), 'Only 1 BookOpinion; the new one got inserted and the previously associated one got deleted');
     $this->assertEquals(1, count($b->getBookOpinions()), 'Book has 1 BookOpinion');
     $this->assertEquals(1, count($op2->getBook()), 'BookOpinion2 has a relation to the Book');
     $this->assertEquals(1, count($br1->getBookOpinions()), 'BookReader1 has 1 BookOpinion (BookOpinion1)');
     $this->assertEquals(1, count($br2->getBookOpinions()), 'BookReader2 has 1 BookOpinion (BookOpinion2)');
     $this->assertFalse($op1->isDeleted(), 'BookOpinion1 think it has not been deleted');
     $caughtException = false;
     try {
         $op1->reload(false);
         // will fail because won't find the entry in the db
     } catch (PropelException $pe) {
         $caughtException = true;
     }
     $this->assertTrue($caughtException, 'Could not reload BookOpinion1 because it has been deleted from the db');
     $this->assertFalse($op2->isDeleted(), 'BookOpinion2 is not deleted');
     $this->assertEquals(1, count($br1->getBookOpinions()), 'BookReader1 thinks it is assigned to 1 BookOpinion (BookOpinion1)');
     $temp_op = $br1->getBookOpinions();
     $this->assertEquals(spl_object_hash($op1), spl_object_hash($temp_op[0]), 'BookReader1 assigned BookOpinion is still BookOpinion1');
     $this->assertFalse($temp_op[0]->isDeleted(), 'BookReader1 assigned BookOpinion still thinks it has not been deleted');
     $br1->reload(true);
     // and reset the relations
     $this->assertEquals(0, count($br1->getBookOpinions()), 'BookReader1 no longer has any BookOpinion');
 }

				while ($it_creneau != null && $dt_fin_cours->format('U') > $it_creneau->getHeuredebutDefiniePeriode('U')) {
					foreach ($eleve->getAbsenceEleveSaisiesDuCreneau($it_creneau, $dt_date_absence_eleve) as $abs) {
						if (!$absences_du_creneau->contains($abs)) {
							$absences_du_creneau->append($abs);
						}
					}
					$it_creneau = $it_creneau->getNextEdtCreneau();
					$nb_creneau_a_saisir++;
				}
			}
			// pour le creneau en cours on garde uniquement les absences de l'utilisateur pour ne pas l'influencer par d'autres saisies sauf si configuré autrement
			if (getSettingValue("abs2_afficher_saisies_creneau_courant")!='y') {
				$absences_du_creneau_du_prof = new PropelObjectCollection();
				foreach ($absences_du_creneau as $abs) {
						if ($abs->getUtilisateurId() == $utilisateur->getPrimaryKey()) {
								$absences_du_creneau_du_prof->append($abs);
						}
				}
				$absences_du_creneau = $absences_du_creneau_du_prof;
			}
		} else if ($current_creneau != null && $edt_creneau->getHeuredebutDefiniePeriode('U') > $current_creneau->getHeuredebutDefiniePeriode('U')) {
			//on n'affiche pas les informations apres le creneau en cours pour ne pas influencer la saisie si c'est un enseignant
			if($utilisateur->getStatut() == "professeur"){
				$absences_du_creneau = new PropelCollection();
			}else{
				$absences_du_creneau = $eleve->getAbsenceEleveSaisiesDuCreneau($edt_creneau, $dt_date_absence_eleve);
			}
		} else {
			//on affiche  les informations pour les crenaux avant la saisie sauf si configuré autrement
			if (getSettingValue("abs2_montrer_creneaux_precedents")=='y') {
				$absences_du_creneau = $eleve->getAbsenceEleveSaisiesDuCreneau($edt_creneau, $dt_date_absence_eleve);

 /**
  * @depends testUpdateObjectAuditing
  */
 public function testUpdateClassFieldAuditing()
 {
     $collection = new \PropelObjectCollection();
     $collection->setModel('Propel\\Bundle\\PropelAclBundle\\Model\\Acl\\Entry');
     $entry = $this->createEntry();
     $entry->setFieldName('name')->setSecurityIdentity(SecurityIdentity::fromAclIdentity($this->getRoleSecurityIdentity()))->setAclClass($this->getAclClass());
     $collection->append($entry);
     $acl = new AuditableAcl($collection, $this->getAclObjectIdentity(), new PermissionGrantingStrategy());
     $aces = $acl->getClassFieldAces('name');
     $this->assertCount(1, $aces);
     $acl->updateClassFieldAuditing(0, 'name', true, true);
     $aces = $acl->getClassFieldAces('name');
     $this->assertTrue($aces[0]->isAuditSuccess());
     $this->assertTrue($aces[0]->isAuditFailure());
     $acl->updateClassFieldAuditing(0, 'name', false, false);
     $aces = $acl->getClassFieldAces('name');
     $this->assertFalse($aces[0]->isAuditSuccess());
     $this->assertFalse($aces[0]->isAuditFailure());
 }

 public function testRefIsOnlySavedWhenRequired()
 {
     BookQuery::create()->deleteAll();
     $book = new Book();
     $book->setTitle('Propel Book');
     $book->setISBN('TEST');
     $book->save();
     $bookId = $book->getId();
     BookPeer::clearInstancePool();
     $summary = $this->getMock('BookSummary');
     $summary->expects($this->once())->method('isDeleted')->will($this->returnValue(false));
     $summary->expects($this->once())->method('isNew')->will($this->returnValue(false));
     $summary->expects($this->once())->method('isModified')->will($this->returnValue(false));
     $summary->expects($this->never())->method('save');
     $coll = new PropelObjectCollection();
     $coll->append($summary);
     $book = BookQuery::create()->findOneById($bookId);
     // In conjunction with the mock above, this simulates loading those entries prior saving the book.
     $book->setBookSummarys($coll);
     $book->setTitle('Propel2 Book');
     $book->save();
 }

 public function showRoles()
 {
     if (!$this->hasPermission(self::PERMISSION_ROLES)) {
         throw new Exception('You dont have permission to access this view.');
     }
     $this->addMenu();
     $user = User::getUser();
     $backendModules = Curry_Backend::getBackendList();
     $disable = array();
     $backend = array("*" => "All");
     if (!$user->hasAccess('*')) {
         $disable[] = '*';
     }
     foreach ($backendModules as $backendClass => $backendName) {
         $backend[$backendClass] = $backendName;
         $permissions = method_exists($backendClass, 'getPermissions') ? call_user_func(array($backendClass, 'getPermissions')) : array();
         foreach ($permissions as $permission) {
             $backend[$backendClass . "/" . $permission] = Curry_Core::SELECT_TREE_PREFIX . $permission;
             if (!$user->hasAccess($backendClass . "/" . $permission)) {
                 $disable[] = $backendClass . "/" . $permission;
             }
         }
         if (!$user->hasAccess($backendClass)) {
             $disable[] = $backendClass;
         }
     }
     $content = array();
     $contentAccess = array("*" => "All") + Curry_Module::getModuleList();
     $allContentAccess = $user->hasAccess('Curry_Backend_Content/*');
     foreach ($contentAccess as $k => $v) {
         $content['Curry_Backend_Content/' . $k] = $v;
         if (!$allContentAccess && !$user->hasAccess('Curry_Backend_Content/' . $k)) {
             $disable[] = 'Curry_Backend_Content/' . $k;
         }
     }
     $form = new Curry_ModelView_Form('UserRole', array('elements' => array('backend' => array('multiselect', array('label' => 'Backend access', 'multiOptions' => $backend, 'size' => 10, 'order' => 1, 'disable' => $disable, 'validators' => array(array('InArray', true, array(array_diff(array_keys($backend), $disable)))))), 'content' => array('multiselect', array('label' => 'Content access', 'multiOptions' => $content, 'size' => 10, 'order' => 2, 'disable' => $disable, 'validators' => array(array('InArray', true, array(array_diff(array_keys($content), $disable))))))), 'onFillForm' => function (UserRole $role, $form) {
         $access = UserRoleAccessQuery::create()->filterByUserRole($role)->select('Module')->find()->getArrayCopy();
         $form->backend->setValue($access);
         $form->content->setValue($access);
     }, 'onFillModel' => function (UserRole $role, $form, $values) {
         $access = array_merge((array) $values['backend'], (array) $values['content']);
         $collection = new PropelObjectCollection();
         $collection->setModel('UserRoleAccess');
         foreach ($access as $a) {
             $ura = new UserRoleAccess();
             $ura->setModule($a);
             $collection->append($ura);
         }
         $role->setUserRoleAccesss($collection);
     }));
     $q = UserRoleQuery::create();
     $list = new Curry_ModelView_List($q, array('modelForm' => $form));
     $list->addAction('file_permissions', array('action' => $this->getFileAccessList(), 'class' => 'inline', 'single' => true));
     $list->show($this);
 }

	/**
	 *
	 * Renvoi sous forme d'un tableau la liste des profs d'une classe.
	 * Manually added for N:M relationship
	 *
	 * @periode integer numero de la periode
	 * @return     PropelObjectCollection UtilisateurProfessionel[]
	 *
	 */
	public function getProfesseurs() {
		$profs = new PropelObjectCollection();
		$criteria = new Criteria();
		$criteria->add(JGroupesProfesseursPeer::ID_GROUPE,$this->getId());
		foreach($this->getJGroupesProfesseurssJoinUtilisateurProfessionnel($criteria) as $ref) {
		    if ($ref != null && $ref->getUtilisateurProfessionnel() != null) {
			$profs->append($ref->getUtilisateurProfessionnel());
		    }
		}
		return $profs;
	}

 public function testToKeyValue()
 {
     $author = new Author();
     $author->setId(5678);
     $author->setFirstName('George');
     $author->setLastName('Byron');
     $book = new Book();
     $book->setId(9012);
     $book->setTitle('Don Juan');
     $book->setISBN('0140422161');
     $book->setPrice(12.99);
     $book->setAuthor($author);
     $coll = new PropelObjectCollection();
     $coll->setModel('Book');
     $coll->append($book);
     $this->assertCount(1, $coll);
     // This will call $book->getId()
     $this->assertEquals(array(9012 => 'Don Juan'), $coll->toKeyValue('Id', 'Title'));
     // This will call: $book->getAuthor()->getBooks()->getFirst()->getId()
     $this->assertEquals(array(9012 => 'Don Juan'), $coll->toKeyValue(array('Author', 'Books', 'First', 'Id'), 'Title'));
 }

 public function testSerializeUnserialize()
 {
     $collection = new \PropelObjectCollection();
     $collection->setModel('Propel\\PropelBundle\\Model\\Acl\\Entry');
     $entry = $this->createEntry();
     $entry->setSecurityIdentity(SecurityIdentity::fromAclIdentity($this->getRoleSecurityIdentity('ROLE_ADMIN')))->setAclClass($this->getAclClass());
     $collection->append($entry);
     $acl = new MutableAcl($collection, $this->getAclObjectIdentity(), new PermissionGrantingStrategy());
     $serialized = serialize($acl);
     $unserialized = unserialize($serialized);
     $this->assertNotEmpty($serialized);
     $this->assertNotEmpty($unserialized);
     $this->assertInstanceOf('Propel\\PropelBundle\\Security\\Acl\\Domain\\MutableAcl', $unserialized);
     $this->assertEquals($serialized, serialize($unserialized));
 }

		    $message_enregistrement .= ", le type ne correspond pas au cours.";
		} else {
		    $saisie = new AbsenceEleveSaisie();
		    $saisie->setUtilisateurProfessionnel($utilisateur);
		    $saisie->setCommentaire($commentaire);

		    $date_debut = $current_cours->getDate($semaine->getNumEdtSemaine());
		    $date_debut->setTime($current_cours->getHeureDebut('H'), $current_cours->getHeureDebut('i'));
		    $saisie->setDebutAbs($date_debut);

		    $date_fin = clone $date_debut;
		    $heure_fin = $current_cours->getHeureFin();
		    $date_fin->setTime($current_cours->getHeureFin('H'), $current_cours->getHeureFin('i'));
		    $saisie->setFinAbs($date_fin);

		    $saisie_col_modele->append($saisie);
		}
	}
    }
} else {
    try {
	$date_debut = new DateTime(str_replace("/",".",$_POST['date_absence_eleve_debut_saisir_eleve']));
    } catch (Exception $x) {
	$message_enregistrement .= "Mauvais format de date.<br/>";
    }
    try {
	$date_fin = new DateTime(str_replace("/",".",$_POST['date_absence_eleve_fin_saisir_eleve']));
    } catch (Exception $x) {
	$message_enregistrement .= "Mauvais format de date.<br/>";
    }

	/**
	 *
	 * Renvoi un liste de saisies qui sont en contradiction avec celle la concernant le manquement des obligations de presence (apparition dans le bulletin)
	 *
	 * @param boolean $retourne_booleen la fonction retourne vrai ou faux selon qu'il y ai des saisies contradictoires au lieu de retourner une collection
	 *
	 * @return mixed boolean or PropelObjectCollection AbsenceEleveSaisie[]
	 *
	 */
	public function getSaisiesContradictoiresManquementObligation($retourne_booleen = false) {
	    //if (isset($this->boolSaisiesContradictoiresManquementObligation)) {echo 'mis en cache';} else {echo 'pas de cache';}
	    if (($retourne_booleen && (!isset($this->boolSaisiesContradictoiresManquementObligation) || $this->boolSaisiesContradictoiresManquementObligation === null))
		|| (!$retourne_booleen && (!isset($this->collectionSaisiesContradictoiresManquementObligation) || $this->collectionSaisiesContradictoiresManquementObligation === null))) {
		$result = new PropelObjectCollection();
		$result->setModel('AbsenceEleveSaisie');
		if ($this->getEleve() === null) {
		    $this->boolSaisiesContradictoiresManquementObligation = false;
		    $this->collectionSaisiesContradictoiresManquementObligation = $result;
		} else {

		    //on regarde les saisies sur cet eleve
		    $eleve = $this->getEleve();
		    $manque = $this->getManquementObligationPresence();
		    foreach ($eleve->getAbsenceEleveSaisiesFilterByDate($this->getDebutAbs(null), $this->getFinAbs(null)) as $saisie) {
			if ($manque !== $saisie->getManquementObligationPresence()) {
			    if ($retourne_booleen) {
				$this->boolSaisiesContradictoiresManquementObligation = true;
				return true;
			    }
			    $result->append($saisie);
			}
		    }

		    if ($manque == true) {
			//on recupere les saisies de marquage d'absence (donc sans eleves) qui se chevauchent avec celle-la
			//optimisation : utiliser la requete pour stocker ca
			if (isset($_REQUEST['query_AbsenceEleveSaisieQuery_getSaisiesContradictoires_'.$this->getDebutAbs('U').'_'.$this->getFinAbs('U')])
				&& $_REQUEST['query_AbsenceEleveSaisieQuery_getSaisiesContradictoires_'.$this->getDebutAbs('U').'_'.$this->getFinAbs('U')] != null) {
			    $saisie_col = $_REQUEST['query_AbsenceEleveSaisieQuery_getSaisiesContradictoires_'.$this->getDebutAbs('U').'_'.$this->getFinAbs('U')];
			} else {
			    $query = AbsenceEleveSaisieQuery::create();
			    $query->filterByPlageTemps($this->getDebutAbs(null), $this->getFinAbs(null))
				->add(AbsenceEleveSaisiePeer::ELEVE_ID, NULL)
                                ->addOr(AbsenceEleveSaisiePeer::ELEVE_ID, $this->getEleveId())
                                ;
			    $saisie_col = $query->find();
			    $_REQUEST['query_AbsenceEleveSaisieQuery_getSaisiesContradictoires_'.$this->getDebutAbs('U').'_'.$this->getFinAbs('U')] = $saisie_col;
			}

			//on va filtrer pour supprimer de la liste les aid, classe ou groupe qui serait le meme que cette saisie la
			$temp_saisie_col = new PropelObjectCollection();
			$temp_saisie_col->setModel('AbsenceEleveSaisie');
			if ($this->getClasse() != null) {
			    foreach ($saisie_col as $saisie) {
				if ($saisie->getIdClasse() != $this->getIdClasse()) {
				    $temp_saisie_col->append($saisie);
				}
			    }
			} elseif ($this->getGroupe() != null) {
			    foreach ($saisie_col as $saisie) {
				if ($saisie->getIdGroupe() != $this->getIdGroupe()) {
				    $temp_saisie_col->append($saisie);
				}
			    }
			} elseif ($this->getAidDetails() != null) {
			    foreach ($saisie_col as $saisie) {
				if ($saisie->getIdAid() != $this->getIdAid()) {
				    $temp_saisie_col->append($saisie);
				}
			    }
			} else {
			    foreach ($saisie_col as $saisie) {
				if ($saisie->getId() != $this->getId()) {
				    $temp_saisie_col->append($saisie);
				}
			    }
			}
			$saisie_col = $temp_saisie_col;

			//on regarde si un groupe, classe ou aid auquel appartient cet eleve a été saisi et pour lequel l'eleve en question n'a pas ete saisi (c'est donc que l'eleve est present)
			//on va utiliser comme periode pour determiner les classes et groupes la periode correspondant au debut de l'absence
			$periode = $eleve->getPeriodeNote($this->getDebutAbs(null));

			//on recupere la liste des classes de l'eleve et on regarde si il y a eu des saisies pour ces classes
			$classes = $eleve->getClasses($periode);
			$saisie_col_classe_id_array = $saisie_col->toKeyValue('PrimaryKey','IdClasse');
			$saisie_col_array_copy = $saisie_col->getArrayCopy('Id');
			foreach ($classes as $classe) {
			    $keys = array_keys($saisie_col_classe_id_array, $classe->getId());
			    if (!empty($keys)) {
				//on a des saisies pour cette classe
				//est-ce que l'eleve a bien été saisi absent ?
				$temp_col = new PropelObjectCollection();
				$bool_eleve_saisi = false;
				foreach ($keys as $key) {
				    $saisie_temp = $saisie_col_array_copy[$key];
				    if ($saisie_temp->getEleveId() === null) {
					$temp_col->append($saisie_temp);
				    }
				    if ($this->getEleveId() == $saisie_temp->getEleveId()) {
//.........这里部分代码省略.........

 public function testCollectionRemoveDoesNothingWhenObjectIsNotFound()
 {
     $manager = new ModelManager();
     $object = new \stdClass();
     $object->foo = 42;
     $otherObject = new \stdClass();
     $otherObject->bar = 'baz';
     $collection = new \PropelObjectCollection();
     $collection->append($object);
     $this->assertSame(array($object), $collection->getArrayCopy());
     $manager->collectionRemoveElement($collection, $otherObject);
     $this->assertSame(array($object), $collection->getArrayCopy());
 }

  	/**
	 *
	 * Retourne une liste de saisie dont la periode de temps coincide avec les dates passees en paremetre (methode optimisee)
	 *
	 * @param      $dt_debut DateTime
	 * @param      $dt_fin DateTime
	 *
 	 * @return PropelColection AbsenceEleveSaisie[]
	 */
	public function getAbsenceEleveSaisiesFilterByDate($dt_debut, $dt_fin) {
	    $result = new PropelObjectCollection();
	    $result->setModel('AbsenceEleveSaisie');
	    if ($dt_debut != null && $dt_debut->format('d/m/Y') == $dt_fin->format('d/m/Y')) {
		//on a une date de debut et de fin le meme jour, on va optimiser un peu
		$saisie_col = $this->getAbsenceEleveSaisiesDuJour($dt_debut);
	    } else {
		if ($this->countAbsenceEleveSaisies() > 100) {
		    //il y a trop de saisie, on passe l'optimisation et on fait une requete db
		    $query = AbsenceEleveSaisieQuery::create()->filterByEleve($this);
		    $query->filterByPlageTemps($dt_debut, $dt_fin)
			->leftJoinWith('AbsenceEleveSaisie.JTraitementSaisieEleve')
			->leftJoinWith('JTraitementSaisieEleve.AbsenceEleveTraitement')
			->leftJoinWith('AbsenceEleveTraitement.AbsenceEleveType');
		    return $query->distinct()->find();
		} else {
		    $saisie_col = $this->getAbsenceEleveSaisies();
		}
	    }
	    foreach ($saisie_col as $saisie) {
		if ($dt_debut != null && $dt_fin!= null && $dt_debut->format('U') == $dt_fin->format('U')) {
		    //si on a un seul dateTime pour la plage de recherche, on renvoi les saisie qui chevauchent cette date
		    //ainsi que les saisies qui commence juste à cette date
		    if ($dt_debut->format('U') >=  $saisie->getFinAbs('U')) {
			continue;
		    }
		    if ($dt_fin != null && ($dt_fin->format('U') <  $saisie->getDebutAbs('U'))) {
			continue;
		    }
		    $result->append($saisie);
		} else {
		    if ($dt_debut != null && ($dt_debut->format('U') >=  $saisie->getFinAbs('U'))) {
			continue;
		    }
		    if ($dt_fin != null && ($dt_fin->format('U') <=  $saisie->getDebutAbs('U'))) {
			continue;
		    }
		    $result->append($saisie);
		}
	    }

	    return $result;
	}