
## What can I automate with Obsidian?
Obsidian can be used for tasks such as organising research, creating outlines for projects, and managing tasks and to-do lists. Obsidian uses plain text markdown files, which makes it easy to combine with other automation apps and you can also extend its capabilities with community plugins.

## How much does Obsidian cost? 
Obsidian is free but you can pay for [Obsidian sync](https://obsidian.md/sync) to help and support development.

## How can I learn how to use Obsidian?
Visit the Obsidian Forum or Discord on their [Community page](https://obsidian.md/community). Also because we love Obsidian we have a bunch of tutorials that use it below.

Obsidian is a note-taking/personal knowledge management app that uses markdown to help you organie their thoughts and ideas. 

Obsidian

## Overview
In this tutorial, we will demonstrate how to integrate your Outlook calendar events into Obsidian daily notes using Make and the Templater plugin. This powerful combination allows you to automatically populate your daily notes with meeting details and provides an efficient way to manage your schedule and notes all in one place

[How I get calendar events into my Obsidian Daily Note](https://www.youtube.com/watch?v=o2JH_jIKY_Q)

## Flow
[![](https://mermaid.ink/img/pako:eNplkm9PwjAQxr_KpYZ3SOJfzF6Y4GCKESFgNHH1RdkOaeh6S9uZELbvbjdgxPiq7d3vuXuu7Y4llCILWKezk1q6YMeZW2OGnAWcLYX1my4cYu_CSLFUaH0SPJgbmQmzDUmRafiz_kUURaO9xGJCOv2bjwZ34bDPWVVVnQ7XXH8bka_hZc71IJ4WThFtIBQKa-EXnJ_fl4PZuI6oEh7iidhgL6EMFglqb4a-uH5oqIsefOBy7eUlhHFYWOepQ6SFLnswkYkhSysHV7c3bSc4NRnGj-hg9IPa2VZ41YM3I7RdkcnAETwvpq8ljOJ6PWWEk6RbzXXrCOZoc9IWS4j2kmPAw4_xdGllKoVuxoWn-A2zXAmHBmaq-JZ1xaemYm2sdbx3CC1cwvh0PcfG9UhePm7k4ywn869CCc_xUEi1hVdytSHWZRn6YWTqf8WOa4DTj_Bbr9xwxnXluSJPfetRKh0ZFqyEsthlonC02OqEBc4UeISGUvinzloqF_qT6HiufgHrVtuC?type=png)](https://mermaid.live/edit#pako:eNplkm9PwjAQxr_KpYZ3SOJfzF6Y4GCKESFgNHH1RdkOaeh6S9uZELbvbjdgxPiq7d3vuXuu7Y4llCILWKezk1q6YMeZW2OGnAWcLYX1my4cYu_CSLFUaH0SPJgbmQmzDUmRafiz_kUURaO9xGJCOv2bjwZ34bDPWVVVnQ7XXH8bka_hZc71IJ4WThFtIBQKa-EXnJ_fl4PZuI6oEh7iidhgL6EMFglqb4a-uH5oqIsefOBy7eUlhHFYWOepQ6SFLnswkYkhSysHV7c3bSc4NRnGj-hg9IPa2VZ41YM3I7RdkcnAETwvpq8ljOJ6PWWEk6RbzXXrCOZoc9IWS4j2kmPAw4_xdGllKoVuxoWn-A2zXAmHBmaq-JZ1xaemYm2sdbx3CC1cwvh0PcfG9UhePm7k4ywn869CCc_xUEi1hVdytSHWZRn6YWTqf8WOa4DTj_Bbr9xwxnXluSJPfetRKh0ZFqyEsthlonC02OqEBc4UeISGUvinzloqF_qT6HiufgHrVtuC)

```mermaidignore
%%{init:{"theme":"base", "themeVariables": {"primaryColor":"#71FFFE", "secondaryColor":"#FA8CD7"}}}%%

  

graph LR

A[Outlook Calendar] -->|API Call| B[Make.com Scenario]

B -->|1. Webhook| C[Custom Webhook]

B -->|2. Microsoft 365 Calendar API Call| D[Get Events]

B -->|3. Transform to JSON| E[JSON Transformation]

B -->|4. Webhook Response| F[JSON Response]

G[Obsidian] --> H[Templater Plugin]

H -->|Get Calendar Events Templater| I[Make.com Webhook Call]

I -->|Import Calendar Events| J[Daily Note]
```

## How to recreate this automation
### Resources
- [Obsidian](https://obsidian.md)
- [Templater plugin for Obsidian](https://github.com/SilentVoid13/Templater)
- [Make.com](https://www.make.com/en/register?pc=rymawby)

### Step 1: Create a Make.com Scenario
![Completed scenario will look like this](https://ry.d.pr/i/x6MJRz.png)
1. Log in to your Make.com account and create a new scenario.
2. Add a Webhook module with a Custom Webhook.
3. Name the webhook and add any necessary security measures, then copy the unique URL provided.
![Create a webhook](https://ry.d.pr/i/WqY4Ty.png)



### Step 2: Set up the Outlook Calendar Connection
1. In the Make.com scenario, add a Microsoft 365 Calendar module and choose the API call option.
2. Configure the API call using the date parameter passed from the webhook, adjusting the time zone if necessary.
![The Outlook 365 Calendar node](https://ry.d.pr/i/QeHxH5.png)

### Step 3: Transform the Data to JSON
1. Add a JSON module to the scenario and choose the "Transform to JSON" option.
2. Select the body returned from the previous step as the object to transform.
![JSON Transform node](https://ry.d.pr/i/GhnomZ.png)

### Step 4: Create a Webhook Response
1. Add a Webhook Response module to the scenario and set the status to 200.
2. In the body, use the JSON string created in the previous step.
3. Save the scenario and run it once to test the setup.
![Webhook response node](https://ry.d.pr/i/tZzeOJ.png)


### Step 5: Configure the Templater Plugin in Obsidian
1. Install the Templater plugin in Obsidian and create a new template.
2. In the template, write the code to call the Make.com webhook, ignore specified subjects, and output the events as Markdown text.
3. Save the template in a designated folder in Obsidian. Here is the code we used for our Templater plugin.
```
<%*
async function getDataFromAPI() {

const ignoredSubjects = ['SR', 'Standup/Knowledge Share', 'Review Day/Write up notes', 'Friday Afternoon Internal Meeting Free Zone'];
var ret = ''

try {
  const dateToRequest = tp.file.title;
  const response = await fetch('https://hook.eu1.make.com/12345678?date=' + dateToRequest);
  
  const data = await response.json();
  
	console.log('returned data')
  data.map((item) => {
    if (!ignoredSubjects.includes(item.subject)) {
      const line = '### ' + item.subject;
      console.log(line);
      ret += line + '\n' + '\n';
    }
  });
} catch (error) {
  console.error(error);
}

return ret;

}

tR += await getDataFromAPI();
%>
```


### Step 6: Integrate the Templater Template into Daily Notes
1. In your Obsidian daily note template, add the code `tp.file.Include` followed by the name of the Templater template created in Step 5.
2. This will ensure that the calendar events are imported each time a new daily note is created.

With this setup, your Outlook calendar events will be dynamically imported into your Obsidian daily notes, allowing you to easily manage your schedule and meeting notes in one place. This method can also be adapted to integrate other APIs or personal data using Make.com or similar automation platforms.

Learn how to get external data into your Obsidian Daily Note.

Getting calendar events into my Obsidian Daily note


## Overview

The last tutorial taught us how to create [automated emails](https://tinyautomations.com/posts/2022-07-19-Release-Process-Automation) using macOS shortcuts. However, you may want to automate creating a draft email to make it easier for you to conduct your regular email marketing campaigns. Once created you will only need to enter your recipients in the automated draft email.

We use Obsidian and the JSON text strings created in the previous tutorial to create a draft email. JSON text strings use Shortcuts to make the draft email automation.

[How to automate creating a draft email with Shortcuts - YouTube](https://www.youtube.com/watch?v=18JTHqigEsA)

## Flow
[![](https://mermaid.ink/img/pako:eNpVUE1rwzAM_StCI9BCe9ipI4fBaJvb2KFjJ1-UWG3MEjvIzqGE_PfJ_dg6DOb56T1JfhM2wTKWWBST8y6Vk8HUcs8GS4M1RQUruHFfJI7qjqMWQYWDuJ7kvA1dkIv-afNcVdX-aoncBG__16u3l-1uY3Ce56IwPp-T0NDC5y7jJO50YllsyUPN8FFHZ53iIBB0A4GbYGl8bIOkZkxxcbgjZXty3eJdr-VDO1iv70agMYWekgseyFsYKEZwHiwlUtkr_LZ9mJD9Y-SrKAVohCnpU-iYgPPIizWD65cAcIU9izJWo50y8xerQk3l26Dxs-rGQfvy3roUBMsjdZFXmNc8nH2DZZKR76KdI02rv6nmH436mcY)](https://mermaid.live/edit#pako:eNpVUE1rwzAM_StCI9BCe9ipI4fBaJvb2KFjJ1-UWG3MEjvIzqGE_PfJ_dg6DOb56T1JfhM2wTKWWBST8y6Vk8HUcs8GS4M1RQUruHFfJI7qjqMWQYWDuJ7kvA1dkIv-afNcVdX-aoncBG__16u3l-1uY3Ce56IwPp-T0NDC5y7jJO50YllsyUPN8FFHZ53iIBB0A4GbYGl8bIOkZkxxcbgjZXty3eJdr-VDO1iv70agMYWekgseyFsYKEZwHiwlUtkr_LZ9mJD9Y-SrKAVohCnpU-iYgPPIizWD65cAcIU9izJWo50y8xerQk3l26Dxs-rGQfvy3roUBMsjdZFXmNc8nH2DZZKR76KdI02rv6nmH436mcY)
```mermaidignore
graph TD

trigger(Can be Obsidian or other trigger)
shortcuts(Shortcuts)
mail(Mail)

trigger -- trigger automation and pass in data --> shortcuts
shortcuts -- use data to create draft email --> mail

```

## Let's recreate this automation

### Resources
- [TA Create draft email (icloud.com)](https://www.icloud.com/shortcuts/2b188b2d60574a8ca87f47d881b2e4a4)
- [Obsidian](https://obsidian.md/)

### Step 1: Create empty shortcut and check JSON

- The first step is to add a blank shortcut.
-  In this case, we will add the show results node to the shortcut to test the JSON. Drag the **Show Result** node from the right side panel and drop it below the empty shortcut.

![Drop the Show Result node at the end of the workflow](https://ry.d.pr/1gcMZr.png)

-  Click the **Release email** button created in the [previous tutorial](https://tinyautomations.com/posts/2022-07-19-Release-Process-Automation) in your dataview to check if the JSON runs. 

**Note:** After every step of this draft email automation tutorial, check if it works correctly using the Show Results node. If it works, delete the Show Result node and continue to step 2.

### Step 2: Create dictionary from JSON

-  Go to the "Input search" label in the right panel and type **Get Dictionary from Input.** The results will bring up the dictionary. Click **Get dictionary from** Input, which will be inserted below your shortcut.

![](https://ry.d.pr/wIrkQe.png)

The dictionary helps JSON to insert the email title, description, and tags into the draft email. Now let's add information to the dictionary.

- Search **text** in the "input search" label. Check the results for the **Text** node, drag and drop it under the dictionary.
- Click **Text** and type the body of your email. 
![](https://ry.d.pr/gJjiqF.png)


If you have a description of your email body saved in your dictionary, you can insert the description at the end of the sentence.

- Right-click where you want the description to appear in the **Text** node. Select **Insert Variable** and click **Dictionary** in the drop-down list.

![Click dictionary in the dropdown list screenshot](https://ry.d.pr/qUhcpR.png)

- The Dictionary properties will appear. Here you can set the information you want to be displayed - type **Description** in the **Get Value for Key** input. 

![Get value for key input screenshot](https://ry.d.pr/qUhcpR.png)

Check the JSON to ensure the automation is working correctly. As explained in `Step 1` insert a **Results** node under the workflow created. The result should appear like in the image below: 

![Create draft email screenshot](https://ry.d.pr/FSTgfq.png)

### Step 3: Create the body of the email

- Next, we set a variable to indicate the body of the email. Go to the "Input search" label on the right-side panel and type **Set Variable**. Click the result **Set Variable** to insert it into the workflow.

![Set variable screenshot](https://ry.d.pr/KGhf8k.png)


- Giving the variable a name will help you to find it easily when automating all the variables in the last step of this tutorial. Click the variable name and type "Body".
- Insert a **text** node to type in the details of the email body. Check `Step 2` to insert the text node. Right-click in the Text node and select **Insert Variable** , then click **Dictionary**.

![Insert dictionary screenshot](https://ry.d.pr/vM77tv.png)

- The **Text** properties will appear. Go to **Get Value for Key** and type "Title". Press **return** when done. 

![Get Value for Key "title" screenshot](https://ry.d.pr/mvSLkZ.png)

**Note:** Use the **Show Results** node to check JSON, as seen in `Step 1`. If it brings up the body description, continue to the next step.

### Step 4: Create the subject variable

We have to set the body into a variable. Go to the **Input search** label and search for **Variable.** Select **Set Variable** from the results. Name the variable as "Subject".

![Create the subject variable screenshot](https://ry.d.pr/bXWQNr.png)

### Step 5: Automate email creation

- For the final step, search **Mail** in the **Input search** label. Click **Send Mail** from the results.

![Select Send Mail screenshot](https://ry.d.pr/GR3DW9.png)

- The send mail node will appear under the workflow. Let's set the first and last input box in the node as **Body** and **Title** respectively. Right-click the first textbox and select **Insert Variable** and then click **Body**.

![Insert "Body" Variable screenshot](https://ry.d.pr/7gnOIH.png)

-  For the last input box in the **Send email** node, right-click the input and select **Insert Variable** and then click **Subject**.

**Note:** Since it is a draft email, the **Recipients** input in the middle of the **Send email** node should remain empty.

-  Finally, the draft email automation is completed. To preview the results, go to the Obsidian dashboard and click the **Release email** button created in the [previous tutorial.](https://tinyautomations.com/posts/2022-07-19-Release-Process-Automation) The final automated draft email should appear as below.

![Release email screenshot](https://ry.d.pr/jOn9bc.png)



Bored of sending the same old emails? Let Shortcuts do the heavy lifting.

How to automate draft email creation with Shortcuts

## How do I automate emails from Obsidian on a Mac?
To automate emails from Obsidian you can use macOS Shortcuts.
* Make sure you fill in the relevant data as YAML front matter in Obsidian.
* Create a button within Obsidian to trigger the macOS Shortcut.
* Create a macOS Shortcut to take the data from Obsidian and create an email in Mail.

[How I reduced release email stress with this automation - YouTube](https://www.youtube.com/watch?v=sFIXR0TuxX8)

This tutorial will cover the triggering of the macOS Shortcut within Obsidian and the following tutorial will cover the creation of the email with Shortcuts.

## Flow
```mermaidignore
graph TD

obsidian(Obsidian)
shortcuts(macOS Shortcuts)
mail(Mail)

obsidian -- pass frontmatter data --> shortcuts
shortcuts -- create email with frontmatter data --> mail
```

![](https://mermaid.ink/svg/pako:eNptUE1rwzAM_StCI5BCetipI4fBaJvb6KFjJ1_URF1MYzvYCqOE_Pcpa7t1MAzm6X1ha8Q6NIwlZtlovZVyNCgtOzZYGjxQUlDAlXunaOnQcVIR1NhH6yie16EL8dv_sHqsqmp7iSSug2_-6tXL03qzMjhNU5YZP5-PSH0Lb5sZh0OyjSWf765gYXxqQ5R6kJQ7qnd72N9m1RzZLn_Va3GfhuUSekoJjjF4cSTCERoSUuEZfvruqudEHZmEgedO-LTS_h-f5cvDAbBAx1GZRhc4zszv8hTq308GjZ_UN_TawNvGSohYHqlLXCANEvZnX2MpceCbaWNJd-KurukLkX6RGw)


## How do I automate an email with Obsidian on a Mac?
### Step 1: Create a page in Obsidian with all the email details
This information should also include anything you want to filter in your [Obsidian dataviews](https://github.com/blacksmithgu/obsidian-dataview) and anything you want to include in your emails. The simplest way to do this is within the [YAML front matter](https://help.obsidian.md/Advanced+topics/YAML+front+matter) of the Obsidian markdown document.

#### What is an Obsidian dataview?
An [Obsidian dataview](https://github.com/blacksmithgu/obsidian-dataview) allows you to create tables by querying your Obsidian vault. It works like querying a traditional database but with a dataview you query your markdown files within your vault. We will use Obsidian buttons within each row of this dataview to trigger the macOS shortcut that creates the email.

#### What is YAML front matter in Obsidian?
YAML front matter is text at the top of your Obsidian markdown document surrounded with three dashes `---`. You can store data associated with the file such as `tags`, `title`, `description` and `published`. The below image shows the type of data we have used for this automation.

![YAML front matter example](https://ry.d.pr/bCE8wU.png)


### Step 2: Create an Obsidian dataview that lists your unpublished blog posts
In a page embed the following code:
````
```dataview
TABLE "BUTTON" AS " "
FROM "tiny-automations" SORT date DESC
WHERE published = false AND contains(sites, "tinyautomations.com")
```
````

This will create a table that contains all the files within the `tiny-automations` folder where `released` is `false` and `sites` contains `tinyautomations.com`. This will list all blog posts that haven't been published yet.

You'll notice we have the text `BUTTON` that appears in the second column. We are going to replace that text with code for a clickable button to trigger the automation.

### Step 3: Create a button within your dataview
In place of the `BUTTON` text we want a `Release email` button that we can click to trigger the automation. We do this by swapping out the `BUTTON` text in the dataview with the code for a button. Here is an example of how to embed a button in Obsidian:

````
```button
name Release email
type link
action shortcuts://run-shortcut?name=Create%20draft%20email&input=text&text=INPUT_DATA_HERE
class button-css
```
````

This will create a standalone button that runs a macOS Shortcut named `Create draft email` (the `%20` is a URL encoded version of a space character). We want to embed this button in each dataview row so that when we click it it runs the `Create draft email` shortcut with data from our markdown documents.

To embed the button in the dataview we need to replace the `BUTTON` text with the above `button` code:
````
```dataview
TABLE "```button
name Release email
type link
action shortcuts://run-shortcut?name=Create%20draft%20email&input=text&text=INPUT_DATA_HERE
class button-css
```" AS " "
FROM "tiny-automations" SORT date DESC
WHERE published = false AND contains(sites, "tinyautomations.com")
```
````



This will create a dataview with a `Release email` button that looks like this:

![Obsidian dataview screenshot](https://ry.d.pr/nfhRX2.png)


### Step 4: Pass data into the shortcut
This is the most complicated step. We want to pass data into the macOS shortcut from Obsidian. To do this we replace the `INPUT_DATA_HERE` text with a JSON object filled with data from your markdown files. JSON is a way of constructing data that follows a format like:
```json
{
	"property1": "value1",
	"property2": "value2"
}
```

We want to pass in the `title`, `description` and `tags` of the relevant page to the shortcut (we can then create an email from this data). So the JSON we want to create will look like this:
```json
{
	"title": "Title of page goes here",
	"description": "Description of page goes here"
	"tags": "Tags from page go here"
}
```

As you can see we need to fill in the values with the correct text from the YAML front matter of each page in each of the rows of the dataview. Obsidian dataviews allow us to access the files front matter with the variable `file.frontmatter` - so if I wanted to reference the `title` from the front matter I could use `file.frontmatter.title`. Replacing the text above with correct data from each row we get:
```json
{
	"title": file.frontmatter.title,
	"description": file.frontmatter.description
	"tags": file.frontmatter.tags
}
```

There are two more steps to make this actionable. We need to replace certain strings (text) with their URL encoded counterparts - this is to make it machine readable. We also have to do some `escaping` of characters for this reason as well - especially with  `\"` as it is an embedded string. This may look a little complex but after a while you get used to it.

If we construct the JSON so it is readable within the Obsidian dataview it will look like this:
```json
replace(replace(replace(replace(replace(replace(
	"{\"title\": \"" + file.frontmatter.title +
	"\", \"description\":\"" + file.frontmatter.description + 
	"\", \"tags\":\"" + file.frontmatter.tags + "\"}", " ", "%20"), "/", "%2F"), "?", "%3F"), "=", "%3D"), ":", "%3A"), "&", "%26")
```

We then need to add this to the button code:
````
```button
name Release email
type link
action shortcuts://run-shortcut?name=TA%20Create%20draft%20email&input=text&text=" + replace(replace(replace(replace(replace(replace(
	"{\"title\": \"" + file.frontmatter.title +
	"\", \"description\":\"" + file.frontmatter.description + 
	"\", \"tags\":\"" + file.frontmatter.tags + "\"}", " ", "%20"), "/", "%2F"), "?", "%3F"), "=", "%3D"), ":", "%3A"), "&", "%26") + "
class button-css
```
````
This is is the button complete. We replaced `INPUT_DATA_HERE` with the JSON we created above. Now if we replace the `BUTTON` text in the dataview with the above button we get the completed code of: 
````
```dataview
TABLE "```button
name Release email
type link
action shortcuts://run-shortcut?name=Create%20draft%20email&input=text&text=" + replace(replace(replace(replace(replace(replace(
	"{\"title\": \"" + file.frontmatter.title +
	"\", \"description\":\"" + file.frontmatter.description + 
	"\", \"tags\":\"" + file.frontmatter.tags + "\"}", " ", "%20"), "/", "%2F"), "?", "%3F"), "=", "%3D"), ":", "%3A"), "&", "%26") + "
class button-css
```" AS " "
FROM "tiny-automations" SORT date DESC
WHERE published = false AND contains(sites, "tinyautomations.com")
```
````

This dataview now lists all the not yet published blog posts. When we click the `Release email` button it will trigger the macOS Shortcut `Create draft email` (covered in our next tutorial) and we can create our release email.

## Resources
- [Obsidian](https://obsidian.md/) 
- [blacksmithgu/obsidian-dataview: A high-performance data index and query language over Markdown files, for https://obsidian.md/. (github.com)](https://github.com/blacksmithgu/obsidian-dataview)
- [shabegom/buttons: Buttons in Obsidian (github.com)](https://github.com/shabegom/buttons)
- [YAML front matter - Obsidian Help](https://help.obsidian.md/Advanced+topics/YAML+front+matter)
- [JSON Introduction (w3schools.com)](https://www.w3schools.com/js/js_json_intro.asp)




Release emails are necessary to communicate to the wider business but can be tedious. Use automation to make them a joy to send.

How I took the stress out of release emails using Obsidian dataviews and macOS shortcuts

## Overview

[Use Alfred's snippets to create quick templates for daily tasks - YouTube](https://www.youtube.com/watch?v=my3-yZPdYPM)

## Daily standup note with Alfred automation flow diagram
![Daily standup not with Alfred automation flow diagram](https://mermaid.ink/svg/pako:eNpVkEFrwzAMhf-K0Ai00A526shhUJLmOAYtOwxf1FhtTR3b2A5bCPnvc9JmZRjs96zvCaQeaysZc8yyXhkV815gvHDDAnOBRwpJrOD-90le0VFzSEVIoPOqId8VVls_8U-bl6qqdrdI4Noa-b9ebV-LciNwGIYsE2Y8Z0_uAody1JF_4uJDkzJwSBLebeSwFCZoqq-L_XgnR_rkWS6207Occ7BeQ2FdB3fzBlPqHh6rsXMMLJ9DJCNbNzG3XnPPkfq2_hqgobOqH11whQ37hpRMq-qFAXisKck05VWgMEPiWicp8k6qaD3mJ9KBV0httPvO1JhH3_IMlYrS9M0f5ch8WTv74Rer-ovJ)
```mermaidignore
graph TD

text(Plain Text Notes)
slack(Slack)
alfred(Alfred)

text -- Copy text --> slack
slack -- type ed.standup --> alfred
alfred -- works magic --> slack
```

## How to recreate this automation
### Step 1: Create an Alfred snippet
Go to the preferences in Alfred and open up `Snippets` in the `Features` section. Create a snippet similar to this:
![Alfred snippet example](https://ry.d.pr/VBA7Pb.png)

Plain text format of the example in the video:
```
*{date:EEEE} Standup - {date:long}*
{clipboard}
```

### Step 2: Copy your notes
![Highlighted notes](https://ry.d.pr/Fqs2lw.png)

### Step 3: Go to Slack and type your trigger keyword
Type in your keyword - mine is `ed.standup` - and hit enter.
![Slack example](https://ry.d.pr/g0JI9s.png)


Creating a daily standup note using Alfred snippets

## Overview
A quick video of how to use buttons in Obsidian with Bunch for quick context switching with todos.

[How to use buttons in Obsidian and Bunch for quick context switching - YouTube](https://www.youtube.com/watch?v=sevVgvdUeFc)

### Resources
- [Bunch](https://bunchapp.co/)
- [Bunch url scheme](https://bunchapp.co/docs/integration/url-handler/)
- [Obsidian](https://obsidian.md/)
- [Buttons in Obsidian](https://github.com/shabegom/buttons)


How to use and create buttons in Obsidian to context switch with Bunch

Using buttons in Obsidian to quickly context switch with Bunch

I wanted to create a system where I could just focus on writing and not have to worry about publishing articles to my site (and the procrastination that comes along with that). I write in Obsidian but you could do this with any editor. I set up Hazel to watch the folder where these articles are written and if the file meets certain criteria it is copied to a different folder which is then uploaded to this site. I'll cover the upload in another article but for this one I want to mainly focus on Hazel and analysing front matter.

Front matter is metadata/text that sits at the very start of a markdown file and describes the file itself and its contents. Hazel analyses any changes made to the markdown file's front matter and if it meets certain criteria it will copy the file to my blog posts folder. The front matter for this article can be seen here.

![This article's front matter](https://ry.d.pr/6Gn2GU.png)

Hazel runs a node script (shown below) that checks if the front matter has a `title`, says `published: true` and for the `date` to be in the past. 

Once the front matter matches the criteria above and hasn't been modified in the past minute Hazel assumes the article is publishable and copies it to my blog build server.

## Automation flow diagram for publishing a blog post from Obsidian using Hazel

![Automation flow diagram for publishing a blog post from Obsidian using Hazel](https://mermaid.ink/svg/pako:eNpVkEFvwjAMhf-K5akSSHBgHJh6mLQB1W47bNphysU0Lo1IkyoNQqzqf59TYBO39-zPL7F7LL1mzDHLeuNMzHuFseaGFeYKd9SJmMG19kXB0M5yJ00QsA2moXBee-vDyD-sFkVRbC8jHZfe6ft-8fK03qwUDsOQZcoptw_U1vC5SdroxeR91xltyE2TfZy80Q_bUS8nr9bvofJWc5gmfByA-RxOwUQGchqOrSaRVfAuQkMxchDgGSRqzEv0XbNMo7JU8mXN3ZhSp0eh9K2Rgix40P7koDKWr2FLnGHDoSGj5XK9cgD_VxMpSx8UKjcId_nSVpvoA-YV2Y5nSMfoP86uxDyGI9-gjSE5R_NHteS-vb_54Rd0RZC8)

```mermaidignore
graph TD

id1(Obsidian)
id2(Hazel)
id3(Blog folder)


id1 -- write and update front matter --> id2
id2 -- front matter criteria matches and hazel copies markdown file --> id3
```

## Step 1: Write.
Write a blog post, much like this one.  Modify the front-matter so that it is valid. Like this:
![Publishable front matter](https://ry.d.pr/kYYxBo.png).

## Step 2: Hazel.
To do this I have used a node script that uses the [front-matter](https://www.npmjs.com/package/front-matter) library to analyse the markdown file I'm editing for matching/valid front matter criteria.

### Hazel setup
![The hazel settings](https://ry.d.pr/WnerYx.png)

And in the embedded script I call my node script containing the front matter check. The variable passed in `$1` is the matching file name.
```bash
cd /Users/me/hazel
output=$(node hazel-check-tiny-automations-blog-frontmatter.js $1);
exit ${output};

```

### Node script
The `console.log(0)` or `console.log(1)` passes `0` or `1` back to the Alfred shell script above and the script exits with either a `0` (successfully matched) or a `1` (no match as yet).
```javascript
var fs = require('fs')
var fm = require('front-matter')
var uri = process.argv[2];

return fs.readFile(uri, 'utf8', function(err, data){
	if (err) throw err

	var content = fm(data);
	var isPublished = content.attributes && content.attributes.published;
	var isDatePast = content.attributes.date && Date.parse(content.attributes.date ) < new Date();
	var hasTitle = content.attributes.title && true;

	if(isDatePast && isPublished && hasTitle){
		console.log(0);
	} else {
		console.log(1);
	}
})

```

Once the above script matches Hazel then copies the file to my posts (which is another automated build system in itself - I will cover this in another post) folder - I also do some renaming of the file so it is suitable for this blog.



Automate blog publishing direct from file Front matter

Learn how to automate with Obsidian

What can I automate with Obsidian?

How much does Obsidian cost?

How can I learn how to use Obsidian?