constructor(public store: Store<any[]>) {
this.filteredTodos = Observable.combineLatest(store.select('todos'), store.select('visibility'), (todos: any, visibilityFilter: any) => todos.filter(visibilityFilter.filter));
this.todos = store.select('todos');
this.visibilityFilter = store.select('visibility');
this.completedCount = this.todos.map((todos: any) => todos.reduce((count, todo) => todo.completed ? count + 1 : count, 0));
this.activeCount = this.todos.map((todos: any) => todos.length - (todos.reduce((count, todo) => todo.completed ? count + 1 : count, 0)));
}
ngOnInit() {
this.codeList = this.tagList.tags$
.map(tags => tags.map(tag => tag.id))
.switchMap(tagIds => this.codeService.getAllCodes(tagIds));
this.showList = this.codeList.map(codes => codes.length > 0);
this.showEmptyMessage = this.showList.map(showList => !showList);
}
protected handleResponse(entity: Observable<Response>): Observable<T> {
return entity.map(this.extractData)
.catch((err: any, caught: Observable<T>) => {
if (this.config.handleError) this.config.handleError(err, caught);
return Observable.throw(err);
});
}
request(url: string | Request, options?: RequestOptionsArgs): Observable<Response> {
const tokenPromise: Promise<string> = this._keycloakService.getToken();
const tokenObservable: Observable<string> = Observable.fromPromise(tokenPromise);
if (typeof url === 'string') {
return tokenObservable.map(token => {
const authOptions = new RequestOptions({headers: new Headers({'Authorization': 'Bearer ' + token})});
return new RequestOptions().merge(options).merge(authOptions);
}).concatMap(opts => super.request(url, opts));
} else if (url instanceof Request) {
return tokenObservable.map(token => {
url.headers.set('Authorization', 'Bearer ' + token);
return url;
}).concatMap(request => super.request(request));
}
}
private createRequest(type: string,data ?: Object) : Observable<any> {
let _url : string = this.buildUrl(data);
let _request : Observable<any>
let stringParam : string = '';
let _jsonBuild : any = {}
if(_url.split('?')[1] && _url.split('?')[1].length) {
(_url.split('?')[1].split('&')).forEach( _paramPart => {
_jsonBuild[_paramPart.split('=')[0]] = _paramPart.split('=')[1];
});
stringParam = JSON.stringify(_jsonBuild);
}
switch (type) {
case "post":
_request = this._http.post(_url.split('?')[0], stringParam);
break;
case "patch":
_request = this._http.patch(_url.split('?')[0], stringParam);
break;
case "put":
_request = this._http.put(_url.split('?')[0], stringParam);
break;
case "delete":
_request = this._http.delete(_url);
break;
case "head":
_request = this._http.head(_url);
break;
default:
_request = this._http.get(_url);
break;
}
this._request = _request.map((response: Response) => response.json());
return this._request;
}
export function invokeCommand<TObj extends ReactiveObject, TArg, TResult>(source: Observable<TArg>, obj: TObj, command: string | ReactiveCommand<TArg, TResult>): Observable<TResult> {
var commandObservable: Observable<ReactiveCommand<TArg, TResult>>;
var canExecute: Observable<boolean>;
var isExecuting: Observable<boolean>;
if (typeof command === "string") {
// Make sure that the current command is observed
commandObservable = obj.whenSingle(command, true).map(e => e.newPropertyValue);
canExecute = commandObservable.map(c => c.canExecute).switch();
} else {
commandObservable = Observable.of(command);
canExecute = command.canExecute;
}
var results = source
.withLatestFrom(commandObservable, canExecute, (v1, command, canExecute) => {
return {
canExecute,
command,
observedValue: v1
};
})
.filter(o => o.canExecute && o.command != null)
.distinctUntilChanged()
.flatMap(o => {
return o.command.execute(o.observedValue);
});
return results;
}
ngOnInit() {
const peopleSignal: Observable<{}> = Observable.create(observer => {
this.addNewPerson = () => observer.next();
}).share();
const startForm = [];
for (let i = 0; i < 10000; i++){
startForm[i] = new Form();
}
this.forms = peopleSignal.map(() => [new Form()])
.startWith(startForm)
.scan((acc: Form[], value) => acc.concat(value));
this.numberOfPeople = this.forms.map(forms => forms.length);
}
// TODO There has to be a better way.
/**
*
* @returns {Observable<R>}
*/
public getUserLists(): Observable<Observable<FirebaseObjectObservable<any>[]>> {
let userIdObservable: Observable<string> = this.authenticationService.observableUserId;
return userIdObservable.map((uuid) => {
return this.angularFire.database.list('users/' + uuid + '/task_lists').map((taskLists) => {
return taskLists.map((taskList) => {
return this.angularFire.database.object(TASK_LIST_METADATA_PATH + '/' + taskList['$key']);
});
});
});
}
constructor(fb: FormBuilder) {
const peopleSignal: Observable<{}> = Observable.create(observer => {
this.addNewPerson = () => observer.next();
});
this.people = peopleSignal.map(() => [new Person()])
.startWith([new Person()])
.scan((acc: Person[], value) => acc.concat(value));
}
constructor(
private _http: Http,
private _notes: NotificationsService,
private _trackService: TrackService,
private _configService: ConfigService
) {
// Api base
this._apiBase = _configService._baseApi + 'projects/';
// Local datastore
this._dataStore = {
credits: [],
trackCredits: [],
selectedTrack: undefined
};
// Credits stream
this.credits$ = new Observable(observer => this._creditsObserver = observer).share();
// Update track credits when a new track is selected
this._trackService.selectedTrack$.subscribe(selectedTrack => {
this._dataStore.selectedTrack = selectedTrack;
// Update track credits when a new track is selected
this._creditsObserver.next(this._dataStore.credits);
});
// Track credits stream
this.trackCredits$ = this.credits$.map(credits => this.getTrackCredits(credits));
// Unique credits stream
this.uniqCredits$ = this.credits$.map(credits => this.getUniqueCredits(credits));
// Unused credits stream
this.unusedCredits$ = this.credits$.map(credits => {
let uniq = this.getUniqueCredits(credits);
let trackCreds = this.getTrackCredits(credits);
return uniq.filter(x =>
trackCreds.filter(z => z.partyrealid === x.partyrealid && z.instrumentcode === x.instrumentcode).length === 0);
});
}
