352 lines
11 KiB
TypeScript
352 lines
11 KiB
TypeScript
/** @file
|
|
* @author Edouard DUPIN
|
|
* @copyright 2018, Edouard DUPIN, all right reserved
|
|
* @license PROPRIETARY (see license file)
|
|
*/
|
|
|
|
import { Injectable, Output, EventEmitter } from '@angular/core';
|
|
|
|
import { NavigationEnd, NavigationError, NavigationStart, Router } from '@angular/router';
|
|
|
|
import { TypeService } from './type';
|
|
import { SeriesService } from './series';
|
|
import { SeasonService } from './season';
|
|
import { VideoService } from './video';
|
|
import { environment } from 'environments/environment';
|
|
import { NodeData } from 'common/model';
|
|
import { isNullOrUndefined, isStringNullOrUndefined, isUndefined } from 'common/utils';
|
|
|
|
export class InputOrders {
|
|
public typeId: number = undefined;
|
|
public seriesId: number = undefined;
|
|
public seasonId: number = undefined;
|
|
public videoId: number = undefined;
|
|
}
|
|
|
|
@Injectable()
|
|
export class ArianeService {
|
|
public typeId: number = undefined;
|
|
public typeName: string = undefined;
|
|
@Output() typeChange: EventEmitter<number> = new EventEmitter();
|
|
|
|
public seriesId: number = undefined;
|
|
public seriesName: string = undefined;
|
|
@Output() seriesChange: EventEmitter<number> = new EventEmitter();
|
|
|
|
public seasonId: number = undefined;
|
|
public seasonName: string = undefined;
|
|
@Output() seasonChange: EventEmitter<number> = new EventEmitter();
|
|
|
|
public videoId: number = undefined;
|
|
public videoName: string = undefined;
|
|
@Output() videoChange: EventEmitter<number> = new EventEmitter();
|
|
|
|
public segment: string = "";
|
|
@Output() segmentChange: EventEmitter<string> = new EventEmitter();
|
|
|
|
constructor(private router: Router,
|
|
private typeService: TypeService,
|
|
private seriesService: SeriesService,
|
|
private seasonService: SeasonService,
|
|
private videoService: VideoService) {
|
|
let self = this;
|
|
this.router.events.subscribe((event: any) => {
|
|
if (event instanceof NavigationStart) {
|
|
// Show progress spinner or progress bar
|
|
//console.log('>>>>>>>>>>>>>> Route change detected');
|
|
}
|
|
|
|
if (event instanceof NavigationEnd) {
|
|
// Hide progress spinner or progress bar
|
|
//this.currentRoute = event.url;
|
|
//console.log(`>>>>>>>>>>>> ${event}`);
|
|
self.updateProperties();
|
|
}
|
|
|
|
if (event instanceof NavigationError) {
|
|
// Hide progress spinner or progress bar
|
|
|
|
// Present error to user
|
|
//console.log(`<<<<<<<<<<<<< ${event.error}`);
|
|
}
|
|
|
|
});
|
|
}
|
|
updateParams(params) {
|
|
console.log(`sparams ${ params}`);
|
|
console.log(`sparams['typeId'] ${ params.typeId}`);
|
|
if(params.typeId) {
|
|
this.setType(params.typeId);
|
|
} else {
|
|
this.setType(undefined);
|
|
}
|
|
}
|
|
getCurrrentSegment(): string|undefined {
|
|
return this.segment;
|
|
}
|
|
|
|
getIsParam(params: any, name: string): undefined|number {
|
|
let valueStr = params.get(name);
|
|
if(isNullOrUndefined(valueStr) || isStringNullOrUndefined(valueStr)) {
|
|
return undefined;
|
|
}
|
|
return parseInt(valueStr, 10);
|
|
|
|
}
|
|
|
|
updateProperties() {
|
|
let elem = this.router.routerState.root;
|
|
while (!isNullOrUndefined(elem.firstChild)) {
|
|
elem = elem.firstChild;
|
|
}
|
|
//console.log(`!!!!!!!!!!!!!!!!!!!!!!!!!! ${JSON.stringify(elem.snapshot.paramMap)}`);
|
|
let params = elem.snapshot.paramMap;
|
|
let segment: string[] = location.pathname.split("/");
|
|
while (segment.length > 1 && (segment[0] === "" || segment[0] === environment.applName)) {
|
|
segment = segment.slice(1);
|
|
}
|
|
if (segment.length > 0) {
|
|
if (this.segment !== segment[0]) {
|
|
this.segment = segment[0];
|
|
this.segmentChange.emit(this.segment)
|
|
}
|
|
} else {
|
|
if (this.segment !== "") {
|
|
this.segment = "";
|
|
this.segmentChange.emit(this.segment)
|
|
}
|
|
}
|
|
console.log(`segment: ${JSON.stringify(this.segment)}`);
|
|
console.log(`params: ${JSON.stringify(params)}`);
|
|
|
|
|
|
|
|
let typeId = this.getIsParam(params, 'typeId');
|
|
let seriesId = this.getIsParam(params, 'seriesId');
|
|
let seasonId = this.getIsParam(params, 'seasonId');
|
|
let videoId = this.getIsParam(params, 'videoId');
|
|
|
|
this.setType(typeId);
|
|
this.setSeries(seriesId);
|
|
this.setSeason(seasonId);
|
|
this.setVideo(videoId);
|
|
}
|
|
reset():void {
|
|
this.typeId = undefined;
|
|
this.typeName = undefined;
|
|
this.typeChange.emit(this.typeId);
|
|
this.seriesId = undefined;
|
|
this.seriesName = undefined;
|
|
this.seriesChange.emit(this.seriesId);
|
|
this.seasonId = undefined;
|
|
this.seasonName = undefined;
|
|
this.seasonChange.emit(this.seasonId);
|
|
this.videoId = undefined;
|
|
this.videoName = undefined;
|
|
this.videoChange.emit(this.videoId);
|
|
}
|
|
|
|
/*
|
|
getCurrentRoute():InputOrders {
|
|
let out = new InputOrders()
|
|
out.typeId = parseInt(this.route.snapshot.paramMap.get('typeId'));
|
|
if (out.typeId === 0){
|
|
out.typeId = undefined;
|
|
}
|
|
out.seriesId = parseInt(this.route.snapshot.paramMap.get('seriesId'));
|
|
if (out.seriesId === 0){
|
|
out.seriesId = undefined;
|
|
}
|
|
out.seasonId = parseInt(this.route.snapshot.paramMap.get('seasonId'));
|
|
if (out.seasonId === 0){
|
|
out.seasonId = undefined;
|
|
}
|
|
out.videoId = parseInt(this.route.snapshot.paramMap.get('videoId'));
|
|
if (out.videoId === 0){
|
|
out.videoId = undefined;
|
|
}
|
|
return out;
|
|
}
|
|
|
|
routeTo(data:InputOrders, destination:string = null) {
|
|
routeTo = ""
|
|
//if (
|
|
this.router.navigate(['/type/' + this.typeId + '/series/' + this.idSeries + '/season/' + IdSelected ]);
|
|
}
|
|
*/
|
|
|
|
setType(id:number):void {
|
|
if(this.typeId === id) {
|
|
return;
|
|
}
|
|
this.typeId = id;
|
|
this.typeName = '??--??';
|
|
if(isUndefined(this.typeId)) {
|
|
this.typeChange.emit(this.typeId);
|
|
return;
|
|
}
|
|
let self = this;
|
|
this.typeService.get(id)
|
|
.then((response) => {
|
|
self.typeName = response.name;
|
|
self.typeChange.emit(self.typeId);
|
|
}).catch((response) => {
|
|
self.typeChange.emit(self.typeId);
|
|
});
|
|
}
|
|
getTypeId():number|undefined {
|
|
return this.typeId;
|
|
}
|
|
getTypeName():string|undefined {
|
|
return this.typeName;
|
|
}
|
|
|
|
setSeries(id:number|undefined):void {
|
|
if(this.seriesId === id) {
|
|
return;
|
|
}
|
|
this.seriesId = id;
|
|
this.seriesName = '??--??';
|
|
if(isUndefined(this.seriesId)) {
|
|
this.seriesChange.emit(this.seriesId);
|
|
return;
|
|
}
|
|
let self = this;
|
|
this.seriesService.get(id)
|
|
.then((response: NodeData) => {
|
|
self.seriesName = response.name;
|
|
self.seriesChange.emit(self.seriesId);
|
|
}).catch((response) => {
|
|
self.seriesChange.emit(self.seriesId);
|
|
});
|
|
}
|
|
getSeriesId():number {
|
|
return this.seriesId;
|
|
}
|
|
getSeriesName():string {
|
|
return this.seriesName;
|
|
}
|
|
|
|
setSeason(id:number|undefined):void {
|
|
if(this.seasonId === id) {
|
|
return;
|
|
}
|
|
this.seasonId = id;
|
|
this.seasonName = '??--??';
|
|
if(isUndefined(this.seasonId)) {
|
|
this.seasonChange.emit(this.seasonId);
|
|
return;
|
|
}
|
|
let self = this;
|
|
this.seasonService.get(id)
|
|
.then((response: NodeData) => {
|
|
// self.setSeries(response.seriesId);
|
|
self.seasonName = response.name;
|
|
self.seasonChange.emit(self.seasonId);
|
|
}).catch((response) => {
|
|
self.seasonChange.emit(self.seasonId);
|
|
});
|
|
}
|
|
getSeasonId():number {
|
|
return this.seasonId;
|
|
}
|
|
getSeasonName():string {
|
|
return this.seasonName;
|
|
}
|
|
|
|
setVideo(id:number|undefined):void {
|
|
if(this.videoId === id) {
|
|
return;
|
|
}
|
|
this.videoId = id;
|
|
this.videoName = '??--??';
|
|
if(isUndefined(this.videoId)) {
|
|
this.videoChange.emit(this.videoId);
|
|
return;
|
|
}
|
|
let self = this;
|
|
this.videoService.get(id)
|
|
.then((response) => {
|
|
// self.setSeason(response.seasonId);
|
|
// self.setSeries(response.seriesId);
|
|
self.videoName = response.name;
|
|
self.videoChange.emit(self.videoId);
|
|
}).catch((response) => {
|
|
self.videoChange.emit(self.videoId);
|
|
});
|
|
}
|
|
getVideoId():number {
|
|
return this.videoId;
|
|
}
|
|
getVideoName():string {
|
|
return this.videoName;
|
|
}
|
|
|
|
/**
|
|
* Generic navigation on the browser.
|
|
* @param destination - new destination url
|
|
* @param typeId - type IF
|
|
* @param seriesId - series real ID
|
|
* @param seasonId - season ID
|
|
* @param videoId - Video ID
|
|
* @param newWindows - open in a new windows
|
|
* @param replaceCurrentPage - consider the curent page is removed from history
|
|
*/
|
|
genericNavigate(
|
|
destination:string,
|
|
typeId:number,
|
|
seriesId:number,
|
|
seasonId:number,
|
|
videoId:number,
|
|
newWindows:boolean = false,
|
|
replaceCurrentPage: boolean = false): void {
|
|
let addressOffset = `${ destination }/${ typeId }/${ seriesId }/${ seasonId }/${ videoId }`;
|
|
if(newWindows === true) {
|
|
window.open(`/${ addressOffset}`);
|
|
} else {
|
|
this.router.navigate([ addressOffset ], { replaceUrl: replaceCurrentPage });
|
|
}
|
|
}
|
|
|
|
navigateType(id:number, newWindows:boolean, ctrl:boolean = false):void {
|
|
if(ctrl === true) {
|
|
this.navigateTypeEdit(id, newWindows);
|
|
return;
|
|
}
|
|
this.genericNavigate('type', id, null, null, null, newWindows);
|
|
}
|
|
navigateTypeEdit(id:number, newWindows:boolean):void {
|
|
this.genericNavigate('type-edit', id, null, null, null, newWindows);
|
|
}
|
|
navigateSeries(id:number, newWindows:boolean, ctrl:boolean = false):void {
|
|
if(ctrl === true) {
|
|
this.navigateSeriesEdit(id, newWindows);
|
|
return;
|
|
}
|
|
this.genericNavigate('series', this.typeId, id, null, null, newWindows);
|
|
}
|
|
navigateSeriesEdit(id:number, newWindows:boolean):void {
|
|
this.genericNavigate('series-edit', this.typeId, id, null, null, newWindows);
|
|
}
|
|
navigateSeason(id:number, newWindows:boolean, ctrl:boolean = false, replaceCurrentPage: boolean = false):void {
|
|
if(ctrl === true) {
|
|
this.navigateSeasonEdit(id, newWindows);
|
|
return;
|
|
}
|
|
this.genericNavigate('season', this.typeId, this.seriesId, id, null, newWindows, replaceCurrentPage);
|
|
}
|
|
navigateSeasonEdit(id:number, newWindows:boolean):void {
|
|
this.genericNavigate('season-edit', this.typeId, this.seriesId, id, null, newWindows);
|
|
}
|
|
navigateVideo(id:number, newWindows:boolean, ctrl:boolean = false):void {
|
|
if(ctrl === true) {
|
|
this.navigateVideoEdit(id, newWindows);
|
|
return;
|
|
}
|
|
this.genericNavigate('video', this.typeId, this.seriesId, this.seasonId, id, newWindows);
|
|
}
|
|
navigateVideoEdit(id:number, newWindows:boolean):void {
|
|
this.genericNavigate('video-edit', this.typeId, this.seriesId, this.seasonId, id, newWindows);
|
|
}
|
|
}
|