in(contents): Observable<boolean> {
const data = JSON.parse(contents);
// const parsed = JSON.parse(contents);
var parsed = [];
// Save present state of Patients into Backup database
this.store.dispatch(this.backupActions.save());
// Full restore
// parsed = data.full;
parsed = data.updated;
const __ = (name, action, db, method = 'init') => {
return Observable.of(null).do(() => {
db.upsert(parsed[name], (x) => {
this.store.dispatch(action[method](db.data()));
db.save();
});
});
}
const a = __('diary', this.diaryActions, DiaryDB);
const b = __('messages', this.messagesActions, MessagesDB);
const c = __('store', this.storeActions, StoreDB);
const d = __('storeAction', this.storeActions, StoreActionDB, 'init_actions');
const x = __('sessions', this.sessionsActions, SessionsDB);
const y = __('payments', this.paymentsActions, PaymentsDB);
const z = __('patients', this.patientsActions, PatientsDB);
return Observable.concat(a, b, c, d, x, y, z)
.map(() => true)
.delay(1500)
}
constructor(private zone: NgZone) {
// Extract a typed version of navigator.serviceWorker.
this.container = navigator['serviceWorker'] as ServiceWorkerContainer;
// Final Observable that will always give back the current controlling worker,
// and follow changes over time.
this.controllingWorker = Observable
// Combine current and future controllers.
.concat(
// Current controlling worker (if any).
Observable.of(this.container.controller),
// Future changes of the controlling worker.
Observable
// Track changes of the controlling worker via the controllerchange event.
.fromEvent(this.container, 'controllerchange')
// Read the new controller when it changes.
.map(_ => this.container.controller)
)
// Cache the latest controller for immediate delivery.
.cache(1);
// To make one-off calls to the worker, awaitSingleControllingWorker waits for
// a controlling worker to exist.
this.awaitSingleControllingWorker = this
.controllingWorker
.filter(worker => !!worker)
.take(1);
// Setup the push Observable as a broadcast mechanism for push notifications.
this.push = Observable
.defer(() => this.send({cmd: 'push'}))
.share();
}
.mergeMap(({type, payload})=> {
switch (type) {
case SELECT_REDDIT:
return Observable.concat(
//isFetching true
Observable.of({type: LOADING}),
//wait 2 seconds
Observable.timer(2000),
//request posts
reddit.fetchPosts(payload)
.map((body)=>({
type: RECEIVE_POSTS,
payload: {reddit: payload, data: body.data}
})),
//isFetching false, change selected item
Observable.of({type: SELECTED_REDDIT, payload})
);
default:
return o$;
}
});
it('should emit values from sourceTwo after sourceOne when used as static method', () => {
const sourceOne = Observable.of(1,2,3);
const sourceTwo = Observable.of(4,5,6);
const example = Observable.concat(sourceOne,sourceTwo);
const values = {a: 1, b: 2, c: 3, d: 4, e: 5, f: 6};
const expected = '(abcdef|)';
expectObservable(example).toBe(expected, values);
});
public add(doc: any): Observable<FalcorJsonGraph.PathValue | FalcorJsonGraph.InvalidPath> {
let obj: any = {
_id: doc._id
};
this.options.fields.forEach((f: string): void => {
obj[f] = doc[f];
});
return Observable.concat(
this.put(obj),
Observable.from([FalcorJsonGraph.pathInvalidation([this.options.indexKey])])
);
}
.flatMap(data =>
Observable.concat(
// Form needs to be initilized first with correct values else question inputs will be empty. TODO: find better solution.
Observable.of(
initialize('application', {
characters: data.characters,
questions: data.questions,
}),
),
Observable.of({
type: GET_APPLICATION_TEMPLATE_SUCCESS,
template: data,
}),
),
let logStream = Observable.create(observer => {
// Create the subject if it doesn't exist already.
if (logSubject === null) {
logSubject = new LiteSubject<LogEntry>();
}
// An Observable representing buffered messages. Initialized to empty.
let buffered: Observable<LogEntry> = Observable.empty<LogEntry>();
// If the buffer exists, make it Observable.
if (logBuffer !== null) {
buffered = Observable.from(logBuffer);
logBuffer = null;
}
// Combine (possibly empty) buffered messages with the subject, and pipe them to the
// subscriber.
return buffered
.concat(logSubject.observable)
.subscribe(observer);
});
const op: Operation = () => Observable
.concat(
copyExistingCacheOp(oldWorker, newWorker, url, cache)(),
cacheFromNetworkOp(newWorker, url, cache)()
)
.take(1);