module.exports = function(options) {
var validOptions = {};
if (options.hasOwnProperty('value')) {
validOptions.value = parseInt(options.value, 10);
if (isNaN(validOptions.value) || validOptions.value < 0 || validOptions.value > 100) {
return utils.promise.reject(new Error('Volume value must be integer percentage 0 - 100'));
}
}
if (options.hasOwnProperty('diff')) {
validOptions.diff = parseInt(options.diff, 10);
if (isNaN(validOptions.diff)) {
return utils.promise.reject(new Error('Volume diff must be integer'));
}
}
if (!options.hasOwnProperty('value') && !options.hasOwnProperty('diff')) {
return utils.promise.reject(new Error('Volume requires value or diff property'));
}
if (validOptions.diff && validOptions.value) {
return utils.promise.reject(new Error('Diff and value provided - must have only 1'));
}
return utils.promise.resolve(validOptions);
};
.then(null, function(err) {
logger.warn(err);
// resolving ready promise so we can work with offline services
ready.resolve();
return utils.promise.reject(new Error('BBC Services offline?'));
});
function build() {
var deferred = utils.promise.defer(),
text = renderTemplate(options, ports);
deferred.resolve(text);
return deferred.promise;
}
.then(function(data) {
var settings = data || defaults;
delete settings['type'];
delete settings['_id'];
return utils.promise.resolve(settings);
})
module.exports = function(options) {
var validOptions = {};
validOptions.force = options.force || false;
if (validOptions.force !== true && validOptions.force !== false) {
return utils.promise.reject(new Error('Force must be a boolean'));
}
if (options.hasOwnProperty('path') ) {
if (typeof options.path === 'string') {
validOptions.path = options.path;
} else {
return utils.promise.reject(new Error('Path must be a string'));
}
}
return utils.promise.resolve(validOptions);
};
function writeConfigToDisk(content) {
var generateFileName = utils.promise.nfcall(tmp.tmpName);
return generateFileName.then(function(tmpFilePath) {
logger.debug("Writing mpd config to file " + tmpFilePath);
return utils.promise.nfcall(fs.writeFile, tmpFilePath, content)
.then(function() { return tmpFilePath; });
});
}
ServicesRegister.prototype.stations = function() {
var providers = this._providers, promises;
promises = Object.keys(providers).map(function(k) {
return providers[k].stations();
});
return utils.promise.all(promises)
.then(function(allStations) {
return allStations.reduce(function(a,b) {
return a.concat(b);
});
});
};
ServicesRegister.prototype.register = function(serviceprovider) {
var self = this,
providerId = serviceprovider.id,
exists = Object.keys(self._providers).indexOf(providerId) > -1;
if(exists) {
return utils.promise.reject('Provider ' + providerId + ' already registered');
} else {
return self._registerProvider(providerId, serviceprovider)
.then(function() {
self._bindToEvents(providerId, serviceprovider);
});
}
};
function validate(input) {
var validated = utils.promise.defer(),
inputKeys, defaultKeys;
input = input || {};
inputKeys = Object.keys(input).sort();
defaultKeys = Object.keys(defaults).sort();
if(deepEqual(inputKeys, defaultKeys)) {
validated.resolve(input);
} else {
var err = new Error('Required settings keys not found: '+defaultKeys);
validated.reject(err);
}
return validated.promise;
}
module.exports = function(options) {
var validOptions = {};
if(options.hasOwnProperty('to')) {
validOptions.to = parseInt(options.to, 10);
} else {
return utils.promise.reject(new Error('Destination not set'));
}
if(options.hasOwnProperty('from')) {
options.position = options.from;
}
return position(options)
.then(function(position) {
validOptions.from = position.value;
return utils.promise.resolve(validOptions);
});
};
ServicesRegister.prototype._registerProvider = function(providerId, serviceprovider) {
var that = this,
dfd = utils.promise.defer();
this._providers[providerId] = serviceprovider;
serviceprovider.fetchServices()
.then(function(services) {
services.forEach(function(serviceId) {
try {
that._registerService(providerId, serviceId);
} catch(err) {
dfd.reject(err);
}
});
dfd.resolve();
});
return dfd.promise;
}
function get() {
var getPromise = utils.promise.defer();
db.findOne(query, function(err, settings) {
if(err) {
getPromise.reject(err);
} else {
getPromise.resolve(settings);
}
});
return getPromise.promise
.then(function(data) {
var settings = data || defaults;
delete settings['type'];
delete settings['_id'];
return utils.promise.resolve(settings);
})
.then(null, utils.failedPromiseHandler(logger));
}
function set(data) {
var setPromise = utils.promise.defer(),
options = { upsert: true },
validData,
dataToStore;
return validate(data).then(function(validated) {
validData = validated;
dataToStore = utils.mergeObjects(query, validData);
db.update(query, dataToStore, options, function(err, numReplaced) {
if(err) {
setPromise.reject(err);
} else {
setPromise.resolve(numReplaced);
}
})
emitUpdate(validData);
return setPromise.promise;
});
}
instance.fetchServices = function() {
return utils.promise.resolve([id]);
};
.then(function(filePath) {
return utils.promise.resolve([filePath, ports[0]]);
})
function empty() {
return utils.promise.resolve({});
}
function formatResponse(radio, playlistInfo) {
var playlistArray = radio.formatResponse(playlistInfo, true),
playlist = formatPlaylist(playlistArray);
return utils.promise.resolve(playlist);
}
function create(myLogger) {
var instance = new EventEmitter({wildcard: true}),
serviceIds = [],
ready = utils.promise.defer(),
stationsPromise;
logger = myLogger || logger;
instance.id = 'bbc-services';
instance.ready = ready.promise;
instance.cache = {};
instance.metadata = metadata;
instance.fetchServices = fetchServices;
instance.stations = stations;
instance.playlist = playlist;
instance.connect = connect;
instance.listenForEvents = listenForEvents;
instance.cacheStore = cacheStore;
return instance;
function playlist(serviceId) {
var service = cacheFor(serviceId),
playlist;
if (service && service.playlist) {
return {
type: 'playlist',
value: service.playlist
};
}
}
function fetchServices() {
instance.connect();
return instance.ready.then(function() {
return serviceIds;
});
}
function metadata(serviceId) {
if(typeof serviceId === 'undefined') {
return serviceIds.map(function(serviceId) {
var data = cacheFor(serviceId);
data.id = serviceId;
return data;
});
} else if(serviceIds.indexOf(serviceId) > -1) {
return cacheFor(serviceId);
} else {
return null;
}
}
function stations() {
var url = bbcServicesURL+'/stations.json';
if (!stationsPromise) {
stationsPromise = http.get(url)
.then(function (data) {
var list = [],
json = JSON.parse(data);
if (json.stations) {
list = json.stations;
}
return list;
})
.then(null, function(err) {
logger.warn(err);
return [];
});
}
return stationsPromise;
}
function connect() {
if(typeof bbcServicesURL === 'undefined') {
logger.error('BBC_SERVICES_URL not found in ENV');
}
seedCache().then(connectToEventSource);
return instance;
}
function seedCache() {
var url = bbcServicesURL+'/services.json';
return http.get(url).then(function(data) {
var services;
try {
services = JSON.parse(data).services;
} catch(err) {
logger.warn(err);
services = [];
}
services.forEach(function(service) {
var serviceId = service.id;
Object.keys(service).forEach(function(key) {
cacheStore(serviceId, key, service[key]);
});
});
return ready.resolve();
})
.then(null, function(err) {
logger.warn(err);
// resolving ready promise so we can work with offline services
ready.resolve();
return utils.promise.reject(new Error('BBC Services offline?'));
});
}
function connectToEventSource() {
var url = bbcServicesURL+'/stream',
es;
es = new EventSource(url);
logger.debug('Connecting to', url);
listenForEvents(es);
}
function listenForEvents(es) {
var firstError = true;
es.addEventListener('message', function(data) {
handleMessage(data);
});
es.addEventListener('error', function(error) {
// always fails on startup
if(firstError) {
firstError = false;
} else {
logger.warn('EventSource error', error.stack);
}
});
}
function handleMessage(msg) {
var data = parseMessage(msg.data),
isNewData;
if(!data) {
logger.warn('Invalid JSON recieved', msg);
return false;
}
isNewData = cacheStore(data.service, data.topic, data.data);
if(isNewData) {
// this is for the avoider
instance.emit(data.service + '.' + data.topic, data.data);
logger.debug('new data', data.service, data.topic, data.data);
} else {
logger.debug('data is the same', data.service, data.topic);
}
}
function cacheStore(serviceId, topic, data) {
var cache = cacheFor(serviceId);
data = data || {};
// delete timestamp to check for data difference
delete data.received;
if(JSON.stringify(data) === JSON.stringify(cache[topic])) {
return false;
} else {
cache[topic] = data;
return true;
}
}
function cacheFor(serviceId) {
if(typeof instance.cache[serviceId] == 'undefined') {
serviceIds.push(serviceId);
instance.cache[serviceId] = {};
}
return instance.cache[serviceId];
}
function parseMessage(data) {
try {
return JSON.parse(data);
} catch(err) {
logger.warn('Cannot parse', err);
return false;
}
}
}
.then(function(position) {
validOptions.from = position.value;
return utils.promise.resolve(validOptions);
});
instance.stations = function() {
var stations = [instance.station()];
return utils.promise.resolve(stations);
}