DEV Community: TephlonDude

2021: The Year to Automate the New You with n8n ☀️

TephlonDude — Mon, 18 Jan 2021 07:29:04 +0000

The occasional indulgence is a good thing. The keyword there is “occasional”. I have found that with all of the strangeness that has gone on over the past year, it has become easier for me to indulge myself.

Should I go out for a run? No, better “stay safe” and stay home baking the umpteenth batch of decadent cookies. Should I order that amazing new life-changing self-improvement book all my friends have been recommending to me? Naw, I’m already paying for all these streaming services and I’m sure that I will find something to watch that won’t put me into a coma.

Sometimes, all it takes to get out of these ruts is a little nudge. A bit of a prod to move you closer where you know you should be mentally and physically.

To assist with this, n8n has put together a list of five workflows that can help you to meet your New Year’s resolution and start you on some great new habits.

New Recipes Emailed Daily

Many of us want to start eating better in the new year. The holiday season tends to be a time when we allow ourselves to indulge in foods which may not be extremely healthy.

Example Recipe from Edamam

The challenge comes when trying to figure out what healthy meals to make. It is too easy to simply say, “I don’t know what to make for supper so I will eat this entire family-sized back of potato chips instead!”.

The Daily Recipe Email workflow allows you to configure what type of meals you would like to eat. It will then daily send you three recipes from Edamam so that you can pick up groceries on the way home and make a healthy meal.

Tracking Your (Crypto) Finances

With Bitcoin reaching records highs over the last number of weeks, cryptocurrency is becoming more and more attractive when it comes to investing.

Example AirTable Cryptocurrency Portfolio

Using the CoinGecko node, the Crypto Portfolio Tracking workflow, you can set up your cryptocurrency portfolio! Watch all of the ups and downs as it records the running value of your crypto assets. It also shows you which of your assets are up and which ones are losing you money.

Automate Your Task Planning

Sometimes we feel like there is not enough time at the end of the day. One of the reasons this happens is because we do not plan or organize the tasks that we need to complete. Often, it is something that is mentioned to us as we are passing in the hallway which you completely forgot about by the time you got back to your office.

ClickUp with Automated Tasks

But, if you set up a workflow that uses a Typeform web form to gather the information about the task request directly from the user and then categorizes it properly into ClickUp, not only do you not need to remember the task, you don’t have to do the data entry, saving you time.

Get Daily Work-Out Encouragement

With so many of us at home or working in offices, it can be difficult to get motivated to get up and get moving. “I’ll just sit here rather than getting up and going for a walk. Who’s going to know?”

Sample Strava Activities‌‌

If you are using the Activity Encouragement workflow, the answer is at least three people! This workflow monitors your Strava account and checks to see if you have been active enough that day. If not, it will send an email to three of your friends who will reach out to you with words of (we hope) encouragement!

Summary

It is really easy for me to get into a routine that does not contribute to me being the best version of myself. I have found that little nudges from friends, family and, yes, even computers can make a huge difference in shaking me out of my “lather, rinse, repeat” life so that I can pursue becoming the person I know that I can be. My hope is that some of these tools that I have presented to you here can do that for you as well.

Do you have an amazing idea of how to make the New Year fantastic using n8n? Feel free to message me on Twitter or ask for help on our forum 🧡

This post originally appeared on the n8n.io blog.

How to host virtual coffee breaks with n8n ☕️

TephlonDude — Mon, 11 Jan 2021 07:29:04 +0000

Almost all of us have had to start something new, be it a new job or a new school. When I find myself in this situation, I make it my mission to do two things:

Get to know as many people as possible
Find out what tech they are using

Fortunately, n8n has a great way of doing both at once. Using this coffee chat workflow, I can familiarize myself with their systems and get to meet a bunch of people at the same time.

This workflow automatically arranges coffee chats with people in Mattermost. It even schedules the appointment in their calendars! Virtual networking has never been so easy.

In this article, we are going to learn how to build this workflow and then change it to accommodate different chat systems that you may find plus accommodate some differences in the technology.

Prerequisites

This article assumes that you have the following in place already:

n8n

You will need a working copy of n8n. This can be either installed on your system or running on the new n8n.io.cloud environment. This workflow was created in n8n version 0.101.0.

Google Calendar

We will be using Google Calendar to send out the meeting requests. It is important that you have access to this online app and that you have already set up the credentials in n8n as outlined here.

Chat Program

You will need to have one of the two following chat programs:

Please ensure that you have created accounts for one of these programs and set up the credentials for n8n to access them. If you need more information on setting up the credentials for these chat systems, please check out the appropriate set of documentation below:

Quick Start

If you are just here to get this workflow up and running and are not interested in figuring out what each of the nodes does, you can take a shortcut and download the already completed workflow located here:

Please select the one that matches the technology and accounts that you have. All you will be required to do is paste the workflow into your copy of n8n and then modify the corresponding nodes for the chat system and Google Calendar.

Completed Mattermost Workflow

The Mattermost Workflow

There are four different nodes used in this workflow:

Cron Node

We would like this workflow to run once a week each Monday. To accomplish that, we use the cron node. To configure this to run at 10:00 each Monday morning, we will set the node parameters as follows:

Mode: Every Week
Hour: 10
Minute: 0
Weekday: Monday

Once you set each of these parameters, you can rename the cron node to Weekly Trigger on Monday and close the node.

First Mattermost Node (Greetings)

So, the first thing that we would like this workflow to do when the cron node triggers, is to post a quick message letting everybody know that the coffee groups are about to be released. To do this, set the following parameters in the Mattermost node:

Mattermost API credentials: Select your credentials that you set up earlier
Resource: Message
Operation: Post
Channel ID: Your channel ID
Message: 👋 Happy Monday! Groups for this week's virtual coffee are:

If you are not sure what the channel ID is for your Mattermost node, simply go to the title of the channel in the Mattermost page, click on the down chevron, and click on view info. This will pop up a new window telling you about your channel the channel ID is in fine print at the bottom left-hand corner of the window copy and paste this long string of letters into the channel ID field in the Mattermost node window.

Mattermost Channel ID

You are now ready to test your Mattermost node click on the execute node button at the top right-hand corner of the node window. You should now see the contents of your message field posted in the appropriate Mattermost channel.

You can rename the Mattermost node to Greetings.

Second Mattermost Node (Employees in Coffee Chat Channel)

The next Mattermost node will get a complete list of everybody who is in the channel that you chose in the previous node. The difference between this node and the previous Mattermost node that you created is that this node is being used to retrieve information whereas the previous node was used to post information. To configure this node, enter the following into the Mattermost node fields:

Mattermost API credentials: Select your credentials that you set up earlier
Resource: User
Operation: Get All
Return all: On

You will also want to add a field below the standard Mattermost fields. Click the add field dropdown button and select In Channel from the dropdown menu. In this field, use the Expression Editor to enter {{$node["Greetings"].parameter["channelId"]}} so that the same channel ID is used as in the previous Mattermost node.

Please note that you may receive an error message indicating that you do not have appropriate permissions on the server. This will not affect the results of this workflow.

Potential Error in Mattermost Node

You can now test the second Mattermost node. Click the Execute Node button at the top right-hand corner. You should get a list of all the users that are present in the channel along with some extra information.

Once you have successfully retrieved this information you can rename the node Employees in Coffee Chat Channel and close the node.

Function Node

The function node is now going to be used to perform a few things:

Put all users into an array
Shuffle the list of channel users
Break them up into groups of three
If there is a group of just one, added to the previously created group
Forward the groups on to the next nodes

Since reading function node can be some of the most complicated parts of writing a workflow, we are going to just provide you with the contents of this function node so that you can quickly get moving on to the next step. Here is the code:

const ideal_group_size = 3;
let groups = [];
let data_as_array = [];
let newItems = [];

// Take all the users and add them to an array
for (let j = 0; j < items.length; j++) {
    data_as_array.push({username: items[j].json.username, email: items[j].json.email});
}

// Fisher-Yates (aka Knuth) Shuffle
function shuffle(array) {
    let currentIndex = array.length, temporaryValue, randomIndex;

    // While there remain elements to shuffle...
    while (0 !== currentIndex) {

        // Pick a remaining element...
        randomIndex = Math.floor(Math.random() * currentIndex);
        currentIndex -= 1;
        // And swap it with the current element.
        temporaryValue = array[currentIndex];
        array[currentIndex] = array[randomIndex];
        array[randomIndex] = temporaryValue;
    }
    return array;
}

// Randomize the sequence of names in the array
data_as_array = shuffle(data_as_array);

// Create groups of ideal group size (3)
for (let i = 0; i < data_as_array.length; i += ideal_group_size) {
groups.push(data_as_array.slice(i, i + ideal_group_size));
}

// Make sure that no group has just one person. If it does, take
// one from previous group and add it to that group
for (let k = 0; k < groups.length; k++) {
    if (groups[k].length === 1) {
        groups[k].push(groups[k-1].shift());
    }
}

for (let l = 0; l < groups.length; l++) {
    newItems.push({json: {groupsUsername: groups[l].map(a=> a.username), groupsEmail: groups[l].map(b=> b.email)}})
}

return newItems;

Copy and paste this code into the JavaScript code field in the function node. Rename the function node Divide into groups.

You can test to see if the code in the function node is working properly by pressing the Execute Node button at the top right-hand corner of the node.

You should get several array sets of three users each as your output. There is a chance that the last array will have two or four members in the array if the number of users in the channel is not evenly divisible by three. Close the function node.

Third Mattermost Node (Announce Groups)

The next thing that we are going to do is send out a post with the names of the people who will be getting together in the coffee groups.

Fill in the following parameters in this Mattermost node:

Mattermost API credentials: select the credentials that were provided earlier

Mattermost API credentials: select the credentials that were provided earlier
Resource: message
Operation: post
Channel ID: the channel that you used previously
Message: groups to be distributed

For the information to go out properly, the message field will have to be filled out with an expression. Use the expression editor next to the message field and paste in the following:

☀️ {{$node["Divide into groups"].json["groupsUsername"].join(', ')}}

This will pull the user groups from the function node and use their information. Close the expression editor.

You can test your latest Mattermost node by clicking the Execute Node button at the top right corner. If this worked properly, you will be able to see the coffee groups appear in the appropriate Mattermost channel. You can rename the Mattermost node to Announce groups and close the node.

Google Calendar Node

The final thing we want to do with this workflow is to send out calendar invites to everyone in the groups. The Google calendar node will perform this for us.

Connect the Google Calendar node to the Divide into groups function node and set the following parameters:

Google Calendar OAuth credentials: select your Google calendar credentials or set them up if this is the first time you have used them
Resource: event
Operation: create
Calendar ID: your calendar ID
Start: start date and time
End: end date and time
Use default reminder: on

We also want to use some additional fields in this node. Select and set the following additional fields using the add field dropdown button:

Attendees: use the expression editor and add the following for the expression: {{$node["Divide into groups"].json["groupsEmail"].join(',')}}
Conference Data:
- Conference Link:
- Type: Google Meet
Guests Can Modify: On
Summary: n8n coffee catchup

You can test this node by clicking on the Execute Node button at the top right corner.

If everything works properly, each of the attendees should see a new calendar request in their calendar.

You can rename the node Send Calendar Invites and close the node.

At this point, please save and active your node so that it runs on schedule! Your final result should look like this:

Completed Mattermost Workflow

If everything goes according to plan, every Monday at 10:00 AM you will get an invitation for coffee.

Different Technology

Now if your new school or workplace uses Mattermost as their chat system, you're all set and ready to go. But, there are many different chat systems out there other than just Mattermost. Fortunately, n8n has you covered. It is simply a matter of replacing the Mattermost nodes with the comparable node from the other chat systems and fine-tuning the function node to support this new information.

Substituting Matrix

To use the Matrix messaging system rather than the Mattermost messaging system, follow these steps:

Delete the 3 Mattermost nodes from the workflow and replace them with Matrix nodes with the same names and connect them the same way they were connected in the Mattermost workflow.
Configure the Greetings node with the following settings:

Matrix API Credentials: Your credentials that you had previously set up
Resource: Message
Operation: Create
Room ID: This should be the room name that you are using for the coffee chat meetings
Text: 👋 Happy Monday Groups for this week's virtual coffee are:
Message Type: Text
Message Format: Plain Text

Configure the Employees in coffee chat channel node with the following settings:

Matrix API Credentials: Your credentials that you had previously set up
Resource: Room Member
Operation: Get All
Room ID: This should be the room name that you are using for the coffee chat meetings
Filters:
Membership: Any

Update the Divide into groups function node with the following code so that it accepts the different output from the Matrix node and it does not look for email addresses (since Matrix does not supply them):

const ideal_group_size = 3;
let groups = [];
let data_as_array = [];
let newItems = [];

// Take all the users and add them to an array
for (let j = 0; j < items.length; j++) {
    data_as_array.push({username: items[j].json.user_id});
}

// Fisher-Yates (aka Knuth) Shuffle
function shuffle(array) {
    var currentIndex = array.length, temporaryValue, randomIndex;

    // While there remain elements to shuffle...
    while (0 !== currentIndex) {
        // Pick a remaining element...
        randomIndex = Math.floor(Math.random() * currentIndex);
        currentIndex -= 1;
        // And swap it with the current element.
        temporaryValue = array[currentIndex];
        array[currentIndex] = array[randomIndex];
        array[randomIndex] = temporaryValue;
    }
    return array;
}

// Randomize the sequence of names in the array
data_as_array = shuffle(data_as_array);

// Create groups of ideal group size (3)
for (let i = 0; i < data_as_array.length; i += ideal_group_size) {
    groups.push(data_as_array.slice(i, i + ideal_group_size));
}

// Make sure that no group has just one person. If it does, take
// one from previous group and add it to that group
for (let k = 0; k < groups.length; k++) {
    if (groups[k].length === 1) {
        groups[k].push(groups[k-1].shift());
        }
    }
    for (let l = 0; l < groups.length; l++) {
    newItems.push({json: {groupsUsername: groups[l].map(a=> a.username)}})
}
return newItems;

Configure the *Announce groups *node with the following settings:

Matrix API Credentials: Your credentials that you had previously set up
Resource: Message
Operation: Create
Room ID: This should be the room name that you are using for the coffee chat meetings
Text: *Use the Expression editor to enter the following expression: *☀️ {{$node["Divide into groups"].json["groupsUsername"].join(', ')}}
Message Type: Text
Message Format: Plain Text

Delete the Calendar node. Since Matrix does not provide email addresses, there is nowhere to send out a calendar invite. (Maybe a shared Google Sheet with everyone’s account name and email address could be used as a lookup table in future versions! 🤔)
Don’t forget to activate the workflow so that it runs every Monday

Your final Matrix workflow should look like this:

Completed Matrix Workflow

What’s Next?

Now that we have this basic coffee chat workflow running properly in different environments using different technologies, where could we take this? Here are some ideas:

Send out calendar invites via the chat program using a calendar (ICS) file
Integrate other chat technologies (e.g. Slack, Telegram, Teams, etc.)
Create invitations to the actual video conference program (e.g. Zoom) and send the links
Check people’s calendars and opt them out of the chat if they already have a meeting scheduled

Our Journey

We’ve covered a lot of ground today. Let’s review what we have accomplished:

Built a workflow for creating random groups of three for a virtual meeting and sent out the groupings using Mattermost along with an invitation to their calendars
Modified the workflow to use the Matrix chat program rather than Mattermost, taking into account differences in technology.

I’d love to hear about what you’ve built using n8n! Or if you’ve run into an issue while following the tutorial, feel free to reach out to me on Twitter or ask for help on our forum 💙

Dashing Through The Data: Visualizing Metrics with n8n

TephlonDude — Fri, 02 Oct 2020 16:37:10 +0000

I use information from all over the internet. I visit hundreds of new web pages every day, both for personal and professional projects. It’s part of the process, and I’m happy to do it.

But, every day, I also waste precious time checking the same old websites for other vital information; weather, news, stock portfolio, email, Twitter, work alerts, and so on. And we all have a list like this. And you may find yours just as frustrating.

What annoys me the most is that the second I leave the site, I instantly wonder if the information has changed, and I stress out until I check it out again.

I finally got so fed up with all this chasing after information! Instead of me going to look up information in twenty different places, why can’t this information come to me in one single spot?

And that’s when it hit me 🥊

I Need a Dashboard!

A dashboard makes so much sense! It can contain any information that I want! It can be updated several times a day and can be permanently displayed on a monitor. All I need to do is glance at it for a few seconds, and I know what is going on.

What sealed the deal for me was that most web services can be easily queried with n8n, which can then talk to Smashing, a dashboarding system. Combining these three technologies (web services, n8n and Smashing) would save me significant time every day and keep me better in the loop with what is going on in other areas of my life.

And the best part? You can build your custom dashboard as well!

In this article, we will pull information from GitHub, Docker, npm, and Product Hunt about the n8n project and then display it using a Smashing dashboard. Since this information is constantly changing, n8n will perform this every minute. The workflow for this project looks something like this:

n8n Dashboard Data Workflow

n8n and Smashing

The two essential pieces of this project are n8n and Smashing. They make up the core of the project and are very well suited to working together.

Every minute, n8n gathers the data from the four data sources using their API interfaces. It then takes this data and extracts the pieces which are useful and then pushes it to the Smashing dashboard.

At this point, Smashing takes over and displays the information it receives from n8n based on how the dashboard was built inside the Docker container and which Smashing API endpoint receives the information.

How Smashing Works

While it is outside of the scope of this article to go into detail on how Smashing works, it is important for you to understand some of the fundamentals of Smashing.

Each Smashing dashboard is made up of a series of widgets. Each widget displays a piece of information. This information is fed to the widget through the Smashing API. Each widget has its own unique API endpoint. When the endpoint receives information, the widget displays that information.

These are the endpoints that have been created for this project and where their information originates:

Dashboard Widgets and Their Data Origins

This dashboard API interface along with the widget types are defined in the n8n_overview.erb file located in the docker container. (If you are interested in seeing how this file creates the dashboard, it is available here.)

Prerequisites

If you want to build this project yourself, you will need a couple of things ready to go before you start:

n8n — You can get this up and running by checking out the Quickstart page. You should have a fresh install without any workflows.
Docker — To save you time, we have built a Docker container with all of the Smashing pieces pre-configured. This way, you can have this piece running quickly and easily. For more information on setting up a Docker environment, please check out one of these tutorials.
GitHub Account — In order to ensure that you do not run into issues accessing the GitHub API, you can use your account to increase how frequently you can retrieve information from the API. If you do not have a GitHub account, you can join here and you can learn how to set up your credentials for GitHub in n8n here.
Product Hunt Account — To use the Product Hunt API, you are required to authenticate with them using your account and a developer token (see “But… I just wanted to run a simple script?” in the Product Hunt API documentation). If you do not have an account with Product Hunt, you can sign up here.

Quick Start

Many of you want to experience the result before committing to a project or already know the majority of what you will be learning in this article. For you, I have put together this Quick Start option. Follow these steps to get up and running quickly. If something is unclear or you want to learn more about how it works, feel free to dig deeper into the sections that follow.

Here are the quick start steps:

Install the docker container with the following two commands:

docker pull tephlon/n8n\_dashboard

docker run --name n8n\_dashboard -d -p 8080:3030 --rm tephlon/n8n\_dashboard:latest

Copy the n8n workflow from here and paste it into your n8n installation
Modify the following nodes with your information. I have highlighted them in red in the workflow for easy identification:
Dashboard Configuration — set value of dashboardHostname to your docker install
Retrieve Product Hunt Data — set your token value based on your developer token
Set up your GitHub credentials
Activate workflow
Browse to port 8080 of your docker installation

Now that you have a fully functioning dashboard, let’s take a look at what everything does, and maybe inspire you to tweak this workflow to suit your needs.

The Five Stages of an n8n Workflow

I have noticed in many of the workflows that I create there are five distinct stages that the workflow goes through from start to finish and this workflow is no exception.

Trigger
Configuration
Data Retrieval
Data Processing
Action

This is how the dashboard workflow looks broken up into these different stages:

The Five Stages of the n8n Dashboard Workflow

Let’s work through setting up these five stages as they pertain to the dashboard project.

Stage 1 — Trigger

Every workflow has to be told how to start, and this is referred to as the trigger. In this project, we want to update the dashboard with new information every minute. We’ll use the Cron node for that.

Set the Mode parameter to Every Minute. Doing this will run the workflow (you guessed it) every minute.

Now, the workflow knows how and when to run.

Stage 2 — Configuration

The configuration stage is generally a little more defined in my workflows than they are for others. I like to create a Set node with the majority of the configuration options so that they are all in one place (although there are exceptions to this rule which we will cover in a minute). For those of you who have developed in other tools before, you can think of this node as global variables that are available to all other nodes within the workflow.

Not all configuration settings are set at this time for two reasons:

The value is retrieved in a later stage
Set node values get copied when exported. If you have sensitive data such as API tokens in a Set node, they would also get exported (which would be bad)

As a convention for myself, I like to color the borders of my nodes red that require configuration, and you will see that I have done this as well for this workflow.

For the configuration of this workflow, we have created a Set node called Dashboard Configuration, which contains several string values. Most of these values can be ignored at this point, but if you want to customize the dashboard to monitor your project, this is where you would make these changes. (More on this later.)

As described in the quick start section, the only change you need to add to the Dashboard Configuration node is to set the dashboardHostname value so that it matches your docker container deployment. This is very specific to your docker installation and deployment of the tephlon/n8n_dashboard container. If your n8n installation is on the same system as your docker installation, this will be localhost:8080.

If docker is on a different system than your n8n installation, this value will be either :8080 or :8080. So, if your docker installation is on 192.168.4.25, this value would be 192.168.4.25:8080. You should be able to get this information from your docker admin. (If it turns out that this person is you and you are uncertain about what this value is, I have found a handy YouTube video which may point you in the right direction.)

This node is connected to the previous Cron node so that these values are loaded every time that the workflow runs, and the values are reset if one of them gets accidentally changed by a different node.

Stage 3 — Data Retrieval

In this stage, we are collecting all of the data from the different data sources, often using settings from the configuration stage.

We are using two different types of nodes to collect data, depending on the service. n8n has a built-in GitHub node, so it makes sense to use it for gathering the GitHub data. But, there are no custom nodes for the other three services, so we will use the HTTP Request node to pull information from each service’s API.

The output of the Dashboard Configuration node connects into these four nodes. They then use these settings to know which project to be monitoring.

You will need to change the settings in two nodes for this stage. The GitHub node will need your GitHub credentials to work, and the Retrieve Product Hunt Data node will need your developer token.

You should now have the ability to retrieve all of the raw data provided by these services.

Stage 4 — Data Processing

Now that we have this data, we need to make sure that it is in the proper format. The two challenges that need to be overcome are:

Large numbers are difficult to read
Decimal numbers are too long to display properly

To transform these values into something more usable, we will use the Function node. The Function node allows us to write our custom code when a pre-built node may not exist.

A single Function node is added for each service and connected to the output of the nodes created to retrieve the service data.

To add the thousands separator to a value, you reassign the original value with the updated value. The updated value is created by appending the value name with .toString().replace(/\B(?=(\d{3})+(?!\d))/g,","). This tells the system to convert the number to a string and replace every third space between characters with a comma.

For example, to reformat the pull_count from the Docker service, you would enter the following code:

items[0].json.pull\_count = items[0].json.pull\_count.toString().replace(/\B(?=(\d{3})+(?!\d))/g, “,”);

To round a value to two decimal places, we perform a similar action using the parseFloat function and toFixed() method.

So, to round the score.final value from the npm service, use the following code:

items[0].json.score.final = parseFloat(items[0].json.score. **final**.toFixed(2));

Each value that needs to be changed has the appropriate line of code added to its _Function _node.

Stage 5 — Action

The final stage is the action. This is where the n8n workflow performs an action on something. In this case, the workflow posts a value to the dashboard API for a specific dashboard widget.

For example, to update the number of GitHub Stars on the dashboard, the workflow needs to post the stargazers_count value from the formatted data originally generated by the GitHub node. This is performed using the HTTP Request node, one for each widget.

And that is the final piece! Once the workflow is activated, it will update all of the dashboard widgets every minute with the information it pulls from each service.

Monitoring Your Own Project

The one thing that most people will want to do is modify this workflow to monitor their own project. I have tried to make this easy by putting all of the changes in one the Dashboard Configuration node.

dashboardHostname (default http://192.168.1.14:8080): This should be the hostname and port of your docker installation. See Stage 2 — Configuration for more details.
dashboardAuthToken (default n8n-rocks!): Used to authenticate with the Smashing dashboard. There should be no need to change this unless you are playing around with the docker image.
product_hunt_post_id (default 170391): The post_id of the product that is being monitored at Product Hunt. You can find this number by going to your product page on Product Hunt and clicking on the Embed button. In the embed code, look for https://cards.producthunt.com/cards/posts/. The number immediately follows this string.
npm_package (default n8n): Name of the n8n package that is being monitored. You can find your project name by searching for your product at https://www.npmjs.com/ and copying the name exactly as it is on the webpage.
docker_name (default n8nio): Name of the user or organization who owns the docker repo being monitored. Find the repository that you are using at https://hub.docker.com (e.g. jim/nasium). This is the portion of the string before the “/” (e.g. jim)
docker_repository (default n8n): Name of the docker repo being monitored. Find the repository that you are using at https://hub.docker.com (e.g. jim/nasium). This is the portion of the string after the “/” (e.g. nasium)
github_owner (default n8n-io): Name of the user or organization who owns the GitHub repo being monitored. Find the repo that you will be monitoring at https://github.com (e.g. jim/nasium). This is the portion of the string before the “/” (e.g. jim)
github_repo (default n8n): Name of the GitHub repo being monitored. Find the repo that you will be monitoring at https://github.com (e.g. jim/nasium). This is the portion of the string after the “/” (e.g. nasium)

If there are any of these services which you do not wish to monitor, delete the link between that services’ data retrieval node and the Cron node. This will prevent the node from capturing the data and the widgets on the dashboard will remain unchanged.

What’s Next?

We have just touched the tip of the iceberg when it comes to dashboarding. Some other ideas that are possible include:

Charting stock prices
Displaying weather
Aggregating RSS feeds
Monitoring Twitter feeds
Showing videos from a YouTube channel
Company phone activity
Personnel in/out board
Fleet vehicle tracking

Our Journey

We’ve covered a lot of ground today. Let’s review what we have accomplished:

Installed the custom dashboard in Docker
Set the workflow to run every minute
Designed a global configuration node to easily manage common variables
Gathered data from four different online services
Modified the data so that is displays properly
Pushed the information for display in the dashboard using its API

I’d love to hear about what you’ve built using n8n! Or if you’ve run into an issue while following the tutorial, feel free to reach out to me on Twitter or ask for help on our forum 💙

A LowCode Dashboard?

TephlonDude — Tue, 22 Sep 2020 11:06:38 +0000

Did you know that it is possible to have this dashboard up and running with live data in under 5 minutes?

Build your own virtual assistant with n8n: A step by step guide 👦

TephlonDude — Tue, 15 Sep 2020 07:29:04 +0000

There is a lot to do for the average person living in the 21st century. Between work, family, and personal obligations, it is not uncommon for someone to get up early in the morning and run hard all day long just to collapse in bed that night with a list of tasks still unfinished.

Many people will turn to a virtual assistant to help them with these daily tasks. This can take the form of someone who works remotely for you, receiving direction through the internet. But, more recently, a new type of virtual assistant has emerged.

Nathan: Your n8n Virtual Assistant

This is the electronic virtual assistant. They are not people at all. Rather, they are programs on our computer/phone or devices that sit on our kitchen counter at home. Two well known examples of these virtual assistants are the Amazon Alexa and the Google Assistant. They can find details about your day or retrieve information for you quickly and (sometimes) easily.

The one challenge with these virtual assistants is that, at their core, they have a number of basic abilities that can be augmented with different skills created by either the manufacturer or a 3rd party. Because of this model, the majority of the abilities available from your personal assistant do not apply to you and, even worse, they may not have the ability to actually perform the tasks that you want them to do.

A Lesson from Suits

If you’ve watched even just one episode of the television series Suits, it becomes pretty apparent almost immediately that, despite all of his self confidence, the main character Harvey would not be where he is today without his personal assistant Donna.

Donna knows what Harvey wants before Harvey does. Donna anticipates Harvey’s needs and acts on them so that by time Harvey realizes he needs something, Donna has already done it. She is the glue that holds his life together.

Wouldn’t it be wonderful if our virtual assistants were more like Donna?

Well, I may have some good news for you!

Nathan is Here to Help

While it would be impossible to completely recreate the awesome that is Donna, we can definitely put together a useful virtual assistant who can deal with some of the day to day details that somehow find a way to consume our lives!

In this article, we are going to show you how to build your very own virtual assistant using many of the services that you already use today and connecting them all together with n8n. To add a personal touch to our virtual assistant we are going to call him Nathan.

Throughout this article, I’m going to use a Suits analogy. If you haven’t watched Suits, that’s OK! Everything will still make sense so feel free to ignore it! 😄

Goals

We are going to set some specific short term goals which we will complete during this article and then some long term goals which are ideas we can add-on at a later date once we build this initial framework.

Give Nathan the ability to perform basic email management
Set up a way to communicate with Nathan behind the scenes
Give Nathan some sass!

Prerequisites

In order to get Nathan up and running, we need to have the following in place:

n8n — You can get this up and running by checking out the Quickstart page. You should have a fresh install without any workflows. You can also sign-up for n8n.cloud to get access to our hosted service. This workflow was created in n8n version 0.104.2.
Slack — You will need a Slack workspace set up with at least one account for the person who is being assisted. You can find information about your Slack requirements here.
Yahoo Mail — This is used for communication between our users. (Please note that I have decided to use Yahoo mail but most other mail providers will work as well. For example, Gmail, Outlook.com, Zoho and others are fine to use.) Set up the Yahoo mail credentials following the instructions mentioned here.

n8n

The core of our Nathan is the n8n system. It has two primary purposes:

Connect services together that do not presently talk with each other
Provide the logic for how these services interact

A Note About Screenshots and the Start Node

The Start node is the default node for a workflow and can’t be removed. It’s used to initiate processing in a workflow that doesn’t begin with a trigger node (something you’ll learn about next). In the screenshots, the Start node has been omitted for clarity. You can also get your own copy of the workflow to help you follow along as we go.

Okay, enough of the preamble. Let’s get this project started!

You’ve Got Mail!

The first ability that we want to give Nathan is to work with Harvey’s email. We are going to accomplish this using two integrations:

EmailReadImap — reads email from an IMAP enabled mailbox and executes a workflow. This node is sometimes referred to as IMAP Email.
Send Email — sends emails using information received by the node from a workflow.

Reading Email

The first node we are going to configure is the EmailReadImap node. This node will allow Nathan to monitor Harvey’s email and then perform actions based on the email.

Add the EmailReadImap Node

The first step is to add the node into the workflow. To do this, follow these steps:

EmailReadImap node parameters

Click on the + button in the top right corner
Under the All tab, find the EmailReadImap node and click on it to open up the node parameters
In the Parameters tab, under Credentials > IMAP select — Create New — and enter the credentials you created earlier.
I’ve also chosen to change the name of the node to Read Harvey’s Email so that we will know exactly what this node does when looking at the workflow (Trust me, this helps later on when things get really complicated). We rename nodes by opening the node, clicking on the title of the node at the top left corner to enable renaming the node, edit the name and then click on the ✔ to set the new node name.
You can leave the rest of the options as defaults

Test the EmailReadImap Node

Before we move on, let’s test the EmailReadImap node to ensure that it is working properly.

Pro Tip: Save any changes you made to your workflow before you test it. This way, you will not lose your work if you run into any problems.

Email waiting for Harvey

Make sure that there is an unread email for the node to read. As it turns out, it appears that Louis has plans for him and Harvey after court this evening
In the open EmailReadImap node, click on the Execute Node button in the top right corner. This will get the node to reach out and read Harvey’s email.
If everything works right, you should get a table of information in the right hand pane with the following information: • textHTML : The message body in HTML format • textPlain : The message body in plain text format • metadata : All of the information that is needed for the mail client to read the message (mainly looks like gibberish) • date : Time and date that the message was sent • from : Name and email address of the person who sent the message • to : Name and email address of the person who sent the message • subject : The subject line of the email

If we go back into Harvey’s email, we will also see that the email from Louis is now marked as read compared to the unread message from Mike that came in after we tested the node:

Email after executing node and new mail has come in

You can now close the node and your workflow should look something like this:

Workflow after adding EmailReadImap node

Because the EmailReadImap node is a trigger node, it does not have an input but it is triggered each time a new email is detected so that the email can be processed.

Making a Decision

Now that we have the email, what do we do with it? Well, Harvey has given Nathan explicit instructions that he does not want to waste time on any of Louis’s emails. So, Nathan is going to check who sent the email.

There are a couple of ways to do this in n8n:

IF node: Checks a parameter and performs one action if it results in a true result and performs another if it results in a false result
Switch node: Checks a parameter and performs one of many actions, depending upon the value of the parameter.

While either would work for Nathan, we are going to use the Switch node because it allows us more flexibility for further expansion later.

Once you have added the Switch node and made sure that the output from the EmailReadImap node is connected to the input of the new Switch node, this is how we are going to configure it:

Final Switch node Parameters

Set the following parameters in the Parameters section:
Mode : Rules
Data Type : String
For Value 1 , click on the gears icon to the right of the field and click on Add Expression in the dropdown menu to open up the variable selector windows
Click on Current Node > Input Data > JSON > from. You should see the expression display {{$json[“from”]}} and the result below it read Louis Litt <louis_litt_1970@yahoo.com>. This displays the expression that you need to look for and what it is presently based on the information provided by the previous node.
Close the Edit Expression window
Under Routing Rules: , click the Add Routing Rule button. Three new labels and fields appear
Fill in the rule fields as follows:
Operation : Equal
Value 2 : Louis Litt <louis_litt_1970@yahoo.com>
Output : 0
Beneath the Add Routing Rule button, select 3 for the Fallback Output

That completes the configuration of the Switch node. What we have told it to do is this:

If the unread email is from Louis, send it for further processing. Otherwise, let it go through.

I’ve also taken the liberty of renaming the node Who Is The Email From?.

Test the Switch Node

To test the Switch node, simply click on the Execute Node button at the top right corner of the node. If we have configured everything correctly, you should see an indicator above the output side of the node windows.

Switch Node Output Indicator

This is telling me that we are seeing the results for Output 0. It is also telling me that the Switch node sent information out of Output 0 and this information is displayed below. In this case, it is the JSON data that was received in the input sent from the EmailReadImap node (i.e. the contents of the email).

If you were to click on the dropdown field beside the Output label, the Results would change and the output information below would also change to reflect the results and the output from the selected Output.

You can now close the Switch node. The workflow now looks like this:

Workflow after Switch node added

Making Up Excuses

Since Harvey doesn’t want to do anything with Louis, Nathan needs to make up a good excuse for Harvey. Fortunately, he has several (13,800 to be exact) excuses ready to go. We just need to build the excuse generator for him.

There are three separate nodes to this part of the system:

Spreadsheet Node Note

While I chose to create a copy of the Google Sheet as an Excel spreadsheet and then access it from the Read Binary File node, I could have just as easily accessed the information directly from Google Sheets using the Google Sheets node. For bonus points, see if you can replace the Read Binary File and Spreadsheet File nodes with a Google Sheets node

Create a Spreadsheet

The raw data for the generator is stored in an Excel spreadsheet. You can see the Google Sheets version yourself here. Download the file as an Excel spreadsheet and then save it in the same folder where you have installed n8n.

This spreadsheet acts like a database and stores each separate part of the excuse in the file. This spreadsheet should be installed somewhere that the n8n server can get access to; either on the n8n server itself or a remotely mounted network share.

Read Data as Binary Information

Next, we have to load the binary file into the system. This is done using a Read Binary File node. There are only two parameters for this node:

File Path : The full file path to the spreadsheet
Property Name : The property which will contain the binary data. This can be left as the default data

Once they are set, the node can be closed.

Retrieve Information from Spreadsheet

We can now actually view the information stored in the spreadsheet. Using the Spreadsheet File node, we can retrieve the binary data output from the previous node.

The two parameters to set are:

Operation : Since we are reading from the file, we set the value to Read from file
Binary Property : This needs to match the Property Name value entered in the Read Binary File node previously

Create the Excuse

The final node in our excuse generator workflow is a Function node. The Function node is a bit special because it gives you the freedom to do pretty much anything you want with the data that it receives and spit out whatever you want on the other side as long as it follows the proper data structure (See Data Structure for more information).

This is the code that runs in the _Function _node:

var leadinmax = 24;
var perpmax = 25;
var delaymax = 23;
var leadin = Math.floor((Math.random() \* leadinmax ) + 1);
var perp = Math.floor((Math.random() \* perpmax ) + 1);
var delay = Math.floor((Math.random() \* delaymax) + 1);

var excuse = items[leadin].json.Leadin + “ “ + items[perp].json.Perpetrator + “ “ + items[delay].json.Delay;

items = [{json:{}}];

items[0].json.excuse = excuse;
return items;

And this is what it does:

Lines 1–3 : The number of entries that are available for each of the three portions of the excuse
Lines 4–6 : Generates a random number to retrieve a random excuse portion
Line 8 : Creates the excuse from the three randomly selected portions pulled from the Spreadsheet node
Line 10 : Clears all the data originally retrieved from the Spreadsheet node so there isn’t any unused data consuming resources
Line 12 : Adds the excuse to the JSON data
Line 13 : Sends the data to the next node

When done, our workflow now looks like this:

Workflow with Excuse Nodes Added

Next, Nathan is going to make sure that Harvey is not stuck with Louis in a vat of mud this evening.

Not Tonight!

Now that Nathan has the perfect excuse to get Harvey out of that appointment with Louis, he will email Louis (as Harvey) and let him know that Harvey will not be there.

To do this, we need to use the Merge node to combine the excuse with the mail information and then feed that data into the Send Email node which will send the reply to Louis.

Merging the Information

Some nodes do not forward the information they received along to the nodes that follow so the Merge node is useful to retrieve that information and add it to other information for processing together. So, we are going to add a Merge node to the workflow and connect the output from the Generate Excuse Function node to Input 1 of the _Merge _node.

Next, we are going to take a second connector from Output 0 of the Switch node (this contains the email information) and attach it to Input 2 of the _Merge _node.

Inside the Merge node, there are two parameters that we are going to set:

Mode : Merge By Index
Join : Left Join

By setting these parameters, we are going to merge the data into a single JSON array and then send it on its way to the Send Email node.

Send the Email

The Send Email node now has all of the information that it needs to send an email back to Louis. This does take a bit of configuring to get it set up right:

Parameters for the Send Email node

Credentials — SMTP : This is a new credential set that was created to connect to Harvey’s email and send email on his behalf. Much of this information is available in this handy help article.
From Email : This is filled in from the To field supplied by the email by using the expression {{$json[“to”]}}
To Email : This is filled in from the From field supplied by the email by using the expression {{$json[“from”]}}
Subject : This is the same subject that the email used except it is prepended with RE:. This is generated using the expression RE: {{$json[“subject”]}}
Text : This is where we put in the excuse (generated by the expression {{$json[“excuse”]}}) followed by “Maybe next time. Harvey”

The rest of the parameters can be left empty for the time being or if you want to get fancy, you can fill in the HTML field with the same message but format the text using HTML and CSS.

You can now close the Send Email node.

The workflow should now look like this:

Workflow with Merge and Send Email nodes added.

Take Up the Slack

Now, the last thing that Harvey needs is for Louis to come in the next day and start talking about the excuse Nathan made up if Harvey knows nothing about it. This is why we are creating a “back channel” for Harvey and Nathan to communicate with each other while everyone else is none the wiser.

To accomplish this, we have set up Slack accounts for both everyone in the team and set up Nathan Slack app with the proper permissions to access the Pearson Specter LLC Slack workspace. We have also created a private channel which only Harvey and Nathan have access to and added Nathan app to that channel. (While I would love to go into all the fine details about how we set up Slack, it is quite simply beyond the scope of this article. But this could turn into a future article so stay tuned! For now, check out Giving kudos to contributors with GitHub, Slack, and n8n another example.)

Now that all of that preliminary information is out of the way, here is how Nathan is configured to send Harvey a message. The first thing that we need to do is add the Slack node to the workflow and connect the output of the Merge node to the input of the _Slack _node.

Parameters for Slack node

Next, open up the Slack node so we can set up the parameters. The Slack API credential is the first item we need to fill out. This is critical because if it is done incorrectly, then the node will fail.

The reset of the parameters are as follows:

Authentication : Access Token
Resource : Message
Operation : Post
Channel : This is the name of the private channel that we created in Slack. For Nathan, this is called private (Yes, unique, I know!)
Text : The is the content of the actual message (we will talk a bit more about this in a bit)

One of the other things that we would like to do is give our messages a bit more punch by being able to style them. We are going to accomplish this using Markdown language. To enable Markdown language, simply click on the Add option button near the bottom of the Parameters tab and click on Markdown on the pop-up menu. This will add a Markdown option which will, by default, be on.

Markdown Option in Slack Node

Now, you can style the text using Markdown language. If you are not familiar with Markdown language, it is a quick way to format text. There is an excellent tutorial on Markdown available here.

The final piece to this puzzle is to generate the message to Harvey using the excuse that Nathan sent to Louis. For the Text field, we are going to create an expression that looks like this:

Here is what Louis emailed you:

{{$json[“textPlain”]}}

Here is how “you” responded:

\> {{$json[“excuse”]}}

👍 *You’re Welcome!* 😏

This code tells the node to put into a text box the contents of Louis’s email and then add the excuse that Nathan made up. He then finishes off the message with a sassy “You’re Welcome!” with a couple of emojis for good measure.

The final message that will be posted to the private Slack channel will look like this:

Stylized message sent by Slack node

More Mail!?

Now that we have taken care of all the email from Louis, Harvey needs to be notified when he gets an email from anyone else. To accomplish this, we are going to make a copy of the Slack node that we just finished creating and connect the Switch node’s Output 3 to the input of this copied node.

Next, we will reset the value of the Text field and enter You’ve just received an email. You may wish to check it out. into that field.

Now, whenever a non-Louis email comes in, Harvey will get a notification.

What Else Could Nathan Do?

Because Nathan’s abilities are only limited by the services that are available through the internet, there are a lot of things that we could get Nathan to do for us. Some ideas include:

Buy and sell items online
Speak and be spoken to
Make dinner reservations or order food
Oversee our smart homes
Manage our communications (text messages, email, phone calls, etc.)
Make recommendations (movies, recipes, etc.)
Direct employees and customers
Whatever else comes to mind!

Everyone, Introducing Nathan!

That concludes the first steps in creating Nathan! Let’s do a brief review of what Nathan does so far:

Check Harvey’s Email
If there is new email check if it is from Louis
If it is from Louis:
Make-up an excuse
Email the excuse to Louis
Send Harvey a message on Slack with the excuse
If it is not from Louis:
Send a Slack message to Harvey that there is a new email

The final workflow looks like this:

Final Workflow for Nathan

I’d be excited to check out what you’ve built using n8n! In case you’ve run into an issue while following the tutorial, feel free to reach out to me on Twitter or ask for help on our forum 💙

This post originally appeared on the n8n.io blog.

DEV Community: TephlonDude

2021: The Year to Automate the New You with n8n ☀️

New Recipes Emailed Daily

Tracking Your (Crypto) Finances

Read More Books

Automate Your Task Planning

Get Daily Work-Out Encouragement

Summary

How to host virtual coffee breaks with n8n ☕️

Prerequisites

n8n

Google Calendar

Chat Program

Quick Start

The Mattermost Workflow

Cron Node

First Mattermost Node (Greetings)

Second Mattermost Node (Employees in Coffee Chat Channel)

Function Node

Third Mattermost Node (Announce Groups)

Google Calendar Node

Different Technology

Substituting Matrix

What’s Next?

Our Journey

Dashing Through The Data: Visualizing Metrics with n8n

I Need a Dashboard!

n8n and Smashing

How Smashing Works

Prerequisites

Quick Start

The Five Stages of an n8n Workflow

Stage 1 — Trigger

Stage 2 — Configuration

Stage 3 — Data Retrieval

Stage 4 — Data Processing

Stage 5 — Action

Monitoring Your Own Project

What’s Next?

Our Journey

A LowCode Dashboard?

Build your own virtual assistant with n8n: A step by step guide 👦

A Lesson from Suits

Nathan is Here to Help

Goals

Prerequisites

n8n

A Note About Screenshots and the Start Node

You’ve Got Mail!

Reading Email

Add the EmailReadImap Node

Test the EmailReadImap Node

Making a Decision

Test the Switch Node

Making Up Excuses

Spreadsheet Node Note

Create a Spreadsheet

Read Data as Binary Information

Retrieve Information from Spreadsheet

Create the Excuse

Not Tonight!

Merging the Information

Send the Email

Take Up the Slack

More Mail!?

What Else Could Nathan Do?

Everyone, Introducing Nathan!