/**
* Filter the query by a related \User object
*
* @param \User|ObjectCollection $user The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @throws \Propel\Runtime\Exception\PropelException
*
* @return ChildEventQuery The current query, for fluid interface
*/
public function filterByCreator($user, $comparison = null)
{
if ($user instanceof \User) {
return $this->addUsingAlias(EventTableMap::COL_CREATOR_USER_ID, $user->getUserId(), $comparison);
} elseif ($user instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(EventTableMap::COL_CREATOR_USER_ID, $user->toKeyValue('PrimaryKey', 'UserId'), $comparison);
} else {
throw new PropelException('filterByCreator() only accepts arguments of type \\User or Collection');
}
}
/**
* Filter the query by a related \Models\UserGroup object
*
* @param \Models\UserGroup|ObjectCollection $userGroup the related object to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildUserQuery The current query, for fluid interface
*/
public function filterByUserGroup($userGroup, $comparison = null)
{
if ($userGroup instanceof \Models\UserGroup) {
return $this->addUsingAlias(UserTableMap::COL_ID, $userGroup->getUserId(), $comparison);
} elseif ($userGroup instanceof ObjectCollection) {
return $this->useUserGroupQuery()->filterByPrimaryKeys($userGroup->getPrimaryKeys())->endUse();
} else {
throw new PropelException('filterByUserGroup() only accepts arguments of type \\Models\\UserGroup or Collection');
}
}
/**
* Filter the query by a related \ApostaAiApi\Models\Bet object
*
* @param \ApostaAiApi\Models\Bet|ObjectCollection $bet the related object to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildUserQuery The current query, for fluid interface
*/
public function filterByBet($bet, $comparison = null)
{
if ($bet instanceof \ApostaAiApi\Models\Bet) {
return $this->addUsingAlias(UserTableMap::COL_ID, $bet->getUserId(), $comparison);
} elseif ($bet instanceof ObjectCollection) {
return $this->useBetQuery()->filterByPrimaryKeys($bet->getPrimaryKeys())->endUse();
} else {
throw new PropelException('filterByBet() only accepts arguments of type \\ApostaAiApi\\Models\\Bet or Collection');
}
}
/**
* Filter the query by a related \TourQuery object
*
* @param \TourQuery|ObjectCollection $tourQuery the related object to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildUserQuery The current query, for fluid interface
*/
public function filterByTourQuery($tourQuery, $comparison = null)
{
if ($tourQuery instanceof \TourQuery) {
return $this->addUsingAlias(UserTableMap::COL_ID, $tourQuery->getUserId(), $comparison);
} elseif ($tourQuery instanceof ObjectCollection) {
return $this->useTourQueryQuery()->filterByPrimaryKeys($tourQuery->getPrimaryKeys())->endUse();
} else {
throw new PropelException('filterByTourQuery() only accepts arguments of type \\TourQuery or Collection');
}
}
/**
* Filter the query by a related \App\Propel\User object
*
* @param \App\Propel\User|ObjectCollection $user The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @throws \Propel\Runtime\Exception\PropelException
*
* @return ChildSocialRecommendationQuery The current query, for fluid interface
*/
public function filterByUserRelatedBySocialRecommendationTo($user, $comparison = null)
{
if ($user instanceof \App\Propel\User) {
return $this->addUsingAlias(SocialRecommendationTableMap::COL_SOCIAL_RECOMMENDATION_TO, $user->getUserId(), $comparison);
} elseif ($user instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(SocialRecommendationTableMap::COL_SOCIAL_RECOMMENDATION_TO, $user->toKeyValue('PrimaryKey', 'UserId'), $comparison);
} else {
throw new PropelException('filterByUserRelatedBySocialRecommendationTo() only accepts arguments of type \\App\\Propel\\User or Collection');
}
}
/**
* Filter the query by a related \Items object
*
* @param \Items|ObjectCollection $items the related object to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildUserQuery The current query, for fluid interface
*/
public function filterByItems($items, $comparison = null)
{
if ($items instanceof \Items) {
return $this->addUsingAlias(UserTableMap::COL_USER_ID, $items->getUserId(), $comparison);
} elseif ($items instanceof ObjectCollection) {
return $this->useItemsQuery()->filterByPrimaryKeys($items->getPrimaryKeys())->endUse();
} else {
throw new PropelException('filterByItems() only accepts arguments of type \\Items or Collection');
}
}
/**
* Filter the query by a related \SpoilerWiki\AssignedRole object
*
* @param \SpoilerWiki\AssignedRole|ObjectCollection $assignedRole the related object to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildRoleQuery The current query, for fluid interface
*/
public function filterByAssignedRole($assignedRole, $comparison = null)
{
if ($assignedRole instanceof \SpoilerWiki\AssignedRole) {
return $this->addUsingAlias(RoleTableMap::COL_ID, $assignedRole->getUserId(), $comparison);
} elseif ($assignedRole instanceof ObjectCollection) {
return $this->useAssignedRoleQuery()->filterByPrimaryKeys($assignedRole->getPrimaryKeys())->endUse();
} else {
throw new PropelException('filterByAssignedRole() only accepts arguments of type \\SpoilerWiki\\AssignedRole or Collection');
}
}
/**
* Filter the query by a related \ORM\NotificationOnUser object
*
* @param \ORM\NotificationOnUser|ObjectCollection $notificationOnUser the related object to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildUserQuery The current query, for fluid interface
*/
public function filterByNotification($notificationOnUser, $comparison = null)
{
if ($notificationOnUser instanceof \ORM\NotificationOnUser) {
return $this->addUsingAlias(UserTableMap::COL_ID, $notificationOnUser->getUserId(), $comparison);
} elseif ($notificationOnUser instanceof ObjectCollection) {
return $this->useNotificationQuery()->filterByPrimaryKeys($notificationOnUser->getPrimaryKeys())->endUse();
} else {
throw new PropelException('filterByNotification() only accepts arguments of type \\ORM\\NotificationOnUser or Collection');
}
}
/**
* Filter the query by a related \Tekstove\ApiBundle\Model\Artist object
*
* @param \Tekstove\ApiBundle\Model\Artist|ObjectCollection $artist the related object to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildUserQuery The current query, for fluid interface
*/
public function filterByArtist($artist, $comparison = null)
{
if ($artist instanceof \Tekstove\ApiBundle\Model\Artist) {
return $this->addUsingAlias(UserTableMap::COL_ID, $artist->getUserId(), $comparison);
} elseif ($artist instanceof ObjectCollection) {
return $this->useArtistQuery()->filterByPrimaryKeys($artist->getPrimaryKeys())->endUse();
} else {
throw new PropelException('filterByArtist() only accepts arguments of type \\Tekstove\\ApiBundle\\Model\\Artist or Collection');
}
}
/**
* Filter the query by a related \Alchemy\Component\Cerberus\Model\UserRole object
*
* @param \Alchemy\Component\Cerberus\Model\UserRole|ObjectCollection $userRole the related object to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildUserQuery The current query, for fluid interface
*/
public function filterByUserRole($userRole, $comparison = null)
{
if ($userRole instanceof \Alchemy\Component\Cerberus\Model\UserRole) {
return $this->addUsingAlias(UserTableMap::COL_ID, $userRole->getUserId(), $comparison);
} elseif ($userRole instanceof ObjectCollection) {
return $this->useUserRoleQuery()->filterByPrimaryKeys($userRole->getPrimaryKeys())->endUse();
} else {
throw new PropelException('filterByUserRole() only accepts arguments of type \\Alchemy\\Component\\Cerberus\\Model\\UserRole or Collection');
}
}
/**
* Filter the query by a related \App\Propel\Wishlist object
*
* @param \App\Propel\Wishlist|ObjectCollection $wishlist the related object to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildUserQuery The current query, for fluid interface
*/
public function filterByWishlist($wishlist, $comparison = null)
{
if ($wishlist instanceof \App\Propel\Wishlist) {
return $this->addUsingAlias(UserTableMap::COL_USER_ID, $wishlist->getUserId(), $comparison);
} elseif ($wishlist instanceof ObjectCollection) {
return $this->useWishlistQuery()->filterByPrimaryKeys($wishlist->getPrimaryKeys())->endUse();
} else {
throw new PropelException('filterByWishlist() only accepts arguments of type \\App\\Propel\\Wishlist or Collection');
}
}
/**
* Filter the query by a related \Jalle19\StatusManager\Database\Subscription object
*
* @param \Jalle19\StatusManager\Database\Subscription|ObjectCollection $subscription the related object to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildUserQuery The current query, for fluid interface
*/
public function filterBySubscription($subscription, $comparison = null)
{
if ($subscription instanceof \Jalle19\StatusManager\Database\Subscription) {
return $this->addUsingAlias(UserTableMap::COL_ID, $subscription->getUserId(), $comparison);
} elseif ($subscription instanceof ObjectCollection) {
return $this->useSubscriptionQuery()->filterByPrimaryKeys($subscription->getPrimaryKeys())->endUse();
} else {
throw new PropelException('filterBySubscription() only accepts arguments of type \\Jalle19\\StatusManager\\Database\\Subscription or Collection');
}
}
