Source: managers/epg.js

  1. define('application/managers/epg', [
  2.     'product-layer/epg/manager',
  3.     'application/managers/api',
  4.     'rofl/lib/utils',
  5.     'rofl/lib/promise',
  6.     'antie/runtimecontext'
  7. ], function (
  8.     AbstractEpgManager,
  9.     ApiManager,
  10.     Utils,
  11.     Promise,
  12.     RuntimeContext
  13. ) {
  14.     'use strict';
  16.     var api,
  17.         DATA_CHUNK_TIME_SPAN = 24 * 60 * 60,
  18.         instance,
  19.         app,
  20.         EpgManager;
  22.     EpgManager = AbstractEpgManager.extend({
  24.         /**
  25.          * Initialises the EPG manager.
  26.          */
  27.         init: function init () {
  28.             init.base.call(this);
  30.             api = ApiManager.getKPNAPI();
  31.             app = RuntimeContext.getCurrentApplication();
  33.             this.setDataChunkTimeSpan(24 * 60 * 60);
  34.         },
  36.         /**
  37.          * Loads the data for the given channel ids and time.
  38.          *
  39.          * @param {Array} channelIds - The channel ids.
  40.          * @param {number} time - The time in seconds.
  41.          * @returns {Promise} - Promise resolving with epg data.
  42.          */
  43.         load: function (channelIds, time) {
  45.             return api.read('epg', {
  46.                 params: {
  47.                     channels: channelIds,
  48.                     startTime: time * 1000,
  49.                     endTime: (time + this.getDataChunkTimeSpan()) * 1000
  50.                 }
  51.             });
  52.         },
  54.         /**
  55.          * Initiator of the EPG data loading.
  56.          *
  57.          * @param {Array} channelIds - Channel ID's to fetch.
  58.          * @param {number} time - Regulated time for fetching the correct time slot.
  59.          * @returns {Promise} The load promise.
  60.          */
  61.         loadData: function (channelIds, time) {
  62.             var timeSlot = this._regulateTimeSlot(time),
  63.                 self = this,
  64.                 slot = {};
  66.             return this.load(channelIds, timeSlot).then(function (epgData) {
  68.                 if (epgData) {
  69.                     slot.timeSlot = timeSlot;
  70.                     slot.previousSlot = timeSlot - DATA_CHUNK_TIME_SPAN;
  71.                     slot.nextSlot = timeSlot + DATA_CHUNK_TIME_SPAN;
  72.                     slot.compared = false;
  74.                     // Make sure the time slot exists
  75.                     if (!self._slots[timeSlot]) {
  76.                         self._slots[timeSlot] = {};
  77.                     }
  79.                     if (Utils.keys(epgData).length) {
  80.                         Utils.extend(self._slots[timeSlot], epgData);
  81.                     }
  83.                     return Promise.resolve(epgData);
  84.                 }
  85.                 return Promise.resolve();
  86.             });
  87.         },
  89.         /**
  90.          * Get the current and prev EPG item for a channel ID.
  91.          *
  92.          * @param {String|Number|Array} channelIds - Channel ID's to load the data for.
  93.          * @returns {Promise} EPG data promise.
  94.          */
  95.         getNowPrev: function (channelIds) {
  96.             var self = this,
  97.                 currentTime = Math.round((app.getDate()).getTime() / 1000),
  98.                 channels;
  100.             if (Utils.isArray(channelIds)) {
  101.                 channels = channelIds;
  102.             } else if (Utils.isString(channelIds) || Utils.isNumber(channelIds)) {
  103.                 channels = [channelIds];
  104.             }
  106.             return this.getItem(channels, currentTime).then(function (items) {
  107.                 var fillMissingPrevs = Utils.bind(self._fillMissingPrevs, self),
  108.                     fillMissingPrevsInCurrentTime = Utils.bind(self._fillMissingPrevsInCurrentTime, self),
  109.                     prevTime = currentTime - DATA_CHUNK_TIME_SPAN,
  110.                     prevTimeSlot = prevTime - (prevTime % DATA_CHUNK_TIME_SPAN),
  111.                     currentTimeSlot = currentTime - (currentTime % DATA_CHUNK_TIME_SPAN);
  113.                 if (currentTime > currentTimeSlot) {
  114.                     return fillMissingPrevsInCurrentTime(currentTimeSlot, items).then(function (filledItems) {
  115.                         var epgItems = {};
  117.                         Utils.each(filledItems, function (value, key) {
  118.                             epgItems[key] = {
  119.                                 now: value.item,
  120.                                 prev: value.prev
  121.                             };
  122.                         });
  124.                         return fillMissingPrevs(prevTimeSlot, items)
  125.                             .then(function (prevItems) {
  127.                                 Utils.each(prevItems, function (value, key) {
  128.                                     epgItems[key] = {
  129.                                         now: value.item,
  130.                                         prev: value.prev
  131.                                     };
  132.                                 });
  133.                                 return Promise.resolve(epgItems);
  134.                             });
  135.                     });
  136.                 }
  138.                 return fillMissingPrevs(prevTimeSlot, items).then(function (filledItems) {
  139.                     var epgItems = {};
  141.                     Utils.each(filledItems, function (value, key) {
  142.                         epgItems[key] = {
  143.                             now: value.item,
  144.                             prev: value.prev
  145.                         };
  146.                     });
  147.                     return Promise.resolve(epgItems);
  148.                 });
  149.             });
  150.         },
  152.         /**
  153.          * Tries to fill in the blanks, retrieved from the prev time span.
  154.          *
  155.          * @param {number} time - The time to check for.
  156.          * @param {Object} items - The original item to check against.
  157.          * @returns {Promise} Load promise.
  158.          */
  159.         _fillMissingPrevs: function (time, items) {
  160.             var missingPrevs = [],
  161.                 self = this;
  163.             Utils.each(items, function (value, key) {
  164.                 if (!value.prev) {
  165.                     missingPrevs.push(key);
  166.                 }
  167.             });
  169.             return this._loadMissingData(missingPrevs, time).then(function () {
  170.                 var i = 0,
  171.                     max = missingPrevs.length,
  172.                     channelId,
  173.                     channelSlot,
  174.                     item,
  175.                     j,
  176.                     itemAmount;
  178.                 for (; i < max; i++) {
  180.                     channelId = missingPrevs[i];
  181.                     channelSlot = self._getChannelSlot(channelId, time);
  183.                     for (j = 0, itemAmount = channelSlot.length; j < itemAmount; j++) {
  185.                         item = channelSlot[itemAmount - 1];
  187.                         items[channelId].prev = item || null;
  188.                     }
  190.                 }
  191.                 return Promise.resolve(items);
  192.             });
  193.         },
  195.         /**
  196.          * Tries to fill in the blanks, retrieved from the prev time span.
  197.          *
  198.          * @param {number} time - The time to check for.
  199.          * @param {Object} items - The original item to check against.
  200.          * @returns {Promise} Load promise.
  201.          */
  202.         _fillMissingPrevsInCurrentTime: function (time, items) {
  203.             var missingPrevs = [],
  204.                 self = this;
  206.             Utils.each(items, function (value, key) {
  207.                 if (!value.prev) {
  208.                     missingPrevs.push(key);
  209.                 }
  210.             });
  212.             return this._loadMissingData(missingPrevs, time).then(function () {
  213.                 var i = 0,
  214.                     max = missingPrevs.length,
  215.                     channelId,
  216.                     channelSlot,
  217.                     currentItem,
  218.                     item,
  219.                     j,
  220.                     itemAmount;
  222.                 for (; i < max; i++) {
  224.                     channelId = missingPrevs[i];
  225.                     channelSlot = self._getChannelSlot(channelId, time);
  226.                     currentItem = items[channelId].item;
  228.                     for (j = 0, itemAmount = channelSlot.length; j < itemAmount; j++) {
  230.                         if (channelSlot[j] === currentItem) {
  231.                             item = channelSlot[j - 1];
  232.                             items[channelId].prev = item || null;
  233.                         }
  234.                     }
  235.                 }
  237.                 return Promise.resolve(items);
  238.             });
  239.         }
  241.     });
  243.     return {
  245.         /**
  246.          * Returns an instance of the epg manager.
  247.          *
  248.          * @returns {Object} - The epg manager instance.
  249.          */
  250.         getInstance: function () {
  251.             if (!instance) {
  252.                 instance = new EpgManager();
  253.             }
  255.             return instance;
  256.         }
  257.     };
  258. });