We Keep Coding

Check email domain type (personal email or company email)

Example
isPersonalEmail("name#gmail.com") // true
isPersonalEmail("name#companyName.com") // false
I can't find NPM package do that
I need to check email in node.js server

I found two npm packages that you can use to achieve that:
Free Email Domains by Kiko Beats
The package is based on HubSpot-blocked domains
Email Providers by derhuerst
Provides the same solution, with the advantage of having the option to use all 4k domains in the list, or the 312 common domains only. he defines common as follows:
common.json contains those with an Majestic Million rank of < 100000.
Full Solution
I also stumbled upon a relevant issue that you might want to consider when you extract the domain.
const emailProviders = require("email-providers/all.json")
const parser = require('tld-extract');
const validator = require('validator');
const companyEmail = "name#companyName.com"
const personalEmail = "name#gmail.com"
const personalEmailWithSubdomain = "name#abc.gmail.com"
// 1. You should validate that the string is an actual email as well
// if (!validator.isEmail(email)) return error or something...
const isPersonalEmail = (email) => {
// 2. Extract the domain
const broken = email.split('#')
const address = `http://${broken[broken.length - 1]}`
const { domain } = parser(address);
// 3. And check!
return emailProviders.includes(domain)
}
console.log(isPersonalEmail(companyEmail)) // false
console.log(isPersonalEmail(personalEmail)) // true
console.log(isPersonalEmail(personalEmailWithSubdomain)) // true

Twitter style (stock) mention with Slate.js

I am building a note taking app and for text I use the Slate.js editor. Twitter mention also works with stocks like this
It basically turns into a mention if /\$[a-zA-Z]{1,6}/ is true. What I have tried is to use the normalizeNode callback to change if the regex matches, by deleting the text and inserting a new node at that location but so far I've been unsuccessful.
Slate.js also has a nice set of examples but unfortunately haven't found any of them to demonstrate what I'm trying to do. What would be a good way to go about implementing this feature? Am I wrong to assume it's through using normalizeNode?

I solved this question when working on typed in emojis. For example, when a person typed :smile: we wanted the emoji to appear (a la Slack). The only differences with stock symbols and emojis would be the stock lookup and the usage of Transforms.insertNodes instead of Transforms.insertText.
The code below should be enough to help someone solve their use case. The key is startIndex and endIndex which targets the replacement.
Here's my solution:
editor.normalizeNode = entry => {
const [node, path] = entry;
if (!Text.isText(node)) {
return normalizeNode([node, path]);
}
const emojiMatch = node.text.match(EMOJI_REGEX);
if (!emojiMatch) {
return normalizeNode([node, path]);
}
const [searchMatch, colonMatch] = emojiMatch;
const { index: startIndex } = emojiMatch;
const endIndex = startIndex + searchMatch.length;
const [matchedEmoji] = emojiIndex.search(colonMatch).map(emoji => emoji) as BaseEmoji[];
if (!matchedEmoji) {
return normalizeNode([node, path]);
}
Transforms.insertText(editor, matchedEmoji.native, {
at: {
anchor: { path, offset: startIndex },
focus: { path, offset: endIndex },
}
})
normalizeNode([node, path]);
}

Dialogflow Based on Duration

This might not be the best place to ask, but I was wondering if someone can help a new person out with fulfillment based on #sys.duration. For example, if someone responds to a prompt with 5 years or 10 months, they'll get differing replies based on those values.
I understand this may get tricky if someone replies "5 years" vs. a reply with "3 months..."
I've been using the inline editor and used the below based off of some demos and such I've found online:
const functions = require('firebase-functions');
const {dialogflow} = require('actions-on-google');
const TIME_INTENT = "Time";
const LENGTH_OF_TIME_ENTITY = "LengthOfTime";
const app = dialogflow();
app.intent(TIME_INTENT, (conv) => {
const length_of_service = conv.parameters[LENGTH_OF_TIME_ENTITY].toLowerCase();
if (length_of_time > 5) {
conv.ask("Response 1");
} else {
conv.ask("Response 2");
}
});
exports.dialogflowFirebaseFulfillment = functions.https.onRequest(app);

Looks like you're on the right track. I have a couple suggestions:
I would change the name of LENGTH_OF_TIME_ENTITY to LENGTH_OF_TIME_PARAMETER. Entities are sort of like categories that user inputs fall under, which in your case would be #sys.duration. Parameters are the actual inputs.
According to their docs the parameter you get from Dialogflow for a #sys.duration parameter is going to come in as an object that looks like {"amount":10,"unit":"min"}, so you'll want to make sure you're handling an object in that form. The Dialogflow docs are a good reference when working with system entities.
It looks like you're trying to do some sort of duration comparison. Moment.js is a frequently used library that can help with that. If you don't want to depend on a library, you'll need to roll your own solution to convert the different possible inputs you get from Dialogflow into the same unit so you can compare it to the duration cutoff you made to decide which response to use.
Putting that together, you'd do something like this:
const functions = require('firebase-functions');
const {dialogflow} = require('actions-on-google');
const moment = require('moment');
const TIME_INTENT = "Time";
const LENGTH_OF_TIME_ENTITY = "LengthOfTime";
const CUTOFF = moment.duration(5, "month");
const app = dialogflow();
app.intent(TIME_INTENT, (conv) => {
const input = conv.parameters[LENGTH_OF_TIME_ENTITY];
const length_of_service = moment.duration(input.amount, input.unit);
if (length_of_service.asSeconds() > CUTOFF.asSeconds()) {
conv.ask("Response 1");
} else {
conv.ask("Response 2");
}
});
exports.dialogflowFirebaseFulfillment = functions.https.onRequest(app);
You might need to do some conversion to get the unit strings Dialogflow uses to the form that Moment.js expects, but that should be pretty simple to do. I didn't thoroughly check the unit values for either, but something along these lines:
const toMomentUnit = (unit) => {
switch(unit) {
case "min":
return "minutes";
case "day":
return "days";
case "mo":
return "months";
case "year":
return "years";
default:
throw new Error("Unrecognized unit");
}
};

firebase -> date order reverse

I am currently making an app using Firebase.
It is one of those bulletin boards that can be seen anywhere on the web.
But there was one problem.
This is a matter of date sorting.
I want to look at the recent date first, but I always see only the data I created first.
postRef.orderByChild('createData').startAt(reverseDate).limitToFirst(1).on('child_added',(data)=>{
console.log(data.val().name + data.val().createData);
})
result - >hello1496941142093
My firebase tree
My code is the same as above.
How can I check my recent posts first?
How Do I order reverse of firebase database?

The Firebase Database will always return results in ascending order. There is no way to reverse them.
There are two common workaround for this:
Let the database do the filtering, but then reverse the results client-side.
Add an inverted value to the database, and use that for querying.
These options have been covered quite a few times before. So instead of repeating, I'll give a list of previous answers:
Display posts in descending posted order
Sort firebase data in descending order using negative timestamp
firebase sort reverse order
Is it possible to reverse a Firebase list?
many more from this list: https://www.google.com/search?q=site:stackoverflow.com+firebase+reverse%20sort%20javascript

You can simply make a function to reverse the object and then traversing it.
function reverseObject(object) {
var newObject = {};
var keys = [];
for (var key in object) {
keys.push(key);
}
for (var i = keys.length - 1; i >= 0; i--) {
var value = object[keys[i]];
newObject[keys[i]]= value;
}
return newObject;
}

This is how I solved it:
First I made a query in my service where I filter by date in milliseconds:
getImages (): Observable<Image[]> {
this.imageCollection = this.asf.collection<Image>('/images', ref => ref.orderBy('time').startAt(1528445969388).endAt(9999999999999));
this.images = this.imageCollection.snapshotChanges().pipe(
map(actions => actions.map(a => {
const data = a.payload.doc.data() as Image;
const id = a.payload.doc.id;
return { id, ...data };
}))
);
return this.images;
}
Then to get the newest date first I added this to my component where I call the method from my service:
let date = new Date;
let time = 9999999999999 - date.getTime();
console.log(time);
I pass the time let as the date. Since a newer date will be a bigger number to deduct from the 9999999999999, the newest date will turn up first in my query inside my service.
Hope this solved it for you

If you want to display it in the front end, I suggest that after you retrieve the data, use the reverse() function of JavaScript.
Example:
let result = postRef
.orderByChild("createData")
.startAt(reverseDate)
.limitToFirst(1)
.on("child_added", data => {
console.log(data.val().name + data.val().createData);
});
result.reverse();

Ive ended changing how I create my list on the frontend part.
was
posts.add(post);
changed to
posts.insert(0, post);

You could use a method where you save the same or alternate child with a negative value and then parse it.
postRef.orderByChild('createData').orderByChild('createData').on('child_added',(data)=>{
console.log(data.val().name + data.val().createData);})

Far more easier is just use Swift's reversed():
https://developer.apple.com/documentation/swift/array/1690025-reversed
https://developer.apple.com/documentation/swift/reversedcollection
let decodedIds = try DTDecoder().decode([String].self, from: value)
// we reverse it, because we want most recent orders at the top
let reversedDecodedIds = decodedIds.reversed().map {$0}

orderBy("timestamp", "desc")
I think you can give a second argument name "desc".
It worked for me

Advanced arrays and loops in Javascript

I am trying to write a complex function that involves arrays. The problem involves an (imaginary) package installer, with each package containing either 0 or 1 dependencies. The task is to order the packages and dependencies in order so that the install is successful.
The function should accept an array of strings defining dependencies. Each string contains the name of a package followed by a colon and space, then any dependencies required by that package. The program should output a comma separated list of package names in the order of install, such that a package’s dependency will always precede that package.
For example, an input of
['KittenService: ','Leetmeme: Cyberportal','Cyberportal: Ice','CamelCaser: KittenService','Fraudstream: Leetmeme','Ice: ']
should output
'KittenService, Ice, Cyberportal, Leetmeme, CamelCaser, Fraudstream'
I've got the basic steps of the function down like reversing the order of the package and dependency and eliminating the colon. However, when it comes to a more complex system like the one above, I am having trouble. Can anyone help me?

The idea is to form a directed acyclic graph (DAG) then perform a topological sorting on the graph. My solution below doesn't really form a proper DAG but it does a topological sorting using depth-first search. It works for your case. However, this won't work for all cases but you can use the two ideas above to create your own perfect version.
var input = [
'KittenService: ',
'Leetmeme: Cyberportal',
'Cyberportal: Ice',
'CamelCaser: KittenService',
'Fraudstream: Leetmeme',
'Ice: '
];
var dependencies = {};
var result = [];
// Form the dependency graph
for (var i = 0; i < input.length; i += 1) {
var inputSplit = input[i].split(':');
var key = inputSplit[0].trim();
var value = inputSplit[1].trim();
dependencies[key] = value;
}
// Depth-first search
for (var key in dependencies) {
if (dependencies.hasOwnProperty(key)) {
visit(key);
}
}
function visit(key) {
if (!dependencies.hasOwnProperty(key)) {
return;
}
if (dependencies[key] !== '') {
visit(dependencies[key]);
}
result.push(key);
delete dependencies[key];
}
console.log(result);

Here is my way to solve it, my idea was to find the dependencies using iterations. Take a look at the comments in the code
function dependencies(inputPackages){
// the final list of packages
var packages = []
// list of packages there having a dependency
var packagesWithDependency = [];
inputPackages.forEach(function(package){
package = package.split(": "); // seperate package and dependency
if(package[1] === ""){ // package has no dependencies, append it directly to list of packages
packages.push(package[0])
}else{ // package has a dependency, save it for later
packagesWithDependency.push({
package: package[0],
dependencie: package[1]
})
}
})
// while there are unresolved packages
while(packagesWithDependency.length > 0){
// we need this to check if there was found a package in this iteration
var packageWithDependencyCount = packagesWithDependency.length;
packagesWithDependency.forEach(function(packageWithDependency, index, object){
// if the dependencies for a package is found in the packages list, then add the new package, and remove it from the packagesWithDependency list
if( packages.indexOf(packageWithDependency.dependencie) >= 0 ){
packages.push(packageWithDependency.package);
object.splice(index, 1);
}
})
// if no package was resolved in this iteration, then return false, the input requires a package there wasn't specified
if(packagesWithDependency.length == packageWithDependencyCount){
return false;
}
}
// return packages // if you want the array instead
return packages.join(", ")
}
console.log(dependencies(['KittenService: ','Leetmeme: Cyberportal','Cyberportal: Ice','CamelCaser: KittenService','Fraudstream: Leetmeme','Ice: ']))
console.log(dependencies(['KittenService: ','Leetmeme: Unknown package']))
This solution can be extended to handle multiple dependencies.

Array.sort can do wonders too, and it makes your code much more concise:
function orderByDependency(input) {
return input.map(function(str, i) {
return {
dependency: str.split(': ')[1] ? str.split(': ')[1] : false,
name: str.split(': ')[0]
};
}).sort(function(a, b) {
return b.dependency === false || a.dependency == b.name;
});
}
document.body.innerHTML = orderByDependency([
'KittenService: ',
'Leetmeme: Cyberportal',
'Cyberportal: Ice',
'CamelCaser: KittenService',
'Fraudstream: Leetmeme',
'Ice: '
]).map(function(pkg) {
return '<div> Loading ' + pkg.name + '...<hr></div>';
}).join('');