/**
* Filter the query by a related MeshingSchema object
*
* @param MeshingSchema|PropelCollection $meshingSchema The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return MeshingSchemaTableQuery The current query, for fluid interface
*/
public function filterByMeshingSchema($meshingSchema, $comparison = null)
{
if ($meshingSchema instanceof MeshingSchema) {
return $this->addUsingAlias(MeshingSchemaTablePeer::SCHEMA_ID, $meshingSchema->getId(), $comparison);
} elseif ($meshingSchema instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(MeshingSchemaTablePeer::SCHEMA_ID, $meshingSchema->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByMeshingSchema() only accepts arguments of type MeshingSchema or PropelCollection');
}
}
/**
* Filter the query by a related MeshingTrustType object
*
* @param MeshingTrustType|PropelCollection $meshingTrustType The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return MeshingTrustLocalQuery The current query, for fluid interface
*/
public function filterByMeshingTrustType($meshingTrustType, $comparison = null)
{
if ($meshingTrustType instanceof MeshingTrustType) {
return $this->addUsingAlias(MeshingTrustLocalPeer::TYPE, $meshingTrustType->getId(), $comparison);
} elseif ($meshingTrustType instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(MeshingTrustLocalPeer::TYPE, $meshingTrustType->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByMeshingTrustType() only accepts arguments of type MeshingTrustType or PropelCollection');
}
}
/**
* Filter the query by a related CahierTexteSequence object
*
* @param CahierTexteSequence|PropelCollection $cahierTexteSequence The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return CahierTexteCompteRenduQuery The current query, for fluid interface
*/
public function filterByCahierTexteSequence($cahierTexteSequence, $comparison = null)
{
if ($cahierTexteSequence instanceof CahierTexteSequence) {
return $this
->addUsingAlias(CahierTexteCompteRenduPeer::ID_SEQUENCE, $cahierTexteSequence->getId(), $comparison);
} elseif ($cahierTexteSequence instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this
->addUsingAlias(CahierTexteCompteRenduPeer::ID_SEQUENCE, $cahierTexteSequence->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByCahierTexteSequence() only accepts arguments of type CahierTexteSequence or PropelCollection');
}
}
/**
* Filter the query by a related Usuario object
*
* @param Usuario|PropelCollection $usuario The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return Libro_colaboradorQuery The current query, for fluid interface
*/
public function filterByUsuario($usuario, $comparison = null)
{
if ($usuario instanceof Usuario) {
return $this->addUsingAlias(Libro_colaboradorPeer::IDUSUARIO, $usuario->getId(), $comparison);
} elseif ($usuario instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(Libro_colaboradorPeer::IDUSUARIO, $usuario->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByUsuario() only accepts arguments of type Usuario or PropelCollection');
}
}
/**
* Filter the query by a related User object
*
* @param User|PropelCollection $user The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ActionQuery The current query, for fluid interface
*/
public function filterByUser($user, $comparison = null)
{
if ($user instanceof User) {
return $this->addUsingAlias(ActionPeer::USER_ID, $user->getId(), $comparison);
} elseif ($user instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(ActionPeer::USER_ID, $user->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByUser() only accepts arguments of type User or PropelCollection');
}
}
/**
* Filter the query by a related Pelicula object
*
* @param Pelicula|PropelCollection $pelicula The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return SocioAlquilerQuery The current query, for fluid interface
*/
public function filterByPelicula($pelicula, $comparison = null)
{
if ($pelicula instanceof Pelicula) {
return $this->addUsingAlias(SocioAlquilerPeer::PELICULA_ID, $pelicula->getId(), $comparison);
} elseif ($pelicula instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(SocioAlquilerPeer::PELICULA_ID, $pelicula->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByPelicula() only accepts arguments of type Pelicula or PropelCollection');
}
}
/**
* Filter the query by a related AbsenceEleveTraitement object
*
* @param AbsenceEleveTraitement|PropelCollection $absenceEleveTraitement The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return JTraitementSaisieEleveQuery The current query, for fluid interface
*/
public function filterByAbsenceEleveTraitement($absenceEleveTraitement, $comparison = null)
{
if ($absenceEleveTraitement instanceof AbsenceEleveTraitement) {
return $this
->addUsingAlias(JTraitementSaisieElevePeer::A_TRAITEMENT_ID, $absenceEleveTraitement->getId(), $comparison);
} elseif ($absenceEleveTraitement instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this
->addUsingAlias(JTraitementSaisieElevePeer::A_TRAITEMENT_ID, $absenceEleveTraitement->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByAbsenceEleveTraitement() only accepts arguments of type AbsenceEleveTraitement or PropelCollection');
}
}
/**
* Filter the query by a related Dept object
*
* @param Dept|PropelCollection $dept The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return DeptMetadataQuery The current query, for fluid interface
*/
public function filterByDept($dept, $comparison = null)
{
if ($dept instanceof Dept) {
return $this->addUsingAlias(DeptMetadataPeer::DEPT_B_ID, $dept->getBId(), $comparison);
} elseif ($dept instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(DeptMetadataPeer::DEPT_B_ID, $dept->toKeyValue('PrimaryKey', 'BId'), $comparison);
} else {
throw new PropelException('filterByDept() only accepts arguments of type Dept or PropelCollection');
}
}
/**
* Filter the query by a related Socio object
*
* @param Socio|PropelCollection $socio The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return AlquilerQuery The current query, for fluid interface
*/
public function filterBySocio($socio, $comparison = null)
{
if ($socio instanceof Socio) {
return $this->addUsingAlias(AlquilerPeer::SOCIO_ID, $socio->getId(), $comparison);
} elseif ($socio instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(AlquilerPeer::SOCIO_ID, $socio->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterBySocio() only accepts arguments of type Socio or PropelCollection');
}
}
/**
* Filter the query by a related CahierTexteCompteRendu object
*
* @param CahierTexteCompteRendu|PropelCollection $cahierTexteCompteRendu The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return CahierTexteCompteRenduFichierJointQuery The current query, for fluid interface
*/
public function filterByCahierTexteCompteRendu($cahierTexteCompteRendu, $comparison = null)
{
if ($cahierTexteCompteRendu instanceof CahierTexteCompteRendu) {
return $this
->addUsingAlias(CahierTexteCompteRenduFichierJointPeer::ID_CT, $cahierTexteCompteRendu->getIdCt(), $comparison);
} elseif ($cahierTexteCompteRendu instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this
->addUsingAlias(CahierTexteCompteRenduFichierJointPeer::ID_CT, $cahierTexteCompteRendu->toKeyValue('PrimaryKey', 'IdCt'), $comparison);
} else {
throw new PropelException('filterByCahierTexteCompteRendu() only accepts arguments of type CahierTexteCompteRendu or PropelCollection');
}
}
/**
* Filter the query by a related Producto object
*
* @param Producto|PropelCollection $producto The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return VentaQuery The current query, for fluid interface
*/
public function filterByProducto($producto, $comparison = null)
{
if ($producto instanceof Producto) {
return $this->addUsingAlias(VentaPeer::IDPRODUCTO, $producto->getIdproducto(), $comparison);
} elseif ($producto instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(VentaPeer::IDPRODUCTO, $producto->toKeyValue('PrimaryKey', 'Idproducto'), $comparison);
} else {
throw new PropelException('filterByProducto() only accepts arguments of type Producto or PropelCollection');
}
}
/**
* Filter the query by a related sfGuardGroup object
*
* @param sfGuardGroup|PropelCollection $sfGuardGroup The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return sfGuardUserGroupQuery The current query, for fluid interface
*/
public function filterBysfGuardGroup($sfGuardGroup, $comparison = null)
{
if ($sfGuardGroup instanceof sfGuardGroup) {
return $this->addUsingAlias(sfGuardUserGroupPeer::GROUP_ID, $sfGuardGroup->getId(), $comparison);
} elseif ($sfGuardGroup instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(sfGuardUserGroupPeer::GROUP_ID, $sfGuardGroup->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterBysfGuardGroup() only accepts arguments of type sfGuardGroup or PropelCollection');
}
}
/**
* Filter the query by a related Classe object
*
* @param Classe|PropelCollection $classe The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return PeriodeNoteQuery The current query, for fluid interface
*/
public function filterByClasse($classe, $comparison = null)
{
if ($classe instanceof Classe) {
return $this
->addUsingAlias(PeriodeNotePeer::ID_CLASSE, $classe->getId(), $comparison);
} elseif ($classe instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this
->addUsingAlias(PeriodeNotePeer::ID_CLASSE, $classe->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByClasse() only accepts arguments of type Classe or PropelCollection');
}
}
/**
* Filter the query by a related Eleve object
*
* @param Eleve|PropelCollection $eleve The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return JAidElevesQuery The current query, for fluid interface
*/
public function filterByEleve($eleve, $comparison = null)
{
if ($eleve instanceof Eleve) {
return $this
->addUsingAlias(JAidElevesPeer::LOGIN, $eleve->getLogin(), $comparison);
} elseif ($eleve instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this
->addUsingAlias(JAidElevesPeer::LOGIN, $eleve->toKeyValue('PrimaryKey', 'Login'), $comparison);
} else {
throw new PropelException('filterByEleve() only accepts arguments of type Eleve or PropelCollection');
}
}
/**
* Filter the query by a related Tipo_notificacion object
*
* @param Tipo_notificacion|PropelCollection $tipo_notificacion The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return NotificacionQuery The current query, for fluid interface
*/
public function filterByTipo_notificacion($tipo_notificacion, $comparison = null)
{
if ($tipo_notificacion instanceof Tipo_notificacion) {
return $this->addUsingAlias(NotificacionPeer::ID_TIPO_NOTIFICACION, $tipo_notificacion->getId(), $comparison);
} elseif ($tipo_notificacion instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(NotificacionPeer::ID_TIPO_NOTIFICACION, $tipo_notificacion->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByTipo_notificacion() only accepts arguments of type Tipo_notificacion or PropelCollection');
}
}
/**
* Filter the query by a related AncienEtablissement object
*
* @param AncienEtablissement|PropelCollection $ancienEtablissement The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return JEleveAncienEtablissementQuery The current query, for fluid interface
*/
public function filterByAncienEtablissement($ancienEtablissement, $comparison = null)
{
if ($ancienEtablissement instanceof AncienEtablissement) {
return $this
->addUsingAlias(JEleveAncienEtablissementPeer::ID_ETABLISSEMENT, $ancienEtablissement->getId(), $comparison);
} elseif ($ancienEtablissement instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this
->addUsingAlias(JEleveAncienEtablissementPeer::ID_ETABLISSEMENT, $ancienEtablissement->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByAncienEtablissement() only accepts arguments of type AncienEtablissement or PropelCollection');
}
}
/**
* Filter the query by a related AbsenceEleveLieu object
*
* @param AbsenceEleveLieu|PropelCollection $absenceEleveLieu The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return AbsenceEleveSaisieQuery The current query, for fluid interface
*/
public function filterByAbsenceEleveLieu($absenceEleveLieu, $comparison = null)
{
if ($absenceEleveLieu instanceof AbsenceEleveLieu) {
return $this
->addUsingAlias(AbsenceEleveSaisiePeer::ID_LIEU, $absenceEleveLieu->getId(), $comparison);
} elseif ($absenceEleveLieu instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this
->addUsingAlias(AbsenceEleveSaisiePeer::ID_LIEU, $absenceEleveLieu->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByAbsenceEleveLieu() only accepts arguments of type AbsenceEleveLieu or PropelCollection');
}
}
/**
* Filter the query by a related sfGuardUser object
*
* @param sfGuardUser|PropelCollection $sfGuardUser The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return FileQuery The current query, for fluid interface
*/
public function filterBysfGuardUser($sfGuardUser, $comparison = null)
{
if ($sfGuardUser instanceof sfGuardUser) {
return $this->addUsingAlias(FilePeer::LAST_CHANGE_COMMIT_USER, $sfGuardUser->getId(), $comparison);
} elseif ($sfGuardUser instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(FilePeer::LAST_CHANGE_COMMIT_USER, $sfGuardUser->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterBysfGuardUser() only accepts arguments of type sfGuardUser or PropelCollection');
}
}
/**
* Filter the query by a related Ciudad object
*
* @param Ciudad|PropelCollection $ciudad The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ClienteQuery The current query, for fluid interface
*/
public function filterByCiudadRelatedByIdCiudad($ciudad, $comparison = null)
{
if ($ciudad instanceof Ciudad) {
return $this->addUsingAlias(ClientePeer::ID_CIUDAD, $ciudad->getIdciudad(), $comparison);
} elseif ($ciudad instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(ClientePeer::ID_CIUDAD, $ciudad->toKeyValue('PrimaryKey', 'Idciudad'), $comparison);
} else {
throw new PropelException('filterByCiudadRelatedByIdCiudad() only accepts arguments of type Ciudad or PropelCollection');
}
}
/**
* Filter the query by a related Eleve object
*
* @param Eleve|PropelCollection $eleve The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return AbsenceAgregationDecompteQuery The current query, for fluid interface
*/
public function filterByEleve($eleve, $comparison = null)
{
if ($eleve instanceof Eleve) {
return $this
->addUsingAlias(AbsenceAgregationDecomptePeer::ELEVE_ID, $eleve->getId(), $comparison);
} elseif ($eleve instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this
->addUsingAlias(AbsenceAgregationDecomptePeer::ELEVE_ID, $eleve->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByEleve() only accepts arguments of type Eleve or PropelCollection');
}
}
/**
* Filter the query by a related Genero object
*
* @param Genero|PropelCollection $genero The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ProductoQuery The current query, for fluid interface
*/
public function filterByGenero($genero, $comparison = null)
{
if ($genero instanceof Genero) {
return $this->addUsingAlias(ProductoPeer::IDGENERO, $genero->getIdgenero(), $comparison);
} elseif ($genero instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(ProductoPeer::IDGENERO, $genero->toKeyValue('PrimaryKey', 'Idgenero'), $comparison);
} else {
throw new PropelException('filterByGenero() only accepts arguments of type Genero or PropelCollection');
}
}
/**
* Filter the query by a related Privilegios object
*
* @param Privilegios|PropelCollection $privilegios The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return EmpleadoQuery The current query, for fluid interface
*/
public function filterByPrivilegios($privilegios, $comparison = null)
{
if ($privilegios instanceof Privilegios) {
return $this->addUsingAlias(EmpleadoPeer::IDPRIVILEGIO, $privilegios->getIdprivilegios(), $comparison);
} elseif ($privilegios instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(EmpleadoPeer::IDPRIVILEGIO, $privilegios->toKeyValue('PrimaryKey', 'Idprivilegios'), $comparison);
} else {
throw new PropelException('filterByPrivilegios() only accepts arguments of type Privilegios or PropelCollection');
}
}
/**
* Filter the query by a related Adresse object
*
* @param Adresse|PropelCollection $adresse The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return AbsenceEleveNotificationQuery The current query, for fluid interface
*/
public function filterByAdresse($adresse, $comparison = null)
{
if ($adresse instanceof Adresse) {
return $this
->addUsingAlias(AbsenceEleveNotificationPeer::ADR_ID, $adresse->getId(), $comparison);
} elseif ($adresse instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this
->addUsingAlias(AbsenceEleveNotificationPeer::ADR_ID, $adresse->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByAdresse() only accepts arguments of type Adresse or PropelCollection');
}
}
/**
* Filter the query by a related sfGuardPermission object
*
* @param sfGuardPermission|PropelCollection $sfGuardPermission The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return sfGuardUserPermissionQuery The current query, for fluid interface
*/
public function filterBysfGuardPermission($sfGuardPermission, $comparison = null)
{
if ($sfGuardPermission instanceof sfGuardPermission) {
return $this->addUsingAlias(sfGuardUserPermissionPeer::PERMISSION_ID, $sfGuardPermission->getId(), $comparison);
} elseif ($sfGuardPermission instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(sfGuardUserPermissionPeer::PERMISSION_ID, $sfGuardPermission->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterBysfGuardPermission() only accepts arguments of type sfGuardPermission or PropelCollection');
}
}
/**
* Filter the query by a related ResponsableEleve object
*
* @param ResponsableEleve|PropelCollection $responsableEleve The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return JNotificationResponsableEleveQuery The current query, for fluid interface
*/
public function filterByResponsableEleve($responsableEleve, $comparison = null)
{
if ($responsableEleve instanceof ResponsableEleve) {
return $this
->addUsingAlias(JNotificationResponsableElevePeer::PERS_ID, $responsableEleve->getResponsableEleveId(), $comparison);
} elseif ($responsableEleve instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this
->addUsingAlias(JNotificationResponsableElevePeer::PERS_ID, $responsableEleve->toKeyValue('PrimaryKey', 'ResponsableEleveId'), $comparison);
} else {
throw new PropelException('filterByResponsableEleve() only accepts arguments of type ResponsableEleve or PropelCollection');
}
}
/**
* Filter the query by a related Groupe object
*
* @param Groupe|PropelCollection $groupe The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return JEleveGroupeQuery The current query, for fluid interface
*/
public function filterByGroupe($groupe, $comparison = null)
{
if ($groupe instanceof Groupe) {
return $this
->addUsingAlias(JEleveGroupePeer::ID_GROUPE, $groupe->getId(), $comparison);
} elseif ($groupe instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this
->addUsingAlias(JEleveGroupePeer::ID_GROUPE, $groupe->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByGroupe() only accepts arguments of type Groupe or PropelCollection');
}
}
/**
* Filter the query by a related sfGuardUser object
*
* @param sfGuardUser|PropelCollection $sfGuardUser The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return CommentQuery The current query, for fluid interface
*/
public function filterBysfGuardUserRelatedByCheckUserId($sfGuardUser, $comparison = null)
{
if ($sfGuardUser instanceof sfGuardUser) {
return $this->addUsingAlias(CommentPeer::CHECK_USER_ID, $sfGuardUser->getId(), $comparison);
} elseif ($sfGuardUser instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(CommentPeer::CHECK_USER_ID, $sfGuardUser->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterBysfGuardUserRelatedByCheckUserId() only accepts arguments of type sfGuardUser or PropelCollection');
}
}
/**
* Filter the query by a related Course object
*
* @param Course|PropelCollection $course The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return CourseMetadataQuery The current query, for fluid interface
*/
public function filterByCourse($course, $comparison = null)
{
if ($course instanceof Course) {
return $this->addUsingAlias(CourseMetadataPeer::COURSE_B_ID, $course->getBId(), $comparison);
} elseif ($course instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(CourseMetadataPeer::COURSE_B_ID, $course->toKeyValue('PrimaryKey', 'BId'), $comparison);
} else {
throw new PropelException('filterByCourse() only accepts arguments of type Course or PropelCollection');
}
}
/**
* Filter the query by a related UtilisateurProfessionnel object
*
* @param UtilisateurProfessionnel|PropelCollection $utilisateurProfessionnel The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return JProfesseursMatieresQuery The current query, for fluid interface
*/
public function filterByProfesseur($utilisateurProfessionnel, $comparison = null)
{
if ($utilisateurProfessionnel instanceof UtilisateurProfessionnel) {
return $this
->addUsingAlias(JProfesseursMatieresPeer::ID_PROFESSEUR, $utilisateurProfessionnel->getLogin(), $comparison);
} elseif ($utilisateurProfessionnel instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this
->addUsingAlias(JProfesseursMatieresPeer::ID_PROFESSEUR, $utilisateurProfessionnel->toKeyValue('PrimaryKey', 'Login'), $comparison);
} else {
throw new PropelException('filterByProfesseur() only accepts arguments of type UtilisateurProfessionnel or PropelCollection');
}
}
/**
* Filter the query by a related CategorieMatiere object
*
* @param CategorieMatiere|PropelCollection $categorieMatiere The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return MatiereQuery The current query, for fluid interface
*/
public function filterByCategorieMatiere($categorieMatiere, $comparison = null)
{
if ($categorieMatiere instanceof CategorieMatiere) {
return $this
->addUsingAlias(MatierePeer::CATEGORIE_ID, $categorieMatiere->getId(), $comparison);
} elseif ($categorieMatiere instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this
->addUsingAlias(MatierePeer::CATEGORIE_ID, $categorieMatiere->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByCategorieMatiere() only accepts arguments of type CategorieMatiere or PropelCollection');
}
}
