Congegni
/
libretime
mirror of https://github.com/libretime/libretime.git
7
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

chore: remove cloud storage remainings (#1934)

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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
api/libretime_api/legacy/migrations/0034_3_0_0_alpha_13_8.py Normal file
View File

@ -0,0 +1,39 @@
# pylint: disable=invalid-name
from django.db import migrations
from ._migrations import legacy_migration_factory
UP = """
DROP TABLE IF EXISTS "cloud_file" CASCADE;
"""
DOWN = """
CREATE TABLE "cloud_file"
(
"id" serial NOT NULL,
"storage_backend" VARCHAR(512) NOT NULL,
"resource_id" TEXT NOT NULL,
"cc_file_id" INTEGER,
PRIMARY KEY ("id")
);
ALTER TABLE "cloud_file" ADD CONSTRAINT "cloud_file_FK_1"
FOREIGN KEY ("cc_file_id")
REFERENCES "cc_files" ("id")
ON DELETE CASCADE;
"""
class Migration(migrations.Migration):
dependencies = [
("legacy", "0033_3_0_0_alpha_13_7"),
]
operations = [
migrations.RunPython(
code=legacy_migration_factory(
target="3.0.0-alpha.13.8",
sql=UP,
)
)
]

2
api/libretime_api/legacy/migrations/__init__.py
View File

@ -1 +1 @@
LEGACY_SCHEMA_VERSION = "3.0.0-alpha.13.7"
LEGACY_SCHEMA_VERSION = "3.0.0-alpha.13.8"

20
api/libretime_api/legacy/migrations/sql/schema.sql
View File

@ -100,21 +100,6 @@ CREATE TABLE "cc_track_types"
CONSTRAINT "cc_track_types_code_idx" UNIQUE ("code")
);
-----------------------------------------------------------------------
-- cloud_file
-----------------------------------------------------------------------
DROP TABLE IF EXISTS "cloud_file" CASCADE;
CREATE TABLE "cloud_file"
(
"id" serial NOT NULL,
"storage_backend" VARCHAR(512) NOT NULL,
"resource_id" TEXT NOT NULL,
"cc_file_id" INTEGER,
PRIMARY KEY ("id")
);
-----------------------------------------------------------------------
-- cc_show
-----------------------------------------------------------------------
@ -735,11 +720,6 @@ ALTER TABLE "cc_files" ADD CONSTRAINT "cc_files_editedby_fkey"
FOREIGN KEY ("editedby")
REFERENCES "cc_subjs" ("id");
ALTER TABLE "cloud_file" ADD CONSTRAINT "cloud_file_FK_1"
FOREIGN KEY ("cc_file_id")
REFERENCES "cc_files" ("id")
ON DELETE CASCADE;
ALTER TABLE "cc_show" ADD CONSTRAINT "cc_playlist_autoplaylist_fkey"
FOREIGN KEY ("autoplaylist_id")
REFERENCES "cc_playlist" ("id")

1
api/libretime_api/storage/models/__init__.py
View File

@ -1,3 +1,2 @@
from .cloud_file import CloudFile
from .file import File
from .library import Library

17
api/libretime_api/storage/models/cloud_file.py
View File

@ -1,17 +0,0 @@
from django.db import models
class CloudFile(models.Model):
storage_backend = models.CharField(max_length=512)
resource_id = models.TextField()
filename = models.ForeignKey(
"storage.File",
on_delete=models.DO_NOTHING,
blank=True,
null=True,
db_column="cc_file_id",
)
class Meta:
managed = False
db_table = "cloud_file"

3
api/libretime_api/storage/router.py
View File

@ -1,8 +1,7 @@
from rest_framework import routers
from .views import CloudFileViewSet, FileViewSet, LibraryViewSet
from .views import FileViewSet, LibraryViewSet
router = routers.DefaultRouter()
router.register("files", FileViewSet)
router.register("cloud-files", CloudFileViewSet)
router.register("libraries", LibraryViewSet)

1
api/libretime_api/storage/serializers/__init__.py
View File

@ -1,3 +1,2 @@
from .cloud_file import CloudFileSerializer
from .file import FileSerializer
from .library import LibrarySerializer

9
api/libretime_api/storage/serializers/cloud_file.py
View File

@ -1,9 +0,0 @@
from rest_framework import serializers
from ..models import CloudFile
class CloudFileSerializer(serializers.HyperlinkedModelSerializer):
class Meta:
model = CloudFile
fields = "__all__"

1
api/libretime_api/storage/views/__init__.py
View File

@ -1,3 +1,2 @@
from .cloud_file import CloudFileViewSet
from .file import FileViewSet
from .library import LibraryViewSet

10
api/libretime_api/storage/views/cloud_file.py
View File

@ -1,10 +0,0 @@
from rest_framework import viewsets
from ..models import CloudFile
from ..serializers import CloudFileSerializer
class CloudFileViewSet(viewsets.ModelViewSet):
queryset = CloudFile.objects.all()
serializer_class = CloudFileSerializer
model_permission_name = "cloudfile"

183
api/schema.yml
View File

@ -151,153 +151,6 @@ paths:
responses:
"204":
description: No response body
/api/v2/cloud-files/:
get:
operationId: cloud_files_list
tags:
- cloud-files
security:
- cookieAuth: []
- basicAuth: []
responses:
"200":
content:
application/json:
schema:
type: array
items:
$ref: "#/components/schemas/CloudFile"
description: ""
post:
operationId: cloud_files_create
tags:
- cloud-files
requestBody:
content:
application/json:
schema:
$ref: "#/components/schemas/CloudFile"
application/x-www-form-urlencoded:
schema:
$ref: "#/components/schemas/CloudFile"
multipart/form-data:
schema:
$ref: "#/components/schemas/CloudFile"
required: true
security:
- cookieAuth: []
- basicAuth: []
responses:
"201":
content:
application/json:
schema:
$ref: "#/components/schemas/CloudFile"
description: ""
/api/v2/cloud-files/{id}/:
get:
operationId: cloud_files_retrieve
parameters:
- in: path
name: id
schema:
type: integer
description: A unique integer value identifying this cloud file.
required: true
tags:
- cloud-files
security:
- cookieAuth: []
- basicAuth: []
responses:
"200":
content:
application/json:
schema:
$ref: "#/components/schemas/CloudFile"
description: ""
put:
operationId: cloud_files_update
parameters:
- in: path
name: id
schema:
type: integer
description: A unique integer value identifying this cloud file.
required: true
tags:
- cloud-files
requestBody:
content:
application/json:
schema:
$ref: "#/components/schemas/CloudFile"
application/x-www-form-urlencoded:
schema:
$ref: "#/components/schemas/CloudFile"
multipart/form-data:
schema:
$ref: "#/components/schemas/CloudFile"
required: true
security:
- cookieAuth: []
- basicAuth: []
responses:
"200":
content:
application/json:
schema:
$ref: "#/components/schemas/CloudFile"
description: ""
patch:
operationId: cloud_files_partial_update
parameters:
- in: path
name: id
schema:
type: integer
description: A unique integer value identifying this cloud file.
required: true
tags:
- cloud-files
requestBody:
content:
application/json:
schema:
$ref: "#/components/schemas/PatchedCloudFile"
application/x-www-form-urlencoded:
schema:
$ref: "#/components/schemas/PatchedCloudFile"
multipart/form-data:
schema:
$ref: "#/components/schemas/PatchedCloudFile"
security:
- cookieAuth: []
- basicAuth: []
responses:
"200":
content:
application/json:
schema:
$ref: "#/components/schemas/CloudFile"
description: ""
delete:
operationId: cloud_files_destroy
parameters:
- in: path
name: id
schema:
type: integer
description: A unique integer value identifying this cloud file.
required: true
tags:
- cloud-files
security:
- cookieAuth: []
- basicAuth: []
responses:
"204":
description: No response body
/api/v2/countries/:
get:
operationId: countries_list
@ -5791,26 +5644,6 @@ components:
- status
- task_id
- track_reference
CloudFile:
type: object
properties:
item_url:
type: string
format: uri
readOnly: true
storage_backend:
type: string
maxLength: 512
resource_id:
type: string
filename:
type: string
format: uri
nullable: true
required:
- item_url
- resource_id
- storage_backend
Country:
type: object
properties:
@ -6238,22 +6071,6 @@ components:
track_reference:
type: string
format: uri
PatchedCloudFile:
type: object
properties:
item_url:
type: string
format: uri
readOnly: true
storage_backend:
type: string
maxLength: 512
resource_id:
type: string
filename:
type: string
format: uri
nullable: true
PatchedCountry:
type: object
properties:

3
legacy/application/airtime-boot.php
View File

@ -49,9 +49,6 @@ set_include_path(APPLICATION_PATH . '/controllers/plugins' . PATH_SEPARATOR . ge
// Services.
set_include_path(APPLICATION_PATH . '/services' . PATH_SEPARATOR . get_include_path());
// cloud storage directory
set_include_path(APPLICATION_PATH . '/cloud_storage' . PATH_SEPARATOR . get_include_path());
// Upgrade directory
set_include_path(APPLICATION_PATH . '/upgrade' . PATH_SEPARATOR . get_include_path());

30
legacy/application/cloud_storage/FileStorageBackend.php
View File

@ -1,30 +0,0 @@
<?php
class FileStorageBackend extends StorageBackend
{
public function getAbsoluteFilePath($resourceId)
{
// TODO
return $resourceId;
}
public function getDownloadURLs($resourceId, $contentDispositionFilename)
{
return '';
}
public function deletePhysicalFile($resourceId)
{
// TODO
}
public function deleteAllCloudFileObjects()
{
return '';
}
public function getFilePrefix()
{
return '';
}
}

54
legacy/application/cloud_storage/ProxyStorageBackend.php
View File

@ -1,54 +0,0 @@
<?php
/**
* Controls access to the storage backend class where a file is stored.
*/
class ProxyStorageBackend extends StorageBackend
{
private $storageBackend;
/**
* Receives the file's storage backend and instantiates the appropriate
* object.
*
* @param mixed $storageBackend
*/
public function __construct($storageBackend)
{
$CC_CONFIG = Config::getConfig();
// The storage backend in the config file directly corresponds to
// the name of the class that implements it, so we can create the
// right backend object dynamically:
if ($storageBackend == 'file') {
$this->storageBackend = new FileStorageBackend();
} else {
$this->storageBackend = new $storageBackend($CC_CONFIG[$storageBackend]);
}
}
public function getAbsoluteFilePath($resourceId)
{
return $this->storageBackend->getAbsoluteFilePath($resourceId);
}
public function getDownloadURLs($resourceId, $contentDispositionFilename)
{
return $this->storageBackend->getDownloadURLs($resourceId, $contentDispositionFilename);
}
public function deletePhysicalFile($resourceId)
{
$this->storageBackend->deletePhysicalFile($resourceId);
}
public function deleteAllCloudFileObjects()
{
$this->storageBackend->deleteAllCloudFileObjects();
}
public function getFilePrefix()
{
return $this->storageBackend->getFilePrefix();
}
}

60
legacy/application/cloud_storage/StorageBackend.php
View File

@ -1,60 +0,0 @@
<?php
/**
* Provides access to file objects stored on a specific storage backend.
*/
abstract class StorageBackend
{
private $bucket;
private $accessKey;
private $secretKey;
/** Returns the file object's URL to the storage backend it is located on. */
abstract public function getAbsoluteFilePath($resourceId);
/** Returns the file object's signed URL. The URL must be signed since they.
* @param mixed $resourceId
* @param mixed $contentDispositionFilename
* privately stored on the storage backend. */
abstract public function getDownloadURLs($resourceId, $contentDispositionFilename);
/** Deletes the file from the storage backend. */
abstract public function deletePhysicalFile($resourceId);
/** Deletes all objects (files) stored on the cloud service. To be used
* for station termination */
abstract public function deleteAllCloudFileObjects();
/** Get a prefix for the file (which is usually treated like a directory in the cloud) */
abstract public function getFilePrefix();
protected function getBucket()
{
return $this->bucket;
}
protected function setBucket($bucket)
{
$this->bucket = $bucket;
}
protected function getAccessKey()
{
return $this->accessKey;
}
protected function setAccessKey($accessKey)
{
$this->accessKey = $accessKey;
}
protected function getSecretKey()
{
return $this->secretKey;
}
protected function setSecretKey($secretKey)
{
$this->secretKey = $secretKey;
}
}

7
legacy/application/configs/classmap-airtime-conf.php
View File

@ -95,9 +95,6 @@ return [
'BaseCeleryTasks' => 'airtime/om/BaseCeleryTasks.php',
'BaseCeleryTasksPeer' => 'airtime/om/BaseCeleryTasksPeer.php',
'BaseCeleryTasksQuery' => 'airtime/om/BaseCeleryTasksQuery.php',
'BaseCloudFile' => 'airtime/om/BaseCloudFile.php',
'BaseCloudFilePeer' => 'airtime/om/BaseCloudFilePeer.php',
'BaseCloudFileQuery' => 'airtime/om/BaseCloudFileQuery.php',
'BaseImportedPodcast' => 'airtime/om/BaseImportedPodcast.php',
'BaseImportedPodcastPeer' => 'airtime/om/BaseImportedPodcastPeer.php',
'BaseImportedPodcastQuery' => 'airtime/om/BaseImportedPodcastQuery.php',
@ -237,10 +234,6 @@ return [
'CeleryTasksPeer' => 'airtime/CeleryTasksPeer.php',
'CeleryTasksQuery' => 'airtime/CeleryTasksQuery.php',
'CeleryTasksTableMap' => 'airtime/map/CeleryTasksTableMap.php',
'CloudFile' => 'airtime/CloudFile.php',
'CloudFilePeer' => 'airtime/CloudFilePeer.php',
'CloudFileQuery' => 'airtime/CloudFileQuery.php',
'CloudFileTableMap' => 'airtime/map/CloudFileTableMap.php',
'ImportedPodcast' => 'airtime/ImportedPodcast.php',
'ImportedPodcastPeer' => 'airtime/ImportedPodcastPeer.php',
'ImportedPodcastQuery' => 'airtime/ImportedPodcastQuery.php',

4
legacy/application/controllers/LibraryController.php
View File

@ -122,10 +122,6 @@ class LibraryController extends Zend_Controller_Action
// $menu["publish"] = array("name"=> _("Publish..."), "url" => $baseUrl."library/publish/id/{$id}");
}
// It's important that we always return the parent id (cc_files id)
// and not the cloud_file id (if applicable) for track download.
// Our application logic (StoredFile.php) will determine if the track
// is a cloud_file and handle it appropriately.
$url = $baseUrl . "api/get-media/file/{$id}/download/true";
$menu['download'] = ['name' => _('Download'), 'icon' => 'download', 'url' => $url];
} elseif ($type === 'playlist' || $type === 'block') {

15
legacy/application/controllers/PreferenceController.php
View File

@ -465,7 +465,6 @@ class PreferenceController extends Zend_Controller_Action
}
$this->deleteFutureScheduleItems();
$this->deleteCloudFiles();
$this->deleteStoredFiles();
$this->getResponse()
@ -499,20 +498,6 @@ class PreferenceController extends Zend_Controller_Action
}
}
private function deleteCloudFiles()
{
try {
$CC_CONFIG = Config::getConfig();
foreach ($CC_CONFIG['supportedStorageBackends'] as $storageBackend) {
$proxyStorageBackend = new ProxyStorageBackend($storageBackend);
$proxyStorageBackend->deleteAllCloudFileObjects();
}
} catch (Exception $e) {
Logging::info($e->getMessage());
}
}
private function deleteStoredFiles()
{
// Delete all files from the database

20
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,18 +615,9 @@ 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);
}
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;
}
}

13
legacy/build/schema.xml
View File

@ -96,19 +96,6 @@
<unique-column name="code" />
</unique>
</table>
<!-- Class Table Inheritance -->
<table name="cloud_file" phpName="CloudFile">
<column name="id" phpName="DbId" required="true" primaryKey="true" autoIncrement="true" type="INTEGER" />
<column name="storage_backend" phpName="StorageBackend" type="VARCHAR" size="512" required="true" />
<column name="resource_id" phpName="ResourceId" type="LONGVARCHAR" required="true" />
<column name="cc_file_id" type="INTEGER" />
<foreign-key foreignTable="cc_files" onDelete="CASCADE">
<reference local="cc_file_id" foreign="id" />
</foreign-key>
<behavior name="delegate">
<parameter name="to" value="cc_files" />
</behavior>
</table>
<table name="cc_show" phpName="CcShow">
<column name="id" phpName="DbId" type="INTEGER" primaryKey="true" autoIncrement="true" required="true" />
<column name="name" phpName="DbName" type="VARCHAR" size="255" required="true" defaultValue="" />

3
legacy/tests/application/bootstrap.php
View File

@ -59,9 +59,6 @@ set_include_path(APPLICATION_PATH . '/../tests/application/testdata' . PATH_SEPA
// helper functions
set_include_path(APPLICATION_PATH . '/../tests/application/helpers' . PATH_SEPARATOR . get_include_path());
// cloud storage files
set_include_path(APPLICATION_PATH . '/cloud_storage' . PATH_SEPARATOR . get_include_path());
require_once 'jooola/propel1/runtime/lib/Propel.php';
Propel::init('../application/configs/airtime-conf-production.php');