digsig / digsig-player-service

Go to a project
Toggle navigation Toggle navigation pinning
Stefan Huber
643e8077 1 parent c49550ce

rebuild

Expand all
Inline Side-by-side
Showing 21 changed files with 67 additions and 452 deletions
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
interface ProgramRepository {
findById(id:string) : Promise<any>;
findByIds(ids:Array<string>) : Promise<Array<any>>;
findByType(type:string) : Promise<Array<any>>;
replicate() : Promise<void>;
}
interface Player {
on(name:string, any);
start() : void;
stop() : void;
}
interface ProgramManager {
programRepository: ProgramRepository;
}
interface ProgramItemFactory {
basePath: string;
programRepository: ProgramRepository;
getProgramItem(programItemId:string) : Promise<any>;
}
declare var digsigPlayer: {
ProgramRepository: ProgramRepository,
ProgramManager: ProgramManager,
Player : Player,
ProgramItemFactory: ProgramItemFactory
};
declare module "digsig-player-service" {
export = digsigPlayer;
}
\ No newline at end of file
......@@ -2,13 +2,13 @@
"name": "digsig-player-service",
"version": "1.0.0",
"description": "",
"main": "target/index.js",
"types": "types/index.d.ts",
"main": "build/bundle.js",
"types": "index.d.ts",
"scripts": {
"pretest": "tsc --target es5 --outDir .tmp spec/index.ts",
"test": "jasmine .tmp/spec/index.js",
"posttest": "rm -R .tmp",
"build:tsc": "tsc"
"build:tsc": "rollup -c rollup.config.js"
},
"author": "Stefan Huber <stefan.huber@beyondit.at>",
"license": "ISC",
......@@ -17,6 +17,11 @@
"@types/jasmine": "^2.5.41",
"@types/node": "^7.0.0",
"jasmine": "^2.5.3",
"rollup": "^0.41.4",
"rollup-plugin-commonjs": "^7.0.0",
"rollup-plugin-node-builtins": "^2.0.0",
"rollup-plugin-node-globals": "^1.1.0",
"rollup-plugin-typescript": "^0.8.1",
"typescript": "^2.1.5"
}
}
......
var typescript = require('rollup-plugin-typescript');
var builtins = require('rollup-plugin-node-builtins');
var globals = require('rollup-plugin-node-globals');
var rollupConfig = {
moduleName : 'digsig',
entry: 'src/index.ts',
sourceMap: true,
format: 'cjs',
dest: 'build/bundle.js',
plugins: [
builtins(),
globals(),
typescript()
]
};
module.exports = rollupConfig;
\ No newline at end of file
export * from './player';
export * from './program-manager';
export * from './program-item/program-item';
export * from './program-item/program-item-factory';
export * from './program-manager';
export * from './program-repository';
export * from './util';
......
"use strict";
function __export(m) {
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
}
__export(require("./player"));
__export(require("./program-item/program-item"));
__export(require("./program-item/program-item-factory"));
__export(require("./program-manager"));
__export(require("./util"));
"use strict";
var __extends = (this && this.__extends) || function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
var events_1 = require("events");
var util_1 = require("./util");
var STATE_START = "start";
var STATE_STOP = "stop";
var Player = (function (_super) {
__extends(Player, _super);
function Player() {
var _this = _super !== null && _super.apply(this, arguments) || this;
_this._minutesReplication = 5;
_this._replicationRetry = 10000;
_this._currentProgramItemId = '';
_this._currentReplicationCounter = 0;
_this._state = STATE_STOP;
return _this;
}
Object.defineProperty(Player.prototype, "state", {
set: function (st) {
this._state = st;
},
enumerable: true,
configurable: true
});
Object.defineProperty(Player.prototype, "programManager", {
get: function () {
return this._programManager;
},
set: function (pm) {
this._programManager = pm;
},
enumerable: true,
configurable: true
});
Object.defineProperty(Player.prototype, "programRepository", {
get: function () {
return this._programRepository;
},
set: function (pr) {
this._programRepository = pr;
},
enumerable: true,
configurable: true
});
Object.defineProperty(Player.prototype, "minutesReplication", {
get: function () {
return this._minutesReplication;
},
set: function (mr) {
this._minutesReplication = mr;
},
enumerable: true,
configurable: true
});
Object.defineProperty(Player.prototype, "replicationRetry", {
get: function () {
return this._replicationRetry;
},
set: function (rr) {
this._replicationRetry = rr;
},
enumerable: true,
configurable: true
});
Player.prototype.triggerReplication = function () {
var _this = this;
return this.programRepository.replicate()
.then(function () {
_this._currentReplicationCounter = 0;
_this.trigger(_this.triggerProgramItemId, util_1.Util.calculateNextMinute());
})
.catch(function () {
_this.trigger(_this.triggerReplication, _this.replicationRetry);
});
};
Player.prototype.triggerProgramItemId = function () {
var _this = this;
this.programManager.getCurrentProgramItemId()
.then(function (programItemId) {
_this._currentReplicationCounter++;
// if there is a new program item id trigger play
// else (1) calculate next potential program change point
// or (2) trigger replication
if (programItemId != _this._currentProgramItemId) {
_this._currentProgramItemId = programItemId;
_this.emit('play', programItemId);
}
else if (_this._currentReplicationCounter >= _this._minutesReplication) {
_this.triggerReplication();
}
else {
_this.trigger(_this.triggerProgramItemId, util_1.Util.calculateNextMinute());
}
});
};
Player.prototype.trigger = function (func, milliseconds) {
if (this._state === STATE_START) {
setTimeout(function () { func(); }, milliseconds);
}
};
Player.prototype.start = function () {
if (this._state === STATE_STOP) {
this.triggerReplication();
this._state = STATE_START;
}
};
Player.prototype.stop = function () {
this._state = STATE_STOP;
};
return Player;
}(events_1.EventEmitter));
exports.Player = Player;
"use strict";
var program_item_1 = require("./program-item");
var ProgramItemFactory = (function () {
function ProgramItemFactory() {
}
Object.defineProperty(ProgramItemFactory.prototype, "basePath", {
get: function () {
return this._basePath;
},
set: function (bp) {
this._basePath = bp;
},
enumerable: true,
configurable: true
});
Object.defineProperty(ProgramItemFactory.prototype, "programRepository", {
get: function () {
return this._programRepository;
},
set: function (pr) {
this._programRepository = pr;
},
enumerable: true,
configurable: true
});
ProgramItemFactory.prototype.getProgramItem = function (programItemId) {
var _this = this;
return this.programRepository
.findById(programItemId)
.then(function (programItem) {
return _this.prepareProgramItem(programItem.program_item_type, programItem);
});
};
ProgramItemFactory.prototype.prepareProgramItem = function (type, data) {
var programItem = new program_item_1.ProgramItem();
programItem.type = type;
if (type === program_item_1.PROGRAM_ITEM_TYPE_VIDEO) {
return this.prepareVideoItem(programItem, data);
}
else if (type === program_item_1.PROGRAM_ITEM_TYPE_SLIDESHOW) {
return this.prepareSlideshowItem(programItem, data);
}
else {
return null;
}
};
ProgramItemFactory.prototype.prepareSlideshowItem = function (programItem, data) {
var _this = this;
return this._programRepository.findByIds(data.images)
.then(function (images) {
programItem.data = {
speed: data.settings.speed,
effect: data.settings.effect,
images: []
};
for (var _i = 0, images_1 = images; _i < images_1.length; _i++) {
var image = images_1[_i];
programItem.data.images.push(_this.basePath + image.filename);
}
return programItem;
});
};
ProgramItemFactory.prototype.prepareVideoItem = function (programItem, data) {
var _this = this;
return this._programRepository.findById(data.video)
.then(function (data) {
programItem.data = {
video: _this.basePath + data['filename']
};
return programItem;
});
};
return ProgramItemFactory;
}());
exports.ProgramItemFactory = ProgramItemFactory;
"use strict";
exports.PROGRAM_ITEM_TYPE_SLIDESHOW = "slideshow";
exports.PROGRAM_ITEM_TYPE_VIDEO = "video";
var ProgramItem = (function () {
function ProgramItem() {
}
Object.defineProperty(ProgramItem.prototype, "type", {
get: function () {
return this._type;
},
set: function (t) {
this._type = t;
},
enumerable: true,
configurable: true
});
Object.defineProperty(ProgramItem.prototype, "data", {
get: function () {
return this._data;
},
set: function (d) {
this._data = d;
},
enumerable: true,
configurable: true
});
return ProgramItem;
}());
exports.ProgramItem = ProgramItem;
"use strict";
var util_1 = require("./util");
var ProgramManager = (function () {
function ProgramManager() {
}
Object.defineProperty(ProgramManager.prototype, "programRepository", {
get: function () {
return this._programRepository;
},
set: function (pr) {
this._programRepository = pr;
},
enumerable: true,
configurable: true
});
ProgramManager.prototype.getCurrentProgramItemId = function () {
var _this = this;
return new Promise(function (resolve, reject) {
_this.findCurrentProgramSegment().then(function (programSegment) {
var currentProgramItemId = programSegment.default;
if (programSegment.schedule) {
currentProgramItemId = _this.findCurrentProgramItem(programSegment.schedule, util_1.Util.getDateInMinutes());
}
resolve(currentProgramItemId);
});
});
};
/**
* find program item in schedule, which fits
* according to current hh:mm
*/
ProgramManager.prototype.findCurrentProgramItem = function (schedule, dateInMinutes) {
var timeList = [];
var tmpSchedule = {};
for (var startTime in schedule) {
if (schedule.hasOwnProperty(startTime)) {
var minutes = util_1.Util.convertToMinutes(startTime);
timeList.push(minutes);
tmpSchedule[minutes] = schedule[startTime];
}
}
// sort ascending (-)
timeList.sort(function (a, b) { return a - b; });
var last = 0;
for (var i = 0; i < timeList.length; i++) {
if (timeList[i] <= dateInMinutes) {
last = timeList[i];
}
else {
break;
}
}
return tmpSchedule[last];
};
/**
* Find the program segment
* This is dependent on the date set on the device
*/
ProgramManager.prototype.findCurrentProgramSegment = function () {
var _this = this;
return new Promise(function (resolve, reject) {
var today = util_1.Util.getISODate();
_this.programRepository.findByType('program')
.then(function (programs) {
if (programs.length > 0) {
var program = programs[0];
var programSegmentId = void 0;
// if there is a program_segment for today else default
if (program.schedule && program.schedule[today]) {
programSegmentId = program.schedule[today];
}
else {
programSegmentId = program.default;
}
_this.programRepository
.findById(programSegmentId)
.then(function (programSegment) {
resolve(programSegment);
}).catch(function (error) {
reject("program segment not found");
});
}
else {
reject('No Program found');
}
}).catch(function (error) {
reject(error);
});
});
};
return ProgramManager;
}());
exports.ProgramManager = ProgramManager;
"use strict";
var Util = (function () {
function Util() {
}
Util.getISODate = function () {
return (new Date()).toISOString().slice(0, 10);
};
Util.getDateInMinutes = function () {
var now = new Date();
return (now.getHours() * 60) + now.getMinutes();
};
/**
* convert a time input to minutes
* e.g. 23:59 = 1439
*/
Util.convertToMinutes = function (time) {
var times = time.split(":");
var convered = (parseInt(times[0]) * 60) + parseInt(times[1]);
return (convered >= 0 && convered <= 1439) ? convered : 0;
};
Util.calculateNextMinute = function () {
return (60 - (Math.round((new Date()).getTime() / 1000) % 60)) * 1000;
};
return Util;
}());
exports.Util = Util;
{
"compilerOptions": {
"outDir": "./target",
"module": "commonjs",
"target": "es5",
"declaration": true,
"declarationDir": "types"
},
"include": [
"./src/index.ts"
]
}
\ No newline at end of file
export * from './player';
export * from './program-item/program-item';
export * from './program-item/program-item-factory';
export * from './program-manager';
export * from './program-repository';
export * from './util';
/// <reference types="node" />
/// <reference types="es6-promise" />
import { EventEmitter } from 'events';
import { ProgramRepository } from './program-repository';
import { ProgramManager } from './program-manager';
export declare class Player extends EventEmitter {
protected _programRepository: ProgramRepository;
protected _programManager: ProgramManager;
protected _minutesReplication: number;
protected _replicationRetry: number;
protected _currentProgramItemId: string;
protected _currentReplicationCounter: number;
protected _state: string;
state: string;
programManager: ProgramManager;
programRepository: ProgramRepository;
minutesReplication: number;
replicationRetry: number;
triggerReplication(): Promise<void>;
triggerProgramItemId(): void;
trigger(func: Function, milliseconds: number): void;
start(): void;
stop(): void;
}
/// <reference types="es6-promise" />
import { ProgramItem } from './program-item';
import { ProgramRepository } from './../program-repository';
export declare class ProgramItemFactory {
protected _programRepository: ProgramRepository;
protected _basePath: string;
basePath: string;
programRepository: ProgramRepository;
getProgramItem(programItemId: string): Promise<ProgramItem>;
prepareProgramItem(type: string, data: any): Promise<ProgramItem>;
prepareSlideshowItem(programItem: ProgramItem, data: any): Promise<ProgramItem>;
prepareVideoItem(programItem: ProgramItem, data: any): Promise<ProgramItem>;
}
export declare const PROGRAM_ITEM_TYPE_SLIDESHOW = "slideshow";
export declare const PROGRAM_ITEM_TYPE_VIDEO = "video";
export declare class ProgramItem {
protected _type: string;
protected _data: any;
type: string;
data: any;
}
/// <reference types="es6-promise" />
import { ProgramRepository } from './program-repository';
export declare class ProgramManager {
protected _programRepository: ProgramRepository;
programRepository: ProgramRepository;
getCurrentProgramItemId(): Promise<string>;
/**
* find program item in schedule, which fits
* according to current hh:mm
*/
findCurrentProgramItem(schedule: any, dateInMinutes: number): string;
/**
* Find the program segment
* This is dependent on the date set on the device
*/
findCurrentProgramSegment(): Promise<any>;
}
/// <reference types="es6-promise" />
export interface ProgramRepository {
findById(id: string): Promise<any>;
findByIds(ids: Array<string>): Promise<Array<any>>;
findByType(type: string): Promise<Array<any>>;
replicate(): Promise<void>;
}
export declare class Util {
static getISODate(): string;
static getDateInMinutes(): number;
/**
* convert a time input to minutes
* e.g. 23:59 = 1439
*/
static convertToMinutes(time: string): number;
static calculateNextMinute(): number;
}