RxJS Observable reset timeout - timeout

Is it possible to reset/increase the timeout of an Observable after another timeout has already been set? In the following example the timeout of 5 should be overriden with a timeout of 9999, but this does not work:
var source = Rx.Observable
.return(42)
.delay(1000)
.timeout(5)
.timeout(9999); // this statement should override the previous set timeout of 5 MS, but actually it does not
var subscription = source.subscribe(
function (x) {
console.log('Next: ' + x);
},
function (err) {
console.log('Error: ' + err);
},
function () {
console.log('Completed');
});
Are there any possibilities to override the already set timeout?

Short answer: As far as I know, there is no "legit" solution to this.
Hacky answer: You could connect to the source of the timeout-ed stream and set your own timeout, see the example below how this could be done.
However, I would not advise you to do that in any seriouse project - I'm sure there should be another solution to your problem.
var base = Rx.Observable
.return(42)
.delay(1000)
.timeout(1);
var patched = base.source.timeout(2000);
var subscription = patched.subscribe(
function (x) {
console.log('Patched Next: ' + x);
},
function (err) {
console.log('Patched Error: ' + err);
},
function () {
console.log('Patched Completed');
});
var subscription = base.subscribe(
function (x) {
console.log('Base Next: ' + x);
},
function (err) {
console.log('Base Error: ' + err);
},
function () {
console.log('Base Completed');
});
<script src="https://cdnjs.cloudflare.com/ajax/libs/rxjs/4.1.0/rx.all.js"></script>

What about if you use a subject to represent your timeout value?
timeoutSubject = new Rx.ReplaySubject(1);
timeoutSubject
.asObservable()
.switchMap((v) => source.timeout(v))
.subscribe((r) => console.log(r));
timeoutSubject.next(5);
timeoutSubject.next(9999);
switchMap should take handle of the unsubscribing/resubscribing for each one of the timeout values.

Related

How can I get the result of geolocation

navigator.geolocation.getCurrentPosition requires three parameters success, fail and options.
What I want to get is the result of position. I have try return the position by success function, but it returns 'undefined'
function success(pos) {
var crd = pos.coords;
console.log('Your current position is:');
console.log('Latitude : ' + crd.latitude);
console.log('Longitude: ' + crd.longitude);
console.log('More or less ' + crd.accuracy + ' meters.');
return pos;
};
pos = navigator.geolocation.getCurrentPosition(success, error, options);
console.log('pos', pos);
The getCurrentPosition returns the Position object back in the success handler
https://developer.mozilla.org/en-US/docs/Web/API/Geolocation/getCurrentPosition
if you wanted to refer to position later on the only way would be storing it in a global variable and using it later. Just remember the global will not be initialised until after the success callback.
var g_pos;
function error(e){
alert(e);
}
function success(pos) {
var crd = pos.coords;
g_pos = pos; // assign to global
console.log('Your current position is:');
console.log('Latitude : ' + crd.latitude);
console.log('Longitude: ' + crd.longitude);
console.log('More or less ' + crd.accuracy + ' meters.');
return pos;
};
var options = {
enableHighAccuracy: true,
timeout: 5000,
maximumAge: 0
};
navigator.geolocation.getCurrentPosition(success, error, options);
//hint type g_pos in console after and you can see the position object.

How to prevent multiple instances in Electron

I do not know if this is possible but I might as well give it a chance and ask.
I'm doing an Electron app and I'd like to know if it is possible to have no more than a single instance at a time.
I have found this gist but I'm not sure hot to use it. Can someone shed some light of share a better idea ?
var preventMultipleInstances = function(window) {
var socket = (process.platform === 'win32') ? '\\\\.\\pipe\\myapp-sock' : path.join(os.tmpdir(), 'myapp.sock');
net.connect({path: socket}, function () {
var errorMessage = 'Another instance of ' + pjson.productName + ' is already running. Only one instance of the app can be open at a time.'
dialog.showMessageBox(window, {'type': 'error', message: errorMessage, buttons: ['OK']}, function() {
window.destroy()
})
}).on('error', function (err) {
if (process.platform !== 'win32') {
// try to unlink older socket if it exists, if it doesn't,
// ignore ENOENT errors
try {
fs.unlinkSync(socket);
} catch (e) {
if (e.code !== 'ENOENT') {
throw e;
}
}
}
net.createServer(function (connection) {}).listen(socket);;
});
}
There is a new API now: requestSingleInstanceLock
const { app } = require('electron')
let myWindow = null
const gotTheLock = app.requestSingleInstanceLock()
if (!gotTheLock) {
app.quit()
} else {
app.on('second-instance', (event, commandLine, workingDirectory) => {
// Someone tried to run a second instance, we should focus our window.
if (myWindow) {
if (myWindow.isMinimized()) myWindow.restore()
myWindow.focus()
}
})
// Create myWindow, load the rest of the app, etc...
app.on('ready', () => {
})
}
Use the makeSingleInstance function in the app module, there's even an example in the docs.
In Case you need the code.
let mainWindow = null;
//to make singleton instance
const isSecondInstance = app.makeSingleInstance((commandLine, workingDirectory) => {
// Someone tried to run a second instance, we should focus our window.
if (mainWindow) {
if (mainWindow.isMinimized()) mainWindow.restore()
mainWindow.focus()
}
})
if (isSecondInstance) {
app.quit()
}

Failing Parse background job when using beforesave with thousands of objects

I am using a background job to query a json with thousands of objects to initially populate my database. I have also implemented the beforesave function to prevent any duplicate entries. However, once I implemented this, it seems my background job called response.error and does not save all objects. It looks like I might be exceeding the requests/sec? I would really appreciate if someone could take a look at my code and tell me why it is not saving all entries successfully.
Here is my background job:
Parse.Cloud.job("testing", function(request, response) {
var json;
Parse.Cloud.httpRequest({
url: stringURL + pageNumber.toString(),
success: function(httpResponse) {
json = httpResponse.data;
console.log("total is: " + json["meta"].total);
console.log("object 1 is: " + json["events"][1].title);
return json;
}
//after getting the json, save all 1000
}).then(function() {
//helper function called
saveObjects(json).then(function() {
response.success("success");
},
function(error) {
response.error("nooooo");
});
});
});
function saveObjects(json) {
var promises = [];
for(var i = 0; i < 1000; i++) {
var newEvent = new Event();
promises.push(newEvent.save(new Event(json["events"][i])));
}
return Parse.Promise.when(promises);
}
Here is my beforesave code:
Parse.Cloud.beforeSave("Event", function(request, response) {
var newEvent = request.object;
var Event = Parse.Object.extend("Event");
var query = new Parse.Query("Event");
query.equalTo("title", newEvent.get("title"));
query.equalTo("datetime_utc", newEvent.get("datetime_utc"));
query.equalTo("url", newEvent.get("url"));
query.first({
success: function(temp) {
response.error({errorCode:123,errorMsg:"Event already exist!"});
},
error: function(error) {
response.success();
}
});
});
Thanks I really appreciate any help... I've been stuck for a while.
If it's a request rate issue, then you could probably use something like node-function-rate-limit but it's fairly simple to write your own rate limiting batcher. See doInBatches() below.
Also, when using promise-returning methods that also offer a "success:..." callback, it's better not to mix the two styles. It may behave as expected but you are denied the opportunity to pass results from the "success:..." callback to the rest of the promise chain. As you can see below, the "success:..." code has simply been shuffled into the .then() callback.
Parse.Cloud.job("testing", function(request, response) {
Parse.Cloud.httpRequest({
url: stringURL + pageNumber.toString()
}).then(function(httpResponse) {
var json = httpResponse.data;
// console.log("total is: " + json.meta.total);
// console.log("object 1 is: " + json.events[1].title);
/* helper function called */
doInBatches(json.events, 30, 1000, function(evt, i) {
var newEvent = new Event();
return newEvent.save(new Event(evt));
}).then(function() {
response.success('success');
}, function(error) {
response.error('nooooo');
});
});
});
// Async batcher.
function doInBatches(arr, batchSize, delay, fn) {
function delayAsync() {
var p = new Parse.Promise();
setTimeout(p.resolve, delay);
return p;
}
function saveBatch(start) {
if(start < arr.length) {
return Parse.Promise.when(arr.slice(start, start+batchSize).map(fn))
.then(delayAsync) // delay between batches
.then(function() {
return saveBatch(start + batchSize);
});
} else {
return Parse.Promise.as();
}
}
return saveBatch(0);
}
I can't see how or why the beforesave code might affect things.

Remove event handler from memory (ortc) , titanium

I have a memory leak:
var ortc = require("co.realtime.ortc");
function ortcNot() {
ortc.clusterUrl = 'http://ortc-developers.realtime.co/server/2.2';
ortc.connectionMetadata = 'Titanium Example';
ortc.addEventListener('onException', function(e) {
Ti.API.info('Exception: ' + e.info);
});
ortc.addEventListener('onConnected', function(e) {
Ti.API.info('Connected to ORTC server');
ortc.subscribe('yellow24', true);
});
ortc.addEventListener('onDisconnected', function(e) {
Ti.API.info('Disconnected from ORTC');
//remove event handlers
//ortc = null;
});
ortc.addEventListener('onSubscribed', function(e) {
Ti.API.info('Subscribed to: ' + e.channel);
Ti.API.info('Sending a message to: ' + e.channel);
//ortc.send(e.channel, 'Message from iPhone');
});
ortc.addEventListener('onUnsubscribed', function(e) {
Ti.API.info('Unsubscribed from: ' + e.channel);
ortc.disconnect();
});
ortc.addEventListener('onMessage', function(e) {
Ti.API.info('Message received: ' + e.message + ' at channel: ' + e.channel);
//parse message
var message = JSON.parse(e.message);
alert(message.user.message);
//check chat id
if (message.id == args.chatId) {
recieveMessage(message);
}
//ortc.unsubscribe(e.channel);
Ti.API.info(ortc.isConnected());
});
ortc.connect('yellow2');
}
ortcNot();
When I close my controller window, then reopen the window. The old event listeners are still in memory, causing duplicate event listeners to be created.
Any idea why this is happening,and how to solve it? Thanks
Instead of defining listeners with an in-built function, always declare them to a calling function.
To remove an eventListener it has to be identical in both addEventListener and removeEventListener, declaring it as a function and assigning this to the eventListener gets around this. e.g.
var viewObject = null;
function eventTodo(){
// do stuff here ...
viewObject.removeEventListener('click', eventTodo);
}
function addListener() {
viewObject = Ti.UI.createView();
viewObject.addEventListener('click', eventTodo);
 return viewObject;
}
When you close the window you are not calling the removeEventLister which is why every time the window is opened the events are being duplicated. Attach an close event to the window object in question that calls a function to remove all the eventListeners thus removing them from the applications memory.

Override Minimum length string of Select2

Select2 Jquery Plugin
I was having hard time how to override the default message for minimum length input in jquery Select2.
by default the plugin gives the following message.
Default Text
Please enter 1 more characters
My requirement was to show, the following text
Required Text
Enter 1 Character
please share the solution.
Thanks.
The accepted answer does not work for Select2 v4. Expanding on the comment by #IsaacKleinman, the way to override the default messages for an individual Select2 instance is through the language property:
var opts = {
language: {
inputTooShort: function(args) {
// args.minimum is the minimum required length
// args.input is the user-typed text
return "Type more stuff";
},
inputTooLong: function(args) {
// args.maximum is the maximum allowed length
// args.input is the user-typed text
return "You typed too much";
},
errorLoading: function() {
return "Error loading results";
},
loadingMore: function() {
return "Loading more results";
},
noResults: function() {
return "No results found";
},
searching: function() {
return "Searching...";
},
maximumSelected: function(args) {
// args.maximum is the maximum number of items the user may select
return "Error loading results";
}
}
};
$('#mySelect').select2(opts);
To override the functions globally, call the set function on the defaults (according to the docs):
$.fn.select2.defaults.set("key", "value")
However, in our code we do it like this:
$.fn.select2.defaults.defaults['language'].searching = function(){
return 'Custom searching message'
};
I don't know why we don't follow the docs, but it works.
Solution
Here is the solution that i have found out.
Prior to v4
Initialize
$("input[name='cont_responsible'],input[name='corr_responsible'],input[name='prev_responsible'],input[name='pfmea_responsible']").select2({
minimumInputLength: 1,
formatInputTooShort: function () {
return "Enter 1 Character";
},
});
Note
Do not forget to add this code in your document. ready function.
$(document).ready(function () {
});
I shared my solution, any better solutions are welcome.
Thanks.
Using v4 and onwards
The following worked for V4. #Isaac Kleinman
language: { inputTooShort: function () { return ''; } },
You can try this on version 4.0 or higher
you can see reference for answer frome this link :
issues reference
$("#select2").select2({
minimumInputLength: 1,
language: {
inputTooShort: function() {
return 'Please Add More Text';
}
}
});
If you are using django-select2, just add attributes to your form in forms.py:
widget=BookSelect2Widget(
attrs={'data-minimum-input-length': 1}
)
Override the function behaviour like below
$.fn.select2.defaults = $.extend($.fn.select2.defaults, {
formatMatches: function(matches) {
return matches + $filter('translate')('label.matches.found');
},
formatNoMatches: function() {
return $filter('translate')('noMatches.found');
},
formatInputTooShort: function(input, min) {
var n = min - input.length;
return $filter('translate')('label.please.enter ') + n + $filter('translate')(' more.characters') + (n == 1 ? "" : "s");
},
formatInputTooLong: function(input, max) {
var n = input.length - max;
return $filter('translate')('please.delete ') + n + $filter('translate')('')('delete.characters') + (n == 1 ? "" : "s");
},
formatSelectionTooBig: function(limit) {
return $filter('translate')('select.only') + limit + $filter('translate')('select.item ') + (limit == 1 ? "" : "s");
},
formatLoadMore: function(pageNumber) {
return $filter('translate')('load.results');
},
formatSearching: function() {
return $filter('translate')('label.search');
}
});
}

Resources