/**
* Filter the query by a related \Menu\Model\MenuI18n object
*
* @param \Menu\Model\MenuI18n|ObjectCollection $menuI18n The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildMenuI18nVersionQuery The current query, for fluid interface
*/
public function filterByMenuI18n($menuI18n, $comparison = null)
{
if ($menuI18n instanceof \Menu\Model\MenuI18n) {
return $this->addUsingAlias(MenuI18nVersionTableMap::ID, $menuI18n->getId(), $comparison);
} elseif ($menuI18n instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(MenuI18nVersionTableMap::ID, $menuI18n->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByMenuI18n() only accepts arguments of type \\Menu\\Model\\MenuI18n or Collection');
}
}
/**
* Filter the query by a related \Tekstove\ApiBundle\Model\Acl\PermissionGroup object
*
* @param \Tekstove\ApiBundle\Model\Acl\PermissionGroup|ObjectCollection $permissionGroup 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 ChildPermissionGroupUserQuery The current query, for fluid interface
*/
public function filterByPermissionGroup($permissionGroup, $comparison = null)
{
if ($permissionGroup instanceof \Tekstove\ApiBundle\Model\Acl\PermissionGroup) {
return $this->addUsingAlias(PermissionGroupUserTableMap::COL_GROUP_ID, $permissionGroup->getId(), $comparison);
} elseif ($permissionGroup instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(PermissionGroupUserTableMap::COL_GROUP_ID, $permissionGroup->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByPermissionGroup() only accepts arguments of type \\Tekstove\\ApiBundle\\Model\\Acl\\PermissionGroup or Collection');
}
}
/**
* Filter the query by a related \App\Models\TranslationApplication object
*
* @param \App\Models\TranslationApplication|ObjectCollection $translationApplication 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 ChildTranslationCatalogQuery The current query, for fluid interface
*/
public function filterByTranslationApplication($translationApplication, $comparison = null)
{
if ($translationApplication instanceof \App\Models\TranslationApplication) {
return $this->addUsingAlias(TranslationCatalogTableMap::COL_APPLICATION_ID, $translationApplication->getId(), $comparison);
} elseif ($translationApplication instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(TranslationCatalogTableMap::COL_APPLICATION_ID, $translationApplication->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByTranslationApplication() only accepts arguments of type \\App\\Models\\TranslationApplication or Collection');
}
}
/**
* Filter the query by a related \Thelia\Model\Product object
*
* @param \Thelia\Model\Product|ObjectCollection $product The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildProductVersionQuery The current query, for fluid interface
*/
public function filterByProduct($product, $comparison = null)
{
if ($product instanceof \Thelia\Model\Product) {
return $this->addUsingAlias(ProductVersionTableMap::ID, $product->getId(), $comparison);
} elseif ($product instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(ProductVersionTableMap::ID, $product->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByProduct() only accepts arguments of type \\Thelia\\Model\\Product or Collection');
}
}
/**
* Filter the query by a related \Diaporamas\Model\Diaporama object
*
* @param \Diaporamas\Model\Diaporama|ObjectCollection $diaporama The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildDiaporamaVersionQuery The current query, for fluid interface
*/
public function filterByDiaporama($diaporama, $comparison = null)
{
if ($diaporama instanceof \Diaporamas\Model\Diaporama) {
return $this->addUsingAlias(DiaporamaVersionTableMap::ID, $diaporama->getId(), $comparison);
} elseif ($diaporama instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(DiaporamaVersionTableMap::ID, $diaporama->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByDiaporama() only accepts arguments of type \\Diaporamas\\Model\\Diaporama or Collection');
}
}
/**
* Filter the query by a related \Thelia\Model\Order object
*
* @param \Thelia\Model\Order|ObjectCollection $order The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildOrderCouponQuery The current query, for fluid interface
*/
public function filterByOrder($order, $comparison = null)
{
if ($order instanceof \Thelia\Model\Order) {
return $this->addUsingAlias(OrderCouponTableMap::ORDER_ID, $order->getId(), $comparison);
} elseif ($order instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(OrderCouponTableMap::ORDER_ID, $order->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByOrder() only accepts arguments of type \\Thelia\\Model\\Order or Collection');
}
}
/**
* Filter the query by a related \ORM\Purchase object
*
* @param \ORM\Purchase|ObjectCollection $purchase The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildDebitQuery The current query, for fluid interface
*/
public function filterByPurchase($purchase, $comparison = null)
{
if ($purchase instanceof \ORM\Purchase) {
return $this->addUsingAlias(DebitTableMap::COL_PURCHASE_ID, $purchase->getId(), $comparison);
} elseif ($purchase instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(DebitTableMap::COL_PURCHASE_ID, $purchase->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByPurchase() only accepts arguments of type \\ORM\\Purchase or Collection');
}
}
/**
* Filter the query by a related \Users object
*
* @param \Users|ObjectCollection $users 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 ChildBooksQuery The current query, for fluid interface
*/
public function filterByuserSysRef($users, $comparison = null)
{
if ($users instanceof \Users) {
return $this->addUsingAlias(BooksTableMap::COL___USER__, $users->getId(), $comparison);
} elseif ($users instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(BooksTableMap::COL___USER__, $users->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByuserSysRef() only accepts arguments of type \\Users or Collection');
}
}
/**
* Filter the query by a related \Templatenames object
*
* @param \Templatenames|ObjectCollection $templatenames 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 ChildContributionsQuery The current query, for fluid interface
*/
public function filterByTemplatenames($templatenames, $comparison = null)
{
if ($templatenames instanceof \Templatenames) {
return $this->addUsingAlias(ContributionsTableMap::COL__FORTEMPLATE, $templatenames->getId(), $comparison);
} elseif ($templatenames instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(ContributionsTableMap::COL__FORTEMPLATE, $templatenames->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByTemplatenames() only accepts arguments of type \\Templatenames or Collection');
}
}
/**
* Filter the query by a related \ORM\Role object
*
* @param \ORM\Role|ObjectCollection $role The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildNotificationOptionQuery The current query, for fluid interface
*/
public function filterByRole($role, $comparison = null)
{
if ($role instanceof \ORM\Role) {
return $this->addUsingAlias(NotificationOptionTableMap::COL_ROLE_ID, $role->getId(), $comparison);
} elseif ($role instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(NotificationOptionTableMap::COL_ROLE_ID, $role->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByRole() only accepts arguments of type \\ORM\\Role or Collection');
}
}
/**
* Filter the query by a related \gossi\trixionary\model\Reference object
*
* @param \gossi\trixionary\model\Reference|ObjectCollection $reference 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 ChildVideoQuery The current query, for fluid interface
*/
public function filterByReference($reference, $comparison = null)
{
if ($reference instanceof \gossi\trixionary\model\Reference) {
return $this->addUsingAlias(VideoTableMap::COL_REFERENCE_ID, $reference->getId(), $comparison);
} elseif ($reference instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(VideoTableMap::COL_REFERENCE_ID, $reference->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByReference() only accepts arguments of type \\gossi\\trixionary\\model\\Reference or Collection');
}
}
/**
* Filter the query by a related \Questions object
*
* @param \Questions|ObjectCollection $questions The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildResponsesQuery The current query, for fluid interface
*/
public function filterByQuestions($questions, $comparison = null)
{
if ($questions instanceof \Questions) {
return $this->addUsingAlias(ResponsesTableMap::COL_QUESTION_ID, $questions->getId(), $comparison);
} elseif ($questions instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(ResponsesTableMap::COL_QUESTION_ID, $questions->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByQuestions() only accepts arguments of type \\Questions or Collection');
}
}
/**
* Filter the query by a related \Thelia\Model\AttributeAv object
*
* @param \Thelia\Model\AttributeAv|ObjectCollection $attributeAv The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildAttributeAvI18nQuery The current query, for fluid interface
*/
public function filterByAttributeAv($attributeAv, $comparison = null)
{
if ($attributeAv instanceof \Thelia\Model\AttributeAv) {
return $this->addUsingAlias(AttributeAvI18nTableMap::ID, $attributeAv->getId(), $comparison);
} elseif ($attributeAv instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(AttributeAvI18nTableMap::ID, $attributeAv->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByAttributeAv() only accepts arguments of type \\Thelia\\Model\\AttributeAv or Collection');
}
}
/**
* Filter the query by a related \SoColissimo\Model\Thelia\Model\OrderAddress object
*
* @param \SoColissimo\Model\Thelia\Model\OrderAddress|ObjectCollection $orderAddress The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildOrderAddressSocolissimoQuery The current query, for fluid interface
*/
public function filterByOrderAddress($orderAddress, $comparison = null)
{
if ($orderAddress instanceof \SoColissimo\Model\Thelia\Model\OrderAddress) {
return $this->addUsingAlias(OrderAddressSocolissimoTableMap::ID, $orderAddress->getId(), $comparison);
} elseif ($orderAddress instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(OrderAddressSocolissimoTableMap::ID, $orderAddress->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByOrderAddress() only accepts arguments of type \\SoColissimo\\Model\\Thelia\\Model\\OrderAddress or Collection');
}
}
/**
* Filter the query by a related \testpropel\Author object
*
* @param \testpropel\Author|ObjectCollection $author 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 ChildBookQuery The current query, for fluid interface
*/
public function filterByAuthor($author, $comparison = null)
{
if ($author instanceof \testpropel\Author) {
return $this->addUsingAlias(BookTableMap::COL_AUTHOR_ID, $author->getId(), $comparison);
} elseif ($author instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(BookTableMap::COL_AUTHOR_ID, $author->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByAuthor() only accepts arguments of type \\testpropel\\Author or Collection');
}
}
/**
* Filter the query by a related \Thelia\Model\Module object
*
* @param \Thelia\Model\Module|ObjectCollection $module The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildAreaDeliveryModuleQuery The current query, for fluid interface
*/
public function filterByModule($module, $comparison = null)
{
if ($module instanceof \Thelia\Model\Module) {
return $this->addUsingAlias(AreaDeliveryModuleTableMap::DELIVERY_MODULE_ID, $module->getId(), $comparison);
} elseif ($module instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(AreaDeliveryModuleTableMap::DELIVERY_MODULE_ID, $module->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByModule() only accepts arguments of type \\Thelia\\Model\\Module or Collection');
}
}
/**
* Filter the query by a related \Thelia\Model\Hook object
*
* @param \Thelia\Model\Hook|ObjectCollection $hook The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildModuleHookQuery The current query, for fluid interface
*/
public function filterByHook($hook, $comparison = null)
{
if ($hook instanceof \Thelia\Model\Hook) {
return $this->addUsingAlias(ModuleHookTableMap::HOOK_ID, $hook->getId(), $comparison);
} elseif ($hook instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(ModuleHookTableMap::HOOK_ID, $hook->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByHook() only accepts arguments of type \\Thelia\\Model\\Hook or Collection');
}
}
/**
* Filter the query by a related \Thelia\Model\Currency object
*
* @param \Thelia\Model\Currency|ObjectCollection $currency The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildCartQuery The current query, for fluid interface
*/
public function filterByCurrency($currency, $comparison = null)
{
if ($currency instanceof \Thelia\Model\Currency) {
return $this->addUsingAlias(CartTableMap::CURRENCY_ID, $currency->getId(), $comparison);
} elseif ($currency instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(CartTableMap::CURRENCY_ID, $currency->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByCurrency() only accepts arguments of type \\Thelia\\Model\\Currency or Collection');
}
}
/**
* Filter the query by a related \Haus23\Dtp\Model\Match object
*
* @param \Haus23\Dtp\Model\Match|ObjectCollection $match 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 ChildTipQuery The current query, for fluid interface
*/
public function filterByMatch($match, $comparison = null)
{
if ($match instanceof \Haus23\Dtp\Model\Match) {
return $this->addUsingAlias(TipTableMap::COL_MATCH_ID, $match->getId(), $comparison);
} elseif ($match instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(TipTableMap::COL_MATCH_ID, $match->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByMatch() only accepts arguments of type \\Haus23\\Dtp\\Model\\Match or Collection');
}
}
/**
* Filter the query by a related \Проекты object
*
* @param \Проекты|ObjectCollection $�роекты 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 ChildпроблемныевопросыQuery The current query, for fluid interface
*/
public function filterByПроекты($�роекты, $comparison = null)
{
if ($�роекты instanceof \Проекты) {
return $this->addUsingAlias(проблемныевопросыTableMap::COL_ПРОЕКТ, $�роекты->getId(), $comparison);
} elseif ($�роекты instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(проблемныевопросыTableMap::COL_ПРОЕКТ, $�роекты->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByПроекты() only accepts arguments of type \\Проекты or Collection');
}
}
/**
* Filter the query by a related \INSEEGeo\Model\InseeGeoDepartmentI18n object
*
* @param \INSEEGeo\Model\InseeGeoDepartmentI18n|ObjectCollection $inseeGeoDepartmentI18n the related object to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildInseeGeoDepartmentQuery The current query, for fluid interface
*/
public function filterByInseeGeoDepartmentI18n($inseeGeoDepartmentI18n, $comparison = null)
{
if ($inseeGeoDepartmentI18n instanceof \INSEEGeo\Model\InseeGeoDepartmentI18n) {
return $this->addUsingAlias(InseeGeoDepartmentTableMap::ID, $inseeGeoDepartmentI18n->getId(), $comparison);
} elseif ($inseeGeoDepartmentI18n instanceof ObjectCollection) {
return $this->useInseeGeoDepartmentI18nQuery()->filterByPrimaryKeys($inseeGeoDepartmentI18n->getPrimaryKeys())->endUse();
} else {
throw new PropelException('filterByInseeGeoDepartmentI18n() only accepts arguments of type \\INSEEGeo\\Model\\InseeGeoDepartmentI18n or Collection');
}
}
/**
* Filter the query by a related \gossi\trixionary\model\Skill object
*
* @param \gossi\trixionary\model\Skill|ObjectCollection $skill 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 ChildFunctionPhaseQuery The current query, for fluid interface
*/
public function filterBySkillRelatedBySkillId($skill, $comparison = null)
{
if ($skill instanceof \gossi\trixionary\model\Skill) {
return $this->addUsingAlias(FunctionPhaseTableMap::COL_SKILL_ID, $skill->getId(), $comparison);
} elseif ($skill instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(FunctionPhaseTableMap::COL_SKILL_ID, $skill->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterBySkillRelatedBySkillId() only accepts arguments of type \\gossi\\trixionary\\model\\Skill or Collection');
}
}
/**
* Filter the query by a related \keeko\core\model\User object
*
* @param \keeko\core\model\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 ChildJudgeQuery The current query, for fluid interface
*/
public function filterByUser($user, $comparison = null)
{
if ($user instanceof \keeko\core\model\User) {
return $this->addUsingAlias(JudgeTableMap::COL_USER_ID, $user->getId(), $comparison);
} elseif ($user instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(JudgeTableMap::COL_USER_ID, $user->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByUser() only accepts arguments of type \\keeko\\core\\model\\User or Collection');
}
}
/**
* Filter the query by a related \Thelia\Model\CategoryDocumentI18n object
*
* @param \Thelia\Model\CategoryDocumentI18n|ObjectCollection $categoryDocumentI18n the related object to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildCategoryDocumentQuery The current query, for fluid interface
*/
public function filterByCategoryDocumentI18n($categoryDocumentI18n, $comparison = null)
{
if ($categoryDocumentI18n instanceof \Thelia\Model\CategoryDocumentI18n) {
return $this->addUsingAlias(CategoryDocumentTableMap::ID, $categoryDocumentI18n->getId(), $comparison);
} elseif ($categoryDocumentI18n instanceof ObjectCollection) {
return $this->useCategoryDocumentI18nQuery()->filterByPrimaryKeys($categoryDocumentI18n->getPrimaryKeys())->endUse();
} else {
throw new PropelException('filterByCategoryDocumentI18n() only accepts arguments of type \\Thelia\\Model\\CategoryDocumentI18n or Collection');
}
}
/**
* Filter the query by a related \Thelia\Model\Coupon object
*
* @param \Thelia\Model\Coupon|ObjectCollection $coupon The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildCouponCountryQuery The current query, for fluid interface
*/
public function filterByCoupon($coupon, $comparison = null)
{
if ($coupon instanceof \Thelia\Model\Coupon) {
return $this->addUsingAlias(CouponCountryTableMap::COUPON_ID, $coupon->getId(), $comparison);
} elseif ($coupon instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(CouponCountryTableMap::COUPON_ID, $coupon->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByCoupon() only accepts arguments of type \\Thelia\\Model\\Coupon or Collection');
}
}
/**
* Filter the query by a related \Haus23\Dtp\Model\Account object
*
* @param \Haus23\Dtp\Model\Account|ObjectCollection $account 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 ChildPlayerQuery The current query, for fluid interface
*/
public function filterByAccount($account, $comparison = null)
{
if ($account instanceof \Haus23\Dtp\Model\Account) {
return $this->addUsingAlias(PlayerTableMap::COL_ACCOUNT_ID, $account->getId(), $comparison);
} elseif ($account instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(PlayerTableMap::COL_ACCOUNT_ID, $account->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByAccount() only accepts arguments of type \\Haus23\\Dtp\\Model\\Account or Collection');
}
}
/**
* Filter the query by a related \Thelia\Model\CustomerTitle object
*
* @param \Thelia\Model\CustomerTitle|ObjectCollection $customerTitle The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildCustomerTitleI18nQuery The current query, for fluid interface
*/
public function filterByCustomerTitle($customerTitle, $comparison = null)
{
if ($customerTitle instanceof \Thelia\Model\CustomerTitle) {
return $this->addUsingAlias(CustomerTitleI18nTableMap::ID, $customerTitle->getId(), $comparison);
} elseif ($customerTitle instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(CustomerTitleI18nTableMap::ID, $customerTitle->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByCustomerTitle() only accepts arguments of type \\Thelia\\Model\\CustomerTitle or Collection');
}
}
/**
* Filter the query by a related \Models\Pack object
*
* @param \Models\Pack|ObjectCollection $pack 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 ChildFileQuery The current query, for fluid interface
*/
public function filterByPack($pack, $comparison = null)
{
if ($pack instanceof \Models\Pack) {
return $this->addUsingAlias(FileTableMap::COL_PACK_ID, $pack->getId(), $comparison);
} elseif ($pack instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(FileTableMap::COL_PACK_ID, $pack->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByPack() only accepts arguments of type \\Models\\Pack or Collection');
}
}
/**
* Filter the query by a related \GoogleShopping\Model\GoogleshoppingAccount object
*
* @param \GoogleShopping\Model\GoogleshoppingAccount|ObjectCollection $googleshoppingAccount The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildGoogleshoppingProductSynchronisationQuery The current query, for fluid interface
*/
public function filterByGoogleshoppingAccount($googleshoppingAccount, $comparison = null)
{
if ($googleshoppingAccount instanceof \GoogleShopping\Model\GoogleshoppingAccount) {
return $this->addUsingAlias(GoogleshoppingProductSynchronisationTableMap::GOOGLESHOPPING_ACCOUNT_ID, $googleshoppingAccount->getId(), $comparison);
} elseif ($googleshoppingAccount instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(GoogleshoppingProductSynchronisationTableMap::GOOGLESHOPPING_ACCOUNT_ID, $googleshoppingAccount->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByGoogleshoppingAccount() only accepts arguments of type \\GoogleShopping\\Model\\GoogleshoppingAccount or Collection');
}
}
/**
* Filter the query by a related \Thelia\Model\ProductSaleElements object
*
* @param \Thelia\Model\ProductSaleElements|ObjectCollection $productSaleElements The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildCartItemQuery The current query, for fluid interface
*/
public function filterByProductSaleElements($productSaleElements, $comparison = null)
{
if ($productSaleElements instanceof \Thelia\Model\ProductSaleElements) {
return $this->addUsingAlias(CartItemTableMap::PRODUCT_SALE_ELEMENTS_ID, $productSaleElements->getId(), $comparison);
} elseif ($productSaleElements instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(CartItemTableMap::PRODUCT_SALE_ELEMENTS_ID, $productSaleElements->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByProductSaleElements() only accepts arguments of type \\Thelia\\Model\\ProductSaleElements or Collection');
}
}