/** * Filter the query by a related \Author object. * * @param \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 * @return $this|BookQuery The current query, for fluid interface */ public function filterByAuthor($author, $comparison = null) { if ($author instanceof \Author) { return $this->addUsingAlias(BookEntityMap::COL_AUTHORID, $author->getid(), $comparison); } elseif ($author instanceof ObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(BookEntityMap::COL_AUTHORID, $author->toKeyValue('PrimaryKey', 'id'), $comparison); } else { throw new PropelException('filterByAuthor() only accepts arguments of type \\Author or Collection'); } }
/** * 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 \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 \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 \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\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 \App\Propel\Variation object * * @param \App\Propel\Variation|ObjectCollection $variation 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 ChildVariationI18nQuery The current query, for fluid interface */ public function filterByVariation($variation, $comparison = null) { if ($variation instanceof \App\Propel\Variation) { return $this->addUsingAlias(VariationI18nTableMap::COL_VARIATION_ID, $variation->getVariationId(), $comparison); } elseif ($variation instanceof ObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(VariationI18nTableMap::COL_VARIATION_ID, $variation->toKeyValue('PrimaryKey', 'VariationId'), $comparison); } else { throw new PropelException('filterByVariation() only accepts arguments of type \\App\\Propel\\Variation 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 \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 \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 \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 \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 \App\Propel\Resource object * * @param \App\Propel\Resource|ObjectCollection $resource 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 ChildProductHighlightedQuery The current query, for fluid interface */ public function filterByResource($resource, $comparison = null) { if ($resource instanceof \App\Propel\Resource) { return $this->addUsingAlias(ProductHighlightedTableMap::COL_PRODUCT_HIGHLIGHTED_FOR, $resource->getResourceId(), $comparison); } elseif ($resource instanceof ObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(ProductHighlightedTableMap::COL_PRODUCT_HIGHLIGHTED_FOR, $resource->toKeyValue('PrimaryKey', 'ResourceId'), $comparison); } else { throw new PropelException('filterByResource() only accepts arguments of type \\App\\Propel\\Resource 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 \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\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 \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\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 \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 \INSEEGeo\Model\InseeGeoRegion object * * @param \INSEEGeo\Model\InseeGeoRegion|ObjectCollection $inseeGeoRegion The related object(s) 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 filterByInseeGeoRegion($inseeGeoRegion, $comparison = null) { if ($inseeGeoRegion instanceof \INSEEGeo\Model\InseeGeoRegion) { return $this->addUsingAlias(InseeGeoDepartmentTableMap::REGION_ID, $inseeGeoRegion->getId(), $comparison); } elseif ($inseeGeoRegion instanceof ObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(InseeGeoDepartmentTableMap::REGION_ID, $inseeGeoRegion->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByInseeGeoRegion() only accepts arguments of type \\INSEEGeo\\Model\\InseeGeoRegion 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 \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 \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 \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 \Thelia\Model\Category object * * @param \Thelia\Model\Category|ObjectCollection $category The related object(s) 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 filterByCategory($category, $comparison = null) { if ($category instanceof \Thelia\Model\Category) { return $this->addUsingAlias(CategoryDocumentTableMap::CATEGORY_ID, $category->getId(), $comparison); } elseif ($category instanceof ObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(CategoryDocumentTableMap::CATEGORY_ID, $category->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByCategory() only accepts arguments of type \\Thelia\\Model\\Category 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 \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 \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 \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'); } }