async function main() {
const dsClient = deepstream(process.env.DEEPSTREAM_HOST_PORT).login({
username: process.env.DEEPSTREAM_USERNAME,
password: process.env.DEEPSTREAM_PASSWORD
});
const bot = new Discord.Client();
await bot.login(process.env.DISCORD_TOKEN);
const songStateRecord = dsClient.record.getRecord('song-state');
const songState$ = dsRecordObservable(songStateRecord)
.debounceTime(500);
const messages$ = Rx.Observable.fromEvent(bot, 'message');
const lastStatusMsg$ = messages$
.filter(R.pipe(
R.prop('cleanContent'),
R.anyPass([
R.test(/^#current$/),
R.test(/^#queue$/)
])
))
.flatMap(msg => msg.channel.sendMessage('Hold on a second...'));
const lastStatusMessageCount = 3;
await Promise.all([
Rx.Observable.combineLatest(
lastStatusMsg$
// like bufferCount(), but starts immediately
// (even with less than N elements)
.scan(
R.flip(R.compose(
R.takeLast(lastStatusMessageCount),
R.append
)),
[]
),
songState$
)
.flatMap(([msgs, songState]) =>
Promise.all(msgs.map(msg =>
msg.edit(songStateAsText(songState))
))
)
.toPromise(),
songState$
.flatMap(songState =>
bot.user.setGame(songState.currentSong)
)
.toPromise()
]);
}
AttachmentService.prototype.saveModel = function (model) {
if (!model) {
return Rx_1.Observable.of(false);
}
return Rx_1.Observable.create(function (observer) {
var formData = new FormData(), xhr = new XMLHttpRequest();
formData.append("id", model.id);
formData.append("name", model.name);
formData.append("metaObjectId", model.metaObjectId);
formData.append("objectId", model.objectId);
if (model.file) {
formData.append("file", model.file, model.file.name);
}
else {
formData.append("file", null);
}
xhr.onreadystatechange = function () {
if (xhr.readyState === 4) {
if (xhr.status === 200) {
observer.next(true);
observer.complete();
}
else {
observer.next(false);
observer.complete();
}
}
};
xhr.open('POST', '/api/attachment', true);
xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
xhr.withCredentials = true;
xhr.send(formData);
});
};
.mergeMap(action => {
if (!action.url) return Rx.Observable.never()
const cmdParam = getUrlParamValue('cmd', action.url)
if (!cmdParam || cmdParam[0] !== 'play') return Rx.Observable.never()
const cmdCommand = getSettings(store.getState()).cmdchar + cmdParam[0]
const cmdArgs =
getUrlParamValue('arg', decodeURIComponent(action.url)) || []
const fullCommand = `${cmdCommand} ${cmdArgs.join(' ')}`
return Rx.Observable.of({ type: SET_CONTENT, ...setContent(fullCommand) })
})
setTimeout(function() {
source$.subscribe({
next: function(item) {
console.log(item)
}
})
}, 4000)
NotificationService.prototype.startRandomGeneration = function () {
var _this = this;
this.randomSub = Rx_1.Observable.interval(5000).subscribe(function () {
var notification = _this.createRandomNotification();
_this.addNotification(notification);
});
};
function AutocompleteWidgetComponent(elementRef, http) {
var _this = this;
this.elementRef = elementRef;
this.delay = 300;
this.dropdown = false;
this.jsonData = [];
this.products = [];
this.productCategories = [];
this.http = http;
// this.data.push(true);
// this.data.push(1111);
// this.data.push(111.1);
// this.data.push('string');
// this.stringFunction(this.data[0].toString());
var eventStream = Rx_1.Observable.fromEvent(elementRef.nativeElement, 'keyup')
.map(function () { return _this.query; })
.debounceTime(this.delay)
.distinctUntilChanged();
// eventStream.subscribe(input => this.value.emit(input));
eventStream.subscribe(function (input) {
console.log(input);
if (_this.dropdown === false) {
_this.toggleDropdown();
}
});
}
sendSms(configFile, destinationPhone, message) {
return Rx.Observable.create(s => {
const gammu = spawn(`gammu`, [`-c`, configFile, `sendsms`, 'TEXT', destinationPhone, '-text', message]);
gammu.stderr.on('data', data => {
let message = data.toString().trim();
if (message.startsWith("If you want break")
|| message.startsWith("Sending SMS")) {
}
else {
s.error(new Error(message));
}
});
gammu.stdout.on('data', data => {
let message = String(data);
if (message.startsWith("Sending SMS")
|| message.startsWith("....waiting for network answer")
|| message.startsWith("..error")) {
}
else if (message.startsWith("..OK")) {
s.next(true);
}
else {
s.error(new Error(message));
}
});
gammu.on('close', code => {
s.complete();
});
});
}
this.catchBadResponse = function (errorResponse) {
var res = errorResponse;
var err = res.json();
var emsg = err ?
(err.error ? err.error : JSON.stringify(err)) :
(res.statusText || 'unknown error');
console.log("err: " + err.error);
//this._toastService.activate(`Error - Bad Response - ${emsg}`);
return Rx_1.Observable.throw(emsg); // TODO: We should NOT swallow error here.
// return Observable.of();
};
superagent.Request.prototype.observe = function () {
return Rx.Observable.create(observer => {
this.end((err, res) => {
if (err) {
observer.error(err);
} else {
observer.next(res);
}
observer.complete();
});
});
};
isExists(filePath) {
return Rx.Observable.create(s => {
fs.stat(filePath, (err, stats) => {
if (err) {
s.next(false);
}
else {
s.next(true);
}
});
});
}
identify(configFile) {
return Rx.Observable.create(s => {
const gammu = spawn(`gammu`, [`-c`, configFile, `--identify`]);
gammu.stderr.on('data', data => {
s.error(new Error(String(data)));
});
gammu.stdout.on('data', data => {
s.next(String(data));
});
gammu.on('close', code => {
s.complete();
});
});
}
getUSSD(configFile, ussdCommand) {
return Rx.Observable.create(s => {
const gammu = spawn(`gammu`, [`-c`, configFile, `getussd`]);
gammu.stderr.on('data', data => {
s.error(new Error(String(data)));
});
gammu.stdout.on('data', data => {
s.next(String(data));
});
gammu.on('close', code => {
s.complete();
});
});
}
DesktopCameraService.prototype.getPhoto = function () {
var _this = this;
return Observable.create(function (observer) {
_this.getMediaDevices()
.getUserMedia({ video: true, audio: false })
.then(function (stream) {
var vendorURL = window.URL || window.webkitURL;
var doc = document;
var videoElement = doc.createElement('video');
videoElement.src = vendorURL.createObjectURL(stream);
videoElement.play();
var takePhotoInternal = function () {
var canvasElement = doc.createElement('canvas');
canvasElement.setAttribute('width', videoElement.videoWidth.toString());
canvasElement.setAttribute('height', videoElement.videoHeight.toString());
setTimeout(function () {
var context = canvasElement.getContext('2d');
context.drawImage(videoElement, 0, 0, videoElement.videoWidth, videoElement.videoHeight);
var url = canvasElement.toDataURL('image/png');
videoElement.pause();
if (stream.stop) {
stream.stop();
}
if (stream.getAudioTracks) {
stream.getAudioTracks().forEach(function (track) {
track.stop();
});
}
if (stream.getVideoTracks) {
stream.getVideoTracks().forEach(function (track) {
track.stop();
});
}
observer.next(url);
observer.complete();
}, 500);
};
if (videoElement.readyState >= videoElement.HAVE_FUTURE_DATA) {
takePhotoInternal();
}
else {
videoElement.addEventListener('canplay', function () {
takePhotoInternal();
}, false);
}
}, (function (error) {
console.log(error);
}));
});
};
DocumentService.prototype.handleError = function (error) {
// In a real world app, we might use a remote logging infrastructure
var errMsg;
if (error instanceof http_1.Response) {
var body = error.json() || '';
var err = body.error || JSON.stringify(body);
errMsg = error.status + " - " + (error.statusText || '') + " " + err;
}
else {
errMsg = error.message ? error.message : error.toString();
}
console.error(errMsg);
return Rx_1.Observable.throw(errMsg);
};
exports.watch = function watch() {
return Rx.Observable.create(observer => {
const ignored = [/[\/\\]\./];
if (watchIgnores) {
ignored.push(...watchIgnores.split(','));
}
console.log('Watching directory', watchDirectory, 'ignoring', ignored);
chokidar.watch(watchDirectory, {ignored})
.on('add', path => {
observer.next(path);
})
.on('error', error => {
observer.error(error);
});
});
};
readAllSms(configFile) {
return Rx.Observable.create(s => {
let completeText = '';
const gammu = spawn(`gammu`, [`-c`, configFile, `getallsms`]);
gammu.stderr.on('data', data => {
s.error(new Error(String(data)));
});
gammu.stdout.on('data', data => {
completeText = completeText + String(data);
});
gammu.on('close', code => {
s.next(completeText);
s.complete();
});
});
}
export const login = (creds) => {
const login$ = Rx.Observable.fromPromise(POST('/session', creds))
.map(res => {
if (!res.token) {
throw new Error(res.error)
}
localStorage.setItem('accesstoken', res.token)
return res
})
.catch(e => {
return Rx.Observable.of({error: e.message})
})
.share()
newStateObservable(login$)
return login$
}
export const register = (creds) => {
const register$ = Rx.Observable.fromPromise(POST('/user', creds))
.map(res => {
if (!res[0]) {
console.log(res)
throw new Error(res.error)
}
console.log('hi from register')
return {message: 'You may now log in!'}
})
.catch(e => {
return Rx.Observable.of({error: e.message})
})
.share()
newStateObservable(register$)
return register$
}
deleteAllSms(configFile, startLocation, endLocation) {
return Rx.Observable.create(s => {
const gammu = spawn(`gammu`, [`-c`, configFile, `deletesms`, startLocation, endLocation]);
gammu.stderr.on('data', data => {
s.error(String(data));
});
gammu.stdout.on('data', data => {
let message = String(data);
if (message.length > 0) {
s.error(new Error(message));
}
else {
s.next(true);
}
});
gammu.on('close', code => {
s.complete();
});
});
}
const store = (layoutSubject, selectionSubject) => {
const state = {
vertices: [],
edges: [],
width: 0,
height: 0
}
const subject = new Rx.BehaviorSubject({state, changed: false})
Rx.Observable.zip(layoutSubject, selectionSubject).subscribe(([layout, selection]) => {
if (!layout.changed && !selection.changed) {
subject.next({state, changed: false})
return
}
update(state, layout.state, selection.state)
subject.next({state, changed: true})
})
return subject
}
.catch(e => {
return Rx.Observable.of({error: e.message})
})
import Rx from 'rxjs/Rx'
import {POST} from './rest.js'
import {newStateObservable} from './state.js'
// If window localstorage changes, update access token
const storage$ = Rx.Observable.fromEvent(window, 'storage')
.map(_ => ({token: localStorage.getItem('accesstoken')}))
newStateObservable(storage$)
export const register = (creds) => {
const register$ = Rx.Observable.fromPromise(POST('/user', creds))
.map(res => {
if (!res[0]) {
console.log(res)
throw new Error(res.error)
}
console.log('hi from register')
return {message: 'You may now log in!'}
})
.catch(e => {
return Rx.Observable.of({error: e.message})
})
.share()
newStateObservable(register$)
return register$
}
export const login = (creds) => {
const login$ = Rx.Observable.fromPromise(POST('/session', creds))
import _ from 'ramda';
const parentNode = document.getElementById('root');
const addToDom = child => parentNode.appendChild(child);
const domElement = (name) => {
const li = document.createElement('li');
li.innerHTML = name;
return li;
};
// _.prop returns a property from an object
const createlistItem = _.compose(domElement, _.prop('name'));
const url = user =>
(`https://api.github.com/users/${user}/repos`);
export const getData = _.compose(axios.get, url);
export const app = Rx.Observable.fromPromise(getData('epicallan'));
app
.map(response => response.data)
.flatMap(data => Rx.Observable.from(data))
.take(5)
.map(repoObj => createlistItem(repoObj))
.subscribe(
item => addToDom(item)
);
.flatMap(data => Rx.Observable.from(data))
//// ----------------- throw() ------------------
// Rx.Observable.throw(new Error('something bad'))
// .subscribe(createSubscriber('error'));
//// ----------------- empty(), never() ------------------
// // empty() does NOT produce item, but DO complete
// Rx.Observable.empty()
// .subscribe(createSubscriber('empty'));
// // never() does NOT produce item, does NOT complete
// Rx.Observable.never()
// .subscribe(createSubscriber('never'));
//// ----------------- defer() ------------------
//// - create observable from side effects
// let sideEffect = 0;
// const defer$ = Rx.Observable.defer(()=> {
// ++sideEffect;
// return Rx.Observable.of(sideEffect);
// });
//
// defer$.subscribe(createSubscriber('defer$.one'));
// defer$.subscribe(createSubscriber('defer$.two'));
// defer$.subscribe(createSubscriber('defer$.three'));
//// ----------------- range() ------------------
Rx.Observable.range(10, 10)
.subscribe(createSubscriber('range'));
PersonService.prototype.retrievePeople = function () {
return Rx_1.Observable.forkJoin(this.http.get('./app/people.json').map(function (res) { return res.json(); }), this.http.get('./app/people2.json').map(function (res) { return res.json(); }));
};
'use strict';
const Rx = require('rxjs/Rx');
const timeStart = Date.now();
const source = Rx.Observable.range(1, 5)
.do(value => console.log(`processing value ${value}`))
.observeOn(Rx.Scheduler.asap)
console.log('before subscribe');
source.subscribe(x => console.log(`next ${x}`),
error => console.error(error),
() => console.log(`Total time: ${Date.now() - timeStart}ms`));
console.log(`after subscribe`);
LoginService.prototype.handleErrors = function (error) {
console.log(JSON.stringify(error.json()));
return Rx_1.Observable.throw(error);
};
'use strict';
var Rx = require('rxjs/Rx');
console.log('start');
var source = Rx.Observable.of(1,2,3);
var subscription = source.subscribe(
function (x) {
console.log('Next: ' + x);
},
function (err) {
console.log('Error: ' + err);
},
function () {
console.log('Completed');
});
console.log('done');
AttachmentService.prototype.deleteModel = function (id) {
if (!id) {
return Rx_1.Observable.of(false);
}
return this.http.delete('/api/attachment/' + id).map(function (res) { return res.ok; });
};