/** * Filter the query by a related Corporation object * * @param Corporation|PropelObjectCollection $corporation The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return CourtQuery The current query, for fluid interface * @throws PropelException - if the provided filter is invalid. */ public function filterByCorporation($corporation, $comparison = null) { if ($corporation instanceof Corporation) { return $this->addUsingAlias(CourtPeer::CORPORATION_ID, $corporation->getId(), $comparison); } elseif ($corporation instanceof PropelObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(CourtPeer::CORPORATION_ID, $corporation->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByCorporation() only accepts arguments of type Corporation or PropelCollection'); } }
/** * Filter the query by a related Account object * * @param Account|PropelObjectCollection $account The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return PropertyQuery The current query, for fluid interface * @throws PropelException - if the provided filter is invalid. */ public function filterByAccount($account, $comparison = null) { if ($account instanceof Account) { return $this->addUsingAlias(PropertyPeer::ACCOUNT_ID, $account->getId(), $comparison); } elseif ($account instanceof PropelObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(PropertyPeer::ACCOUNT_ID, $account->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByAccount() only accepts arguments of type Account or PropelCollection'); } }
/** * Filter the query by a related Plugin object * * @param Plugin|PropelObjectCollection $plugin The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return PluginDataQuery The current query, for fluid interface * @throws PropelException - if the provided filter is invalid. */ public function filterByPlugin($plugin, $comparison = null) { if ($plugin instanceof Plugin) { return $this->addUsingAlias(PluginDataPeer::PLUGIN_ID, $plugin->getId(), $comparison); } elseif ($plugin instanceof PropelObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(PluginDataPeer::PLUGIN_ID, $plugin->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByPlugin() only accepts arguments of type Plugin or PropelCollection'); } }
/** * Filter the query by a related sfGuardUser object * * @param sfGuardUser|PropelObjectCollection $sfGuardUser The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return sfGuardRememberKeyQuery The current query, for fluid interface * @throws PropelException - if the provided filter is invalid. */ public function filterBysfGuardUser($sfGuardUser, $comparison = null) { if ($sfGuardUser instanceof sfGuardUser) { return $this->addUsingAlias(sfGuardRememberKeyPeer::USER_ID, $sfGuardUser->getId(), $comparison); } elseif ($sfGuardUser instanceof PropelObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(sfGuardRememberKeyPeer::USER_ID, $sfGuardUser->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterBysfGuardUser() only accepts arguments of type sfGuardUser or PropelCollection'); } }
/** * Filter the query by a related Agenda object * * @param Agenda|PropelObjectCollection $agenda The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return ProcedimientregrogramadoQuery The current query, for fluid interface * @throws PropelException - if the provided filter is invalid. */ public function filterByAgenda($agenda, $comparison = null) { if ($agenda instanceof Agenda) { return $this->addUsingAlias(ProcedimientregrogramadoPeer::AGENDA_ID, $agenda->getId(), $comparison); } elseif ($agenda instanceof PropelObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(ProcedimientregrogramadoPeer::AGENDA_ID, $agenda->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByAgenda() only accepts arguments of type Agenda or PropelCollection'); } }
/** * Filter the query by a related Localidad object * * @param Localidad|PropelObjectCollection $localidad The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return AfiliadoQuery The current query, for fluid interface * @throws PropelException - if the provided filter is invalid. */ public function filterByLocalidad($localidad, $comparison = null) { if ($localidad instanceof Localidad) { return $this->addUsingAlias(AfiliadoPeer::LOCALIDAD_ID, $localidad->getId(), $comparison); } elseif ($localidad instanceof PropelObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(AfiliadoPeer::LOCALIDAD_ID, $localidad->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByLocalidad() only accepts arguments of type Localidad or PropelCollection'); } }
/** * Filter the query by a related Currency object * * @param Currency|PropelObjectCollection $currency The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return CountryQuery The current query, for fluid interface * @throws PropelException - if the provided filter is invalid. */ public function filterByCurrency($currency, $comparison = null) { if ($currency instanceof Currency) { return $this->addUsingAlias(CountryPeer::DEFAULT_CURRENCY_ID, $currency->getId(), $comparison); } elseif ($currency instanceof PropelObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(CountryPeer::DEFAULT_CURRENCY_ID, $currency->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByCurrency() only accepts arguments of type Currency or PropelCollection'); } }
/** * Filter the query by a related PedidoProveedor object * * @param PedidoProveedor|PropelObjectCollection $pedidoProveedor The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return DetallePedidoProveedorQuery The current query, for fluid interface * @throws PropelException - if the provided filter is invalid. */ public function filterByPedidoProveedor($pedidoProveedor, $comparison = null) { if ($pedidoProveedor instanceof PedidoProveedor) { return $this->addUsingAlias(DetallePedidoProveedorPeer::PEDIDO_PROVEEDOR_ID, $pedidoProveedor->getId(), $comparison); } elseif ($pedidoProveedor instanceof PropelObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(DetallePedidoProveedorPeer::PEDIDO_PROVEEDOR_ID, $pedidoProveedor->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByPedidoProveedor() only accepts arguments of type PedidoProveedor or PropelCollection'); } }
/** * Filter the query by a related sfGuardPermission object * * @param sfGuardPermission|PropelObjectCollection $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 * @throws PropelException - if the provided filter is invalid. */ public function filterBysfGuardPermission($sfGuardPermission, $comparison = null) { if ($sfGuardPermission instanceof sfGuardPermission) { return $this->addUsingAlias(sfGuardUserPermissionPeer::PERMISSION_ID, $sfGuardPermission->getId(), $comparison); } elseif ($sfGuardPermission instanceof PropelObjectCollection) { 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 TipoPago object * * @param TipoPago|PropelObjectCollection $tipoPago The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return TransaccionQuery The current query, for fluid interface * @throws PropelException - if the provided filter is invalid. */ public function filterByTipoPago($tipoPago, $comparison = null) { if ($tipoPago instanceof TipoPago) { return $this->addUsingAlias(TransaccionPeer::TIPO_PAGO_ID, $tipoPago->getId(), $comparison); } elseif ($tipoPago instanceof PropelObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(TransaccionPeer::TIPO_PAGO_ID, $tipoPago->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByTipoPago() only accepts arguments of type TipoPago or PropelCollection'); } }
/** * Filter the query by a related Supplier object * * @param Supplier|PropelObjectCollection $supplier The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return BarangMasukQuery The current query, for fluid interface * @throws PropelException - if the provided filter is invalid. */ public function filterBySupplier($supplier, $comparison = null) { if ($supplier instanceof Supplier) { return $this->addUsingAlias(BarangMasukPeer::ID_SUPPLIER, $supplier->getId(), $comparison); } elseif ($supplier instanceof PropelObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(BarangMasukPeer::ID_SUPPLIER, $supplier->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterBySupplier() only accepts arguments of type Supplier or PropelCollection'); } }
/** * Filter the query by a related Holiday object * * @param Holiday|PropelObjectCollection $holiday The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return HolidayDomainQuery The current query, for fluid interface * @throws PropelException - if the provided filter is invalid. */ public function filterByHoliday($holiday, $comparison = null) { if ($holiday instanceof Holiday) { return $this->addUsingAlias(HolidayDomainPeer::HOLIDAY_ID, $holiday->getId(), $comparison); } elseif ($holiday instanceof PropelObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(HolidayDomainPeer::HOLIDAY_ID, $holiday->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByHoliday() only accepts arguments of type Holiday or PropelCollection'); } }
/** * Filter the query by a related GalleryFolder object * * @param GalleryFolder|PropelObjectCollection $galleryFolder The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return GalleryImageQuery The current query, for fluid interface * @throws PropelException - if the provided filter is invalid. */ public function filterByGalleryFolder($galleryFolder, $comparison = null) { if ($galleryFolder instanceof GalleryFolder) { return $this->addUsingAlias(GalleryImagePeer::GALLERY_FOLDER_ID, $galleryFolder->getId(), $comparison); } elseif ($galleryFolder instanceof PropelObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(GalleryImagePeer::GALLERY_FOLDER_ID, $galleryFolder->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByGalleryFolder() only accepts arguments of type GalleryFolder or PropelCollection'); } }
/** * Filter the query by a related helpHour object * * @param helpHour|PropelObjectCollection $helpHour The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return helpHourSigninQuery The current query, for fluid interface * @throws PropelException - if the provided filter is invalid. */ public function filterByhelpHour($helpHour, $comparison = null) { if ($helpHour instanceof helpHour) { return $this->addUsingAlias(helpHourSigninPeer::HELPHOUR_ID, $helpHour->getId(), $comparison); } elseif ($helpHour instanceof PropelObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(helpHourSigninPeer::HELPHOUR_ID, $helpHour->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByhelpHour() only accepts arguments of type helpHour or PropelCollection'); } }
/** * Filter the query by a related State object * * @param State|PropelObjectCollection $state The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return ContactQuery The current query, for fluid interface * @throws PropelException - if the provided filter is invalid. */ public function filterByState($state, $comparison = null) { if ($state instanceof State) { return $this->addUsingAlias(ContactPeer::STATE_ID, $state->getId(), $comparison); } elseif ($state instanceof PropelObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(ContactPeer::STATE_ID, $state->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByState() only accepts arguments of type State or PropelCollection'); } }
/** * Filter the query by a related BookingType object * * @param BookingType|PropelObjectCollection $bookingType The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return BookingQuery The current query, for fluid interface * @throws PropelException - if the provided filter is invalid. */ public function filterByBookingType($bookingType, $comparison = null) { if ($bookingType instanceof BookingType) { return $this->addUsingAlias(BookingPeer::BOOKING_TYPE_ID, $bookingType->getId(), $comparison); } elseif ($bookingType instanceof PropelObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(BookingPeer::BOOKING_TYPE_ID, $bookingType->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByBookingType() only accepts arguments of type BookingType or PropelCollection'); } }
/** * Filter the query by a related Transaction object * * @param Transaction|PropelObjectCollection $transaction The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return TransactionClockingQuery The current query, for fluid interface * @throws PropelException - if the provided filter is invalid. */ public function filterByTransaction($transaction, $comparison = null) { if ($transaction instanceof Transaction) { return $this->addUsingAlias(TransactionClockingPeer::TRANSACTION_ID, $transaction->getId(), $comparison); } elseif ($transaction instanceof PropelObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(TransactionClockingPeer::TRANSACTION_ID, $transaction->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByTransaction() only accepts arguments of type Transaction or PropelCollection'); } }
/** * Filter the query by a related Address object * * @param Address|PropelObjectCollection $address The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return DomainQuery The current query, for fluid interface * @throws PropelException - if the provided filter is invalid. */ public function filterByAddress($address, $comparison = null) { if ($address instanceof Address) { return $this->addUsingAlias(DomainPeer::ADDRESS_ID, $address->getId(), $comparison); } elseif ($address instanceof PropelObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(DomainPeer::ADDRESS_ID, $address->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByAddress() only accepts arguments of type Address or PropelCollection'); } }
/** * Filter the query by a related Especialidad object * * @param Especialidad|PropelObjectCollection $especialidad The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return AgendaQuery The current query, for fluid interface * @throws PropelException - if the provided filter is invalid. */ public function filterByEspecialidad($especialidad, $comparison = null) { if ($especialidad instanceof Especialidad) { return $this->addUsingAlias(AgendaPeer::SERVICIO, $especialidad->getId(), $comparison); } elseif ($especialidad instanceof PropelObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(AgendaPeer::SERVICIO, $especialidad->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByEspecialidad() only accepts arguments of type Especialidad or PropelCollection'); } }
/** * Filter the query by a related Customers object * * @param Customers|PropelObjectCollection $customers The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return TransaksiQuery The current query, for fluid interface * @throws PropelException - if the provided filter is invalid. */ public function filterByCustomers($customers, $comparison = null) { if ($customers instanceof Customers) { return $this->addUsingAlias(TransaksiPeer::ID_CUSTOMERS, $customers->getId(), $comparison); } elseif ($customers instanceof PropelObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(TransaksiPeer::ID_CUSTOMERS, $customers->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByCustomers() only accepts arguments of type Customers or PropelCollection'); } }
/** * Filter the query by a related Organization object * * @param Organization|PropelObjectCollection $organization The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return PluginOrganizationQuery The current query, for fluid interface * @throws PropelException - if the provided filter is invalid. */ public function filterByOrganization($organization, $comparison = null) { if ($organization instanceof Organization) { return $this->addUsingAlias(PluginOrganizationPeer::ORGANIZATION_ID, $organization->getId(), $comparison); } elseif ($organization instanceof PropelObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(PluginOrganizationPeer::ORGANIZATION_ID, $organization->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByOrganization() only accepts arguments of type Organization or PropelCollection'); } }
/** * Filter the query by a related Kota object * * @param Kota|PropelObjectCollection $kota The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return CustomersQuery The current query, for fluid interface * @throws PropelException - if the provided filter is invalid. */ public function filterByKota($kota, $comparison = null) { if ($kota instanceof Kota) { return $this->addUsingAlias(CustomersPeer::ID_KOTA, $kota->getId(), $comparison); } elseif ($kota instanceof PropelObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(CustomersPeer::ID_KOTA, $kota->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByKota() only accepts arguments of type Kota or PropelCollection'); } }
/** * Filter the query by a related Barang object * * @param Barang|PropelObjectCollection $barang The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return DetailTransaksiQuery The current query, for fluid interface * @throws PropelException - if the provided filter is invalid. */ public function filterByBarang($barang, $comparison = null) { if ($barang instanceof Barang) { return $this->addUsingAlias(DetailTransaksiPeer::ID_BARANG, $barang->getId(), $comparison); } elseif ($barang instanceof PropelObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(DetailTransaksiPeer::ID_BARANG, $barang->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByBarang() only accepts arguments of type Barang or PropelCollection'); } }
/** * Filter the query by a related Chart object * * @param Chart|PropelObjectCollection $chart The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return JobQuery The current query, for fluid interface * @throws PropelException - if the provided filter is invalid. */ public function filterByChart($chart, $comparison = null) { if ($chart instanceof Chart) { return $this->addUsingAlias(JobPeer::CHART_ID, $chart->getId(), $comparison); } elseif ($chart instanceof PropelObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(JobPeer::CHART_ID, $chart->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByChart() only accepts arguments of type Chart or PropelCollection'); } }
/** * Filter the query by a related SystemEventSubscription object * * @param SystemEventSubscription|PropelObjectCollection $systemEventSubscription The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return SystemEventInstanceMessageQuery The current query, for fluid interface * @throws PropelException - if the provided filter is invalid. */ public function filterBySystemEventSubscription($systemEventSubscription, $comparison = null) { if ($systemEventSubscription instanceof SystemEventSubscription) { return $this->addUsingAlias(SystemEventInstanceMessagePeer::SYSTEM_EVENT_SUBSCRIPTION_ID, $systemEventSubscription->getId(), $comparison); } elseif ($systemEventSubscription instanceof PropelObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(SystemEventInstanceMessagePeer::SYSTEM_EVENT_SUBSCRIPTION_ID, $systemEventSubscription->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterBySystemEventSubscription() only accepts arguments of type SystemEventSubscription or PropelCollection'); } }
/** * Filter the query by a related Perfil object * * @param Perfil|PropelObjectCollection $perfil The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return UsuarioQuery The current query, for fluid interface * @throws PropelException - if the provided filter is invalid. */ public function filterByPerfil($perfil, $comparison = null) { if ($perfil instanceof Perfil) { return $this->addUsingAlias(UsuarioPeer::PERFIL_ID, $perfil->getId(), $comparison); } elseif ($perfil instanceof PropelObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(UsuarioPeer::PERFIL_ID, $perfil->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByPerfil() only accepts arguments of type Perfil or PropelCollection'); } }
/** * Filter the query by a related User object * * @param User|PropelObjectCollection $user The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return JournalEntryImageQuery The current query, for fluid interface * @throws PropelException - if the provided filter is invalid. */ public function filterByUserRelatedByUpdatedBy($user, $comparison = null) { if ($user instanceof User) { return $this->addUsingAlias(JournalEntryImagePeer::UPDATED_BY, $user->getId(), $comparison); } elseif ($user instanceof PropelObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(JournalEntryImagePeer::UPDATED_BY, $user->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByUserRelatedByUpdatedBy() only accepts arguments of type User or PropelCollection'); } }
/** * Filter the query by a related Jugador object * * @param Jugador|PropelObjectCollection $jugador The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return JugadorMesaQuery The current query, for fluid interface * @throws PropelException - if the provided filter is invalid. */ public function filterByJugador($jugador, $comparison = null) { if ($jugador instanceof Jugador) { return $this->addUsingAlias(JugadorMesaPeer::JUGADOR_ID, $jugador->getId(), $comparison); } elseif ($jugador instanceof PropelObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(JugadorMesaPeer::JUGADOR_ID, $jugador->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByJugador() only accepts arguments of type Jugador or PropelCollection'); } }
/** * Filter the query by a related Product object * * @param Product|PropelObjectCollection $product The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return OrganizationProductQuery The current query, for fluid interface * @throws PropelException - if the provided filter is invalid. */ public function filterByProduct($product, $comparison = null) { if ($product instanceof Product) { return $this->addUsingAlias(OrganizationProductPeer::PRODUCT_ID, $product->getId(), $comparison); } elseif ($product instanceof PropelObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(OrganizationProductPeer::PRODUCT_ID, $product->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByProduct() only accepts arguments of type Product or PropelCollection'); } }
/** * Filter the query by a related Produsen object * * @param Produsen|PropelObjectCollection $produsen The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return BarangQuery The current query, for fluid interface * @throws PropelException - if the provided filter is invalid. */ public function filterByProdusen($produsen, $comparison = null) { if ($produsen instanceof Produsen) { return $this->addUsingAlias(BarangPeer::ID_PRODUSEN, $produsen->getId(), $comparison); } elseif ($produsen instanceof PropelObjectCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(BarangPeer::ID_PRODUSEN, $produsen->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByProdusen() only accepts arguments of type Produsen or PropelCollection'); } }