Congegni/sintonia
7
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

chore: remove cloud storage remainings (#1934)

Browse source
This commit is contained in:
Jonas L 2022-07-04 22:09:14 +02:00 • committed by GitHub
parent 0e6b0da142
commit 703a8e5856
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
33 changed files with 50 additions and 3571 deletions
Download patch file Download diff file Expand all files Collapse all files

22
legacy/application/models/StoredFile.php
View file

@ -385,7 +385,7 @@ SQL;
}
/**
* Deletes the physical file from the local file system or from the cloud.
* Deletes the physical file from the local file system.
*
* @param mixed $quiet
*/
@ -412,7 +412,6 @@ SQL;
}
// Delete the physical file from either the local stor directory
// or from the cloud
if ($this->_file->getDbImportStatus() == CcFiles::IMPORT_STATUS_SUCCESS) {
try {
$this->_file->deletePhysicalFile();
@ -433,7 +432,7 @@ SQL;
// the file getting deleted
self::updateBlockAndPlaylistLength($this->_file->getDbId());
// delete the file record from cc_files (and cloud_file, if applicable)
// delete the file record from cc_files
$this->_file->delete();
}
@ -616,16 +615,7 @@ SQL;
throw new Exception('Could not recall file with id: ' . $p_id);
}
// Attempt to get the cloud file object and return it. If no cloud
// file object is found then we are dealing with a regular stored
// object so return that
$cloudFile = CloudFileQuery::create()->findOneByCcFileId($p_id);
if (is_null($cloudFile)) {
return self::createWithFile($storedFile, $con);
}
return self::createWithFile($cloudFile, $con);
return self::createWithFile($storedFile, $con);
}
throw new Exception('No arguments passed to RecallById');
@ -681,13 +671,15 @@ SQL;
public static function getLibraryColumns()
{
return ['id', 'track_title', 'artist_name', 'album_title',
return [
'id', 'track_title', 'artist_name', 'album_title',
'genre', 'length', 'year', 'utime', 'mtime', 'ftype',
'track_number', 'mood', 'bpm', 'composer', 'info_url',
'bit_rate', 'sample_rate', 'isrc_number', 'encoded_by', 'label',
'copyright', 'mime', 'language', 'filepath', 'owner_id',
'conductor', 'replay_gain', 'lptime', 'is_playlist', 'is_scheduled',
'cuein', 'cueout', 'description', 'artwork', 'track_type', ];
'cuein', 'cueout', 'description', 'artwork', 'track_type',
];
}
public static function searchLibraryFiles($datatables)

22
legacy/application/models/airtime/CcFiles.php
View file

@ -205,25 +205,7 @@ class CcFiles extends BaseCcFiles
try {
self::validateFileArray($fileArray);
if ($file && isset($fileArray['resource_id'])) {
$file->fromArray($fileArray, BasePeer::TYPE_FIELDNAME);
// store the original filename
$file->setDbFilepath($fileArray['filename']);
$fileSizeBytes = $fileArray['filesize'];
if (!isset($fileSizeBytes) || $fileSizeBytes === false) {
throw new LibreTimeFileNotFoundException("Invalid filesize for {$fileId}");
}
$cloudFile = new CloudFile();
$cloudFile->setStorageBackend($fileArray['storage_backend']);
$cloudFile->setResourceId($fileArray['resource_id']);
$cloudFile->setCcFiles($file);
$cloudFile->save();
Application_Model_Preference::updateDiskUsage($fileSizeBytes);
} elseif ($file) {
if ($file) {
$file->fromArray($fileArray, BasePeer::TYPE_FIELDNAME);
// Our RESTful API takes "full_path" as a field, which we then split and translate to match
@ -265,7 +247,7 @@ class CcFiles extends BaseCcFiles
return CcFiles::sanitizeResponse($file);
}
/** Delete a file from the database and disk (or cloud).
/** Delete a file from the database and disk.
* @param $id The file ID
*
* @throws DeleteScheduledFileException

90
legacy/application/models/airtime/CloudFile.php
View file

@ -1,90 +0,0 @@
<?php
/**
* Skeleton subclass for representing a row from the 'cloud_file' table.
*
* This class uses Propel's delegation feature to virtually inherit from CcFile!
* You can call any CcFile method on this function and it will work! -- Albert
*
* Each cloud_file has a corresponding cc_file referenced as a foreign key.
* The file's metadata is stored in the cc_file table. This, cloud_file,
* table represents files that are stored in the cloud.
*
* You should add additional methods to this class to meet the
* application requirements. This class will only be generated as
* long as it does not already exist in the output directory.
*/
class CloudFile extends BaseCloudFile
{
private $proxyStorageBackend;
/**
* Returns a signed URL to the file's object on Amazon S3. Since we are
* requesting the file's object via this URL, it needs to be signed because
* all objects stored on Amazon S3 are private.
*/
public function getURLsForTrackPreviewOrDownload()
{
if ($this->proxyStorageBackend == null) {
$this->proxyStorageBackend = new ProxyStorageBackend($this->getStorageBackend());
}
return $this->proxyStorageBackend->getDownloadURLs($this->getResourceId(), $this->getFilename());
}
/**
* Returns a url to the file's object on Amazon S3.
*/
public function getAbsoluteFilePath()
{
if ($this->proxyStorageBackend == null) {
$this->proxyStorageBackend = new ProxyStorageBackend($this->getStorageBackend());
}
return $this->proxyStorageBackend->getAbsoluteFilePath($this->getResourceId());
}
public function getFilename()
{
$filename = $this->getDbFilepath();
$info = pathinfo($filename);
// Add the correct file extension based on the MIME type, for files that were uploaded with the wrong extension.
$mime = $this->getDbMime();
$extension = FileDataHelper::getFileExtensionFromMime($mime);
return $info['filename'] . $extension;
}
/**
* Checks if the file is a regular file that can be previewed and downloaded.
*/
public function isValidPhysicalFile()
{
// We don't need to check if the cloud file is a valid file because
// before it is imported the Analyzer runs it through Liquidsoap
// to check its playability. If Liquidsoap can't play the file it
// does not get imported into the Airtime library.
return true;
}
/**
* Deletes the file from cloud storage.
*/
public function deletePhysicalFile()
{
if ($this->proxyStorageBackend == null) {
$this->proxyStorageBackend = new ProxyStorageBackend($this->getStorageBackend());
}
$this->proxyStorageBackend->deletePhysicalFile($this->getResourceId());
}
/**
* Deletes the cc_file and cloud_file entries from the database.
*/
public function delete(PropelPDO $con = null)
{
CcFilesQuery::create()->findPk($this->getCcFileId())->delete();
parent::delete();
}
}

12
legacy/application/models/airtime/CloudFilePeer.php
View file

@ -1,12 +0,0 @@
<?php
/**
* Skeleton subclass for performing query and update operations on the 'cloud_file' table.
*
* You should add additional methods to this class to meet the
* application requirements. This class will only be generated as
* long as it does not already exist in the output directory.
*/
class CloudFilePeer extends BaseCloudFilePeer
{
}

12
legacy/application/models/airtime/CloudFileQuery.php
View file

@ -1,12 +0,0 @@
<?php
/**
* Skeleton subclass for performing query and update operations on the 'cloud_file' table.
*
* You should add additional methods to this class to meet the
* application requirements. This class will only be generated as
* long as it does not already exist in the output directory.
*/
class CloudFileQuery extends BaseCloudFileQuery
{
}

1
legacy/application/models/airtime/map/CcFilesTableMap.php
View file

@ -117,7 +117,6 @@ class CcFilesTableMap extends TableMap
{
$this->addRelation('FkOwner', 'CcSubjs', RelationMap::MANY_TO_ONE, array('owner_id' => 'id', ), null, null);
$this->addRelation('CcSubjsRelatedByDbEditedby', 'CcSubjs', RelationMap::MANY_TO_ONE, array('editedby' => 'id', ), null, null);
$this->addRelation('CloudFile', 'CloudFile', RelationMap::ONE_TO_MANY, array('id' => 'cc_file_id', ), 'CASCADE', null, 'CloudFiles');
$this->addRelation('CcShowInstances', 'CcShowInstances', RelationMap::ONE_TO_MANY, array('id' => 'file_id', ), 'CASCADE', null, 'CcShowInstancess');
$this->addRelation('CcPlaylistcontents', 'CcPlaylistcontents', RelationMap::ONE_TO_MANY, array('id' => 'file_id', ), 'CASCADE', null, 'CcPlaylistcontentss');
$this->addRelation('CcBlockcontents', 'CcBlockcontents', RelationMap::ONE_TO_MANY, array('id' => 'file_id', ), 'CASCADE', null, 'CcBlockcontentss');

72
legacy/application/models/airtime/map/CloudFileTableMap.php
View file

@ -1,72 +0,0 @@
<?php
/**
* This class defines the structure of the 'cloud_file' table.
*
*
*
* This map class is used by Propel to do runtime db structure discovery.
* For example, the createSelectSql() method checks the type of a given column used in an
* ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
* (i.e. if it's a text column type).
*
* @package propel.generator.airtime.map
*/
class CloudFileTableMap extends TableMap
{
/**
* The (dot-path) name of this class
*/
const CLASS_NAME = 'airtime.map.CloudFileTableMap';
/**
* Initialize the table attributes, columns and validators
* Relations are not initialized by this method since they are lazy loaded
*
* @return void
* @throws PropelException
*/
public function initialize()
{
// attributes
$this->setName('cloud_file');
$this->setPhpName('CloudFile');
$this->setClassname('CloudFile');
$this->setPackage('airtime');
$this->setUseIdGenerator(true);
$this->setPrimaryKeyMethodInfo('cloud_file_id_seq');
// columns
$this->addPrimaryKey('id', 'DbId', 'INTEGER', true, null, null);
$this->addColumn('storage_backend', 'StorageBackend', 'VARCHAR', true, 512, null);
$this->addColumn('resource_id', 'ResourceId', 'LONGVARCHAR', true, null, null);
$this->addForeignKey('cc_file_id', 'CcFileId', 'INTEGER', 'cc_files', 'id', false, null, null);
// validators
} // initialize()
/**
* Build the RelationMap objects for this table relationships
*/
public function buildRelations()
{
$this->addRelation('CcFiles', 'CcFiles', RelationMap::MANY_TO_ONE, array('cc_file_id' => 'id', ), 'CASCADE', null);
} // buildRelations()
/**
*
* Gets the list of behaviors registered for this table
*
* @return array Associative array (name => parameters) of behaviors
*/
public function getBehaviors()
{
return array(
'delegate' => array (
'to' => 'cc_files',
),
);
} // getBehaviors()
} // CloudFileTableMap

285
legacy/application/models/airtime/om/BaseCcFiles.php
View file

@ -462,12 +462,6 @@ abstract class BaseCcFiles extends BaseObject implements Persistent
*/
protected $aCcSubjsRelatedByDbEditedby;
/**
* @var PropelObjectCollection|CloudFile[] Collection to store aggregation of CloudFile objects.
*/
protected $collCloudFiles;
protected $collCloudFilesPartial;
/**
* @var PropelObjectCollection|CcShowInstances[] Collection to store aggregation of CcShowInstances objects.
*/
@ -530,12 +524,6 @@ abstract class BaseCcFiles extends BaseObject implements Persistent
*/
protected $alreadyInClearAllReferencesDeep = false;
/**
* An array of objects scheduled for deletion.
* @var PropelObjectCollection
*/
protected $cloudFilesScheduledForDeletion = null;
/**
* An array of objects scheduled for deletion.
* @var PropelObjectCollection
@ -3154,8 +3142,6 @@ abstract class BaseCcFiles extends BaseObject implements Persistent
$this->aFkOwner = null;
$this->aCcSubjsRelatedByDbEditedby = null;
$this->collCloudFiles = null;
$this->collCcShowInstancess = null;
$this->collCcPlaylistcontentss = null;
@ -3313,23 +3299,6 @@ abstract class BaseCcFiles extends BaseObject implements Persistent
$this->resetModified();
}
if ($this->cloudFilesScheduledForDeletion !== null) {
if (!$this->cloudFilesScheduledForDeletion->isEmpty()) {
CloudFileQuery::create()
->filterByPrimaryKeys($this->cloudFilesScheduledForDeletion->getPrimaryKeys(false))
->delete($con);
$this->cloudFilesScheduledForDeletion = null;
}
}
if ($this->collCloudFiles !== null) {
foreach ($this->collCloudFiles as $referrerFK) {
if (!$referrerFK->isDeleted() && ($referrerFK->isNew() || $referrerFK->isModified())) {
$affectedRows += $referrerFK->save($con);
}
}
}
if ($this->ccShowInstancessScheduledForDeletion !== null) {
if (!$this->ccShowInstancessScheduledForDeletion->isEmpty()) {
CcShowInstancesQuery::create()
@ -4014,14 +3983,6 @@ abstract class BaseCcFiles extends BaseObject implements Persistent
}
if ($this->collCloudFiles !== null) {
foreach ($this->collCloudFiles as $referrerFK) {
if (!$referrerFK->validate($columns)) {
$failureMap = array_merge($failureMap, $referrerFK->getValidationFailures());
}
}
}
if ($this->collCcShowInstancess !== null) {
foreach ($this->collCcShowInstancess as $referrerFK) {
if (!$referrerFK->validate($columns)) {
@ -4427,9 +4388,6 @@ abstract class BaseCcFiles extends BaseObject implements Persistent
if (null !== $this->aCcSubjsRelatedByDbEditedby) {
$result['CcSubjsRelatedByDbEditedby'] = $this->aCcSubjsRelatedByDbEditedby->toArray($keyType, $includeLazyLoadColumns, $alreadyDumpedObjects, true);
}
if (null !== $this->collCloudFiles) {
$result['CloudFiles'] = $this->collCloudFiles->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
}
if (null !== $this->collCcShowInstancess) {
$result['CcShowInstancess'] = $this->collCcShowInstancess->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
}
@ -4998,12 +4956,6 @@ abstract class BaseCcFiles extends BaseObject implements Persistent
// store object hash to prevent cycle
$this->startCopy = true;
foreach ($this->getCloudFiles() as $relObj) {
if ($relObj !== $this) { // ensure that we don't try to copy a reference to ourselves
$copyObj->addCloudFile($relObj->copy($deepCopy));
}
}
foreach ($this->getCcShowInstancess() as $relObj) {
if ($relObj !== $this) { // ensure that we don't try to copy a reference to ourselves
$copyObj->addCcShowInstances($relObj->copy($deepCopy));
@ -5211,9 +5163,6 @@ abstract class BaseCcFiles extends BaseObject implements Persistent
*/
public function initRelation($relationName)
{
if ('CloudFile' == $relationName) {
$this->initCloudFiles();
}
if ('CcShowInstances' == $relationName) {
$this->initCcShowInstancess();
}
@ -5237,231 +5186,6 @@ abstract class BaseCcFiles extends BaseObject implements Persistent
}
}
/**
* Clears out the collCloudFiles collection
*
* This does not modify the database; however, it will remove any associated objects, causing
* them to be refetched by subsequent calls to accessor method.
*
* @return CcFiles The current object (for fluent API support)
* @see addCloudFiles()
*/
public function clearCloudFiles()
{
$this->collCloudFiles = null; // important to set this to null since that means it is uninitialized
$this->collCloudFilesPartial = null;
return $this;
}
/**
* reset is the collCloudFiles collection loaded partially
*
* @return void
*/
public function resetPartialCloudFiles($v = true)
{
$this->collCloudFilesPartial = $v;
}
/**
* Initializes the collCloudFiles collection.
*
* By default this just sets the collCloudFiles collection to an empty array (like clearcollCloudFiles());
* however, you may wish to override this method in your stub class to provide setting appropriate
* to your application -- for example, setting the initial array to the values stored in database.
*
* @param boolean $overrideExisting If set to true, the method call initializes
* the collection even if it is not empty
*
* @return void
*/
public function initCloudFiles($overrideExisting = true)
{
if (null !== $this->collCloudFiles && !$overrideExisting) {
return;
}
$this->collCloudFiles = new PropelObjectCollection();
$this->collCloudFiles->setModel('CloudFile');
}
/**
* Gets an array of CloudFile objects which contain a foreign key that references this object.
*
* If the $criteria is not null, it is used to always fetch the results from the database.
* Otherwise the results are fetched from the database the first time, then cached.
* Next time the same method is called without $criteria, the cached collection is returned.
* If this CcFiles is new, it will return
* an empty collection or the current collection; the criteria is ignored on a new object.
*
* @param Criteria $criteria optional Criteria object to narrow the query
* @param PropelPDO $con optional connection object
* @return PropelObjectCollection|CloudFile[] List of CloudFile objects
* @throws PropelException
*/
public function getCloudFiles($criteria = null, PropelPDO $con = null)
{
$partial = $this->collCloudFilesPartial && !$this->isNew();
if (null === $this->collCloudFiles || null !== $criteria || $partial) {
if ($this->isNew() && null === $this->collCloudFiles) {
// return empty collection
$this->initCloudFiles();
} else {
$collCloudFiles = CloudFileQuery::create(null, $criteria)
->filterByCcFiles($this)
->find($con);
if (null !== $criteria) {
if (false !== $this->collCloudFilesPartial && count($collCloudFiles)) {
$this->initCloudFiles(false);
foreach ($collCloudFiles as $obj) {
if (false == $this->collCloudFiles->contains($obj)) {
$this->collCloudFiles->append($obj);
}
}
$this->collCloudFilesPartial = true;
}
$collCloudFiles->getInternalIterator()->rewind();
return $collCloudFiles;
}
if ($partial && $this->collCloudFiles) {
foreach ($this->collCloudFiles as $obj) {
if ($obj->isNew()) {
$collCloudFiles[] = $obj;
}
}
}
$this->collCloudFiles = $collCloudFiles;
$this->collCloudFilesPartial = false;
}
}
return $this->collCloudFiles;
}
/**
* Sets a collection of CloudFile objects related by a one-to-many relationship
* to the current object.
* It will also schedule objects for deletion based on a diff between old objects (aka persisted)
* and new objects from the given Propel collection.
*
* @param PropelCollection $cloudFiles A Propel collection.
* @param PropelPDO $con Optional connection object
* @return CcFiles The current object (for fluent API support)
*/
public function setCloudFiles(PropelCollection $cloudFiles, PropelPDO $con = null)
{
$cloudFilesToDelete = $this->getCloudFiles(new Criteria(), $con)->diff($cloudFiles);
$this->cloudFilesScheduledForDeletion = $cloudFilesToDelete;
foreach ($cloudFilesToDelete as $cloudFileRemoved) {
$cloudFileRemoved->setCcFiles(null);
}
$this->collCloudFiles = null;
foreach ($cloudFiles as $cloudFile) {
$this->addCloudFile($cloudFile);
}
$this->collCloudFiles = $cloudFiles;
$this->collCloudFilesPartial = false;
return $this;
}
/**
* Returns the number of related CloudFile objects.
*
* @param Criteria $criteria
* @param boolean $distinct
* @param PropelPDO $con
* @return int Count of related CloudFile objects.
* @throws PropelException
*/
public function countCloudFiles(Criteria $criteria = null, $distinct = false, PropelPDO $con = null)
{
$partial = $this->collCloudFilesPartial && !$this->isNew();
if (null === $this->collCloudFiles || null !== $criteria || $partial) {
if ($this->isNew() && null === $this->collCloudFiles) {
return 0;
}
if ($partial && !$criteria) {
return count($this->getCloudFiles());
}
$query = CloudFileQuery::create(null, $criteria);
if ($distinct) {
$query->distinct();
}
return $query
->filterByCcFiles($this)
->count($con);
}
return count($this->collCloudFiles);
}
/**
* Method called to associate a CloudFile object to this object
* through the CloudFile foreign key attribute.
*
* @param CloudFile $l CloudFile
* @return CcFiles The current object (for fluent API support)
*/
public function addCloudFile(CloudFile $l)
{
if ($this->collCloudFiles === null) {
$this->initCloudFiles();
$this->collCloudFilesPartial = true;
}
if (!in_array($l, $this->collCloudFiles->getArrayCopy(), true)) { // only add it if the **same** object is not already associated
$this->doAddCloudFile($l);
if ($this->cloudFilesScheduledForDeletion and $this->cloudFilesScheduledForDeletion->contains($l)) {
$this->cloudFilesScheduledForDeletion->remove($this->cloudFilesScheduledForDeletion->search($l));
}
}
return $this;
}
/**
* @param CloudFile $cloudFile The cloudFile object to add.
*/
protected function doAddCloudFile($cloudFile)
{
$this->collCloudFiles[]= $cloudFile;
$cloudFile->setCcFiles($this);
}
/**
* @param CloudFile $cloudFile The cloudFile object to remove.
* @return CcFiles The current object (for fluent API support)
*/
public function removeCloudFile($cloudFile)
{
if ($this->getCloudFiles()->contains($cloudFile)) {
$this->collCloudFiles->remove($this->collCloudFiles->search($cloudFile));
if (null === $this->cloudFilesScheduledForDeletion) {
$this->cloudFilesScheduledForDeletion = clone $this->collCloudFiles;
$this->cloudFilesScheduledForDeletion->clear();
}
$this->cloudFilesScheduledForDeletion[]= $cloudFile;
$cloudFile->setCcFiles(null);
}
return $this;
}
/**
* Clears out the collCcShowInstancess collection
*
@ -7358,11 +7082,6 @@ abstract class BaseCcFiles extends BaseObject implements Persistent
{
if ($deep && !$this->alreadyInClearAllReferencesDeep) {
$this->alreadyInClearAllReferencesDeep = true;
if ($this->collCloudFiles) {
foreach ($this->collCloudFiles as $o) {
$o->clearAllReferences($deep);
}
}
if ($this->collCcShowInstancess) {
foreach ($this->collCcShowInstancess as $o) {
$o->clearAllReferences($deep);
@ -7408,10 +7127,6 @@ abstract class BaseCcFiles extends BaseObject implements Persistent
$this->alreadyInClearAllReferencesDeep = false;
} // if ($deep)
if ($this->collCloudFiles instanceof PropelCollection) {
$this->collCloudFiles->clearIterator();
}
$this->collCloudFiles = null;
if ($this->collCcShowInstancess instanceof PropelCollection) {
$this->collCcShowInstancess->clearIterator();
}

3
legacy/application/models/airtime/om/BaseCcFilesPeer.php
View file

@ -690,9 +690,6 @@ abstract class BaseCcFilesPeer
*/
public static function clearRelatedInstancePool()
{
// Invalidate objects in CloudFilePeer instance pool,
// since one or more of them may be deleted by ON DELETE CASCADE/SETNULL rule.
CloudFilePeer::clearInstancePool();
// Invalidate objects in CcShowInstancesPeer instance pool,
// since one or more of them may be deleted by ON DELETE CASCADE/SETNULL rule.
CcShowInstancesPeer::clearInstancePool();

78
legacy/application/models/airtime/om/BaseCcFilesQuery.php
View file

@ -156,10 +156,6 @@
* @method CcFilesQuery rightJoinCcSubjsRelatedByDbEditedby($relationAlias = null) Adds a RIGHT JOIN clause to the query using the CcSubjsRelatedByDbEditedby relation
* @method CcFilesQuery innerJoinCcSubjsRelatedByDbEditedby($relationAlias = null) Adds a INNER JOIN clause to the query using the CcSubjsRelatedByDbEditedby relation
*
* @method CcFilesQuery leftJoinCloudFile($relationAlias = null) Adds a LEFT JOIN clause to the query using the CloudFile relation
* @method CcFilesQuery rightJoinCloudFile($relationAlias = null) Adds a RIGHT JOIN clause to the query using the CloudFile relation
* @method CcFilesQuery innerJoinCloudFile($relationAlias = null) Adds a INNER JOIN clause to the query using the CloudFile relation
*
* @method CcFilesQuery leftJoinCcShowInstances($relationAlias = null) Adds a LEFT JOIN clause to the query using the CcShowInstances relation
* @method CcFilesQuery rightJoinCcShowInstances($relationAlias = null) Adds a RIGHT JOIN clause to the query using the CcShowInstances relation
* @method CcFilesQuery innerJoinCcShowInstances($relationAlias = null) Adds a INNER JOIN clause to the query using the CcShowInstances relation
@ -2839,80 +2835,6 @@ abstract class BaseCcFilesQuery extends ModelCriteria
->useQuery($relationAlias ? $relationAlias : 'CcSubjsRelatedByDbEditedby', 'CcSubjsQuery');
}
/**
* Filter the query by a related CloudFile object
*
* @param CloudFile|PropelObjectCollection $cloudFile the related object to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return CcFilesQuery The current query, for fluid interface
* @throws PropelException - if the provided filter is invalid.
*/
public function filterByCloudFile($cloudFile, $comparison = null)
{
if ($cloudFile instanceof CloudFile) {
return $this
->addUsingAlias(CcFilesPeer::ID, $cloudFile->getCcFileId(), $comparison);
} elseif ($cloudFile instanceof PropelObjectCollection) {
return $this
->useCloudFileQuery()
->filterByPrimaryKeys($cloudFile->getPrimaryKeys())
->endUse();
} else {
throw new PropelException('filterByCloudFile() only accepts arguments of type CloudFile or PropelCollection');
}
}
/**
* Adds a JOIN clause to the query using the CloudFile relation
*
* @param string $relationAlias optional alias for the relation
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return CcFilesQuery The current query, for fluid interface
*/
public function joinCloudFile($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
{
$tableMap = $this->getTableMap();
$relationMap = $tableMap->getRelation('CloudFile');
// create a ModelJoin object for this join
$join = new ModelJoin();
$join->setJoinType($joinType);
$join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
if ($previousJoin = $this->getPreviousJoin()) {
$join->setPreviousJoin($previousJoin);
}
// add the ModelJoin to the current object
if ($relationAlias) {
$this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
$this->addJoinObject($join, $relationAlias);
} else {
$this->addJoinObject($join, 'CloudFile');
}
return $this;
}
/**
* Use the CloudFile relation CloudFile object
*
* @see useQuery()
*
* @param string $relationAlias optional alias for the relation,
* to be used as main alias in the secondary query
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return CloudFileQuery A secondary query class using the current class as primary query
*/
public function useCloudFileQuery($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
{
return $this
->joinCloudFile($relationAlias, $joinType)
->useQuery($relationAlias ? $relationAlias : 'CloudFile', 'CloudFileQuery');
}
/**
* Filter the query by a related CcShowInstances object
*

1071
legacy/application/models/airtime/om/BaseCloudFile.php
View file

File diff suppressed because it is too large Load diff

1008
legacy/application/models/airtime/om/BaseCloudFilePeer.php
View file

File diff suppressed because it is too large Load diff

470
legacy/application/models/airtime/om/BaseCloudFileQuery.php
View file

@ -1,470 +0,0 @@
<?php
/**
* Base class that represents a query for the 'cloud_file' table.
*
*
*
* @method CloudFileQuery orderByDbId($order = Criteria::ASC) Order by the id column
* @method CloudFileQuery orderByStorageBackend($order = Criteria::ASC) Order by the storage_backend column
* @method CloudFileQuery orderByResourceId($order = Criteria::ASC) Order by the resource_id column
* @method CloudFileQuery orderByCcFileId($order = Criteria::ASC) Order by the cc_file_id column
*
* @method CloudFileQuery groupByDbId() Group by the id column
* @method CloudFileQuery groupByStorageBackend() Group by the storage_backend column
* @method CloudFileQuery groupByResourceId() Group by the resource_id column
* @method CloudFileQuery groupByCcFileId() Group by the cc_file_id column
*
* @method CloudFileQuery leftJoin($relation) Adds a LEFT JOIN clause to the query
* @method CloudFileQuery rightJoin($relation) Adds a RIGHT JOIN clause to the query
* @method CloudFileQuery innerJoin($relation) Adds a INNER JOIN clause to the query
*
* @method CloudFileQuery leftJoinCcFiles($relationAlias = null) Adds a LEFT JOIN clause to the query using the CcFiles relation
* @method CloudFileQuery rightJoinCcFiles($relationAlias = null) Adds a RIGHT JOIN clause to the query using the CcFiles relation
* @method CloudFileQuery innerJoinCcFiles($relationAlias = null) Adds a INNER JOIN clause to the query using the CcFiles relation
*
* @method CloudFile findOne(PropelPDO $con = null) Return the first CloudFile matching the query
* @method CloudFile findOneOrCreate(PropelPDO $con = null) Return the first CloudFile matching the query, or a new CloudFile object populated from the query conditions when no match is found
*
* @method CloudFile findOneByStorageBackend(string $storage_backend) Return the first CloudFile filtered by the storage_backend column
* @method CloudFile findOneByResourceId(string $resource_id) Return the first CloudFile filtered by the resource_id column
* @method CloudFile findOneByCcFileId(int $cc_file_id) Return the first CloudFile filtered by the cc_file_id column
*
* @method array findByDbId(int $id) Return CloudFile objects filtered by the id column
* @method array findByStorageBackend(string $storage_backend) Return CloudFile objects filtered by the storage_backend column
* @method array findByResourceId(string $resource_id) Return CloudFile objects filtered by the resource_id column
* @method array findByCcFileId(int $cc_file_id) Return CloudFile objects filtered by the cc_file_id column
*
* @package propel.generator.airtime.om
*/
abstract class BaseCloudFileQuery extends ModelCriteria
{
/**
* Initializes internal state of BaseCloudFileQuery object.
*
* @param string $dbName The dabase name
* @param string $modelName The phpName of a model, e.g. 'Book'
* @param string $modelAlias The alias for the model in this query, e.g. 'b'
*/
public function __construct($dbName = null, $modelName = null, $modelAlias = null)
{
if (null === $dbName) {
$dbName = 'airtime';
}
if (null === $modelName) {
$modelName = 'CloudFile';
}
parent::__construct($dbName, $modelName, $modelAlias);
}
/**
* Returns a new CloudFileQuery object.
*
* @param string $modelAlias The alias of a model in the query
* @param CloudFileQuery|Criteria $criteria Optional Criteria to build the query from
*
* @return CloudFileQuery
*/
public static function create($modelAlias = null, $criteria = null)
{
if ($criteria instanceof CloudFileQuery) {
return $criteria;
}
$query = new CloudFileQuery(null, null, $modelAlias);
if ($criteria instanceof Criteria) {
$query->mergeWith($criteria);
}
return $query;
}
/**
* Find object by primary key.
* Propel uses the instance pool to skip the database if the object exists.
* Go fast if the query is untouched.
*
* <code>
* $obj = $c->findPk(12, $con);
* </code>
*
* @param mixed $key Primary key to use for the query
* @param PropelPDO $con an optional connection object
*
* @return CloudFile|CloudFile[]|mixed the result, formatted by the current formatter
*/
public function findPk($key, $con = null)
{
if ($key === null) {
return null;
}
if ((null !== ($obj = CloudFilePeer::getInstanceFromPool((string) $key))) && !$this->formatter) {
// the object is already in the instance pool
return $obj;
}
if ($con === null) {
$con = Propel::getConnection(CloudFilePeer::DATABASE_NAME, Propel::CONNECTION_READ);
}
$this->basePreSelect($con);
if ($this->formatter || $this->modelAlias || $this->with || $this->select
|| $this->selectColumns || $this->asColumns || $this->selectModifiers
|| $this->map || $this->having || $this->joins) {
return $this->findPkComplex($key, $con);
} else {
return $this->findPkSimple($key, $con);
}
}
/**
* Alias of findPk to use instance pooling
*
* @param mixed $key Primary key to use for the query
* @param PropelPDO $con A connection object
*
* @return CloudFile A model object, or null if the key is not found
* @throws PropelException
*/
public function findOneByDbId($key, $con = null)
{
return $this->findPk($key, $con);
}
/**
* Find object by primary key using raw SQL to go fast.
* Bypass doSelect() and the object formatter by using generated code.
*
* @param mixed $key Primary key to use for the query
* @param PropelPDO $con A connection object
*
* @return CloudFile A model object, or null if the key is not found
* @throws PropelException
*/
protected function findPkSimple($key, $con)
{
$sql = 'SELECT "id", "storage_backend", "resource_id", "cc_file_id" FROM "cloud_file" WHERE "id" = :p0';
try {
$stmt = $con->prepare($sql);
$stmt->bindValue(':p0', $key, PDO::PARAM_INT);
$stmt->execute();
} catch (Exception $e) {
Propel::log($e->getMessage(), Propel::LOG_ERR);
throw new PropelException(sprintf('Unable to execute SELECT statement [%s]', $sql), $e);
}
$obj = null;
if ($row = $stmt->fetch(PDO::FETCH_NUM)) {
$obj = new CloudFile();
$obj->hydrate($row);
CloudFilePeer::addInstanceToPool($obj, (string) $key);
}
$stmt->closeCursor();
return $obj;
}
/**
* Find object by primary key.
*
* @param mixed $key Primary key to use for the query
* @param PropelPDO $con A connection object
*
* @return CloudFile|CloudFile[]|mixed the result, formatted by the current formatter
*/
protected function findPkComplex($key, $con)
{
// As the query uses a PK condition, no limit(1) is necessary.
$criteria = $this->isKeepQuery() ? clone $this : $this;
$stmt = $criteria
->filterByPrimaryKey($key)
->doSelect($con);
return $criteria->getFormatter()->init($criteria)->formatOne($stmt);
}
/**
* Find objects by primary key
* <code>
* $objs = $c->findPks(array(12, 56, 832), $con);
* </code>
* @param array $keys Primary keys to use for the query
* @param PropelPDO $con an optional connection object
*
* @return PropelObjectCollection|CloudFile[]|mixed the list of results, formatted by the current formatter
*/
public function findPks($keys, $con = null)
{
if ($con === null) {
$con = Propel::getConnection($this->getDbName(), Propel::CONNECTION_READ);
}
$this->basePreSelect($con);
$criteria = $this->isKeepQuery() ? clone $this : $this;
$stmt = $criteria
->filterByPrimaryKeys($keys)
->doSelect($con);
return $criteria->getFormatter()->init($criteria)->format($stmt);
}
/**
* Filter the query by primary key
*
* @param mixed $key Primary key to use for the query
*
* @return CloudFileQuery The current query, for fluid interface
*/
public function filterByPrimaryKey($key)
{
return $this->addUsingAlias(CloudFilePeer::ID, $key, Criteria::EQUAL);
}
/**
* Filter the query by a list of primary keys
*
* @param array $keys The list of primary key to use for the query
*
* @return CloudFileQuery The current query, for fluid interface
*/
public function filterByPrimaryKeys($keys)
{
return $this->addUsingAlias(CloudFilePeer::ID, $keys, Criteria::IN);
}
/**
* Filter the query on the id column
*
* Example usage:
* <code>
* $query->filterByDbId(1234); // WHERE id = 1234
* $query->filterByDbId(array(12, 34)); // WHERE id IN (12, 34)
* $query->filterByDbId(array('min' => 12)); // WHERE id >= 12
* $query->filterByDbId(array('max' => 12)); // WHERE id <= 12
* </code>
*
* @param mixed $dbId The value to use as filter.
* Use scalar values for equality.
* Use array values for in_array() equivalent.
* Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return CloudFileQuery The current query, for fluid interface
*/
public function filterByDbId($dbId = null, $comparison = null)
{
if (is_array($dbId)) {
$useMinMax = false;
if (isset($dbId['min'])) {
$this->addUsingAlias(CloudFilePeer::ID, $dbId['min'], Criteria::GREATER_EQUAL);
$useMinMax = true;
}
if (isset($dbId['max'])) {
$this->addUsingAlias(CloudFilePeer::ID, $dbId['max'], Criteria::LESS_EQUAL);
$useMinMax = true;
}
if ($useMinMax) {
return $this;
}
if (null === $comparison) {
$comparison = Criteria::IN;
}
}
return $this->addUsingAlias(CloudFilePeer::ID, $dbId, $comparison);
}
/**
* Filter the query on the storage_backend column
*
* Example usage:
* <code>
* $query->filterByStorageBackend('fooValue'); // WHERE storage_backend = 'fooValue'
* $query->filterByStorageBackend('%fooValue%'); // WHERE storage_backend LIKE '%fooValue%'
* </code>
*
* @param string $storageBackend The value to use as filter.
* Accepts wildcards (* and % trigger a LIKE)
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return CloudFileQuery The current query, for fluid interface
*/
public function filterByStorageBackend($storageBackend = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($storageBackend)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $storageBackend)) {
$storageBackend = str_replace('*', '%', $storageBackend);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CloudFilePeer::STORAGE_BACKEND, $storageBackend, $comparison);
}
/**
* Filter the query on the resource_id column
*
* Example usage:
* <code>
* $query->filterByResourceId('fooValue'); // WHERE resource_id = 'fooValue'
* $query->filterByResourceId('%fooValue%'); // WHERE resource_id LIKE '%fooValue%'
* </code>
*
* @param string $resourceId The value to use as filter.
* Accepts wildcards (* and % trigger a LIKE)
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return CloudFileQuery The current query, for fluid interface
*/
public function filterByResourceId($resourceId = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($resourceId)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $resourceId)) {
$resourceId = str_replace('*', '%', $resourceId);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CloudFilePeer::RESOURCE_ID, $resourceId, $comparison);
}
/**
* Filter the query on the cc_file_id column
*
* Example usage:
* <code>
* $query->filterByCcFileId(1234); // WHERE cc_file_id = 1234
* $query->filterByCcFileId(array(12, 34)); // WHERE cc_file_id IN (12, 34)
* $query->filterByCcFileId(array('min' => 12)); // WHERE cc_file_id >= 12
* $query->filterByCcFileId(array('max' => 12)); // WHERE cc_file_id <= 12
* </code>
*
* @see filterByCcFiles()
*
* @param mixed $ccFileId The value to use as filter.
* Use scalar values for equality.
* Use array values for in_array() equivalent.
* Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return CloudFileQuery The current query, for fluid interface
*/
public function filterByCcFileId($ccFileId = null, $comparison = null)
{
if (is_array($ccFileId)) {
$useMinMax = false;
if (isset($ccFileId['min'])) {
$this->addUsingAlias(CloudFilePeer::CC_FILE_ID, $ccFileId['min'], Criteria::GREATER_EQUAL);
$useMinMax = true;
}
if (isset($ccFileId['max'])) {
$this->addUsingAlias(CloudFilePeer::CC_FILE_ID, $ccFileId['max'], Criteria::LESS_EQUAL);
$useMinMax = true;
}
if ($useMinMax) {
return $this;
}
if (null === $comparison) {
$comparison = Criteria::IN;
}
}
return $this->addUsingAlias(CloudFilePeer::CC_FILE_ID, $ccFileId, $comparison);
}
/**
* Filter the query by a related CcFiles object
*
* @param CcFiles|PropelObjectCollection $ccFiles The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return CloudFileQuery The current query, for fluid interface
* @throws PropelException - if the provided filter is invalid.
*/
public function filterByCcFiles($ccFiles, $comparison = null)
{
if ($ccFiles instanceof CcFiles) {
return $this
->addUsingAlias(CloudFilePeer::CC_FILE_ID, $ccFiles->getDbId(), $comparison);
} elseif ($ccFiles instanceof PropelObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this
->addUsingAlias(CloudFilePeer::CC_FILE_ID, $ccFiles->toKeyValue('PrimaryKey', 'DbId'), $comparison);
} else {
throw new PropelException('filterByCcFiles() only accepts arguments of type CcFiles or PropelCollection');
}
}
/**
* Adds a JOIN clause to the query using the CcFiles relation
*
* @param string $relationAlias optional alias for the relation
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return CloudFileQuery The current query, for fluid interface
*/
public function joinCcFiles($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
{
$tableMap = $this->getTableMap();
$relationMap = $tableMap->getRelation('CcFiles');
// create a ModelJoin object for this join
$join = new ModelJoin();
$join->setJoinType($joinType);
$join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
if ($previousJoin = $this->getPreviousJoin()) {
$join->setPreviousJoin($previousJoin);
}
// add the ModelJoin to the current object
if ($relationAlias) {
$this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
$this->addJoinObject($join, $relationAlias);
} else {
$this->addJoinObject($join, 'CcFiles');
}
return $this;
}
/**
* Use the CcFiles relation CcFiles object
*
* @see useQuery()
*
* @param string $relationAlias optional alias for the relation,
* to be used as main alias in the secondary query
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return CcFilesQuery A secondary query class using the current class as primary query
*/
public function useCcFilesQuery($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
{
return $this
->joinCcFiles($relationAlias, $joinType)
->useQuery($relationAlias ? $relationAlias : 'CcFiles', 'CcFilesQuery');
}
/**
* Exclude object from result
*
* @param CloudFile $cloudFile Object to remove from the list of results
*
* @return CloudFileQuery The current query, for fluid interface
*/
public function prune($cloudFile = null)
{
if ($cloudFile) {
$this->addUsingAlias(CloudFilePeer::ID, $cloudFile->getDbId(), Criteria::NOT_EQUAL);
}
return $this;
}
}