track type management

2020-01-25 12:09:19 -05:00 · 2020-01-25 12:09:19 -05:00 · 1d7d937a7f
parent 33928eaf73
commit 1d7d937a7f
29 changed files with 3082 additions and 74 deletions
--- a/airtime_mvc/application/configs/ACL.php
+++ b/airtime_mvc/application/configs/ACL.php
@ -12,6 +12,7 @@ $ccAcl->addRole(new Zend_Acl_Role('G'))
 $ccAcl->add(new Zend_Acl_Resource('library'))
      ->add(new Zend_Acl_Resource('index'))
      ->add(new Zend_Acl_Resource('user'))
+      ->add(new Zend_Acl_Resource('tracktype'))
      ->add(new Zend_Acl_Resource('error'))
      ->add(new Zend_Acl_Resource('login'))
      ->add(new Zend_Acl_Resource('playlist'))
@ -66,6 +67,7 @@ $ccAcl->allow('G', 'index')
      ->allow('G', 'setup')
      ->allow('G', 'embeddablewidgets')
      ->allow('G', 'feeds')
+      ->allow('P', 'tracktype')
      ->allow('H', 'soundcloud')
      ->allow('H', 'rest:show-image')
      ->allow('H', 'rest:media')
--- a/airtime_mvc/application/configs/classmap-airtime-conf.php
+++ b/airtime_mvc/application/configs/classmap-airtime-conf.php
@ -85,6 +85,9 @@ return array (
  'BaseCcStreamSetting' => 'airtime/om/BaseCcStreamSetting.php',
  'BaseCcStreamSettingPeer' => 'airtime/om/BaseCcStreamSettingPeer.php',
  'BaseCcStreamSettingQuery' => 'airtime/om/BaseCcStreamSettingQuery.php',
+  'BaseCcTracktypes' => 'airtime/om/BaseCcTracktypes.php',
+  'BaseCcTracktypesPeer' => 'airtime/om/BaseCcTracktypesPeer.php',
+  'BaseCcTracktypesQuery' => 'airtime/om/BaseCcTracktypesQuery.php',
  'BaseCcSubjs' => 'airtime/om/BaseCcSubjs.php',
  'BaseCcSubjsPeer' => 'airtime/om/BaseCcSubjsPeer.php',
  'BaseCcSubjsQuery' => 'airtime/om/BaseCcSubjsQuery.php',
@ -233,6 +236,10 @@ return array (
  'CcStreamSettingPeer' => 'airtime/CcStreamSettingPeer.php',
  'CcStreamSettingQuery' => 'airtime/CcStreamSettingQuery.php',
  'CcStreamSettingTableMap' => 'airtime/map/CcStreamSettingTableMap.php',
+  'CcTracktypes' => 'airtime/CcTracktypes.php',
+  'CcTracktypesPeer' => 'airtime/CcTracktypesPeer.php',
+  'CcTracktypesQuery' => 'airtime/CcTracktypesQuery.php',
+  'CcTracktypesTableMap' => 'airtime/map/CcTracktypesTableMap.php',
  'CcSubjs' => 'airtime/CcSubjs.php',
  'CcSubjsPeer' => 'airtime/CcSubjsPeer.php',
  'CcSubjsQuery' => 'airtime/CcSubjsQuery.php',
--- a/airtime_mvc/application/configs/navigation.php
+++ b/airtime_mvc/application/configs/navigation.php
@ -91,6 +91,12 @@ $pages[] = array(
            'controller' => 'user',
            'action'     => 'add-user',
            'resource'   => 'user'
+        ),array(
+            'label'      => _('Track Types'),
+            'module'     => 'default',
+            'controller' => 'tracktype',
+            'action'     => 'add-tracktype',
+            'resource'   => 'tracktype'
        ),
        array(
            'label'      => _('Streams'),
@ -138,7 +144,7 @@ $pages[] = array(
            'action'     => 'index',
            'resource'   => 'listenerstat'
        ),
-        array(            
+        array(
            'label'      => _('Show Listener Stats'),
            'module'     => 'default',
            'controller' => 'listenerstat',
--- a/airtime_mvc/application/controllers/ApiController.php
+++ b/airtime_mvc/application/controllers/ApiController.php
@ -27,6 +27,7 @@ class ApiController extends Zend_Controller_Action
            "show-schedules",
            "show-logo",
            "track",
+            "track-types",
            "stream-m3u"
        );

@ -635,6 +636,22 @@ class ApiController extends Zend_Controller_Action
        }
    }

+    public function trackTypesAction()
+    {
+        if (Application_Model_Preference::GetAllow3rdPartyApi() || $this->checkAuth()) {
+            // disable the view and the layout
+            $this->view->layout()->disableLayout();
+            $this->_helper->viewRenderer->setNoRender(true);
+
+            $tracktypes = Application_Model_Tracktype::getTracktypes();
+            $this->_helper->json->sendJson($tracktypes);
+        } else {
+            header('HTTP/1.0 401 Unauthorized');
+            print _('You are not allowed to access this resource. ');
+            exit;
+        }
+    }
+
    /**
     * API endpoint to provide station metadata
     */
--- a/airtime_mvc/application/controllers/TracktypeController.php
+++ b/airtime_mvc/application/controllers/TracktypeController.php
@ -0,0 +1,109 @@
+<?php
+
+class TracktypeController extends Zend_Controller_Action
+{
+
+    public function init()
+    {
+        $ajaxContext = $this->_helper->getHelper('AjaxContext');
+        $ajaxContext->addActionContext('get-tracktype-data-table-info', 'json')
+                    ->addActionContext('get-tracktype-data', 'json')
+                    ->addActionContext('remove-tracktype', 'json')
+                    ->initContext();
+    }
+
+    public function addTracktypeAction()
+    {
+        // Start the session to re-open write permission to the session so we can
+        // create the namespace for our csrf token verification
+        SessionHelper::reopenSessionForWriting();
+        $CC_CONFIG = Config::getConfig();
+
+        $request = $this->getRequest();
+
+        Zend_Layout::getMvcInstance()->assign('parent_page', 'Settings');
+
+        $baseUrl = Application_Common_OsPath::getBaseDir();
+
+        $js_files = array(
+            'js/datatables/js/jquery.dataTables.js?',
+            'js/datatables/plugin/dataTables.pluginAPI.js?',
+            'js/airtime/tracktype/tracktype.js?'
+        );
+
+        foreach ($js_files as $js) {
+            $this->view->headScript()->appendFile(
+                $baseUrl.$js.$CC_CONFIG['airtime_version'],'text/javascript');
+        }
+
+        $this->view->headLink()->appendStylesheet($baseUrl.'css/tracktypes.css?'.$CC_CONFIG['airtime_version']);
+
+        $form = new Application_Form_AddTracktype();
+
+        $this->view->successMessage = "";
+
+        if ($request->isPost()) {
+            $params = $request->getPost();
+            $postData = explode('&', $params['data']);
+            $formData = array();
+            foreach($postData as $k=>$v) {
+                $v = explode('=', $v);
+                $formData[$v[0]] = urldecode($v[1]);
+            }
+
+                if ($form->validateCode($formData)) {
+                    $tracktype = new Application_Model_Tracktype($formData['tracktype_id']);
+                    if (empty($formData['tracktype_id'])) {
+                        $tracktype->setCode($formData['code']);
+                    }
+                    $tracktype->setTypeName($formData['type_name']);
+                    $tracktype->setDescription($formData['description']);
+                    $tracktype->setVisibility($formData['visibility']);
+                    $tracktype->save();
+
+                    $form->reset();
+                    $this->view->form = $form;
+
+                    if (strlen($formData['tracktype_id']) == 0) {
+                        $this->view->successMessage = "<div class='success'>"._("Track Type added successfully!")."</div>";
+                    } else {
+                        $this->view->successMessage = "<div class='success'>"._("Track Type updated successfully!")."</div>";
+                    }
+
+                    $this->_helper->json->sendJson(array("valid"=>"true", "html"=>$this->view->render('tracktype/add-tracktype.phtml')));
+                } else {
+                    $this->view->form = $form;
+                    $this->_helper->json->sendJson(array("valid"=>"false", "html"=>$this->view->render('tracktype/add-tracktype.phtml')));
+                }
+
+        }
+
+        $this->view->form = $form;
+    }
+
+    public function getTracktypeDataTableInfoAction()
+    {
+        $post = $this->getRequest()->getPost();
+        $tracktypes = Application_Model_Tracktype::getTracktypesDataTablesInfo($post);
+
+        $this->_helper->json->sendJson($tracktypes);
+    }
+
+    public function getTracktypeDataAction()
+    {
+        $id = $this->_getParam('id');
+        $this->view->entries = Application_Model_Tracktype::GetTracktypeData($id);
+    }
+
+    public function removeTracktypeAction()
+    {
+        // action body
+        $delId = $this->_getParam('id');
+
+        $tracktype = new Application_Model_Tracktype($delId);
+
+        # Delete the track type
+        $this->view->entries = $tracktype->delete();
+    }
+
+}
--- a/airtime_mvc/application/controllers/downgrade_sql/airtime_3.0.0-alpha.9.2/downgrade.sql
+++ b/airtime_mvc/application/controllers/downgrade_sql/airtime_3.0.0-alpha.9.2/downgrade.sql
@ -1 +1,3 @@
 ALTER TABLE cc_files DROP COLUMN IF EXISTS track_type;
+
+DROP TABLE IF EXISTS "cc_track_types" CASCADE;
--- a/airtime_mvc/application/controllers/upgrade_sql/airtime_3.0.0-alpha.9.2/upgrade.sql
+++ b/airtime_mvc/application/controllers/upgrade_sql/airtime_3.0.0-alpha.9.2/upgrade.sql
@ -1 +1,25 @@
 ALTER TABLE cc_files ADD COLUMN track_type VARCHAR(16);
+
+CREATE TABLE IF NOT EXISTS "cc_track_types"
+(
+    "id" integer DEFAULT nextval('cc_subjs_id_seq'::regclass) NOT NULL,
+    "code" VARCHAR(16) NOT NULL,
+    "type_name" VARCHAR(64),
+    "description" VARCHAR(255),
+    "visibility" boolean DEFAULT true NOT NULL,
+    CONSTRAINT "cc_track_types_pkey" PRIMARY KEY ("id"),
+    CONSTRAINT "cc_track_types_code_key" UNIQUE ("code")
+);
+
+INSERT INTO cc_track_types VALUES (1, 'MUS', 'Music', 'This is used for tracks containing music.', true);
+INSERT INTO cc_track_types VALUES (2, 'SID', 'Station ID', 'This is used for Station IDs', true);
+INSERT INTO cc_track_types VALUES (3, 'INT', 'Show Intro', 'This can be used for organizing all the show introductions.', true);
+INSERT INTO cc_track_types VALUES (4, 'OUT', 'Show Outro', 'This can be used for organizing all the show outroductions.', true);
+INSERT INTO cc_track_types VALUES (5, 'SWP', 'Sweeper', 'This is used for segues between songs.', true);
+INSERT INTO cc_track_types VALUES (6, 'JIN', 'Jingle', 'A short song or tune, normally played during commercial breaks. Contains one or more hooks.', true);
+INSERT INTO cc_track_types VALUES (7, 'PRO', 'Promo', 'For promotional use.', true);
+INSERT INTO cc_track_types VALUES (8, 'SHO', 'Shout Out', 'A message of congratulation, greeting. support, or appreciation. ', true);
+INSERT INTO cc_track_types VALUES (9, 'NWS', 'News', 'This is used for noteworthy information, announcements.', true);
+INSERT INTO cc_track_types VALUES (10, 'COM', 'Commercial', 'This is used for commerical advertising.', true);
+INSERT INTO cc_track_types VALUES (11, 'ITV', 'Interview', 'This is used for radio interviews', true);
+INSERT INTO cc_track_types VALUES (12, 'VTR', 'Voice Tracking', 'Also referred as robojock or taped. Make announcements without actually being in the station.', true);
--- a/airtime_mvc/application/forms/AddTracktype.php
+++ b/airtime_mvc/application/forms/AddTracktype.php
@ -0,0 +1,79 @@
+<?php
+
+class Application_Form_AddTracktype extends Zend_Form
+{
+
+    public function init()
+    {
+        $notEmptyValidator = Application_Form_Helper_ValidationTypes::overrideNotEmptyValidator();
+
+        $this->setAttrib('id', 'tracktype_form');
+
+        $hidden = new Zend_Form_Element_Hidden('tracktype_id');
+        $hidden->setDecorators(array('ViewHelper'));
+        $this->addElement($hidden);
+
+        $this->addElement('hash', 'csrf', array(
+           'salt' => 'unique'
+        ));
+
+        $typeName = new Zend_Form_Element_Text('type_name');
+        $typeName->setLabel(_('Type Name:'));
+        $typeName->setAttrib('class', 'input_text');
+        $typeName->addFilter('StringTrim');
+        $this->addElement($typeName);
+
+        $code = new Zend_Form_Element_Text('code');
+        $code->setLabel(_('Code:'));
+        $code->setAttrib('class', 'input_text');
+        $code->setAttrib('style', 'width: 40%');
+        $code->setRequired(true);
+        $code->addValidator($notEmptyValidator);
+        $code->addFilter('StringTrim');
+        $this->addElement($code);
+
+        $description = new Zend_Form_Element_Textarea('description');
+        $description->setLabel(_('Description:'))
+            ->setFilters(array('StringTrim'))
+            ->setValidators(array(
+                new Zend_Validate_StringLength(array('max' => 200))
+            ));
+        $description->setAttrib('class', 'input_text');
+        $description->addFilter('StringTrim');
+        $this->addElement($description);
+
+        $visibility = new Zend_Form_Element_Select('visibility');
+        $visibility->setLabel(_('Visibility:'));
+        $visibility->setAttrib('class', 'input_select');
+        $visibility->setAttrib('style', 'width: 40%');
+        $visibility->setMultiOptions(array(
+                "0" => _("Disabled"),
+                "1" => _("Enabled")
+            ));
+        //$visibility->getValue();
+        $visibility->setRequired(true);
+        $this->addElement($visibility);
+
+        $saveBtn = new Zend_Form_Element_Button('save_tracktype');
+        $saveBtn->setAttrib('class', 'btn right-floated');
+        $saveBtn->setIgnore(true);
+        $saveBtn->setLabel(_('Save'));
+        $this->addElement($saveBtn);
+    }
+
+    public function validateCode($data)
+    {
+        if (strlen($data['tracktype_id']) == 0) {
+            $count = CcTracktypesQuery::create()->filterByDbCode($data['code'])->count();
+
+            if ($count != 0) {
+                $this->getElement('code')->setErrors(array(_("Code is not unique.")));
+
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+}
--- a/airtime_mvc/application/forms/EditAudioMD.php
+++ b/airtime_mvc/application/forms/EditAudioMD.php
@ -76,24 +76,9 @@ class Application_Form_EditAudioMD extends Zend_Form

        // Add track type dropdown
        $track_type_options = array();
-        $track_types = array(
-            ''       => '--- Select Track Type ---',
-            'MUS'    => 'Music (MUS)',
-            'SID'    => 'Station ID (SID)',
-            'INT'    => 'Intro (INT)',
-            'OUT'    => 'Outro (OUT)',
-            'SWP'    => 'Sweeper (SWP)',
-            'JIN'    => 'Jingle (JIN)',
-            'PRO'    => 'Promo (PRO)',
-            'SHO'    => 'Shout Out (SHO)',
-            'NWS'    => 'News (NWS)',
-            'COM'    => 'Commercial (COM)',
-            'ITV'    => 'Interview (ITV)',
-            'VTR'    => 'Voice Tracking (VTR)',
-          );
-
+        $track_types = Application_Model_Tracktype::getTracktypes();
        foreach ($track_types as $key => $tt) {
-            $track_type_options[$key] = $tt;
+            $track_type_options[$tt['code']] = $tt['type_name'];
        }

        $track_type = new Zend_Form_Element_Select('track_type');
--- a/airtime_mvc/application/models/Tracktype.php
+++ b/airtime_mvc/application/models/Tracktype.php
@ -0,0 +1,173 @@
+<?php
+
+class Application_Model_Tracktype
+{
+    private $_tracktypeInstance;
+
+    public function __construct($tracktypeId)
+    {
+        if (empty($tracktypeId)) {
+            $this->_tracktypeInstance = $this->createTracktype();
+        } else {
+            $this->_tracktypeInstance = CcTracktypesQuery::create()->findPK($tracktypeId);
+
+            if (is_null($this->_tracktypeInstance)) {
+                throw new Exception();
+            }
+        }
+    }
+
+    public function getId()
+    {
+        return $this->_tracktypeInstance->getDbId();
+    }
+
+    public function setCode($code)
+    {
+        $tracktype = $this->_tracktypeInstance;
+        $tracktype->setDbCode($code);
+    }
+
+    public function setTypeName($typeName)
+    {
+        $tracktype = $this->_tracktypeInstance;
+        $tracktype->setDbTypeName($typeName);
+    }
+
+    public function setDescription($description)
+    {
+        $tracktype = $this->_tracktypeInstance;
+        $tracktype->setDbDescription($description);
+    }
+
+    public function setVisibility($visibility)
+    {
+        $tracktype = $this->_tracktypeInstance;
+        $tracktype->setDbVisibility($visibility);
+    }
+
+    public function getCode()
+    {
+        $tracktype = $this->_tracktypeInstance;
+
+        return $tracktype->getDbCode();
+    }
+
+    public function getTypeName()
+    {
+        $tracktype = $this->_tracktypeInstance;
+
+        return $tracktype->getDbTypeName();
+    }
+
+    public function getDescription()
+    {
+        $tracktype = $this->_tracktypeInstance;
+
+        return $tracktype->getDbDescription();
+    }
+
+    public function getVisibility()
+    {
+        $tracktype = $this->_tracktypeInstance;
+
+        return $tracktype->getDbVisibility();
+    }
+
+    public function save()
+    {
+        $this->_tracktypeInstance->save();
+    }
+
+    public function delete()
+    {
+        if (!$this->_tracktypeInstance->isDeleted()) {
+            $this->_tracktypeInstance->delete();
+        }
+    }
+
+    private function createTracktype()
+    {
+        $tracktype = new CcTracktypes();
+
+        return $tracktype;
+    }
+
+    public static function getTracktypes($search=null)
+    {
+        return Application_Model_Tracktype::getTracktypesData(array(true), $search);
+    }
+
+    public static function getTracktypesData(array $visible, $search=null)
+    {
+        $con     = Propel::getConnection();
+
+        $sql_gen = "SELECT id, code, type_name, description FROM cc_track_types ";
+
+        $visibility = array();
+        $params = array();
+        for ($i=0; $i<count($visible); $i++) {
+            $p = ":visibility{$i}";
+            $visibility[] = "visibility = $p";
+            $params[$p] = $visible[$i];
+        }
+
+        $sql_type = join(" OR ", $visibility);
+
+        $sql      = $sql_gen ." WHERE (". $sql_type.") ";
+
+        $sql .= " AND code ILIKE :search";
+        $params[":search"] = "%$search%";
+
+        $sql = $sql ." ORDER BY id";
+
+        return Application_Common_Database::prepareAndExecute($sql, $params, "all");
+    }
+
+    public static function getTracktypeCount()
+    {
+        $sql_gen = "SELECT count(*) AS cnt FROM cc_track_types";
+
+        $query = Application_Common_Database::prepareAndExecute($sql_gen, array(),
+            Application_Common_Database::COLUMN);
+
+        return ($query !== false) ? $query : null;
+    }
+
+    public static function getTracktypesDataTablesInfo($datatables)
+    {
+
+        $con = Propel::getConnection(CcTracktypesPeer::DATABASE_NAME);
+
+        $displayColumns = array("id", "code", "type_name", "description", "visibility");
+        $fromTable = "cc_track_types";
+        $tracktypename = "";
+
+        $res = Application_Model_Datatables::findEntries($con, $displayColumns, $fromTable, $datatables);
+
+        foreach($res['aaData'] as $key => &$record){
+            if ($record['code'] == $tracktypename) {
+                $record['delete'] = "self";
+            } else {
+                $record['delete'] = "";
+            }
+            $record = array_map('htmlspecialchars', $record);
+        }
+
+        $res['aaData'] = array_values($res['aaData']);
+
+        return $res;
+    }
+
+    public static function getTracktypeData($id)
+    {
+        $sql = <<<SQL
+SELECT code, type_name, description, visibility, id
+FROM cc_track_types
+WHERE id = :id
+SQL;
+        return Application_Common_Database::prepareAndExecute($sql, array(
+            ":id" => $id), 'single');
+    }
+
+}
--- a/airtime_mvc/application/models/airtime/CcTracktypes.php
+++ b/airtime_mvc/application/models/airtime/CcTracktypes.php
@ -0,0 +1,16 @@
+<?php
+
+/**
+ * Skeleton subclass for representing a row from the 'cc_track_types' 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.
+ *
+ * @package    propel.generator.airtime
+ */
+class CcTracktypes extends BaseCcTracktypes {
+
+} // CcTracktypes
--- a/airtime_mvc/application/models/airtime/CcTracktypesPeer.php
+++ b/airtime_mvc/application/models/airtime/CcTracktypesPeer.php
@ -0,0 +1,18 @@
+<?php
+
+
+
+/**
+ * Skeleton subclass for performing query and update operations on the 'cc_track_types' 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.
+ *
+ * @package    propel.generator.airtime
+ */
+class CcTracktypesPeer extends BaseCcTracktypesPeer {
+
+} // CcTracktypesPeer
--- a/airtime_mvc/application/models/airtime/CcTracktypesQuery.php
+++ b/airtime_mvc/application/models/airtime/CcTracktypesQuery.php
@ -0,0 +1,18 @@
+<?php
+
+
+
+/**
+ * Skeleton subclass for performing query and update operations on the 'cc_track_types' 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.
+ *
+ * @package    propel.generator.airtime
+ */
+class CcTracktypesQuery extends BaseCcTracktypesQuery {
+
+} // CcTracktypesQuery
--- a/airtime_mvc/application/models/airtime/map/CcTracktypesTableMap.php
+++ b/airtime_mvc/application/models/airtime/map/CcTracktypesTableMap.php
@ -0,0 +1,56 @@
+<?php
+
+/**
+ * This class defines the structure of the 'cc_track_types' 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 CcTracktypesTableMap extends TableMap
+{
+
+    /**
+     * The (dot-path) name of this class
+     */
+    const CLASS_NAME = 'airtime.map.CcTracktypesTableMap';
+
+    /**
+     * 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('cc_track_types');
+        $this->setPhpName('CcTracktypes');
+        $this->setClassname('CcTracktypes');
+        $this->setPackage('airtime');
+        $this->setUseIdGenerator(true);
+        $this->setPrimaryKeyMethodInfo('cc_subjs_id_seq');
+        // columns
+        $this->addPrimaryKey('id', 'DbId', 'INTEGER', true, null, null);
+        $this->addColumn('code', 'DbCode', 'VARCHAR', true, 255, '');
+        $this->addColumn('visibility', 'DbVisibility', 'BOOLEAN', true, 1, true);
+        $this->addColumn('type_name', 'DbTypeName', 'VARCHAR', true, 255, '');
+        $this->addColumn('description', 'DbDescription', 'VARCHAR', true, 255, '');
+        // validators
+    } // initialize()
+
+    /**
+     * Build the RelationMap objects for this table relationships
+     */
+    public function buildRelations()
+    {
+
+    } // buildRelations()
+
+} // CcTracktypesTableMap
--- a/airtime_mvc/application/models/airtime/om/BaseCcTracktypes.php
+++ b/airtime_mvc/application/models/airtime/om/BaseCcTracktypes.php
--- a/airtime_mvc/application/models/airtime/om/BaseCcTracktypesPeer.php
+++ b/airtime_mvc/application/models/airtime/om/BaseCcTracktypesPeer.php
@ -0,0 +1,780 @@
+<?php
+
+/**
+ * Base static class for performing query and update operations on the 'cc_track_types' table.
+ *
+ *
+ *
+ * @package propel.generator.airtime.om
+ */
+abstract class BaseCcTracktypesPeer
+{
+
+    /** the default database name for this class */
+    const DATABASE_NAME = 'airtime';
+
+    /** the table name for this class */
+    const TABLE_NAME = 'cc_track_types';
+
+    /** the related Propel class for this table */
+    const OM_CLASS = 'CcTracktypes';
+
+    /** the related TableMap class for this table */
+    const TM_CLASS = 'CcTracktypesTableMap';
+
+    /** The total number of columns. */
+    const NUM_COLUMNS = 5;
+
+    /** The number of lazy-loaded columns. */
+    const NUM_LAZY_LOAD_COLUMNS = 0;
+
+    /** The number of columns to hydrate (NUM_COLUMNS - NUM_LAZY_LOAD_COLUMNS) */
+    const NUM_HYDRATE_COLUMNS = 5;
+
+    /** the column name for the id field */
+    const ID = 'cc_track_types.id';
+
+    /** the column name for the code field */
+    const CODE = 'cc_track_types.code';
+
+    /** the column name for the visibility field */
+    const VISIBILITY = 'cc_track_types.visibility';
+
+    /** the column name for the type_name field */
+    const TYPE_NAME = 'cc_track_types.type_name';
+
+    /** the column name for the description field */
+    const DESCRIPTION = 'cc_track_types.description';
+
+    /** The default string format for model objects of the related table **/
+    const DEFAULT_STRING_FORMAT = 'YAML';
+
+    /**
+     * An identity map to hold any loaded instances of CcTracktypes objects.
+     * This must be public so that other peer classes can access this when hydrating from JOIN
+     * queries.
+     * @var        array CcTracktypes[]
+     */
+    public static $instances = array();
+
+    /**
+     * holds an array of fieldnames
+     *
+     * first dimension keys are the type constants
+     * e.g. CcTracktypesPeer::$fieldNames[CcTracktypesPeer::TYPE_PHPNAME][0] = 'Id'
+     */
+    protected static $fieldNames = array (
+        BasePeer::TYPE_PHPNAME => array ('DbId', 'DbCode', 'DbVisibility', 'DbTypeName', 'DbDescription', ),
+        BasePeer::TYPE_STUDLYPHPNAME => array ('dbId', 'dbCode', 'dbVisibility', 'dbTypeName', 'dbDescription', ),
+        BasePeer::TYPE_COLNAME => array (CcTracktypesPeer::ID, CcTracktypesPeer::CODE, CcTracktypesPeer::VISIBILITY, CcTracktypesPeer::TYPE_NAME, CcTracktypesPeer::DESCRIPTION, ),
+        BasePeer::TYPE_RAW_COLNAME => array ('ID', 'CODE', 'VISIBILITY', 'TYPE_NAME', 'DESCRIPTION', ),
+        BasePeer::TYPE_FIELDNAME => array ('id', 'code', 'visibility', 'type_name', 'description', ),
+        BasePeer::TYPE_NUM => array (0, 1, 2, 3, 4, )
+    );
+
+    /**
+     * holds an array of keys for quick access to the fieldnames array
+     *
+     * first dimension keys are the type constants
+     * e.g. CcTracktypesPeer::$fieldNames[BasePeer::TYPE_PHPNAME]['Id'] = 0
+     */
+    protected static $fieldKeys = array (
+        BasePeer::TYPE_PHPNAME => array ('DbId' => 0, 'DbCode' => 1, 'DbVisibility' => 2, 'DbTypeName' => 3, 'DbDescription' => 4, ),
+        BasePeer::TYPE_STUDLYPHPNAME => array ('dbId' => 0, 'dbCode' => 1, 'dbVisibility' => 2, 'dbTypeName' => 3, 'dbDescription' => 4, ),
+        BasePeer::TYPE_COLNAME => array (CcTracktypesPeer::ID => 0, CcTracktypesPeer::CODE => 1, CcTracktypesPeer::VISIBILITY => 2, CcTracktypesPeer::TYPE_NAME => 3, CcTracktypesPeer::DESCRIPTION => 4, ),
+        BasePeer::TYPE_RAW_COLNAME => array ('ID' => 0, 'CODE' => 1, 'VISIBILITY' => 2, 'TYPE_NAME' => 3, 'DESCRIPTION' => 4, ),
+        BasePeer::TYPE_FIELDNAME => array ('id' => 0, 'code' => 1, 'visibility' => 2, 'type_name' => 3, 'description' => 4, ),
+        BasePeer::TYPE_NUM => array (0, 1, 2, 3, 4, )
+    );
+
+    /**
+     * Translates a fieldname to another type
+     *
+     * @param      string $name field name
+     * @param      string $fromType One of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME
+     *                         BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM
+     * @param      string $toType   One of the class type constants
+     * @return string          translated name of the field.
+     * @throws PropelException - if the specified name could not be found in the fieldname mappings.
+     */
+    public static function translateFieldName($name, $fromType, $toType)
+    {
+        $toNames = CcTracktypesPeer::getFieldNames($toType);
+        $key = isset(CcTracktypesPeer::$fieldKeys[$fromType][$name]) ? CcTracktypesPeer::$fieldKeys[$fromType][$name] : null;
+        if ($key === null) {
+            throw new PropelException("'$name' could not be found in the field names of type '$fromType'. These are: " . print_r(CcTracktypesPeer::$fieldKeys[$fromType], true));
+        }
+
+        return $toNames[$key];
+    }
+
+    /**
+     * Returns an array of field names.
+     *
+     * @param      string $type The type of fieldnames to return:
+     *                      One of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME
+     *                      BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM
+     * @return array           A list of field names
+     * @throws PropelException - if the type is not valid.
+     */
+    public static function getFieldNames($type = BasePeer::TYPE_PHPNAME)
+    {
+        if (!array_key_exists($type, CcTracktypesPeer::$fieldNames)) {
+            throw new PropelException('Method getFieldNames() expects the parameter $type to be one of the class constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME, BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM. ' . $type . ' was given.');
+        }
+
+        return CcTracktypesPeer::$fieldNames[$type];
+    }
+
+    /**
+     * Convenience method which changes table.column to alias.column.
+     *
+     * Using this method you can maintain SQL abstraction while using column aliases.
+     * <code>
+     *		$c->addAlias("alias1", TablePeer::TABLE_NAME);
+     *		$c->addJoin(TablePeer::alias("alias1", TablePeer::PRIMARY_KEY_COLUMN), TablePeer::PRIMARY_KEY_COLUMN);
+     * </code>
+     * @param      string $alias The alias for the current table.
+     * @param      string $column The column name for current table. (i.e. CcTracktypesPeer::COLUMN_NAME).
+     * @return string
+     */
+    public static function alias($alias, $column)
+    {
+        return str_replace(CcTracktypesPeer::TABLE_NAME.'.', $alias.'.', $column);
+    }
+
+    /**
+     * Add all the columns needed to create a new object.
+     *
+     * Note: any columns that were marked with lazyLoad="true" in the
+     * XML schema will not be added to the select list and only loaded
+     * on demand.
+     *
+     * @param      Criteria $criteria object containing the columns to add.
+     * @param      string   $alias    optional table alias
+     * @throws PropelException Any exceptions caught during processing will be
+     *		 rethrown wrapped into a PropelException.
+     */
+    public static function addSelectColumns(Criteria $criteria, $alias = null)
+    {
+        if (null === $alias) {
+            $criteria->addSelectColumn(CcTracktypesPeer::ID);
+            $criteria->addSelectColumn(CcTracktypesPeer::CODE);
+            $criteria->addSelectColumn(CcTracktypesPeer::VISIBILITY);
+            $criteria->addSelectColumn(CcTracktypesPeer::TYPE_NAME);
+            $criteria->addSelectColumn(CcTracktypesPeer::DESCRIPTION);
+        } else {
+            $criteria->addSelectColumn($alias . '.id');
+            $criteria->addSelectColumn($alias . '.code');
+            $criteria->addSelectColumn($alias . '.visibility');
+            $criteria->addSelectColumn($alias . '.type_name');
+            $criteria->addSelectColumn($alias . '.description');
+        }
+    }
+
+    /**
+     * Returns the number of rows matching criteria.
+     *
+     * @param      Criteria $criteria
+     * @param      boolean $distinct Whether to select only distinct columns; deprecated: use Criteria->setDistinct() instead.
+     * @param      PropelPDO $con
+     * @return int Number of matching rows.
+     */
+    public static function doCount(Criteria $criteria, $distinct = false, PropelPDO $con = null)
+    {
+        // we may modify criteria, so copy it first
+        $criteria = clone $criteria;
+
+        // We need to set the primary table name, since in the case that there are no WHERE columns
+        // it will be impossible for the BasePeer::createSelectSql() method to determine which
+        // tables go into the FROM clause.
+        $criteria->setPrimaryTableName(CcTracktypesPeer::TABLE_NAME);
+
+        if ($distinct && !in_array(Criteria::DISTINCT, $criteria->getSelectModifiers())) {
+            $criteria->setDistinct();
+        }
+
+        if (!$criteria->hasSelectClause()) {
+            CcTracktypesPeer::addSelectColumns($criteria);
+        }
+
+        $criteria->clearOrderByColumns(); // ORDER BY won't ever affect the count
+        $criteria->setDbName(CcTracktypesPeer::DATABASE_NAME); // Set the correct dbName
+
+        if ($con === null) {
+            $con = Propel::getConnection(CcTracktypesPeer::DATABASE_NAME, Propel::CONNECTION_READ);
+        }
+        // BasePeer returns a PDOStatement
+        $stmt = BasePeer::doCount($criteria, $con);
+
+        if ($row = $stmt->fetch(PDO::FETCH_NUM)) {
+            $count = (int) $row[0];
+        } else {
+            $count = 0; // no rows returned; we infer that means 0 matches.
+        }
+        $stmt->closeCursor();
+
+        return $count;
+    }
+
+    /**
+     * Selects one object from the DB.
+     *
+     * @param      Criteria $criteria object used to create the SELECT statement.
+     * @param      PropelPDO $con
+     * @return CcTracktypes
+     * @throws PropelException Any exceptions caught during processing will be
+     *		 rethrown wrapped into a PropelException.
+     */
+    public static function doSelectOne(Criteria $criteria, PropelPDO $con = null)
+    {
+        $critcopy = clone $criteria;
+        $critcopy->setLimit(1);
+        $objects = CcTracktypesPeer::doSelect($critcopy, $con);
+        if ($objects) {
+            return $objects[0];
+        }
+
+        return null;
+    }
+
+    /**
+     * Selects several row from the DB.
+     *
+     * @param      Criteria $criteria The Criteria object used to build the SELECT statement.
+     * @param      PropelPDO $con
+     * @return array           Array of selected Objects
+     * @throws PropelException Any exceptions caught during processing will be
+     *		 rethrown wrapped into a PropelException.
+     */
+    public static function doSelect(Criteria $criteria, PropelPDO $con = null)
+    {
+        return CcTracktypesPeer::populateObjects(CcTracktypesPeer::doSelectStmt($criteria, $con));
+    }
+
+    /**
+     * Prepares the Criteria object and uses the parent doSelect() method to execute a PDOStatement.
+     *
+     * Use this method directly if you want to work with an executed statement directly (for example
+     * to perform your own object hydration).
+     *
+     * @param      Criteria $criteria The Criteria object used to build the SELECT statement.
+     * @param      PropelPDO $con The connection to use
+     * @throws PropelException Any exceptions caught during processing will be
+     *		 rethrown wrapped into a PropelException.
+     * @return PDOStatement The executed PDOStatement object.
+     * @see        BasePeer::doSelect()
+     */
+    public static function doSelectStmt(Criteria $criteria, PropelPDO $con = null)
+    {
+        if ($con === null) {
+            $con = Propel::getConnection(CcTracktypesPeer::DATABASE_NAME, Propel::CONNECTION_READ);
+        }
+
+        if (!$criteria->hasSelectClause()) {
+            $criteria = clone $criteria;
+            CcTracktypesPeer::addSelectColumns($criteria);
+        }
+
+        // Set the correct dbName
+        $criteria->setDbName(CcTracktypesPeer::DATABASE_NAME);
+
+        // BasePeer returns a PDOStatement
+        return BasePeer::doSelect($criteria, $con);
+    }
+
+    /**
+     * Adds an object to the instance pool.
+     *
+     * Propel keeps cached copies of objects in an instance pool when they are retrieved
+     * from the database.  In some cases -- especially when you override doSelect*()
+     * methods in your stub classes -- you may need to explicitly add objects
+     * to the cache in order to ensure that the same objects are always returned by doSelect*()
+     * and retrieveByPK*() calls.
+     *
+     * @param CcTracktypes $obj A CcTracktypes object.
+     * @param      string $key (optional) key to use for instance map (for performance boost if key was already calculated externally).
+     */
+    public static function addInstanceToPool($obj, $key = null)
+    {
+        if (Propel::isInstancePoolingEnabled()) {
+            if ($key === null) {
+                $key = (string) $obj->getDbId();
+            } // if key === null
+            CcTracktypesPeer::$instances[$key] = $obj;
+        }
+    }
+
+    /**
+     * Removes an object from the instance pool.
+     *
+     * Propel keeps cached copies of objects in an instance pool when they are retrieved
+     * from the database.  In some cases -- especially when you override doDelete
+     * methods in your stub classes -- you may need to explicitly remove objects
+     * from the cache in order to prevent returning objects that no longer exist.
+     *
+     * @param      mixed $value A CcTracktypes object or a primary key value.
+     *
+     * @return void
+     * @throws PropelException - if the value is invalid.
+     */
+    public static function removeInstanceFromPool($value)
+    {
+        if (Propel::isInstancePoolingEnabled() && $value !== null) {
+            if (is_object($value) && $value instanceof CcTracktypes) {
+                $key = (string) $value->getDbId();
+            } elseif (is_scalar($value)) {
+                // assume we've been passed a primary key
+                $key = (string) $value;
+            } else {
+                $e = new PropelException("Invalid value passed to removeInstanceFromPool().  Expected primary key or CcTracktypes object; got " . (is_object($value) ? get_class($value) . ' object.' : var_export($value,true)));
+                throw $e;
+            }
+
+            unset(CcTracktypesPeer::$instances[$key]);
+        }
+    } // removeInstanceFromPool()
+
+    /**
+     * Retrieves a string version of the primary key from the DB resultset row that can be used to uniquely identify a row in this table.
+     *
+     * For tables with a single-column primary key, that simple pkey value will be returned.  For tables with
+     * a multi-column primary key, a serialize()d version of the primary key will be returned.
+     *
+     * @param      string $key The key (@see getPrimaryKeyHash()) for this instance.
+     * @return CcTracktypes Found object or null if 1) no instance exists for specified key or 2) instance pooling has been disabled.
+     * @see        getPrimaryKeyHash()
+     */
+    public static function getInstanceFromPool($key)
+    {
+        if (Propel::isInstancePoolingEnabled()) {
+            if (isset(CcTracktypesPeer::$instances[$key])) {
+                return CcTracktypesPeer::$instances[$key];
+            }
+        }
+
+        return null; // just to be explicit
+    }
+
+    /**
+     * Clear the instance pool.
+     *
+     * @return void
+     */
+    public static function clearInstancePool($and_clear_all_references = false)
+    {
+      if ($and_clear_all_references) {
+        foreach (CcTracktypesPeer::$instances as $instance) {
+          $instance->clearAllReferences(true);
+        }
+      }
+        CcTracktypesPeer::$instances = array();
+    }
+
+    /**
+     * Method to invalidate the instance pool of all tables related to cc_track_types
+     * by a foreign key with ON DELETE CASCADE
+     */
+    public static function clearRelatedInstancePool()
+    {
+
+    }
+
+    /**
+     * Retrieves a string version of the primary key from the DB resultset row that can be used to uniquely identify a row in this table.
+     *
+     * For tables with a single-column primary key, that simple pkey value will be returned.  For tables with
+     * a multi-column primary key, a serialize()d version of the primary key will be returned.
+     *
+     * @param      array $row PropelPDO resultset row.
+     * @param      int $startcol The 0-based offset for reading from the resultset row.
+     * @return string A string version of PK or null if the components of primary key in result array are all null.
+     */
+    public static function getPrimaryKeyHashFromRow($row, $startcol = 0)
+    {
+        // If the PK cannot be derived from the row, return null.
+        if ($row[$startcol] === null) {
+            return null;
+        }
+
+        return (string) $row[$startcol];
+    }
+
+    /**
+     * Retrieves the primary key from the DB resultset row
+     * For tables with a single-column primary key, that simple pkey value will be returned.  For tables with
+     * a multi-column primary key, an array of the primary key columns will be returned.
+     *
+     * @param      array $row PropelPDO resultset row.
+     * @param      int $startcol The 0-based offset for reading from the resultset row.
+     * @return mixed The primary key of the row
+     */
+    public static function getPrimaryKeyFromRow($row, $startcol = 0)
+    {
+
+        return (int) $row[$startcol];
+    }
+
+    /**
+     * The returned array will contain objects of the default type or
+     * objects that inherit from the default.
+     *
+     * @throws PropelException Any exceptions caught during processing will be
+     *		 rethrown wrapped into a PropelException.
+     */
+    public static function populateObjects(PDOStatement $stmt)
+    {
+        $results = array();
+
+        // set the class once to avoid overhead in the loop
+        $cls = CcTracktypesPeer::getOMClass();
+        // populate the object(s)
+        while ($row = $stmt->fetch(PDO::FETCH_NUM)) {
+            $key = CcTracktypesPeer::getPrimaryKeyHashFromRow($row, 0);
+            if (null !== ($obj = CcTracktypesPeer::getInstanceFromPool($key))) {
+                // We no longer rehydrate the object, since this can cause data loss.
+                // See http://www.propelorm.org/ticket/509
+                // $obj->hydrate($row, 0, true); // rehydrate
+                $results[] = $obj;
+            } else {
+                $obj = new $cls();
+                $obj->hydrate($row);
+                $results[] = $obj;
+                CcTracktypesPeer::addInstanceToPool($obj, $key);
+            } // if key exists
+        }
+        $stmt->closeCursor();
+
+        return $results;
+    }
+
+    /**
+     * Populates an object of the default type or an object that inherit from the default.
+     *
+     * @param      array $row PropelPDO resultset row.
+     * @param      int $startcol The 0-based offset for reading from the resultset row.
+     * @throws PropelException Any exceptions caught during processing will be
+     *		 rethrown wrapped into a PropelException.
+     * @return array (CcTracktypes object, last column rank)
+     */
+    public static function populateObject($row, $startcol = 0)
+    {
+        $key = CcTracktypesPeer::getPrimaryKeyHashFromRow($row, $startcol);
+        if (null !== ($obj = CcTracktypesPeer::getInstanceFromPool($key))) {
+            // We no longer rehydrate the object, since this can cause data loss.
+            // See http://www.propelorm.org/ticket/509
+            // $obj->hydrate($row, $startcol, true); // rehydrate
+            $col = $startcol + CcTracktypesPeer::NUM_HYDRATE_COLUMNS;
+        } else {
+            $cls = CcTracktypesPeer::OM_CLASS;
+            $obj = new $cls();
+            $col = $obj->hydrate($row, $startcol);
+            CcTracktypesPeer::addInstanceToPool($obj, $key);
+        }
+
+        return array($obj, $col);
+    }
+
+    /**
+     * Returns the TableMap related to this peer.
+     * This method is not needed for general use but a specific application could have a need.
+     * @return TableMap
+     * @throws PropelException Any exceptions caught during processing will be
+     *		 rethrown wrapped into a PropelException.
+     */
+    public static function getTableMap()
+    {
+        return Propel::getDatabaseMap(CcTracktypesPeer::DATABASE_NAME)->getTable(CcTracktypesPeer::TABLE_NAME);
+    }
+
+    /**
+     * Add a TableMap instance to the database for this peer class.
+     */
+    public static function buildTableMap()
+    {
+      $dbMap = Propel::getDatabaseMap(BaseCcTracktypesPeer::DATABASE_NAME);
+      if (!$dbMap->hasTable(BaseCcTracktypesPeer::TABLE_NAME)) {
+        $dbMap->addTableObject(new \CcTracktypesTableMap());
+      }
+    }
+
+    /**
+     * The class that the Peer will make instances of.
+     *
+     *
+     * @return string ClassName
+     */
+    public static function getOMClass($row = 0, $colnum = 0)
+    {
+        return CcTracktypesPeer::OM_CLASS;
+    }
+
+    /**
+     * Performs an INSERT on the database, given a CcTracktypes or Criteria object.
+     *
+     * @param      mixed $values Criteria or CcTracktypes object containing data that is used to create the INSERT statement.
+     * @param      PropelPDO $con the PropelPDO connection to use
+     * @return mixed           The new primary key.
+     * @throws PropelException Any exceptions caught during processing will be
+     *		 rethrown wrapped into a PropelException.
+     */
+    public static function doInsert($values, PropelPDO $con = null)
+    {
+        if ($con === null) {
+            $con = Propel::getConnection(CcTracktypesPeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
+        }
+
+        if ($values instanceof Criteria) {
+            $criteria = clone $values; // rename for clarity
+        } else {
+            $criteria = $values->buildCriteria(); // build Criteria from CcTracktypes object
+        }
+
+        if ($criteria->containsKey(CcTracktypesPeer::ID) && $criteria->keyContainsValue(CcTracktypesPeer::ID) ) {
+            throw new PropelException('Cannot insert a value for auto-increment primary key ('.CcTracktypesPeer::ID.')');
+        }
+
+
+        // Set the correct dbName
+        $criteria->setDbName(CcTracktypesPeer::DATABASE_NAME);
+
+        try {
+            // use transaction because $criteria could contain info
+            // for more than one table (I guess, conceivably)
+            $con->beginTransaction();
+            $pk = BasePeer::doInsert($criteria, $con);
+            $con->commit();
+        } catch (Exception $e) {
+            $con->rollBack();
+            throw $e;
+        }
+
+        return $pk;
+    }
+
+    /**
+     * Performs an UPDATE on the database, given a CcTracktypes or Criteria object.
+     *
+     * @param      mixed $values Criteria or CcTracktypes object containing data that is used to create the UPDATE statement.
+     * @param      PropelPDO $con The connection to use (specify PropelPDO connection object to exert more control over transactions).
+     * @return int             The number of affected rows (if supported by underlying database driver).
+     * @throws PropelException Any exceptions caught during processing will be
+     *		 rethrown wrapped into a PropelException.
+     */
+    public static function doUpdate($values, PropelPDO $con = null)
+    {
+        if ($con === null) {
+            $con = Propel::getConnection(CcTracktypesPeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
+        }
+
+        $selectCriteria = new Criteria(CcTracktypesPeer::DATABASE_NAME);
+
+        if ($values instanceof Criteria) {
+            $criteria = clone $values; // rename for clarity
+
+            $comparison = $criteria->getComparison(CcTracktypesPeer::ID);
+            $value = $criteria->remove(CcTracktypesPeer::ID);
+            if ($value) {
+                $selectCriteria->add(CcTracktypesPeer::ID, $value, $comparison);
+            } else {
+                $selectCriteria->setPrimaryTableName(CcTracktypesPeer::TABLE_NAME);
+            }
+
+        } else { // $values is CcTracktypes object
+            $criteria = $values->buildCriteria(); // gets full criteria
+            $selectCriteria = $values->buildPkeyCriteria(); // gets criteria w/ primary key(s)
+        }
+
+        // set the correct dbName
+        $criteria->setDbName(CcTracktypesPeer::DATABASE_NAME);
+
+        return BasePeer::doUpdate($selectCriteria, $criteria, $con);
+    }
+
+    /**
+     * Deletes all rows from the cc_track_types table.
+     *
+     * @param      PropelPDO $con the connection to use
+     * @return int             The number of affected rows (if supported by underlying database driver).
+     * @throws PropelException
+     */
+    public static function doDeleteAll(PropelPDO $con = null)
+    {
+        if ($con === null) {
+            $con = Propel::getConnection(CcTracktypesPeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
+        }
+        $affectedRows = 0; // initialize var to track total num of affected rows
+        try {
+            // use transaction because $criteria could contain info
+            // for more than one table or we could emulating ON DELETE CASCADE, etc.
+            $con->beginTransaction();
+            $affectedRows += BasePeer::doDeleteAll(CcTracktypesPeer::TABLE_NAME, $con, CcTracktypesPeer::DATABASE_NAME);
+            // Because this db requires some delete cascade/set null emulation, we have to
+            // clear the cached instance *after* the emulation has happened (since
+            // instances get re-added by the select statement contained therein).
+            CcTracktypesPeer::clearInstancePool();
+            CcTracktypesPeer::clearRelatedInstancePool();
+            $con->commit();
+
+            return $affectedRows;
+        } catch (Exception $e) {
+            $con->rollBack();
+            throw $e;
+        }
+    }
+
+    /**
+     * Performs a DELETE on the database, given a CcTracktypes or Criteria object OR a primary key value.
+     *
+     * @param      mixed $values Criteria or CcTracktypes object or primary key or array of primary keys
+     *              which is used to create the DELETE statement
+     * @param      PropelPDO $con the connection to use
+     * @return int The number of affected rows (if supported by underlying database driver).  This includes CASCADE-related rows
+     *				if supported by native driver or if emulated using Propel.
+     * @throws PropelException Any exceptions caught during processing will be
+     *		 rethrown wrapped into a PropelException.
+     */
+    public static function doDelete($values, PropelPDO $con = null)
+    {
+        if ($con === null) {
+            $con = Propel::getConnection(CcTracktypesPeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
+        }
+
+        if ($values instanceof Criteria) {
+            // invalidate the cache for all objects of this type, since we have no
+            // way of knowing (without running a query) what objects should be invalidated
+            // from the cache based on this Criteria.
+            CcTracktypesPeer::clearInstancePool();
+            // rename for clarity
+            $criteria = clone $values;
+        } elseif ($values instanceof CcTracktypes) { // it's a model object
+            // invalidate the cache for this single object
+            CcTracktypesPeer::removeInstanceFromPool($values);
+            // create criteria based on pk values
+            $criteria = $values->buildPkeyCriteria();
+        } else { // it's a primary key, or an array of pks
+            $criteria = new Criteria(CcTracktypesPeer::DATABASE_NAME);
+            $criteria->add(CcTracktypesPeer::ID, (array) $values, Criteria::IN);
+            // invalidate the cache for this object(s)
+            foreach ((array) $values as $singleval) {
+                CcTracktypesPeer::removeInstanceFromPool($singleval);
+            }
+        }
+
+        // Set the correct dbName
+        $criteria->setDbName(CcTracktypesPeer::DATABASE_NAME);
+
+        $affectedRows = 0; // initialize var to track total num of affected rows
+
+        try {
+            // use transaction because $criteria could contain info
+            // for more than one table or we could emulating ON DELETE CASCADE, etc.
+            $con->beginTransaction();
+
+            $affectedRows += BasePeer::doDelete($criteria, $con);
+            CcTracktypesPeer::clearRelatedInstancePool();
+            $con->commit();
+
+            return $affectedRows;
+        } catch (Exception $e) {
+            $con->rollBack();
+            throw $e;
+        }
+    }
+
+    /**
+     * Validates all modified columns of given CcTracktypes object.
+     * If parameter $columns is either a single column name or an array of column names
+     * than only those columns are validated.
+     *
+     * NOTICE: This does not apply to primary or foreign keys for now.
+     *
+     * @param CcTracktypes $obj The object to validate.
+     * @param      mixed $cols Column name or array of column names.
+     *
+     * @return mixed TRUE if all columns are valid or the error message of the first invalid column.
+     */
+    public static function doValidate($obj, $cols = null)
+    {
+        $columns = array();
+
+        if ($cols) {
+            $dbMap = Propel::getDatabaseMap(CcTracktypesPeer::DATABASE_NAME);
+            $tableMap = $dbMap->getTable(CcTracktypesPeer::TABLE_NAME);
+
+            if (! is_array($cols)) {
+                $cols = array($cols);
+            }
+
+            foreach ($cols as $colName) {
+                if ($tableMap->hasColumn($colName)) {
+                    $get = 'get' . $tableMap->getColumn($colName)->getPhpName();
+                    $columns[$colName] = $obj->$get();
+                }
+            }
+        } else {
+
+        }
+
+        return BasePeer::doValidate(CcTracktypesPeer::DATABASE_NAME, CcTracktypesPeer::TABLE_NAME, $columns);
+    }
+
+    /**
+     * Retrieve a single object by pkey.
+     *
+     * @param int $pk the primary key.
+     * @param      PropelPDO $con the connection to use
+     * @return CcTracktypes
+     */
+    public static function retrieveByPK($pk, PropelPDO $con = null)
+    {
+
+        if (null !== ($obj = CcTracktypesPeer::getInstanceFromPool((string) $pk))) {
+            return $obj;
+        }
+
+        if ($con === null) {
+            $con = Propel::getConnection(CcTracktypesPeer::DATABASE_NAME, Propel::CONNECTION_READ);
+        }
+
+        $criteria = new Criteria(CcTracktypesPeer::DATABASE_NAME);
+        $criteria->add(CcTracktypesPeer::ID, $pk);
+
+        $v = CcTracktypesPeer::doSelect($criteria, $con);
+
+        return !empty($v) > 0 ? $v[0] : null;
+    }
+
+    /**
+     * Retrieve multiple objects by pkey.
+     *
+     * @param      array $pks List of primary keys
+     * @param      PropelPDO $con the connection to use
+     * @return CcTracktypes[]
+     * @throws PropelException Any exceptions caught during processing will be
+     *		 rethrown wrapped into a PropelException.
+     */
+    public static function retrieveByPKs($pks, PropelPDO $con = null)
+    {
+        if ($con === null) {
+            $con = Propel::getConnection(CcTracktypesPeer::DATABASE_NAME, Propel::CONNECTION_READ);
+        }
+
+        $objs = null;
+        if (empty($pks)) {
+            $objs = array();
+        } else {
+            $criteria = new Criteria(CcTracktypesPeer::DATABASE_NAME);
+            $criteria->add(CcTracktypesPeer::ID, $pks, Criteria::IN);
+            $objs = CcTracktypesPeer::doSelect($criteria, $con);
+        }
+
+        return $objs;
+    }
+
+} // BaseCcTracktypesPeer
+
+// This is the static code needed to register the TableMap for this table with the main Propel class.
+//
+BaseCcTracktypesPeer::buildTableMap();
+
--- a/airtime_mvc/application/models/airtime/om/BaseCcTracktypesQuery.php
+++ b/airtime_mvc/application/models/airtime/om/BaseCcTracktypesQuery.php
@ -0,0 +1,407 @@
+<?php
+
+/**
+ * Base class that represents a query for the 'cc_track_types' table.
+ *
+ *
+ *
+ * @method CcTracktypesQuery orderByDbId($order = Criteria::ASC) Order by the id column
+ * @method CcTracktypesQuery orderByDbCOde($order = Criteria::ASC) Order by the code column
+ * @method CcTracktypesQuery orderByDbVisibility($order = Criteria::ASC) Order by the visibility column
+ * @method CcTracktypesQuery orderByDbTypeName($order = Criteria::ASC) Order by the type_name column
+ * @method CcTracktypesQuery orderByDbDescription($order = Criteria::ASC) Order by the description column
+
+ * @method CcTracktypesQuery groupByDbId() Group by the id column
+ * @method CcTracktypesQuery groupByDbCOde() Group by the code column
+ * @method CcTracktypesQuery groupByDbVisibility() Group by the visibility column
+ * @method CcTracktypesQuery groupByDbTypeName() Group by the type_name column
+ * @method CcTracktypesQuery groupByDbDescription() Group by the description column
+
+ * @method CcTracktypesQuery leftJoin($relation) Adds a LEFT JOIN clause to the query
+ * @method CcTracktypesQuery rightJoin($relation) Adds a RIGHT JOIN clause to the query
+ * @method CcTracktypesQuery innerJoin($relation) Adds a INNER JOIN clause to the query
+ *
+ * @method CcTracktypes findOne(PropelPDO $con = null) Return the first CcTracktypes matching the query
+ * @method CcTracktypes findOneOrCreate(PropelPDO $con = null) Return the first CcTracktypes matching the query, or a new CcTracktypes object populated from the query conditions when no match is found
+ *
+ * @method CcTracktypes findOneByDbCode(string $code) Return the first CcTracktypes filtered by the code column
+ * @method CcTracktypes findOneByDbVisibility(string $visibility) Return the first CcTracktypes filtered by the visibility column
+ * @method CcTracktypes findOneByDbTypeName(string $type_name) Return the first CcTracktypes filtered by the type_name column
+ * @method CcTracktypes findOneByDbDescription(string $description) Return the first CcTracktypes filtered by the description column
+
+ * @method array findByDbId(int $id) Return CcTracktypes objects filtered by the id column
+ * @method array findByDbCode(string $code) Return CcTracktypes objects filtered by the code column
+ * @method array findByDbVisibility(string $visibility) Return CcTracktypes objects filtered by the visibility column
+ * @method array findByDbTypeName(string $type_name) Return CcTracktypes objects filtered by the type_name column
+ * @method array findByDbDescription(string $description) Return CcTracktypes objects filtered by the description column
+
+ * @package    propel.generator.airtime.om
+ */
+abstract class BaseCcTracktypesQuery extends ModelCriteria
+{
+    /**
+     * Initializes internal state of BaseCcTracktypesQuery 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 = 'CcTracktypes';
+        }
+        parent::__construct($dbName, $modelName, $modelAlias);
+    }
+
+    /**
+     * Returns a new CcTracktypesQuery object.
+     *
+     * @param     string $modelAlias The alias of a model in the query
+     * @param   CcTracktypesQuery|Criteria $criteria Optional Criteria to build the query from
+     *
+     * @return CcTracktypesQuery
+     */
+    public static function create($modelAlias = null, $criteria = null)
+    {
+        if ($criteria instanceof CcTracktypesQuery) {
+            return $criteria;
+        }
+        $query = new CcTracktypesQuery(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   CcTracktypes|CcTracktypes[]|mixed the result, formatted by the current formatter
+     */
+    public function findPk($key, $con = null)
+    {
+        if ($key === null) {
+            return null;
+        }
+        if ((null !== ($obj = CcTracktypesPeer::getInstanceFromPool((string) $key))) && !$this->formatter) {
+            // the object is already in the instance pool
+            return $obj;
+        }
+        if ($con === null) {
+            $con = Propel::getConnection(CcTracktypesPeer::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                 CcTracktypes 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                 CcTracktypes A model object, or null if the key is not found
+     * @throws PropelException
+     */
+    protected function findPkSimple($key, $con)
+    {
+        $sql = 'SELECT "id", "code", "visibility", "type_name", "description" FROM "cc_track_types" 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 CcTracktypes();
+            $obj->hydrate($row);
+            CcTracktypesPeer::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 CcTracktypes|CcTracktypes[]|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|CcTracktypes[]|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 CcTracktypesQuery The current query, for fluid interface
+     */
+    public function filterByPrimaryKey($key)
+    {
+
+        return $this->addUsingAlias(CcTracktypesPeer::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 CcTracktypesQuery The current query, for fluid interface
+     */
+    public function filterByPrimaryKeys($keys)
+    {
+
+        return $this->addUsingAlias(CcTracktypesPeer::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 CcTracktypesQuery 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(CcTracktypesPeer::ID, $dbId['min'], Criteria::GREATER_EQUAL);
+                $useMinMax = true;
+            }
+            if (isset($dbId['max'])) {
+                $this->addUsingAlias(CcTracktypesPeer::ID, $dbId['max'], Criteria::LESS_EQUAL);
+                $useMinMax = true;
+            }
+            if ($useMinMax) {
+                return $this;
+            }
+            if (null === $comparison) {
+                $comparison = Criteria::IN;
+            }
+        }
+
+        return $this->addUsingAlias(CcTracktypesPeer::ID, $dbId, $comparison);
+    }
+
+    /**
+     * Filter the query on the code column
+     *
+     * Example usage:
+     * <code>
+     * $query->filterByDbCode('fooValue');   // WHERE code = 'fooValue'
+     * $query->filterByDbCode('%fooValue%'); // WHERE code LIKE '%fooValue%'
+     * </code>
+     *
+     * @param     string $dbCode 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 CcTracktypesQuery The current query, for fluid interface
+     */
+    public function filterByDbCode($dbCode = null, $comparison = null)
+    {
+        if (null === $comparison) {
+            if (is_array($dbCode)) {
+                $comparison = Criteria::IN;
+            } elseif (preg_match('/[\%\*]/', $dbCode)) {
+                $dbCode = str_replace('*', '%', $dbCode);
+                $comparison = Criteria::LIKE;
+            }
+        }
+
+        return $this->addUsingAlias(CcTracktypesPeer::CODE, $dbCode, $comparison);
+    }
+
+    /**
+     * Filter the query on the visibility column
+     *
+     * Example usage:
+     * <code>
+     * $query->filterByDbVisibility('fooValue');   // WHERE visibility = 'fooValue'
+     * $query->filterByDbVisibility('%fooValue%'); // WHERE visibility LIKE '%fooValue%'
+     * </code>
+     *
+     * @param     string $dbVisibility 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 CcTracktypesQuery The current query, for fluid interface
+     */
+    public function filterByDbVisibility($dbVisibility = null, $comparison = null)
+    {
+        if (null === $comparison) {
+            if (is_array($dbVisibility)) {
+                $comparison = Criteria::IN;
+            } elseif (preg_match('/[\%\*]/', $dbVisibility)) {
+                $dbVisibility = str_replace('*', '%', $dbVisibility);
+                $comparison = Criteria::LIKE;
+            }
+        }
+
+        return $this->addUsingAlias(CcTracktypesPeer::VISIBILITY, $dbVisibility, $comparison);
+    }
+
+    /**
+     * Filter the query on the first_name column
+     *
+     * Example usage:
+     * <code>
+     * $query->filterByDbTypeName('fooValue');   // WHERE type_name = 'fooValue'
+     * $query->filterByDbTypeName('%fooValue%'); // WHERE type_name LIKE '%fooValue%'
+     * </code>
+     *
+     * @param     string $dbFirstName 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 CcTracktypesQuery The current query, for fluid interface
+     */
+    public function filterByDbFirstName($dbFirstName = null, $comparison = null)
+    {
+        if (null === $comparison) {
+            if (is_array($dbFirstName)) {
+                $comparison = Criteria::IN;
+            } elseif (preg_match('/[\%\*]/', $dbFirstName)) {
+                $dbFirstName = str_replace('*', '%', $dbFirstName);
+                $comparison = Criteria::LIKE;
+            }
+        }
+
+        return $this->addUsingAlias(CcTracktypesPeer::FIRST_NAME, $dbFirstName, $comparison);
+    }
+
+    /**
+     * Filter the query on the last_name column
+     *
+     * Example usage:
+     * <code>
+     * $query->filterByDbLastName('fooValue');   // WHERE last_name = 'fooValue'
+     * $query->filterByDbLastName('%fooValue%'); // WHERE last_name LIKE '%fooValue%'
+     * </code>
+     *
+     * @param     string $dbLastName 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 CcTracktypesQuery The current query, for fluid interface
+     */
+    public function filterByDbLastName($dbLastName = null, $comparison = null)
+    {
+        if (null === $comparison) {
+            if (is_array($dbLastName)) {
+                $comparison = Criteria::IN;
+            } elseif (preg_match('/[\%\*]/', $dbLastName)) {
+                $dbLastName = str_replace('*', '%', $dbLastName);
+                $comparison = Criteria::LIKE;
+            }
+        }
+
+        return $this->addUsingAlias(CcTracktypesPeer::LAST_NAME, $dbLastName, $comparison);
+    }
+
+    /**
+     * Exclude object from result
+     *
+     * @param   CcTracktypes $ccTracktypes Object to remove from the list of results
+     *
+     * @return CcTracktypesQuery The current query, for fluid interface
+     */
+    public function prune($ccTracktypes = null)
+    {
+        if ($ccTracktypes) {
+            $this->addUsingAlias(CcTracktypesPeer::ID, $ccTracktypes->getDbId(), Criteria::NOT_EQUAL);
+        }
+
+        return $this;
+    }
+
+}
--- a/airtime_mvc/application/views/scripts/plupload/index.phtml
+++ b/airtime_mvc/application/views/scripts/plupload/index.phtml
@ -13,24 +13,14 @@
    $disk = $partitions[0];
    $used = $disk->totalSpace-$disk->totalFreeSpace;
    $total = $disk->totalSpace;
-    ?>
-
-    <?php
-    $track_type_options = array();
-    $track_types = array(
-        'MUS'    => 'Music',
-        'SID'    => 'Station IDs',
-        'INT'    => 'Intros',
-        'OUT'    => 'Outros',
-        'SWP'    => 'Sweepers',
-        'JIN'    => 'Jingles',
-        'PRO'    => 'Promos',
-        'SHO'    => 'Shout Outs',
-        'NWS'    => 'News',
-        'COM'    => 'Commercials',
-        'ITV'    => 'Interviews',
-        'VTR'    => 'Voice Trackings',
-      );
+    $tracktypes = Application_Model_Tracktype::getTracktypes();
+    if(count($tracktypes) == 0) {
+        $hasTracktypes = "disabled";
+        $showTracktypesDropdown = false;
+    } else {
+        $hasTracktypes = "";
+        $showTracktypesDropdown = true;
+    }
    ?>
    <?php
     if (isset($_COOKIE['tt_upload'])) {
@ -45,28 +35,36 @@

        <div id="track_type_selection">
            <form>
-              <select id="select_type" class="form-control">
-                  <?php
-                  foreach ($track_types as $key => $tt) {
-                    $selected = "";
-                    if ($ttsaved == $key) {
-                      $selected = "selected";
+              <?php
+              if ($showTracktypesDropdown != false) {  ?>
+                <select id="select_type" class="form-control" <?php echo $hasTracktypes; ?>>
+                    <?php
+                    foreach ($tracktypes as $key => $tt) {
+                        $selected = "";
+                        if ($ttsaved == $tt['code']) {
+                            $selected = "selected";
+                        }
+                        $code = $tt['code'];
+                        $typename = $tt['type_name'];
+                        echo "<option value='$code' $selected>$typename</option>";
                    }
-                    echo "<option value='$key' $selected>$tt</option>";
-                  }
-                  ?>
-              </select>
+                ?>
+                </select>
+              <?php } ?>
            </form>
        </div>

        <?php
-        foreach ($track_types as $key => $tt) {
-            if ($ttsaved == $key) {
-              $ttTitle = $tt;
+        if ($showTracktypesDropdown) {
+            foreach ($tracktypes as $key => $tt) {
+                if ($ttsaved == $key) {
+                  $ttTitle = $tt['type_name'];
+                }
            }
        }
        ?>
-        <H2><?php echo _("Upload")?> <span id="upload_type" style="color:#ff611f"><?php echo $ttTitle; ?></span></H2>
+        <H2><?php echo _("Upload")?> <span id="upload_type" <?php echo $showTracktypesDropdown ? 'style="color:#ff611f"' : "" ?>>
+          <?php echo $showTracktypesDropdown ? $ttTitle : "Tracks"; ?></span></H2>
        <form action="/rest/media" method="post" id="add-media-dropzone" class="dropzone dz-clickable">
            <?php echo $this->form->getElement('csrf') ?>
            <div class="dz-message">
--- a/airtime_mvc/application/views/scripts/tracktype/add-tracktype.phtml
+++ b/airtime_mvc/application/views/scripts/tracktype/add-tracktype.phtml
@ -0,0 +1,36 @@
+
+<div class="ui-widget prefpanel clearfix padded-strong tracktype-management">
+
+    <h2><?php echo _("Manage Track Types") ?></h2>
+    <div class="tracktype-list-wrapper">
+        <div id="tracktypes_wrapper" class="dataTables_wrapper">
+
+            <div class="button-holder">
+                <button type="button" id="add_tracktype_button" name="search_add_group" class="ui-button ui-widget  ui-button-text-icon-primary btn">
+                    <span class="ui-icon ui-icon-plusthick"></span>
+                    <span class="ui-button-text"><?php echo _("New Track Type")?></span>
+                </button>
+            </div>
+
+            <table cellspacing="0" cellpadding="0" style="" id="tracktypes_datatable" class="datatable">
+                <thead>
+                    <tr>
+                        <th><?php echo _("id") ?></th>
+                        <th><?php echo _("Code") ?></th>
+                        <th><?php echo _("Label")?></th>
+                        <th><?php echo _("Description")?></th>
+                        <th><?php echo _("Visibility")?></th>
+                        <th>&nbsp;</th>
+                    </tr>
+                </thead>
+                <tbody></tbody>
+            </table>
+        </div>
+    </div>
+    <div class="tracktype-data simple-formblock" id="tracktype_details">
+        <?php echo $this->successMessage ?>
+        <fieldset class="padded">
+            <?php echo $this->form ?>
+        </fieldset>
+    </div>
+</div>
--- a/airtime_mvc/application/views/scripts/tracktype/get-tracktype-data-table-info.phtml
+++ b/airtime_mvc/application/views/scripts/tracktype/get-tracktype-data-table-info.phtml
--- a/airtime_mvc/application/views/scripts/tracktype/get-tracktype-data.phtml
+++ b/airtime_mvc/application/views/scripts/tracktype/get-tracktype-data.phtml
@ -0,0 +1,3 @@
+<?php
+    echo $this->entries;
+?>
--- a/airtime_mvc/application/views/scripts/tracktype/index.phtml
+++ b/airtime_mvc/application/views/scripts/tracktype/index.phtml
--- a/airtime_mvc/application/views/scripts/tracktype/remove-tracktype.phtml
+++ b/airtime_mvc/application/views/scripts/tracktype/remove-tracktype.phtml
@ -0,0 +1,3 @@
+<?php
+echo $this->entries;
+?>
--- a/airtime_mvc/build/schema.xml
+++ b/airtime_mvc/build/schema.xml
@ -102,6 +102,19 @@
      <index-column name="name"/>
    </index>
  </table>
+  <table name="cc_track_types" phpName="CcTracktypes">
+    <column name="id" phpName="DbId" type="INTEGER" primaryKey="true" autoIncrement="true" required="true"/>
+    <column name="code" phpName="DbCode" type="VARCHAR" size="16" required="true" defaultValue=""/>
+    <column name="visibility" phpName="DbVisibility" type="BOOLEAN" required="true" defaultValue="true"/>
+    <column name="type_name" phpName="DbTypeName" type="VARCHAR" size="64" required="true" defaultValue=""/>
+	  <column name="description" phpName="DbDescription" type="VARCHAR" size="255" required="true" defaultValue=""/>
+    <unique name="cc_track_types_id_idx">
+      <unique-column name="id"/>
+    </unique>
+    <unique name="cc_track_types_code_idx">
+      <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"/>
--- a/airtime_mvc/build/sql/defaultdata.sql
+++ b/airtime_mvc/build/sql/defaultdata.sql
@ -392,4 +392,21 @@ INSERT INTO cc_pref("keystr", "valstr") VALUES('whats_new_dialog_viewed', 1);
 --added for LibreTime to turn on podcast album override by default 3.0.0.alpha6
 INSERT INTO cc_pref("keystr", "valstr") VALUES('podcast_album_override', 1);
 INSERT INTO cc_pref("keystr", "valstr") VALUES('podcast_auto_smartblock', 0);
+
+--added in 3.0.0.alpha9.2 to add default track types
+INSERT INTO cc_track_types (id, code, type_name, description, visibility) VALUES (1, 'MUS', 'Music', 'This is used for tracks containing music.', true);
+INSERT INTO cc_track_types (id, code, type_name, description, visibility) VALUES (2, 'SID', 'Station IDs', 'This is used for Station IDs.', true);
+INSERT INTO cc_track_types (id, code, type_name, description, visibility) VALUES (3, 'INT', 'Show Intros', 'This can be used for organizing all the show introductions.', true);
+INSERT INTO cc_track_types (id, code, type_name, description, visibility) VALUES (4, 'OUT', 'Show Outros', 'This can be used for organizing all the show outroductions.', true);
+INSERT INTO cc_track_types (id, code, type_name, description, visibility) VALUES (5, 'SWP', 'Sweepers', 'This is used for segues between songs.', true);
+INSERT INTO cc_track_types (id, code, type_name, description, visibility) VALUES (6, 'JIN', 'Jingles', 'A short song or tune, normally played during commercial breaks. Contains one or more hooks.', true);
+INSERT INTO cc_track_types (id, code, type_name, description, visibility) VALUES (7, 'PRO', 'Promos', 'For promotional use.', true);
+INSERT INTO cc_track_types (id, code, type_name, description, visibility) VALUES (8, 'SHO', 'Shout Outs', 'A message of congratulation, greeting. support, or appreciation.', true);
+INSERT INTO cc_track_types (id, code, type_name, description, visibility) VALUES (9, 'NWS', 'News', 'This is used for noteworthy information and announcements.', true);
+INSERT INTO cc_track_types (id, code, type_name, description, visibility) VALUES (10, 'COM', 'Commercials', 'This is used for commerical advertising.', true);
+INSERT INTO cc_track_types (id, code, type_name, description, visibility) VALUES (11, 'ITV', 'Radio Interviews', 'This is used for radio interviews', true);
+INSERT INTO cc_track_types (id, code, type_name, description, visibility) VALUES (12, 'VTR', 'Voice Trackings', 'Also referred as robojock or taped. Play announcements without actually being in the station.', true);
+
+--end added in 3.0.0.alpha9.2
+
 -- end
--- a/airtime_mvc/build/sql/schema.sql
+++ b/airtime_mvc/build/sql/schema.sql
@ -105,6 +105,24 @@ CREATE INDEX "cc_files_md5_idx" ON "cc_files" ("md5");

 CREATE INDEX "cc_files_name_idx" ON "cc_files" ("name");

+-----------------------------------------------------------------------
+-- cc_track_types
+-----------------------------------------------------------------------
+
+DROP TABLE IF EXISTS "cc_track_types" CASCADE;
+
+CREATE TABLE "cc_track_types"
+(
+    "id" serial NOT NULL,
+    "code" VARCHAR(16) DEFAULT '' NOT NULL,
+    "type_name" VARCHAR(64) DEFAULT '' NOT NULL,
+    "description" VARCHAR(255) DEFAULT '' NOT NULL,
+    "visibility" boolean DEFAULT true NOT NULL,
+    PRIMARY KEY ("id"),
+    CONSTRAINT "cc_track_types_id_idx" UNIQUE ("id"),
+    CONSTRAINT "cc_track_types_code_idx" UNIQUE ("code")
+);
+
 -----------------------------------------------------------------------
 -- cloud_file
 -----------------------------------------------------------------------
--- a/airtime_mvc/public/css/styles.css
+++ b/airtime_mvc/public/css/styles.css
@ -1725,11 +1725,13 @@ h2#scheduled_playlist_name span {
    padding: 4px 0 8px;
 }

-.user-form-label {
+.user-form-label,
+.tracktype-form-label {
    width: 30% !important;
 }

-.user-form-element {
+.user-form-element,
+.tracktype-form-element {
    width: 65% !important;
 }

@ -1818,27 +1820,32 @@ button, input {
    margin-bottom:0;
 }

-#user_details
+#user_details,
+#tracktype_details
 {
    visibility: hidden;
 }

-.user-management {
+.user-management,
+.tracktype-management {
    min-width: 910px;
    min-height: 410px;
 }

-.user-management-expanded {
+.user-management-expanded,
+.tracktype-management-expanded {
    width: 910px;
 }

-.user-data {
+.user-data,
+.tracktype-data {
    float:right;
    width:420px;
    margin-left:10px;
 }

-.user-list-wrapper {
+.user-list-wrapper,
+.tracktype-list-wrapper {
    float:left;
    width:480px;
    position: absolute;
@ -1846,59 +1853,72 @@ button, input {
    /*margin-right:10px;*/
 }

-#users_datatable {
+#users_datatable,
+#tracktypes_datatable {
    border: 0;
 }

-#users_datatable_wrapper td {
+#users_datatable_wrapper td,
+#tracktypes_datatable_wrapper td {
    vertical-align: middle;
 }

-.user-management div.user-list-wrapper .ui-widget-header:first-child {
+.user-management div.user-list-wrapper .ui-widget-header:first-child,
+.tracktype-management div.tracktype-list-wrapper .ui-widget-header:first-child {
    background: none repeat scroll 0 0 transparent;
    border-width: 0;
    color: #444444;
    font-weight: bold;
 }
-.user-list-wrapper .ui-widget-header:first-child .dataTables_filter {
+.user-list-wrapper .ui-widget-header:first-child .dataTables_filter,
+.tracktype-list-wrapper .ui-widget-header:first-child .dataTables_filter {
    margin:0;
 }
-.user-management h2 {
+.user-management h2,
+.tracktype-management h2 {
    font-size: 1.7em;
    padding-bottom: 12px;
 }
-.user-management .dataTables_filter input {
+.user-management .dataTables_filter input,
+.tracktype-management .dataTables_filter input {
    width: 100%;
    -webkit-box-sizing: border-box;
    -moz-box-sizing: border-box;
    box-sizing: border-box;
    margin-bottom:8px;
 }
-.user-data.simple-formblock dd {
+.user-data.simple-formblock dd,
+.tracktype-data.simple-formblock dd {
    width: 73%;
 }

-.user-data fieldset {
+.user-data fieldset,
+.tracktype-data fieldset {
    margin-bottom:8px;
 }
-.user-data fieldset:last-child {
+.user-data fieldset:last-child,
+.tracktype-data fieldset:last-child {
    margin-bottom:0;
 }

-.user-list-wrapper .button-holder {
+.user-list-wrapper .button-holder,
+.tracktype-list-wrapper .button-holder {
    padding:0;
    height:37px;
 }
-.user-list-wrapper .button-holder .ui-button {
+.user-list-wrapper .button-holder .ui-button,
+.tracktype-list-wrapper .button-holder .ui-button {
    margin:0;
 }
-.ui-widget-content .user-list-wrapper .ui-icon.ui-icon-closethick {
+.ui-widget-content .user-list-wrapper .ui-icon.ui-icon-closethick,
+.ui-widget-content .tracktype-list-wrapper .ui-icon.ui-icon-closethick {
    background-image:url(redmond/images/ui-icons_666666_256x240.png);
    cursor:pointer;
    float:right;
    margin-right:5px;
 }
-.ui-widget-content .user-list-wrapper .ui-icon.ui-icon-closethick:hover {
+.ui-widget-content .user-list-wrapper .ui-icon.ui-icon-closethick:hover,
+.ui-widget-content .tracktype-list-wrapper .ui-icon.ui-icon-closethick:hover {
    background-image:url(redmond/images/ui-icons_ff5d1a_256x240.png);
 }

@ -3929,12 +3949,14 @@ li .ui-state-hover {
    flex: 1;
 }

-#user_list_inner_wrapper {
+#user_list_inner_wrapper,
+#tracktype_list_inner_wrapper {
    height: 272px;
    overflow: auto;
 }

-#users_datatable_wrapper {
+#users_datatable_wrapper,
+#tracktypes_datatable_wrapper {
    display: -webkit-box;
    display: -moz-box;
    display: -ms-flexbox;
@ -3944,11 +3966,13 @@ li .ui-state-hover {
    flex-flow: column;
 }

-#users_datatable {
+#users_datatable,
+#tracktypes_datatable {
    overflow: auto;
 }

-#users_datatable tbody {
+#users_datatable tbody,
+#tracktypes_datatable tbody {

    vertical-align: top !important;
 }
--- a/airtime_mvc/public/css/tracktypes.css
+++ b/airtime_mvc/public/css/tracktypes.css
@ -0,0 +1,9 @@
+@charset "utf-8";
+
+.dataTables_filter input {
+	margin-left: 0;
+}
+
+.dataTables_processing {
+	top: 20px;
+}
--- a/airtime_mvc/public/js/airtime/tracktype/tracktype.js
+++ b/airtime_mvc/public/js/airtime/tracktype/tracktype.js
@ -0,0 +1,151 @@
+
+function populateForm(entries){
+
+    $('.errors').remove();
+    $('.success').remove();
+
+    $('#tracktype_id').val(entries.id);
+    $('#code').val(entries.code);
+    $('#type_name').val(entries.type_name);
+    $('#description').val(entries.description);
+
+    if (entries.visibility) {
+      var visibility_value = 1;
+    } else {
+      var visibility_value = 0;
+    }
+    $('#visibility').val(visibility_value);
+
+    if (entries.id.length != 0){
+        $('#code').attr('readonly', 'readonly');
+    } else {
+        $('#code').removeAttr('readonly');
+    }
+}
+
+function rowClickCallback(row_id){
+      $.ajax({ url: baseUrl+'Tracktype/get-tracktype-data/id/'+ row_id +'/format/json', dataType:"json", success:function(data){
+        populateForm(data.entries);
+          $("#tracktype_details").css("visibility", "visible");
+	  }});
+}
+
+function removeTracktypeCallback(row_id, nRow) {
+    if (confirm($.i18n._("Are you sure you want to delete this tracktype?"))) {
+        $.ajax({
+            url: baseUrl + 'Tracktype/remove-tracktype/id/' + row_id + '/format/json',
+            dataType: "text",
+            success: function (data) {
+                var o = $('#tracktypes_datatable').dataTable().fnDeleteRow(nRow);
+            }
+        });
+    }
+}
+
+function rowCallback( nRow, aData, iDisplayIndex ){
+    $(nRow).click(function(){rowClickCallback(aData['id'])});
+    if( aData['delete'] != "self"){
+    	$('td:eq(4)', nRow).append( '<span class="ui-icon ui-icon-closethick"></span>').children('span').click(function(e){e.stopPropagation(); removeTracktypeCallback(aData['id'], nRow)});
+    }else{
+    	$('td:eq(4)', nRow).empty().append( '<span class="ui-icon ui-icon-closethick"></span>').children('span').click(function(e){e.stopPropagation(); alert("Can't delete yourself!")});
+    }
+
+    if ( aData['visibility'] == "1" ) {
+	    $('td:eq(3)', nRow).html( $.i18n._('Enabled') );
+    } else {
+	    $('td:eq(3)', nRow).html( $.i18n._('Disabled') );
+    }
+
+    return nRow;
+}
+
+function populateTracktypeTable() {
+    var dt = $('#tracktypes_datatable');
+    dt.dataTable( {
+        "bProcessing": true,
+        "bServerSide": true,
+        "sAjaxSource": baseUrl+"Tracktype/get-tracktype-data-table-info/format/json",
+        "fnServerData": function ( sSource, aoData, fnCallback ) {
+            $.ajax( {
+                "dataType": 'json',
+                "type": "POST",
+                "url": sSource,
+                "data": aoData,
+                "success": fnCallback
+            } );
+        },
+        "fnRowCallback": rowCallback,
+        "aoColumns": [
+            /* Id */         { "sName": "id", "bSearchable": false, "bVisible": false, "mDataProp": "id" },
+            /* code */  { "sName": "code", "mDataProp": "code" },
+            /* type_name */ { "sName": "type_name", "mDataProp": "type_name" },
+            /* description */  { "sName": "description", "mDataProp": "description" },
+            /* visibility */  { "sName": "visibility", "bSearchable": false, "mDataProp": "visibility" },
+            /* del button */ { "sName": "null as delete", "bSearchable": false, "bSortable": false, "mDataProp": "delete"}
+        ],
+        "bJQueryUI": true,
+        "bAutoWidth": false,
+        "bLengthChange": false,
+        "oLanguage": getDatatablesStrings({
+            "sEmptyTable": $.i18n._("No track types were found."),
+            "sEmptyTable":     $.i18n._("No track types found"),
+            "sZeroRecords":    $.i18n._("No matching track types found"),
+            "sInfo":           $.i18n._("Showing _START_ to _END_ of _TOTAL_ track types"),
+            "sInfoEmpty":      $.i18n._("Showing 0 to 0 of 0 track types"),
+            "sInfoFiltered":   $.i18n._("(filtered from _MAX_ total track types)"),
+        }),
+        "sDom": '<"H"lf<"dt-process-rel"r>><"#tracktype_list_inner_wrapper"t><"F"ip>'
+    });
+}
+
+function sizeFormElements() {
+    $("dt[id$='label']").addClass('tracktype-form-label');
+    $("dd[id$='element']").addClass('tracktype-form-element');
+}
+
+function initTracktypeData() {
+    var visibility = $('#visibility');
+
+    var table = $("#tracktypes_datable");//.DataTable();
+    $('.datatable tbody').on( 'click', 'tr', function () {
+        $(this).parent().find('tr.selected').removeClass('selected');
+        $(this).addClass('selected');
+    } );
+
+    $('#button').click( function () {
+        table.row('.selected').remove().draw( false );
+    } );
+
+    var newTracktype = {code:"", type_name:"", description:"", visibility:"1", id:""};
+
+    $('#add_tracktype_button').live('click', function(){
+        populateForm(newTracktype);
+        $("#tracktype_details").css("visibility", "visible");
+    });
+}
+
+$(document).ready(function() {
+
+    populateTracktypeTable();
+    initTracktypeData();
+
+    $('#save_tracktype').live('click', function(){
+        var data = $('#tracktype_form').serialize();
+        var url = baseUrl+'Tracktype/add-tracktype';
+
+        $.post(url, {format: "json", data: data}, function(json){
+            if (json.valid === "true") {
+                $('#content').empty().append(json.html);
+                populateTracktypeTable();
+                init(); // Reinitialize
+            } else {
+                //if form is invalid we only need to redraw the form
+                $('#tracktype_form').empty().append($(json.html).find('#tracktype_form').children());
+            }
+            setTimeout(removeSuccessMsg, 5000);
+            sizeFormElements();
+        });
+    });
+
+    sizeFormElements();
+});