847 lines
35 KiB
JavaScript
847 lines
35 KiB
JavaScript
var AIRTIME = (function (AIRTIME) {
|
|
var mod;
|
|
|
|
if (AIRTIME.podcast === undefined) {
|
|
AIRTIME.podcast = {};
|
|
}
|
|
|
|
mod = AIRTIME.podcast;
|
|
|
|
var endpoint = '/rest/podcast/', PodcastEpisodeTable;
|
|
|
|
/**
|
|
* PodcastController constructor.
|
|
*
|
|
* @param {angular.scope} $scope angular scope service object
|
|
* @param {angular.http} $http angular http service object
|
|
* @param {Object} podcast podcast metadata object
|
|
* @param {int} podcast.id podcast unique identifier
|
|
* @param {string} podcast.title podcast metadata title
|
|
* @param {Tab} tab Tab object the controller is being bootstrapped in
|
|
*
|
|
* @constructor
|
|
*/
|
|
function PodcastController($scope, $http, podcast, tab) {
|
|
// We need to pass in the tab object and the episodes table object so we can reference them
|
|
var self = this,
|
|
view = tab ? tab.contents : $(document);
|
|
|
|
//We take a podcast object in as a parameter rather fetching the podcast by ID here because
|
|
//when you're creating a new podcast, we already have the object from the result of the POST. We're saving
|
|
//a roundtrip by not fetching it again here.
|
|
$scope.podcast = podcast;
|
|
$scope.tab = tab;
|
|
$scope.csrf = jQuery("#csrf").val();
|
|
view.find("table").attr("id", "podcast_episodes_" + podcast.id);
|
|
|
|
self.onSaveCallback = function () {
|
|
var successMsg = $('.active-tab .btn-toolbar .success')
|
|
successMsg.text($.i18n._("Podcast settings saved")).show("fast");
|
|
setTimeout(function () {
|
|
successMsg.hide("fast");
|
|
}, 5000);
|
|
AIRTIME.library.podcastDataTable.fnDraw();
|
|
};
|
|
|
|
/**
|
|
* Save and update the podcast object.
|
|
*/
|
|
$scope.savePodcast = function () {
|
|
$http.put(endpoint + $scope.podcast.id, {csrf_token: $scope.csrf, podcast: $scope.podcast})
|
|
.success(function () {
|
|
self.onSaveCallback();
|
|
});
|
|
};
|
|
|
|
|
|
/**
|
|
* Generate a smartblock and playlist for this smartblock.
|
|
*/
|
|
$scope.createSmartblock = function () {
|
|
// send smarblock creation instruction to API
|
|
$.post(
|
|
endpoint + "smartblock",
|
|
{
|
|
csrf_token: $("#csrf").val(),
|
|
id: $scope.podcast.id,
|
|
title: $scope.podcast.title
|
|
},
|
|
function() {
|
|
// show success message
|
|
var successMsg = $('.active-tab .pc-sb-success')
|
|
successMsg.text($.i18n._('Smartblock and playlist generated'));
|
|
successMsg.show("fast");
|
|
setTimeout(function(){
|
|
successMsg.hide("fast");
|
|
}, 5000);
|
|
|
|
// save podcast but do not display notification beside save button below
|
|
$http.put(endpoint + $scope.podcast.id,
|
|
{
|
|
csrf_token: $scope.csrf,
|
|
podcast: $scope.podcast
|
|
})
|
|
.success(function () {
|
|
AIRTIME.library.podcastDataTable.fnDraw();
|
|
});
|
|
|
|
// redraw list of smartblocks just in case they have it visible on the left
|
|
dt = $('table[id="library_display"]').dataTable();
|
|
dt.fnStandingRedraw();
|
|
}
|
|
);
|
|
};
|
|
/**
|
|
* Close the tab and discard any changes made to the podcast data.
|
|
*/
|
|
$scope.discard = function () {
|
|
!tab || tab.close();
|
|
$scope.podcast = {};
|
|
};
|
|
|
|
self.$scope = $scope;
|
|
self.$http = $http;
|
|
self.initialize();
|
|
|
|
return self;
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Initialize the controller.
|
|
*
|
|
* Sets up the internal datatable.
|
|
*/
|
|
PodcastController.prototype.initialize = function() {
|
|
var self = this;
|
|
// TODO: this solves a race condition, but we should look for the root cause
|
|
AIRTIME.tabs.onResize();
|
|
self.$scope.tab.setName(self.$scope.podcast.title);
|
|
// Add an onclose hook to the tab to remove the table object and the
|
|
// import listener so we don't cause memory leaks.
|
|
if (self.episodeTable) {
|
|
self.$scope.tab.assignOnCloseHandler(function () {
|
|
self.episodeTable.destroy();
|
|
self.episodeTable = null;
|
|
self.$scope.$destroy();
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* StationPodcastController constructor.
|
|
*
|
|
* @param {angular.scope} $scope angular scope service object
|
|
* @param {angular.http} $http angular http service object
|
|
* @param {Object} podcast podcast metadata object
|
|
* @param {int} podcast.id podcast unique identifier
|
|
* @param {string} podcast.title podcast metadata title
|
|
* @param {Tab} tab Tab object the controller is being bootstrapped in
|
|
*
|
|
* @constructor
|
|
*/
|
|
function StationPodcastController($scope, $http, podcast, tab) {
|
|
// Super call to parent controller
|
|
PodcastController.call(this, $scope, $http, podcast, tab);
|
|
this.onSaveCallback = function () {
|
|
$http({
|
|
method: 'POST',
|
|
url: '/preference/station-podcast-settings',
|
|
headers: {'Content-Type': 'application/x-www-form-urlencoded'},
|
|
data: { stationPodcastPrivacy: $("#podcast-settings").find("input:checked").val() }
|
|
}).success(function (data) {
|
|
jQuery.extend($scope.podcast, data);
|
|
$(".success").text($.i18n._("Podcast settings saved")).slideDown("fast");
|
|
setTimeout(function () {
|
|
$(".success").slideUp("fast");
|
|
}, 2000);
|
|
});
|
|
};
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Subclass the PodcastController object.
|
|
*
|
|
* @type {PodcastController}
|
|
*/
|
|
StationPodcastController.prototype = Object.create(PodcastController.prototype);
|
|
|
|
/**
|
|
* Remove the selected episodes from the station podcast feed.
|
|
*/
|
|
StationPodcastController.prototype.unpublishSelectedEpisodes = function () {
|
|
var self = this, $scope = self.$scope,
|
|
episodes = self.episodeTable.getSelectedRows();
|
|
jQuery.each(episodes, function () {
|
|
self.$http.delete(endpoint + $scope.podcast.id + '/episodes/' + this.id + '?csrf_token=' + $scope.csrf)
|
|
.success(function () {
|
|
self.reloadEpisodeTable();
|
|
});
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Initialize the Station podcast episode table.
|
|
*
|
|
* @private
|
|
*/
|
|
StationPodcastController.prototype._initTable = function() {
|
|
var self = this, $scope = this.$scope,
|
|
buttons = {
|
|
deleteBtn: {
|
|
title : $.i18n._('Unpublish'),
|
|
iconClass : 'icon-trash',
|
|
extraBtnClass : 'btn-danger',
|
|
elementId : '',
|
|
eventHandlers : {
|
|
click: self.unpublishSelectedEpisodes.bind(self)
|
|
},
|
|
validateConstraints: function () {
|
|
return this.getSelectedRows().length >= 1;
|
|
}
|
|
}
|
|
},
|
|
params = {
|
|
sAjaxSource : endpoint + $scope.podcast.id + '/episodes',
|
|
aoColumns: [
|
|
// TODO: it might be wrong to use CcFiles here? We should alias this instead
|
|
/* Title */ { "sTitle" : $.i18n._("Title") , "mDataProp" : "CcFiles.track_title" , "sClass" : "podcast_episodes_title" , "sWidth" : "170px" },
|
|
/* Description */ { "sTitle" : $.i18n._("Description") , "mDataProp" : "CcFiles.description" , "sClass" : "podcast_episodes_description" , "sWidth" : "300px" }
|
|
]
|
|
};
|
|
|
|
this.episodeTable = AIRTIME.podcast.initPodcastEpisodeDatatable(
|
|
$('.podcast_episodes'),
|
|
params,
|
|
buttons,
|
|
{
|
|
hideIngestCheckboxes: true,
|
|
podcastId: $scope.podcast.id,
|
|
emptyPlaceholder: {
|
|
iconClass: "icon-white icon-th-list",
|
|
html: $.i18n._("You haven't published any episodes!")
|
|
+ "<br/>" + $.i18n._("You can publish your uploaded content from the 'Tracks' view.")
|
|
+ "<br/><a target='_parent' href='/showbuilder#tracks'>" + $.i18n._("Try it now") + "</a>"
|
|
}
|
|
}
|
|
);
|
|
|
|
mod.stationPodcastTable = this.episodeTable.getDatatable();
|
|
};
|
|
|
|
/**
|
|
* Initialize the Station podcast.
|
|
*/
|
|
StationPodcastController.prototype.initialize = function() {
|
|
// We want to override the default tab name behaviour and use "My Podcast" for clarity
|
|
this._initTable();
|
|
};
|
|
|
|
/**
|
|
* @override
|
|
*
|
|
* Reload the Station podcast episode table.
|
|
*/
|
|
StationPodcastController.prototype.reloadEpisodeTable = function() {
|
|
this.episodeTable.getDatatable().fnDraw();
|
|
};
|
|
|
|
/**
|
|
* AngularJS app for podcast functionality.
|
|
*
|
|
* Bootstrapped for each podcast or Station podcast tab.
|
|
*/
|
|
mod.podcastApp = angular.module('podcast', [])
|
|
.controller('Podcast', ['$scope', '$http', 'podcast', 'tab', PodcastController])
|
|
.controller('StationPodcast', ['$scope', '$http', 'podcast', 'tab', StationPodcastController]);
|
|
|
|
/**
|
|
* Implement bulk editing of podcasts in order to accommodate the existing selection
|
|
* mechanisms on the frontend.
|
|
*
|
|
* Bulk methods use a POST request because we need to send data in the request body.
|
|
*
|
|
* @param selectedData the data to operate on
|
|
* @param method HTTP request method type
|
|
* @param callback function to run upon success
|
|
* @private
|
|
*/
|
|
function _bulkAction(selectedData, method, callback) {
|
|
var ids = [];
|
|
selectedData.forEach(function(el) {
|
|
var uid = AIRTIME.library.MediaTypeStringEnum.PODCAST+"_"+el.id,
|
|
t = AIRTIME.tabs.get(uid);
|
|
if (t && method == HTTPMethods.DELETE) {
|
|
t.close();
|
|
}
|
|
if (!(t && method == HTTPMethods.GET)) {
|
|
ids.push(el.id);
|
|
} else if (t != AIRTIME.tabs.getActiveTab()) {
|
|
t.switchTo();
|
|
}
|
|
});
|
|
|
|
if (ids.length > 0) {
|
|
$.post(endpoint + "bulk", {csrf_token: $("#csrf").val(), method: method, ids: ids}, callback);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Bootstrap and initialize the Angular app for the podcast being opened.
|
|
*
|
|
* @param podcast podcast JSON object to pass to the angular app
|
|
* @param tab Tab object the angular app will be initialized in
|
|
* @private
|
|
*/
|
|
function _bootstrapAngularApp(podcast, tab) {
|
|
mod.podcastApp.value('podcast', podcast);
|
|
mod.podcastApp.value('tab', tab);
|
|
var wrapper = tab.contents.find(".angular_wrapper");
|
|
angular.bootstrap(wrapper.get(0), ["podcast"]);
|
|
}
|
|
|
|
/**
|
|
* Initialization function for a podcast tab.
|
|
* Called when editing one or more podcasts.
|
|
*
|
|
* @param data JSON data returned from the server.
|
|
* Contains a JSON encoded podcast object and tab
|
|
* content HTML and has the following form:
|
|
* {
|
|
* podcast: '{
|
|
* ...
|
|
* }'
|
|
* html: '<...>'
|
|
* }
|
|
* @private
|
|
*/
|
|
function _initAppFromResponse(data) {
|
|
var podcast = JSON.parse(data.podcast),
|
|
uid = AIRTIME.library.MediaTypeStringEnum.PODCAST+"_"+podcast.id,
|
|
tab = AIRTIME.tabs.openTab(data.html, uid, null);
|
|
_bootstrapAngularApp(podcast, tab);
|
|
|
|
$(".album_names.help_icon").qtip({
|
|
content: {
|
|
text: $.i18n._('Overwrite downloaded podcast episodes\' "Album" metadata tag with the Podcast Name specified above. This album name can then be used as a search criteria by a smartblock.')
|
|
},
|
|
hide: {
|
|
delay: 500,
|
|
fixed: true
|
|
},
|
|
style: {
|
|
border: {
|
|
width: 0,
|
|
radius: 4
|
|
},
|
|
classes: "ui-tooltip-dark ui-tooltip-rounded"
|
|
},
|
|
position: {
|
|
my: "left bottom",
|
|
at: "right center"
|
|
}
|
|
});
|
|
|
|
// Add podcast episode table in right-side panel below podcast edit form
|
|
var episodeTable = AIRTIME.podcast.initPodcastEpisodeDatatableWithButtonEvents(
|
|
$("#podcast_episodes_" + podcast.id),
|
|
);
|
|
episodeTable.reload(podcast.id);
|
|
episodeTable.clearSelection()
|
|
}
|
|
|
|
/**
|
|
* Initialize the PodcastTable subclass object (from Table).
|
|
*
|
|
* Do this in its own function to avoid unnecessary reinitialization of the object.
|
|
*
|
|
* @private
|
|
*/
|
|
function _initPodcastEpisodeTable() {
|
|
PodcastEpisodeTable = function(wrapperDOMNode, bItemSelection, toolbarButtons, dataTablesOptions, config) {
|
|
this.config = config; // Internal configuration object
|
|
this._setupImportListener();
|
|
// Call the superconstructor
|
|
return AIRTIME.widgets.Table.call(this, wrapperDOMNode, bItemSelection, toolbarButtons, dataTablesOptions, config.emptyPlaceholder);
|
|
}; // Subclass AIRTIME.widgets.Table
|
|
PodcastEpisodeTable.prototype = Object.create(AIRTIME.widgets.Table.prototype);
|
|
PodcastEpisodeTable.prototype.constructor = PodcastEpisodeTable;
|
|
PodcastEpisodeTable.prototype._SELECTORS = Object.freeze({
|
|
SELECTION_CHECKBOX: ".airtime_table_checkbox:has(input)",
|
|
SELECTION_TABLE_ROW: "tr:has(td.airtime_table_checkbox > input)"
|
|
});
|
|
|
|
/**
|
|
* @override
|
|
*
|
|
* Override the checkbox delegate function in the Table object to change
|
|
* the row's checkbox and import status columns depending on the status
|
|
* of the episode (unimported: 0, imported: 1, pending import: -1).
|
|
*
|
|
* @param rowData
|
|
* @param callType
|
|
* @param dataToSave
|
|
*
|
|
* @returns {string}
|
|
* @private
|
|
*/
|
|
PodcastEpisodeTable.prototype._datatablesCheckboxDataDelegate = function(rowData, callType, dataToSave) {
|
|
var defaultIcon = "<span class='icon icon-circle-arrow-down'></span>",
|
|
importIcon = "<span class='sp-checked-icon checked-icon imported-flag'></span>",
|
|
pendingIcon = "<span class='loading-icon'></span>";
|
|
if (this.config.hideIngestCheckboxes && rowData.ingested && rowData.ingested != 0) {
|
|
return rowData.ingested > 0 ? importIcon : pendingIcon;
|
|
}
|
|
rowData.importIcon = (rowData.ingested != 0) ? (rowData.ingested > 0 ? importIcon : pendingIcon) : defaultIcon;
|
|
return AIRTIME.widgets.Table.prototype._datatablesCheckboxDataDelegate.call(this, rowData, callType, dataToSave);
|
|
};
|
|
|
|
/**
|
|
* Reload the episode table.
|
|
* Since we're sometimes using a static source, define a separate function to fetch and reload the table data.
|
|
* We use this when we save the Podcast because we need to flag rows the user is ingesting.
|
|
*
|
|
* @param [id] optional podcast identifier
|
|
*/
|
|
PodcastEpisodeTable.prototype.reload = function (id) {
|
|
// When using static source data, we instantiate an empty table
|
|
// and pass this function the ID of the podcast we want to display.
|
|
if (id) this.config.podcastId = id;
|
|
var self = this, dt = self._datatable;
|
|
dt.block({
|
|
message: "",
|
|
theme: true,
|
|
applyPlatformOpacityRules: false
|
|
});
|
|
$.get(endpoint + self.config.podcastId + '/episodes', function (json) {
|
|
dt.fnClearTable(false);
|
|
dt.fnAddData(JSON.parse(json));
|
|
}).done(function () {
|
|
dt.unblock();
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Setup an interval that checks for any pending imports and reloads
|
|
* the table once imports are finished.
|
|
*
|
|
* TODO: remember selection; make this more elegant?
|
|
*
|
|
* @private
|
|
*/
|
|
PodcastEpisodeTable.prototype._setupImportListener = function () {
|
|
var self = this;
|
|
self.importListener = setInterval(function () {
|
|
var podcastId = self.config.podcastId, pendingRows = [];
|
|
if (!podcastId) return false;
|
|
var dt = self.getDatatable(), data = dt.fnGetData();
|
|
// Iterate over the table data to check for any rows pending import
|
|
$.each(data, function () {
|
|
if (this.ingested == -1) {
|
|
pendingRows.push(this.guid);
|
|
}
|
|
});
|
|
if (pendingRows.length > 0) {
|
|
// Manually trigger the Celery task to update the internal
|
|
// task reference because the upload will often finish quickly
|
|
$.get('/api/poll-celery');
|
|
// Fetch the table data if there are pending rows,
|
|
// then check if any of the pending rows have
|
|
// succeeded or failed before reloading the table.
|
|
$.get(endpoint + podcastId + '/episodes', function (json) {
|
|
data = JSON.parse(json);
|
|
var delta = false;
|
|
$.each(data, function () {
|
|
var idx = pendingRows.indexOf(this.guid);
|
|
if (idx > -1 && this.ingested != -1) {
|
|
delta = true;
|
|
pendingRows.slice(idx, 0);
|
|
}
|
|
});
|
|
if (delta) { // Has there been a change?
|
|
// We already have the data, so there's no reason to call
|
|
// reload() here; this also provides a smoother transition
|
|
dt.fnClearTable(false);
|
|
dt.fnAddData(data);
|
|
}
|
|
});
|
|
}
|
|
}, 5000); // Run every 5 seconds
|
|
};
|
|
|
|
/**
|
|
* Explicit destructor
|
|
*/
|
|
PodcastEpisodeTable.prototype.destroy = function () {
|
|
clearInterval(this.importListener);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create and show the URL dialog for podcast creation.
|
|
*/
|
|
mod.createUrlDialog = function () {
|
|
$.get('/render/podcast-url-dialog', function(json) {
|
|
$(document.body).append(json.html);
|
|
$("#podcast_url_dialog").dialog({
|
|
title: $.i18n._("Add New Podcast"),
|
|
resizable: false,
|
|
modal: true,
|
|
width: '450px',
|
|
height: 129,
|
|
close: function () {
|
|
$(this).remove();
|
|
}
|
|
});
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Find the URL in the podcast creation dialog and POST it to the server
|
|
* to store the feed as a Podcast object.
|
|
*
|
|
* FIXME: we should probably be passing the serialized form into this function instead
|
|
*/
|
|
mod.addPodcast = function () {
|
|
$.post(endpoint, $("#podcast_url_dialog").find("form").serialize(), function(json) {
|
|
// Refresh left-side library pane to show newly created podcast
|
|
AIRTIME.library.podcastDataTable.fnDraw();
|
|
|
|
// close modal
|
|
$("#podcast_url_dialog").dialog("close");
|
|
|
|
// open newly created podcast in right-side edit pane
|
|
_initAppFromResponse(json);
|
|
}).fail(function (e) {
|
|
var errors = $("#podcast_url_dialog").find(".errors");
|
|
errors.show(200).text(e.responseText);
|
|
setTimeout(function () {
|
|
errors.hide(200);
|
|
}, 3000);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Create a bulk request to edit all currently selected podcasts.
|
|
*/
|
|
mod.editSelectedPodcasts = function () {
|
|
_bulkAction(AIRTIME.library.podcastTableWidget.getSelectedRows(), HTTPMethods.GET, function(json) {
|
|
json.forEach(function(data) {
|
|
_initAppFromResponse(data);
|
|
});
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Create a bulk request to delete all currently selected podcasts.
|
|
*/
|
|
mod.deleteSelectedPodcasts = function () {
|
|
if (confirm($.i18n._("Are you sure you want to delete the selected podcasts from your library?"))) {
|
|
_bulkAction(AIRTIME.library.podcastTableWidget.getSelectedRows(), HTTPMethods.DELETE, function () {
|
|
AIRTIME.library.podcastDataTable.fnDraw();
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Open metadata editor tabs for each of the selected episodes.
|
|
*
|
|
* @param {Array} episodes the array of selected episodes
|
|
*/
|
|
mod.editSelectedEpisodes = function (episodes) {
|
|
$.each(episodes, function () {
|
|
if (this.file && !Object.keys(this.file).length > 0) return false;
|
|
var fileId = this.file_id || this.file.id, uid = AIRTIME.library.MediaTypeStringEnum.FILE + "_" + fileId;
|
|
$.get(baseUrl + "library/edit-file-md/id/" + fileId, {format: "json"}, function (json) {
|
|
AIRTIME.playlist.fileMdEdit(json, uid);
|
|
});
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Import one or more podcast episodes.
|
|
*
|
|
* @param {Array} episodes array of episode data to be imported
|
|
* @param {PodcastEpisodeTable} dt PodcastEpisode table containing the data
|
|
*/
|
|
mod.importSelectedEpisodes = function (episodes, dt) {
|
|
$.each(episodes, function () {
|
|
// remainingDiskSpace is defined in layout.phtml
|
|
if (this.enclosure.length > remainingDiskSpace) {
|
|
alert("You don't have enough disk space to import " + this.title);
|
|
return false;
|
|
}
|
|
if (this.file && Object.keys(this.file).length > 0) return false;
|
|
$.post(endpoint + this.podcast_id + '/episodes', JSON.stringify({
|
|
csrf_token: $("#csrf").val(),
|
|
episode: this
|
|
}), function () {
|
|
dt.reload(this.podcast_id);
|
|
});
|
|
|
|
remainingDiskSpace -= this.enclosure.length;
|
|
});
|
|
|
|
dt.clearSelection();
|
|
};
|
|
|
|
/**
|
|
* Delete one or more podcast episodes.
|
|
*
|
|
* @param {id:string, type:string}[] data Array of data objects to be deleted
|
|
* @param {PodcastEpisodeTable} dt PodcastEpisode table containing the data
|
|
*/
|
|
mod.deleteSelectedEpisodes = function (data, dt) {
|
|
$.each(data, function () {
|
|
AIRTIME.library.fnDeleteItems(data);
|
|
});
|
|
dt.reload(this.podcast_id);
|
|
dt.clearSelection();
|
|
};
|
|
|
|
/**
|
|
* Initialize the podcast episode table with working buttons
|
|
*/
|
|
mod.initPodcastEpisodeDatatableWithButtonEvents = function (domNode) {
|
|
|
|
/**
|
|
* Check the import statuses of each selected episode to see which
|
|
* buttons should be enabled or disabled.
|
|
*
|
|
* @param shouldBeImported whether or not the selected item(s)
|
|
* should be imported to obtain a valid result.
|
|
*
|
|
* @returns {boolean} true if all selected episodes are valid and
|
|
* the button should be enabled, otherwise false.
|
|
*/
|
|
var checkSelectedEpisodeImportStatus = function (shouldBeImported) {
|
|
var selected = this.getSelectedRows(), isValid = true;
|
|
if (selected.length == 0) return false;
|
|
$.each(selected, function () {
|
|
if (this.ingested < 0) isValid = false;
|
|
var isImported = !$.isEmptyObject(this.file);
|
|
if (shouldBeImported ? !isImported : isImported) {
|
|
isValid = false;
|
|
}
|
|
});
|
|
return isValid;
|
|
};
|
|
|
|
// Setup the default buttons (new, edit, delete)
|
|
podcastEpisodeButtons = AIRTIME.widgets.Table.getStandardToolbarButtons();
|
|
$.extend(true, podcastEpisodeButtons[AIRTIME.widgets.Table.TOOLBAR_BUTTON_ROLES.NEW],
|
|
{
|
|
title: "Import",
|
|
eventHandlers: {
|
|
click: function () {
|
|
var episodes = mod.podcastEpisodeTableWidget.getSelectedRows();
|
|
AIRTIME.podcast.importSelectedEpisodes(episodes, mod.podcastEpisodeTableWidget);
|
|
}
|
|
},
|
|
validateConstraints: function () {
|
|
return checkSelectedEpisodeImportStatus.call(this, false);
|
|
}
|
|
});
|
|
$.extend(true, podcastEpisodeButtons[AIRTIME.widgets.Table.TOOLBAR_BUTTON_ROLES.EDIT],
|
|
{
|
|
eventHandlers: {
|
|
click: function () {
|
|
var episodes = mod.podcastEpisodeTableWidget.getSelectedRows();
|
|
AIRTIME.podcast.editSelectedEpisodes(episodes);
|
|
}
|
|
},
|
|
validateConstraints: function () {
|
|
return checkSelectedEpisodeImportStatus.call(this, true);
|
|
}
|
|
});
|
|
$.extend(true, podcastEpisodeButtons[AIRTIME.widgets.Table.TOOLBAR_BUTTON_ROLES.DELETE],
|
|
{
|
|
eventHandlers: {
|
|
click: function () {
|
|
var data = [], episodes = mod.podcastEpisodeTableWidget.getSelectedRows();
|
|
$.each(episodes, function () {
|
|
data.push({id: this.file.id, type: this.file.ftype});
|
|
});
|
|
console.log("podcast deletion:", data, mod.podcastEpisodeTableWidget);
|
|
AIRTIME.podcast.deleteSelectedEpisodes(data, mod.podcastEpisodeTableWidget);
|
|
}
|
|
},
|
|
validateConstraints: function () {
|
|
return checkSelectedEpisodeImportStatus.call(this, true);
|
|
}
|
|
});
|
|
|
|
// Reassign these because integer keys take precedence in iteration order - we want to order based on insertion
|
|
// FIXME: this is a pretty flimsy way to try to set up iteration order (possibly not xbrowser compatible?)
|
|
podcastEpisodeButtons = {
|
|
newBtn : podcastEpisodeButtons[AIRTIME.widgets.Table.TOOLBAR_BUTTON_ROLES.NEW],
|
|
editBtn: podcastEpisodeButtons[AIRTIME.widgets.Table.TOOLBAR_BUTTON_ROLES.EDIT],
|
|
delBtn : podcastEpisodeButtons[AIRTIME.widgets.Table.TOOLBAR_BUTTON_ROLES.DELETE]
|
|
};
|
|
|
|
$.extend(true, podcastEpisodeButtons, {
|
|
// addToScheduleBtn: {
|
|
// title : $.i18n._('Add to Schedule'),
|
|
// iconClass : '',
|
|
// extraBtnClass : 'btn-small',
|
|
// elementId : '',
|
|
// eventHandlers : {
|
|
// click: function () {
|
|
// var data = [], selected = mod.podcastEpisodeTableWidget.getSelectedRows();
|
|
// $.each(selected, function () { data.push(this.file); });
|
|
// mod.addToSchedule(data);
|
|
// }
|
|
// },
|
|
// validateConstraints: function () {
|
|
// // TODO: change text + behaviour for playlists, smart blocks, etc.
|
|
// return checkSelectedEpisodeImportStatus.call(this, true);
|
|
// }
|
|
// },
|
|
viewDescBtn: {
|
|
title : $.i18n._("View"),
|
|
iconClass : "icon-globe",
|
|
extraBtnClass : "btn-small",
|
|
elementId : "",
|
|
eventHandlers : {
|
|
click: mod.openPodcastEpisodeDialog
|
|
},
|
|
validateConstraints: function () {
|
|
return this.getSelectedRows().length == 1;
|
|
}
|
|
}
|
|
});
|
|
|
|
mod.podcastEpisodeTableWidget = AIRTIME.podcast.initPodcastEpisodeDatatable(
|
|
domNode,
|
|
podcastEpisodeButtons,
|
|
{
|
|
hideIngestCheckboxes: false,
|
|
emptyPlaceholder: {
|
|
iconClass: "icon-white icon-th-list",
|
|
html: $.i18n._("This podcast doesn't have any episodes!")
|
|
+ "<br/>" + $.i18n._("Make sure the RSS feed contains audio items (with enclosure tags).")
|
|
+ "<br/><a target='_blank' href='http://www.apple.com/ca/itunes/podcasts/specs.html'>" + $.i18n._("Learn about podcasts") + "</a>"
|
|
}
|
|
}
|
|
);
|
|
|
|
mod.podcastEpisodeDataTable = mod.podcastEpisodeTableWidget.getDatatable();
|
|
mod.podcastEpisodeTableWidget.assignDblClickHandler(function () {
|
|
var data = mod.podcastEpisodeDataTable.fnGetData(this);
|
|
if (!$.isEmptyObject(data.file)) {
|
|
mod.dblClickAdd(data.file, data.file.ftype);
|
|
} else {
|
|
if (data.ingested >= 0) { // Only import if the file isn't pending
|
|
AIRTIME.podcast.importSelectedEpisodes([data], mod.podcastEpisodeTableWidget);
|
|
}
|
|
}
|
|
});
|
|
|
|
return mod.podcastEpisodeTableWidget;
|
|
};
|
|
|
|
/**
|
|
* Initialize the internal datatable for the podcast editor view to hold episode data passed back from the server.
|
|
*
|
|
* Selection for the internal table represents episodes marked for ingest and is disabled for ingested episodes.
|
|
*
|
|
* @param {jQuery} domNode the jQuery DOM node to create the table inside.
|
|
* @param {Object} buttons JSON object containing datatables button parameters
|
|
* @param {Object} config JSON object containing internal PodcastEpisodeTable parameters
|
|
* @param {boolean} config.hideIngestCheckboxes flag denoting whether or not to hide checkboxes for ingested items
|
|
*
|
|
* @returns {Table} the created Table object
|
|
*/
|
|
mod.initPodcastEpisodeDatatable = function (domNode, buttons, config) {
|
|
|
|
params = {
|
|
aoColumns : [
|
|
/* GUID */ { "sTitle" : "" , "mDataProp" : "guid" , "sClass" : "podcast_episodes_guid" , "bVisible" : false },
|
|
/* Ingested */ { "sTitle" : $.i18n._("Imported?") , "mDataProp" : "importIcon" , "sClass" : "podcast_episodes_imported" , "sWidth" : "120px" },
|
|
/* Title */ { "sTitle" : $.i18n._("Title") , "mDataProp" : "title" , "sClass" : "podcast_episodes_title" , "sWidth" : "170px" },
|
|
/* Author */ { "sTitle" : $.i18n._("Author") , "mDataProp" : "author" , "sClass" : "podcast_episodes_author" , "sWidth" : "170px" },
|
|
/* Description */ { "sTitle" : $.i18n._("Description") , "mDataProp" : "description" , "sClass" : "podcast_episodes_description" , "sWidth" : "300px" },
|
|
/* Link */ { "sTitle" : $.i18n._("Link") , "mDataProp" : "link" , "sClass" : "podcast_episodes_link" , "sWidth" : "170px" },
|
|
/* Publication Date */ { "sTitle" : $.i18n._("Publication Date") , "mDataProp" : "pub_date" , "sClass" : "podcast_episodes_pub_date" , "sWidth" : "170px" }
|
|
],
|
|
bServerSide : false,
|
|
sAjaxSource : null,
|
|
// Initialize the table with empty data so we can defer loading
|
|
// If we load sequentially there's a delay before the table appears
|
|
aaData : {},
|
|
oColVis : {
|
|
buttonText: $.i18n._("Columns"),
|
|
iOverlayFade: 0,
|
|
aiExclude: [0, 1, 2]
|
|
},
|
|
bDeferRender: true,
|
|
oColReorder: {
|
|
iFixedColumns: 3 // Checkbox + imported
|
|
},
|
|
fnCreatedRow: function(nRow, aData, iDataIndex) {
|
|
var self = this;
|
|
if (aData.file && Object.keys(aData.file).length > 0) {
|
|
$(nRow).draggable({
|
|
helper: function () {
|
|
var $row = $(this), data = self._datatable.fnGetData(nRow);
|
|
$row.data("aData", data.file);
|
|
self.selectRow(this, data, self.SELECTION_MODE.SINGLE, $row.index());
|
|
var selected = self.getSelectedRows().length, container,
|
|
width = self._$wrapperDOMNode.closest(".dataTables_wrapper").outerWidth(), message;
|
|
|
|
message = sprintf($.i18n._(selected > 1 ? "Adding %s Items" : "Adding %s Item"), selected);
|
|
container = $('<div/>').attr('id', 'draggingContainer').append('<tr/>')
|
|
.find("tr").append('<td/>').find("td")
|
|
.attr("colspan", 100).width(width).css("max-width", "none")
|
|
.addClass("ui-state-highlight").append(message).end().end();
|
|
|
|
return container;
|
|
},
|
|
tolerance: 'pointer',
|
|
cursor: 'move',
|
|
cursorAt: {
|
|
top: 20,
|
|
left: Math.floor(self._datatable.outerWidth() / 2)
|
|
},
|
|
distance: 25, // min-distance for dragging
|
|
connectToSortable: $("#show_builder_table, .active-tab .spl_sortable")
|
|
});
|
|
}
|
|
},
|
|
fnDrawCallback: function () {
|
|
AIRTIME.library.drawEmptyPlaceholder(this);
|
|
// Hide the processing div
|
|
var dt = this.getDatatable();
|
|
!dt || dt.closest(".dataTables_wrapper").find(".dataTables_processing").css("visibility", "hidden");
|
|
}
|
|
}
|
|
|
|
if (typeof PodcastEpisodeTable === 'undefined') {
|
|
_initPodcastEpisodeTable();
|
|
}
|
|
|
|
var podcastEpisodeTableObj = new PodcastEpisodeTable(
|
|
domNode, // DOM node to create the table inside.
|
|
true, // Enable item selection
|
|
buttons, // Toolbar buttons
|
|
params, // Datatables overrides.
|
|
config // Internal config
|
|
);
|
|
|
|
podcastEpisodeTableObj.getDatatable().addTitles("td");
|
|
return podcastEpisodeTableObj;
|
|
};
|
|
|
|
return AIRTIME;
|
|
}(AIRTIME || {}));
|
|
|
|
$(document).ready(function() {
|
|
$(document).on("submit", "#podcast_url_form", function (e) {
|
|
e.preventDefault();
|
|
AIRTIME.podcast.addPodcast();
|
|
});
|
|
});
|