/**
* 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 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 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 Expediente object
*
* @param Expediente|PropelObjectCollection $expediente The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ExpedienteanticipoQuery The current query, for fluid interface
* @throws PropelException - if the provided filter is invalid.
*/
public function filterByExpediente($expediente, $comparison = null)
{
if ($expediente instanceof Expediente) {
return $this->addUsingAlias(ExpedienteanticipoPeer::IDEXPEDIENTE, $expediente->getIdexpediente(), $comparison);
} elseif ($expediente instanceof PropelObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(ExpedienteanticipoPeer::IDEXPEDIENTE, $expediente->toKeyValue('PrimaryKey', 'Idexpediente'), $comparison);
} else {
throw new PropelException('filterByExpediente() only accepts arguments of type Expediente or PropelCollection');
}
}
/**
* Filter the query by a related Categoriagasto object
*
* @param Categoriagasto|PropelObjectCollection $categoriagasto The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return GastofacturacionQuery The current query, for fluid interface
* @throws PropelException - if the provided filter is invalid.
*/
public function filterByCategoriagasto($categoriagasto, $comparison = null)
{
if ($categoriagasto instanceof Categoriagasto) {
return $this->addUsingAlias(GastofacturacionPeer::IDCATEGORIAGASTO, $categoriagasto->getIdcategoriagasto(), $comparison);
} elseif ($categoriagasto instanceof PropelObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(GastofacturacionPeer::IDCATEGORIAGASTO, $categoriagasto->toKeyValue('PrimaryKey', 'Idcategoriagasto'), $comparison);
} else {
throw new PropelException('filterByCategoriagasto() only accepts arguments of type Categoriagasto 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 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 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 Rol object
*
* @param Rol|PropelObjectCollection $rol The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return EmpleadoQuery The current query, for fluid interface
* @throws PropelException - if the provided filter is invalid.
*/
public function filterByRol($rol, $comparison = null)
{
if ($rol instanceof Rol) {
return $this->addUsingAlias(EmpleadoPeer::IDROL, $rol->getIdrol(), $comparison);
} elseif ($rol instanceof PropelObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(EmpleadoPeer::IDROL, $rol->toKeyValue('PrimaryKey', 'Idrol'), $comparison);
} else {
throw new PropelException('filterByRol() only accepts arguments of type Rol 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 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 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 Conceptocajachica object
*
* @param Conceptocajachica|PropelObjectCollection $conceptocajachica The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return CajachicaQuery The current query, for fluid interface
* @throws PropelException - if the provided filter is invalid.
*/
public function filterByConceptocajachica($conceptocajachica, $comparison = null)
{
if ($conceptocajachica instanceof Conceptocajachica) {
return $this->addUsingAlias(CajachicaPeer::IDCONCEPTOCAJACHICA, $conceptocajachica->getIdconceptocajachica(), $comparison);
} elseif ($conceptocajachica instanceof PropelObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(CajachicaPeer::IDCONCEPTOCAJACHICA, $conceptocajachica->toKeyValue('PrimaryKey', 'Idconceptocajachica'), $comparison);
} else {
throw new PropelException('filterByConceptocajachica() only accepts arguments of type Conceptocajachica 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 Ordencompra object
*
* @param Ordencompra|PropelObjectCollection $ordencompra The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return TraspasoQuery The current query, for fluid interface
* @throws PropelException - if the provided filter is invalid.
*/
public function filterByOrdencompra($ordencompra, $comparison = null)
{
if ($ordencompra instanceof Ordencompra) {
return $this->addUsingAlias(TraspasoPeer::IDORDENCOMPRA, $ordencompra->getIdordencompra(), $comparison);
} elseif ($ordencompra instanceof PropelObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(TraspasoPeer::IDORDENCOMPRA, $ordencompra->toKeyValue('PrimaryKey', 'Idordencompra'), $comparison);
} else {
throw new PropelException('filterByOrdencompra() only accepts arguments of type Ordencompra or PropelCollection');
}
}
/**
* Filter the query by a related Proveedorcliente object
*
* @param Proveedorcliente|PropelObjectCollection $proveedorcliente The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ExpedienteQuery The current query, for fluid interface
* @throws PropelException - if the provided filter is invalid.
*/
public function filterByProveedorcliente($proveedorcliente, $comparison = null)
{
if ($proveedorcliente instanceof Proveedorcliente) {
return $this->addUsingAlias(ExpedientePeer::IDCONSIGNATARIOEMBARCADOR, $proveedorcliente->getIdproveedorcliente(), $comparison);
} elseif ($proveedorcliente instanceof PropelObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(ExpedientePeer::IDCONSIGNATARIOEMBARCADOR, $proveedorcliente->toKeyValue('PrimaryKey', 'Idproveedorcliente'), $comparison);
} else {
throw new PropelException('filterByProveedorcliente() only accepts arguments of type Proveedorcliente or PropelCollection');
}
}
/**
* Filter the query by a related Proveedoritrade object
*
* @param Proveedoritrade|PropelObjectCollection $proveedoritrade The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ExpedientegastoQuery The current query, for fluid interface
* @throws PropelException - if the provided filter is invalid.
*/
public function filterByProveedoritrade($proveedoritrade, $comparison = null)
{
if ($proveedoritrade instanceof Proveedoritrade) {
return $this->addUsingAlias(ExpedientegastoPeer::IDPROVEEDORITRADE, $proveedoritrade->getIdproveedoritrade(), $comparison);
} elseif ($proveedoritrade instanceof PropelObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(ExpedientegastoPeer::IDPROVEEDORITRADE, $proveedoritrade->toKeyValue('PrimaryKey', 'Idproveedoritrade'), $comparison);
} else {
throw new PropelException('filterByProveedoritrade() only accepts arguments of type Proveedoritrade 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 Gasto object
*
* @param Gasto|PropelObjectCollection $gasto The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return CajachicadetalleQuery The current query, for fluid interface
* @throws PropelException - if the provided filter is invalid.
*/
public function filterByGasto($gasto, $comparison = null)
{
if ($gasto instanceof Gasto) {
return $this->addUsingAlias(CajachicadetallePeer::IDGASTO, $gasto->getIdgasto(), $comparison);
} elseif ($gasto instanceof PropelObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(CajachicadetallePeer::IDGASTO, $gasto->toKeyValue('PrimaryKey', 'Idgasto'), $comparison);
} else {
throw new PropelException('filterByGasto() only accepts arguments of type Gasto 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 Consulta object
*
* @param Consulta|PropelObjectCollection $consulta The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ConsultaanticipoQuery The current query, for fluid interface
* @throws PropelException - if the provided filter is invalid.
*/
public function filterByConsulta($consulta, $comparison = null)
{
if ($consulta instanceof Consulta) {
return $this->addUsingAlias(ConsultaanticipoPeer::IDCONSULTA, $consulta->getIdconsulta(), $comparison);
} elseif ($consulta instanceof PropelObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(ConsultaanticipoPeer::IDCONSULTA, $consulta->toKeyValue('PrimaryKey', 'Idconsulta'), $comparison);
} else {
throw new PropelException('filterByConsulta() only accepts arguments of type Consulta or PropelCollection');
}
}
/**
* Filter the query by a related Paciente object
*
* @param Paciente|PropelObjectCollection $paciente The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return PacientefacturacionQuery The current query, for fluid interface
* @throws PropelException - if the provided filter is invalid.
*/
public function filterByPaciente($paciente, $comparison = null)
{
if ($paciente instanceof Paciente) {
return $this->addUsingAlias(PacientefacturacionPeer::IDPACIENTE, $paciente->getIdpaciente(), $comparison);
} elseif ($paciente instanceof PropelObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(PacientefacturacionPeer::IDPACIENTE, $paciente->toKeyValue('PrimaryKey', 'Idpaciente'), $comparison);
} else {
throw new PropelException('filterByPaciente() only accepts arguments of type Paciente 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 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 Empleado object
*
* @param Empleado|PropelObjectCollection $empleado The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return EmpleadofacturacionQuery The current query, for fluid interface
* @throws PropelException - if the provided filter is invalid.
*/
public function filterByEmpleado($empleado, $comparison = null)
{
if ($empleado instanceof Empleado) {
return $this->addUsingAlias(EmpleadofacturacionPeer::IDEMPLEADO, $empleado->getIdempleado(), $comparison);
} elseif ($empleado instanceof PropelObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(EmpleadofacturacionPeer::IDEMPLEADO, $empleado->toKeyValue('PrimaryKey', 'Idempleado'), $comparison);
} else {
throw new PropelException('filterByEmpleado() only accepts arguments of type Empleado or PropelCollection');
}
}
/**
* Filter the query by a related Medico object
*
* @param Medico|PropelObjectCollection $medico The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return MedicofacturacionQuery The current query, for fluid interface
* @throws PropelException - if the provided filter is invalid.
*/
public function filterByMedico($medico, $comparison = null)
{
if ($medico instanceof Medico) {
return $this->addUsingAlias(MedicofacturacionPeer::IDMEDICO, $medico->getIdmedico(), $comparison);
} elseif ($medico instanceof PropelObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(MedicofacturacionPeer::IDMEDICO, $medico->toKeyValue('PrimaryKey', 'Idmedico'), $comparison);
} else {
throw new PropelException('filterByMedico() only accepts arguments of type Medico 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 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 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');
}
}
