PHP ObjectCollection::getUserId方法代码示例

 /**
  * 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');
     }
 }