resolve(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<ICartaoCredito> {
const id = route.params['id'] ? route.params['id'] : null;
if (id) {
return this.service.find(id).pipe(
filter((response: HttpResponse<CartaoCredito>) => response.ok),
map((cartaoCredito: HttpResponse<CartaoCredito>) => cartaoCredito.body)
);
}
return of(new CartaoCredito());
}
async allocate(binderOpts: BinderOptions): Promise<ServerConfig> {
let original = this.get(binderOpts);
switch (original.type) {
case UP:
// cache hit with an UP server, check if it's really up
const isUp = await this.checkUp(original);
if (isUp) {
// It is so we can plow forward
return original.config;
}
// Otherwise we need to make a new server
break;
case NOHOST:
// Definitely need to launch
break;
case PROVISIONING:
// Wait for the provisioning server to get up
while (original.type !== UP) {
await sleep(1000);
// NOTE: Could do coordination here by recording timestamps in the PROVISIONING type
// At the very least there should come a point we time out at
original = this.get(binderOpts);
}
if (original && original.type === UP) {
return original.config;
}
}
const host = await binder(binderOpts)
.pipe(
tap(x => {
// Log binder messages to the console for debuggability
console.log("%c BINDER MESSAGE", "color: rgb(87, 154, 202)");
console.log(x);
}),
filter(msg => msg.phase === "ready"),
map(msg => makeHost({ endpoint: msg.url, token: msg.token }))
)
.toPromise();
if (
!host.config ||
!host.config.endpoint ||
!host.config.token ||
!host.config.crossDomain
) {
throw new Error(`Bad host created: ${JSON.stringify(host, null, 2)}`);
}
this.set(binderOpts, host);
return host.config;
}
ngOnInit() {
const end$ = this.router.events.pipe(
filter(e => e instanceof NavigationEnd || e instanceof NavigationCancel || e instanceof NavigationError)
);
this.progress$ = this.router.events.pipe(
filter(e => e instanceof NavigationStart), // trigger the emission when a navigation starts
switchMap(() => merge( // then emit every 500ms, and when the navigation ends or cancels or errors. This delay must
// match the transition duration in the .scss file
timer(0, 500).pipe(
map(i => 100 - (100 / Math.pow(2, i))), // emit 0 then 50, 75, 87.5, etc.
takeWhile(i => i < 99.95), // stop because that just triggers change detection with no visual change anymore
takeUntil(end$), // but stop emitting every 500ms when the navigation ends or cancels or errors
map(i => ({ value: i }))
),
end$.pipe(first(), map(() => null)) // set back to null when the navigation ends or cancels or errors to hide
// the progress bar
))
);
}
watchForRawEvents(logger: RawEventLogger, topicFilter: string, topicPrefix: string) {
this.communicationManager
.observeRaw(this.identity, topicFilter)
// Note that all published raw messages are dispatched on all raw observables!
.pipe(filter(([topic]) => topic.startsWith(topicPrefix)))
.subscribe(([topic, payload]) => {
logger.count++;
// Raw values are emitted as tuples of topic name and Uint8Array/Buffer payload
logger.eventData.push([topic, payload.toString()]);
});
}
checkStore(panelId: number, boardId: number): Observable<boolean> {
return this.store.select(fromStore.getBoardLoaded).pipe(
tap(loaded => {
if (!loaded || !this.hasBoardInStore(boardId)) {
this.store.dispatch(new fromStore.LoadBoard({ panelId, boardId }));
}
}),
filter(loaded => loaded),
take(1)
);
}
checkStore(): Observable<boolean>{
return this.store.select(fromStore.getPizzasLoaded).pipe(
tap(loaded => {
if(!loaded){
this.store.dispatch(new fromStore.LoadPizzas());
}
}),
filter(loaded => loaded),
take(1)
)
}
/** A helper function to get descendants recursively. */
protected _getDescendants(descendants: T[], dataNode: T): void {
descendants.push(dataNode);
const childrenNodes = this.getChildren(dataNode);
if (Array.isArray(childrenNodes)) {
childrenNodes.forEach((child: T) => this._getDescendants(descendants, child));
} else if (childrenNodes instanceof Observable) {
childrenNodes.pipe(take(1), filter(Boolean)).subscribe(children => {
children.forEach((child: T) => this._getDescendants(descendants, child));
});
}
}
private _observeDiscoverIdentity() {
this._discoverIdentitySubscription =
this.communicationManager.observeDiscover(this.identity)
.pipe(filter(event =>
(event.eventData.isDiscoveringTypes &&
event.eventData.isCoreTypeCompatible("Component")) ||
(event.eventData.isDiscoveringObjectId &&
event.eventData.objectId === this.identity.objectId)))
.subscribe(event =>
event.resolve(ResolveEvent.withObject(this.identity, this.identity)));
}
function factory(
observable: Observable<SubjectPayload<string, any, any>>,
initialState: number,
) {
return {
view: observable.pipe(
filter(args => args.type === 'test'),
mapTo(1),
),
};
}
checkStore(): Observable<boolean> {
return this.store.select(getUserLoaded).pipe(
tap(loaded => {
if (!loaded) {
this.store.dispatch(new LoadUsers());
}
}),
filter(loaded => loaded),
take(1)
);
}
