DEV Community: Wachira

How to move your .ssh generated keys to a new laptop.

Wachira — Wed, 16 Feb 2022 17:44:41 +0000

So I recently changed laptops, from being a Linux user for the past 2.5 years. I was running Parrot during that time, great os by the way if you are into cyber security stuff or just another full-stack developer like me.

I switch over to Mac, and all my ssh keys were in my previous laptop, they access all of my servers in Digital Ocean and AWS, to cloning and pushing to Github and so much more. I could not convince myself to update all servers with the new ssh keys and I had some issues with Github SSH cloning. So here are the steps I took, enabling me to move all my keys to my new laptop.

Copy over the ssh keys from your old laptop to the new one, they should be located in the ~/.ssh/ folder. You can use a flash drive or a cloud platform, whatever works for you.
Paste the files in your new laptop in the same directory.
Add the to your keychain

# for macos
ssh-add --apple-use-keychain ~/.ssh/id_rsa

# for linux
ssh-add -K ~/.ssh/id_rsa

The Catch: If you do that you will get an error like this:

@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@         WARNING: UNPROTECTED PRIVATE KEY FILE!          @
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
Permissions 0664 for 'id_rsa' are too open.
It is required that your private key files are NOT accessible by others.
This private key will be ignored.

To avoid this, run this command;

# this basically makes the keys read-writable by you
chmod 600 id_rsa

Retry adding it to the keychain

# for macos
ssh-add --apple-use-keychain ~/.ssh/id_rsa

# for linux
ssh-add -K ~/.ssh/id_rsa

The output should be:

Identity added: id_rsa (<ssh_name_will_appear_here)

Just published the 5th Issue of my Newsletter

Wachira — Thu, 06 May 2021 22:42:27 +0000

Click to read here

How do Notion Web Clipper and Instapaper work?

Wachira — Thu, 06 May 2021 17:18:31 +0000

I read a lot of articles and when I don't have the time to through one I do three things:

Save to Medium
Save to Instapaper
Save to Notion

So what happens after that is Notion/Medium/Instapaper scrape the page so that when I do have the time I don't have to look for the link rather just open one of those platforms and the article will be saved under my profile.

So my question is how are they able to achieve that?

Because each website HTML document is different, and my knowledge around scraping is that you have to know how the document structure looks like to collect relevant info. For example:

You might opt to use class names like .article which will house the article body but then if another developer uses a css-in-js library then that won't be effective.
Another way maybe the developer uses HTML5 tags like <article> and houses the article body, [chrome reader mode works when you do it this way] inside but another developer might use <div>

I asked one of my friends he mentioned they might be doing some analysis on the page and figuring out when an article starts and ends.

How To Stream Mp3 With NodeJS To HTML Audio Tag

Wachira — Mon, 25 Jan 2021 08:01:04 +0000

In this article we are going to make a simple nodejs API endpoint that streams an mp3 file hosted on publicly anywhere example:

Amazon S3
Cloudinary
Megaphone
Public mp3 file

Prerequisites

Nodejs Basics
Used Axios request library
Express basics
Hosted audio

Note: This is not a scalable way to stream audio, there are better ways by handling the streaming using HLS and FFmpeg on a server somewhere. You can use this script to stream and binge your favorite podcast.

Let's get started

First, we need to setup our project:

yarn init

Fill out the prompts or just work with the default values by adding -y argument at the end.

Next, we need to install relevant npm packages

yarn add express axios

Let's create our endpoint

// We will use this to make HTTP request to the mp3 link
const axios = require("axios");
// adapters are axios modules that handle dispatching a request and settling a returned Promise once a response is received.
const httpAdapter = require("axios/lib/adapters/http");
// express is lightweight web framework
const express = require("express");

// Initialize express and assign to variable app
const app = express();

const INPUT =
  "https://dcs.megaphone.fm/ADV3183643348.mp3?key=c3dc25ae82cc18218902aa6a0675798a";

app.get("/audio", (req, res) => {
  axios
    .get(INPUT, { responseType: "stream", adapter: httpAdapter, 'Content-Range': 'bytes 16561-8065611'  })
    .then((Response) => {
      const stream = Response.data;

      res.set("content-type", "audio/mp3");
      res.set("accept-ranges", "bytes");
      res.set("content-length", Response.headers["content-length"]);
      console.log(Response);

      stream.on("data", (chunk) => {
        res.write(chunk);
      });

      stream.on("error", (err) => {
        res.sendStatus(404);
      });

      stream.on("end", () => {
        res.end();
      });
    })
    .catch((Err) => {
      console.log(Err.message);
    });
});

app.listen(4000, () => {
  console.log("Server is running");
});

Continue here

Just found out top 10 starred public repos in Github are written in Go.

Wachira — Mon, 18 Jan 2021 13:12:27 +0000

Here

Will Golang ever stop using their strict GOPATH path in order to code with it

Wachira — Wed, 13 Jan 2021 09:15:58 +0000

When I started learning, being a beginner it was such a hustle to set it up, nowadays I am okay with setting up on any PC but for new beginners its not that pleases.

Is there a reason it's setup that way and not like node or python where you install and can write your script anywhere on your PC without any path related issues?

How to create a CLI program in Go and host it on npm

Wachira — Sat, 19 Dec 2020 00:29:43 +0000

Recently I started building tools that will help me automate my app deployment process easier and cheaper, to do that I knew CLIs are definitely going to be involved one way or another. So I started building two CLIs:

Simp CLI: It's like Makefile just easy
Thrusta CLI: It's a remote command execution tool

Both CLIs were built with Golang but only one is hosted on npm here, this tutorial will guide you on how you can do the same.

Note: Am still new to Go

Let's jump into it

Prerequisites

Basic Golang syntax and concepts (Beginner friendly)
NPM installed
Golang installed (its a process, so here is a link)

What are we building?

We are going to create a CLI that serves a directory over a HTTP server.

Lets get started

Create a new folder inside

$GOPATH/src/<github.com|gitea.com|gitlab.com|bitbucket.com>/<username>/html-server-cli

Next, we will create our go.mod file to track packages we are going to use

go mod init

I have my directory setup as below:

.
+-- cli
    +-- cli.go
+-- helpers
    +-- helpers.go
+-- server
    +-- server.go
+-- go.mod
+-- go.sum
+-- html-server.go

Let add some code to our helpers/helpers.go

package helpers

import (
    "math/rand"
    "time"
)

// GeneratePortNumber handle generating port number
func GeneratePortNumber() int {
    rand.Seed(time.Now().UnixNano())

    min := 1000
    max := 99999

    port := rand.Intn(max-min+1) + min

    return port
}

The block of code above enables us to generate a random port number, you can add more logic to see if a port is used.

Next, let's add some code to our server/server.go

package server

import (
    "log"
    "net/http"
    "strconv"

    "github.com/bywachira/html-server/helpers"
)

// Serve handles serving the directory
func Serve() {
    // Generate our port number
    port := helpers.GeneratePortNumber()
    // Inform the user which port we are running
    log.Println("We are running on port: " + strconv.Itoa(port))
    // Exit to a live server
    log.Fatal(http.ListenAndServe(":"+strconv.Itoa(port), http.FileServer(http.Dir("."))))
}

Let's create a method to initialize our CLI

package cli

import (
    "fmt"
    "sort"

    "github.com/bywachira/html-server/server"

    "github.com/urfave/cli/v2"
)

// SetupCLI initialize cli
func SetupCLI() *cli.App {
    app := &cli.App{
        // List your commands here
        Commands: []*cli.Command{
            {
                // Provide details about our cli flags
                Name:    "run",
                Aliases: []string{"r"},
                Usage:   "Serve your HTML file",
                Action: func(c *cli.Context) error {
                    // The logic to be called when this commad is ran
                    fmt.Println("We are serving this directory")

                    server.Serve()
                    return nil
                },
            },
        },
    }

    sort.Sort(cli.FlagsByName(app.Flags))
    sort.Sort(cli.CommandsByName(app.Commands))

    // Return our cli
    return app
}

Let's update our package main, which is html-server.go

package main

import (
    "log"
    "os"

    "github.com/bywachira/html-server/cli"
)

func main() {
    // Assign our cli to the app variable
    app := cli.SetupCLI()

    err := app.Run(os.Args)

    // Exit program when we get an error and show error
    if err != nil {
        log.Fatal("Error: ", err)
    }
}

Note: You don't have to use github.com/urfave/cli/v2 package by default, you can use whatever package you want because all we need to publish is the binary file.

The Publishing Part

Click here to continue reading this part

Summary

We made a CLI in Golang
We generated binaries for all major OSs
We published our package
Add dist folder created by goreleaser to .gitignore file

Questions

Join my discord, I answer all questions, here

I have web monetization enabled so you can support my work or give me feedback on this article on what I should improve on.

Socials

Twitter

APIs vs SDKs

Wachira — Mon, 02 Nov 2020 19:30:22 +0000

APIs (Application Programming Interface)

They are all about communications to other apps, they are like a bridge.

What makes them useful?

Communication: allows communication between apps
Abstraction: gets you what saving one the need to know the logic behind
Standardized: there are industry standards that define an API e.g. SOAP, REST(Representational State Transfer), and GRAPH

REST API Request Requirements

Operation: POST, GET, PATCH e.t.c
Parameters: Files, JSON, XML
Endpoint: The URL for the service/app you want to talk to

All REST requests have a response back from the service or app which can be a result, status, or empty content.

SDK (Software Development Kit)

SDK is basically a tool or code that makes API calls for you, an example you SDK could hold methods that one could basically call a payment gateway transaction by either passing certain arguments and get results from the initialized transaction.

What is lossy and lossless compression

Wachira — Sun, 04 Oct 2020 14:07:44 +0000

Just a quick note, this article is based on my own understanding, so my input might be limited if there is anything I leave out of this article please comment, so I can improve on it more. Also will be adding resources were necessary for further research.

For this article I will focus mainly on images, videos will come later as I look into more including video delivery.

What is compression?

Compression is the process of reducing file sizes and changing various attributes of media example an image/video.

Some of the attributes affected by compression are:

file type i.e. jpg, png, wav, mp4. more
resolution i.e. 480p, 1080p, 720p, 4K. more
dimensions i.e. 640x480
bit depth i.e the number of bits to indicate color in a single pixel. more

There are two types of compression, lossy and lossless.

Lossless

Lossless compression means as the file size is compressed, quality is not taken into account, and the file can be compressed to retrieve the lost data from the compression.

There are a number of image file formats that offer lossless compression the common one being Portable Network Graphics (.png). Others include Bitmap (.bmp)(by Microsoft).

Lossy

Lossy compression means as the file size is compressed, there is a loss of quality, and data is lost permanently without retrieval.

The most common lossy image file format is the JPEG, and am pretty if you have used image compression software, the result is always a JPEG, these bad boys can be compressed to bits I tell you, its the reason why some sites restrict uploading or recommend uploading JPEG, example Spotify Playlist cover restricts to JPEG only.

There are also file formats that also do both lossy and lossless, they are the hybrids of image formats. These are:

WebP (.webp) -> by Google
AV1 Image File Format (.avif) -> by Netflix

You might be wondering, how are these file formats able to achieve both types of compression, well they do so because of their ability to use an alpha channel(transparency for UI and design elements) - more.). These file formats boast of high-quality images with smaller file sizes.

Source

Before you go jumping into using this hybrid file formats you have to know they support is not that great especially .avif because it's fairly new and as for .webp I think is not supported in Safari, so rushing to use them you might lose potential users of your product due to accessibility.

You might use AVIF soon as more and more developers are jumping into it by the day increasing adoption.

// Detect dark theme var iframe = document.getElementById('tweet-1307705964141973509-704'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1307705964141973509&theme=dark" }

Lossless Compression Disadvantages?

The resulting compression have large file sizes

Which File Format Should I Use?

Well both lossless and lossy file formats are needed in certain situations example if your product needs to showcase high-quality images then lossless compression is the way to go and expect longer load-times.

Follow me on Twitter @wachira_dev

How to setup Dokku

Wachira — Sat, 22 Aug 2020 21:02:14 +0000

Let's jump into it... fast. You got here because you want to setup Dokku and the other ways don't work... let's goooo

I will setup for Dokku only

Point your domain to the VPS of choice

Spin up new VPS server here:
- Digital Ocean
- Linode
Buy a domain from Namecheap/Godaddy for 0.99\$ for first-time accounts

Create an A record to point to your VPS Ip

 - Type -> A
 - Name -> *.your-domain-name.com
 - Value -> <your.vps.ip>

Just a note pick a VPS server with 1GB RAM memory that will probably cost you \$5

SSH into your server through IP and pass or SSH key if you provided one.

ssh username@ip-address

Change the server hostname

hostnamectl set-hostname <your-domain.com>

echo "<your.vps.ip> <your-domain.com> dokku" >> /etc/hosts

So we gonna use a script to get this thing installed, we will head over to Package cloud to get the script.

The script was created Dokku and they one for each Linux os

Let's run that script on our Ubuntu server

   curl -s https://packagecloud.io/install/repositories/dokku/dokku/script.deb.sh | sudo bash
   sudo apt-get install dokku

Select Yes when this window pops up
Check if dokku is installed by typing id dokku
Start the Dokku service

    sytemctl status dokku-installer.service

Confirm the service is running by typing systemctl is-enabled dokku-installer.service the result is enabled if it's running
Let's install core dependencies

    dokku plugin:install-dependencies --core

Install docker

   wget -nv -O - https://get.docker.com/ | sh

Check if Docker is installed by running

   docker version

    Client:
    Version:           18.06.0-ce
    API version:       1.38
    Go version:        go1.10.3
    Git commit:        0ffa825
    Built:             Wed Jul 18 19:09:54 2018
    OS/Arch:           linux/amd64
    Experimental:      false
    Server:
    Engine:
    Version: 18.06.0-ce
    API version: 1.38 (minimum version 1.12)
    Go version: go1.10.3
    Git commit: 0ffa825
    Built: Wed Jul 18 19:07:56 2018
    OS/Arch: linux/amd64
    Experimental: false

Versions may vary

Configure Dokku by visiting your IP on your browser
- Remember the hostname we provided step 3 just paste on the Hostname input and check the virtualized host checkbox.
- The value for the input of the virtualized hostname will now be.
```
 http://<app-name>.<your-host-name.com>
```

Click on Finish Setup you will be redirected to the dokku docs.

Conclusion

In the next Bits I will look into more Dokku or something else.

What is Dokku

Wachira — Sat, 22 Aug 2020 21:00:17 +0000

So what is Dokku, another bit, another TL;DR;

Let's jump into it.

You might know Heroku, (my opinion) the greatest platform to ever make it easy to deploy server and client-side applications so fast and easy.

Well Heroku is a business and they have to make their money, so it has a pricing plan, and the free tier can only get so far.

So what if..., this is about to blow your mind.
.

You can have your own Heroku-ish, host as many applications as you want(might dent your wallet), set your own rules, and still keep the Heroku's simplicity on deployments.

Its Dokku 🙌

I mean when I discovered Dokku man, been using it ever since -> I frigging love it. Everything basic feature that Heroku offers Dokku offers and its free to host your own Dokku(it's Open-source).

Okay I know if the deal is too good think twice.

So let's jump into the pros and cons of Dokku.

Pros

Allow deployment of apps faster and easier just like Heroku
Allows installation of plugins such as Postgres/MongoDB and more
Allocate certificate with Let's encrypt for free using their plugin
No learning curve if you worked with Heroku CLI
It's cheaper to run Dokku than pay for Dyno hours.
Your apps aren't shutdown on inactivity

Cons

Well, it's all CLI not UI(Heroku kills it here), there are tools that give dokku a UI, will list them in the future.
Cloud version control integrations like Github/BitBucket.
Review app -> Heroku allows branch deploys, Dokku doesn't do that out of the box.
Having your apps run on Heroku lets you worry about other things other than maintaining a server.

Conclusion

If you want to setup Dokku to your web service here

Create API with Gin in Golang Part 3

Wachira — Wed, 12 Aug 2020 21:40:05 +0000

The third part of this series is here, its actually an interesting one because we dabble with a bit of web scrapping and Gin middlewares. In the last part, I mentioned we are going to create a bookmark API instead of TODO, I figured there are way too many out there.

By the end of this article you will have a number of endpoints that perform certain CRUD operations, these are:

Create a bookmark The link is scrapped to collect the meta tag details for Twitter and Facebook if we ever want to show Rich link previews on the client side.
Delete a bookmark
Protect the endpoints with the help of the middleware
Fetch all bookmarks they saved.

Introduction

Prerequisites

The basics of Golang and you read the previous articles in this series.

Getting Started

Goals

A logged-in user is able to create a bookmark
A logged-in user is able to fetch their own bookmarks
A logged-in user is able to delete a bookmark they created
Protect bookmark endpoints with middleware to confirm that

Setup

Go through the last articles for the project setup

Let's hack it

Authentication Middleware

We will need to create a middleware to check if users have logged in order to perform certain actions which are creating, fetching, and deleting bookmarks.

First, we will create a new file under middlewares folder, called authenticate.go

// Define the package
package middlewares

import (
    // Import Gin to abort on any errors
    "github.com/gin-gonic/gin"
    // To retrieve certain methods and User model
    "github.com/tesh254/golang_todo_api/models"
    // Services to enable use to handle decoding jwt tokens
    "github.com/tesh254/golang_todo_api/services"
)

// This will help in handling error response
func responseWithError(c *gin.Context, code int, message interface{}) {
    c.AbortWithStatusJSON(code, gin.H{"message": message})
}

// Authenticate is a middleware that fetches user details from token
func Authenticate() gin.HandlerFunc {
    return func(c *gin.Context) {

        // Fetch token from the headers
        requiredToken := c.Request.Header["Authorization"]

        // Check if the token is provided
        if len(requiredToken) == 0 {
            // Abort with error
            responseWithError(c, 403, "Please login to your account")
        }

        // Get email from encoded token
        userID, _ := services.DecodeToken(requiredToken[0])

        // Fetch user based on email retrieved from token
        result, err := new(models.UserModel).GetUserByEmail(userID)

        // Check if an account was not found
        if result.Email == "" {
            // Respond with a 404 when resource is not found
            responseWithError(c, 404, "User account not found")
            return
        }

        // Check if an error occured while fetching a user
        if err != nil {
            // Respond with an Internal Server Error
            responseWithError(c, 500, "Something went wrong giving you access")
            return
        }

        // Set the User variable so that we can easily retrieve from other middlewares
        c.Set("User", result)

        // Call the next middlware
        c.Next()
    }
}

Scrapping a website

While making this API, having it all plain CRUD did seem fun and felt lazy so I decided to make a scrapper to check the meta tags for the save bookmark.

I was able to achieve this with the help of goquery and net library

The meta tags that we are interested in are twitter: and og: which help Twitter and Facebook respectively show rich link previews when you share links, like the one below

An example of a Twitter meta tag is shown below

<meta property="twitter:site" content="Dev Community" />

All Facebook meta tags have og guess it means Open Graph like their API.

So lets install goquery

go get github.com/PuerkitoBio/goquery

Next lets write the scrapper

// Define the package
package services

import (
    // will allow us to make calls to the website
    "net/http"
    // help in defining a timeout for the request
    "time"

    // Help in finding tags and attributes in the html loaded
    "github.com/PuerkitoBio/goquery"
    // To handle failed responses
    "github.com/gin-gonic/gin"
)

// Scrapper holds methods to scrape a site
type Scrapper struct{}

// Meta define meta data type
type Meta struct {
    Image, Description, URL, Title, Site string
}

// CallWebsite make an http request to a website
func (scrapper *Scrapper) CallWebsite(websiteURL string, c *gin.Context) Meta {
    // Define variable to hold the attributes srapped
    var meta Meta = Meta{
        Image:       "",
        Description: "",
        URL:         "",
        Title:       "",
        Site:        "",
    }

    // Define the client timeout
    client := &http.Client{
        // Set timeout to abort if the request takes too long
        Timeout: 30 * time.Second,
    }

    // Define the request obviously it is a GET one
    request, err := http.NewRequest("GET", websiteURL, nil)

    // Check if we get an error
    if err != nil {
        // Respond with a 500 status code
        c.AbortWithStatusJSON(500, gin.H{"message": err})
    }

    // Set headers
    request.Header.Set("pragma", "no-cache")

    request.Header.Set("cache-control", "no-cache")

    request.Header.Set("dnt", "1")

    request.Header.Set("upgrade-insecure-requests", "1")

    request.Header.Set("referer", websiteURL)

    // Make website request call
    resp, err := client.Do(request)

    // If we have a successful request
    if resp.StatusCode == 200 {
        doc, err := goquery.NewDocumentFromReader(resp.Body)

        if err != nil {
            c.AbortWithStatusJSON(400, gin.H{"message": err})
        }

        // Map through all meta tags fetched
        doc.Find("meta").Each(func(i int, s *goquery.Selection) {
            // Specify the meta tags we want and assign the variables as the doc.Find
            // loops through all of them
            metaProperty, _ := s.Attr("property")
            metaContent, _ := s.Attr("content")

            // If we happen to get any of the two then assign the Site attribute for Meta
            if metaProperty == "og:site_name" || metaProperty == "twitter:site" {
                meta.Site = metaContent
            }

            // If we happen to get any of the two then assign the URL attribute for Meta
            if metaProperty == "og:url" {
                meta.URL = metaContent
            }
            // If we happen to get any of the two then assign the Image attribute for Meta
            if metaProperty == "og:image" || metaProperty == "twitter:image" {
                meta.Image = metaContent
            }

            // If we happen to get any of the two then assign the Title attribute for Meta
            if metaProperty == "og:title" || metaProperty == "twitter:title" {
                meta.Title = metaContent
            }

            // If we happen to get any of the two then assign the Description attribute for Meta
            if metaProperty == "og:description" || metaProperty == "twitter:description" {
                meta.Description = metaContent
            }
        })
    }

    // Return the meta variable with updated fields
    return meta
}

Create a bookmark model

Create a file in the models folder called bookmark.go and lets jump into some code, there is nothing new about this file just defining the methods we are going to use to perform Read and Write operations to the database

// Define the package
package models

import (
    "time"

    "gopkg.in/mgo.v2/bson"
)

// Link defines user object structure
type Link struct {
    ID              bson.ObjectId `json:"_id,omitempty" bson:"_id,omitempty"`
    Name            string        `json:"name" bson:"name"`
    MetaImage       string        `json:"meta_image" bson:"meta_image"`
    MetaDescription string        `json:"meta_description" bson:"meta_description"`
    MetaSite        string        `json:"meta_site" bson:"meta_site"`
    MetaURL         string        `json:"meta_url" bson:"meta_url"`
    MetaTitle       string        `json:"meta_title" bson:"meta_title"`
    Link            string        `json:"link" bson:"link"`
    Owner           bson.ObjectId `json:"owner" bson:"owner"`
    CreateAt        time.Time     `json:"created_at" bson:"created_at"`
}

// BookmarkModel defines the model structure
type BookmarkModel struct{}

// CreateBookmark handles creating a bookmark by the user
func (l *BookmarkModel) CreateBookmark(data Link) error {
    // Connect to the bookmark collection
    collection := dbConnect.Use(databaseName, "bookmark")
    // Assign result to error object while saving bookmark
    err := collection.Insert(bson.M{
        "name":             data.Name,
        "meta_image":       data.MetaImage,
        "meta_description": data.MetaDescription,
        "meta_site":        data.MetaSite,
        "meta_url":         data.MetaURL,
        "meta_title":       data.MetaTitle,
        "link":             data.Link,
        "owner":            data.Owner,
        "created_at":       data.CreateAt,
    })

    return err
}

// FetchBookmarks handles fetching bookmarks by a user
func (l *BookmarkModel) FetchBookmarks(id bson.ObjectId) (bookmarks []Link, err error) {
    collection := dbConnect.Use(databaseName, "bookmark")

    err = collection.Find(bson.M{"owner": id}).Sort("-$natural").All(&bookmarks)

    return bookmarks, err
}

// DeleteBookmark handles deleting a bookmark
func (l *BookmarkModel) DeleteBookmark(id string) error {
    collection := dbConnect.Use(databaseName, "bookmark")

    err := collection.RemoveId(id)

    return err
}

Create the bookmark controllers

Go ahead and create a file on the controllers folder called bookmark.go

package controllers

import (
    "log"
    "time"

    "github.com/gin-gonic/gin"
    "github.com/tesh254/golang_todo_api/forms"
    "github.com/tesh254/golang_todo_api/helpers"
    "github.com/tesh254/golang_todo_api/models"
    "github.com/tesh254/golang_todo_api/services"
)

// Import bookmark model from the models file
var bookmarkModel = new(models.BookmarkModel)

// BookmarkController defines the bookmark controller
type BookmarkController struct{}

func responseWithError(c *gin.Context, code int, message interface{}) {
    c.AbortWithStatusJSON(code, gin.H{"message": message})
}

// FetchBookmarks controller handles fetching all bookmarks of a specific user
func (b *BookmarkController) FetchBookmarks(c *gin.Context) {
    // Get the user we set in the Authenticate middleware
    user := c.MustGet("User").(models.User)

    // Check if we have user and respond if not
    if user.Email == "" {
        responseWithError(c, 404, "Please login")
        return
    }

    // Define a variable to hold the model methods
    var linkModel models.BookmarkModel

    // Fetch own bookmarks based on ID of the user
    results, err := linkModel.FetchBookmarks(user.ID)

    // Check if we have an error performing the database operation
    if err != nil {
        responseWithError(c, 500, "Problem fetching your articles")
        return
    }

    // Return results if none an empty array
    if results != nil {
        c.JSON(200, gin.H{"bookmarks": results})
    } else {
        c.JSON(200, gin.H{"bookmarks": []string{}})
    }

}

// DeleteBookmark controller handles deleting a single bookmark
func (b *BookmarkController) DeleteBookmark(c *gin.Context) {
     // Get the user we set in the Authenticate middleware
    user := c.MustGet("User").(models.User)

    // Check if we have user and respond if not
    if user.Email == "" {
        responseWithError(c, 404, "Please login")
        return
    }

    // Get query parameter value that holds the bookmakr id
    bookmarkID, found := c.GetQuery("bookmark_id")

    // Check if the query parameter `bookmark_id` is provided, respond if not
    if !found {
        responseWithError(c, 400, "Please provide bookmark id")
        return
    }

    // Define variable to hold the model methods
    var linkModel models.BookmarkModel

    // Delete record
    err := linkModel.DeleteBookmark(bookmarkID)

    // Check if we got an error while deleting the file
    if err != nil {
        responseWithError(c, 500, "Problem deleting bookmark")
        return
    }

    // Respond with a 204 No Content on successful delete
    c.JSON(204, gin.H{"message": "Deleted bookmark successfully"})
}

// CreateBookmak controller handles creating a bookmark of a specifi user
func (b *BookmarkController) CreateBookmak(c *gin.Context) {
     // Get the user we set in the Authenticate middleware
    user := c.MustGet("User").(models.User)

    // Check if we have user and respond if not
    if user.Email == "" {
        responseWithError(c, 404, "Please login")
        return
    }

    // Define variable to hold the payload structure
    var data forms.BookmarkPayload

    // Check if required fields are provided
    if c.BindJSON(&data) != nil {
        log.Fatal(c.BindJSON(&data))
        responseWithError(c, 406, "Please provide link, and name")
        return
    }

    // Define variable to hold the model methods
    var linkModel models.BookmarkModel

    // Check if the url is valid and respond if its not
    if !helpers.IsValidURL(data.Link) {
        responseWithError(c, 400, "Link is invalid")
    }

    // Define a variable to hold out scrapper methods
    var scrapper services.Scrapper

    // Make a website request based on the link provided on the request body
    var meta services.Meta = scrapper.CallWebsite(data.Link, c)

    // Define the data to be save to the database
    var bookmarkPayload models.Link = models.Link{
        Name:            data.Name,
        MetaImage:       meta.Image,
        MetaDescription: meta.Description,
        MetaSite:        meta.Site,
        MetaURL:         meta.URL,
        Link:            data.Link,
        Owner:           user.ID,
        CreateAt:        time.Now(),
    }

    // Save the bookmakr
    err := linkModel.CreateBookmark(bookmarkPayload)

    // Check if we got an error while saving and respond if we do
    if err != nil {
        responseWithError(c, 500, "Problem saving your bookmark")
        log.Fatal(err)
        return
    }

    // Return a 201 Created on successful creation with the bookmark saved
    c.JSON(201, gin.H{"message": "Bookmark saved", "bookmark": bookmarkPayload})
}

Some things that I shouldn't leave out

The URL validator

// Define the package
package helpers

// Import the URL
import "net/url"

// IsValidURL checks validity of URL
func IsValidURL(link string) bool {
    // Parse the URL with the net library
    _, err := url.ParseRequestURI(link)

    // Check if we got an error while parsing the url
    if err != nil {
        return false
    }

    u, err := url.Parse(link)

    // Check if we had an error while parsing
    // Check if the scheme is provided https:// http://
    // Check if a host exists google.com, bywachira.com
    if err != nil || u.Scheme == "" || u.Host == "" {
        return false
    }

    return true
}

Bookmark request body structure

package forms

// BookmarkPayload defines the payload sent by the user
type BookmarkPayload struct {
    Name string `json:"name" binding:"required"`
    Link string `json:"link" binding:"required"`
}

This will belong in the forms/bookmark.go file.

And that's it

Define the endpoints

Finally we need to define the endpoints for the bookmark endpoints for us to make calls and make use of the blocks of code we created

// v1 group...

// Define a group to hold the bookmarks
bookmarks := v1.Group("/bookmarks")

// Use the Authenticate middleware
bookmarks.Use(middlewares.Authenticate())

{
    // Create GET request for the bookmakrs
    bookmarks.GET("/all", link.FetchBookmarks)
    // Create POST request to create a bookmark
    bookmarks.POST("/create", link.CreateBookmak)
    // Create DELETE request to delete a bookmark
    bookmarks.DELETE("/delete", link.DeleteBookmark)
}
// ...

Summary

Created endpoints to handle creating, fetching and deleting bookmark(s).
Create a middleware to check if user is authenticated.

Extras

Repo link here
Follow me on twitter here
Join Discord server for any questions here

DEV Community: Wachira

How to move your .ssh generated keys to a new laptop.

Just published the 5th Issue of my Newsletter

How do Notion Web Clipper and Instapaper work?

How To Stream Mp3 With NodeJS To HTML Audio Tag

Prerequisites

Let's get started

Just found out top 10 starred public repos in Github are written in Go.

Will Golang ever stop using their strict GOPATH path in order to code with it

How to create a CLI program in Go and host it on npm

Prerequisites

What are we building?

Lets get started

The Publishing Part

Summary

Questions

Socials

APIs vs SDKs

APIs (Application Programming Interface)

SDK (Software Development Kit)

What is lossy and lossless compression

What is compression?

Lossless

Lossy

Lossless Compression Disadvantages?

Which File Format Should I Use?

Read More

How to setup Dokku

Conclusion

What is Dokku

Its Dokku 🙌

Pros

Cons

Conclusion

Create API with Gin in Golang Part 3

Introduction

Prerequisites

Getting Started

Goals

Setup

Let's hack it

Authentication Middleware

Scrapping a website

Create a bookmark model

Create the bookmark controllers

Some things that I shouldn't leave out

Define the endpoints

Summary

Extras