Why Small Business AI Implementation Matters in 2025

The AI revolution has reached a tipping point. According to recent studies, 73% of small businesses that have implemented AI report increased efficiency, while 67% see improved customer satisfaction within the first six months. More importantly, businesses using AI solutions show an average 15% increase in revenue growth compared to their non-AI counterparts.

The competitive advantage is clear: Early AI adopters in the small business space are capturing market share while their competitors struggle with manual processes and outdated systems.

Step 1: Identify AI Opportunities in Your Business

Before diving into artificial intelligence consulting or purchasing AI tools, you need to identify where AI can make the biggest impact in your operations.

Common AI Implementation Areas for Small Businesses:

Customer Service & Support

• Chatbots for 24/7 customer inquiries
• Automated ticket routing and prioritization
• Sentiment analysis for customer feedback

Sales & Marketing

• Lead scoring and qualification
• Personalized email marketing campaigns
• Predictive analytics for customer behavior

Operations & Inventory

• Demand forecasting and inventory optimization
• Automated scheduling and resource allocation
• Quality control through computer vision

Financial Management

• Automated bookkeeping and expense categorization
• Fraud detection and risk assessment
• Cash flow prediction and budgeting

Action Item: Conduct an AI Readiness Assessment

Create a simple spreadsheet listing your current business processes. For each process, ask:

1. Is this task repetitive and rule-based?
2. Do we have sufficient data to train an AI system?
3. Would automation here save significant time or money?
4. Could AI improve accuracy or customer experience?

Processes scoring high on these criteria are prime candidates for AI implementation.

Step 2: Choose the Right AI Solutions for Your Budget

Not all AI solutions require massive investments. In 2025, small business AI options range from affordable SaaS tools to custom implementations.

Budget-Friendly AI Tools ($50-500/month):

Customer Relationship Management

• HubSpot’s AI-powered lead scoring
• Salesforce Einstein for small teams
• Pipedrive’s sales automation features

Marketing Automation

• Mailchimp’s predictive analytics
• Hootsuite’s AI content scheduling
• Canva’s AI design assistant

Business Operations

• QuickBooks’ AI bookkeeping features
• Calendly’s smart scheduling
• Zapier’s workflow automation

Mid-Range Solutions ($500-2,000/month):

• Custom chatbot development
• Advanced analytics dashboards
• Inventory management AI systems
• Employee scheduling optimization

Enterprise-Level Implementations ($2,000+/month):

• Custom machine learning models
• Computer vision quality control systems
• Predictive maintenance solutions
• Advanced customer analytics platforms

Step 3: Calculate Your AI Implementation ROI

Smart small business owners measure twice and cut once. Before investing in AI, calculate your expected return on investment.

ROI Calculation Framework:

Time Savings Value

• Hours saved per week × hourly wage × 52 weeks = Annual time savings value
• Example: 10 hours/week × $25/hour × 52 = $13,000 annual savings

Revenue Enhancement

• Improved conversion rates × average customer value × annual customers
• Example: 5% conversion improvement × $500 average sale × 1,000 customers = $25,000

Cost Reductions

• Reduced errors, fewer returns, lower customer service costs
• Example: 20% reduction in customer service calls × $50 per call × 2,000 calls = $20,000

Total Annual Benefit: $58,000 Annual AI Investment: $12,000 ROI: 383%

This framework helps justify AI investments to stakeholders and ensures you’re making data-driven decisions.

Step 4: Implementation Best Practices

Successful AI implementation follows proven methodologies. Here’s how to ensure your small business AI project succeeds:

Phase 1: Planning and Preparation (Weeks 1-2)

• Define clear objectives and success metrics
• Assess data quality and availability
• Identify key stakeholders and champions
• Create an implementation timeline

Phase 2: Pilot Testing (Weeks 3-6)

• Start with a small, low-risk use case
• Test with a limited user group
• Gather feedback and iterate quickly
• Document lessons learned

Phase 3: Full Deployment (Weeks 7-10)

• Roll out to all relevant users
• Provide comprehensive training
• Monitor performance metrics closely
• Establish ongoing support processes

Phase 4: Optimization and Scaling (Weeks 11+)

• Analyze performance data
• Fine-tune algorithms and processes
• Identify additional AI opportunities
• Plan next implementation phase

Real-World Success Stories

Case Study 1: Local Restaurant Chain Challenge: Managing inventory across 5 locations AI Solution: Predictive analytics for demand forecasting Results: 30% reduction in food waste, 15% increase in profit margins

Case Study 2: Manufacturing Startup Challenge: Quality control consistency AI Solution: Computer vision inspection system Results: 95% defect detection accuracy, 50% reduction in manual inspection time

Case Study 3: E-commerce Retailer Challenge: Customer service scalability AI Solution: Intelligent chatbot with human handoff Results: 80% of inquiries resolved automatically, 24/7 customer support coverage

Common Implementation Pitfalls to Avoid

Learning from others’ mistakes can save you time and money:

1. Starting Too Big: Begin with simple, high-impact use cases
2. Ignoring Data Quality: Clean, organized data is essential for AI success
3. Skipping User Training: Even the best AI tools fail without proper adoption
4. Unrealistic Expectations: AI is powerful but not magic—set realistic timelines
5. Going It Alone: Partner with experienced AI consultants for complex implementations

Getting Started: Your Next Steps

Ready to implement AI in your small business? Here’s your action plan:

Week 1:

• Complete the AI readiness assessment
• Research 3-5 relevant AI tools for your industry
• Calculate potential ROI for your top opportunities

Week 2:

• Schedule demos with AI solution providers
• Consult with artificial intelligence consulting experts
• Create an implementation budget and timeline

Week 3:

• Select your first AI implementation
• Begin pilot testing with a small team
• Document your process for future scaling

Why Partner with AI Consulting Experts

While many AI tools are user-friendly, working with experienced artificial intelligence consulting professionals can accelerate your success and avoid costly mistakes. Professional AI consultants bring:

• Industry-specific expertise and best practices
• Technical knowledge for complex integrations
• Objective vendor evaluation and selection
• Ongoing support and optimization services
• Strategic guidance for long-term AI adoption

The investment in professional AI consulting often pays for itself through faster implementation, better tool selection, and avoiding common pitfalls.

Conclusion: The Future is AI-Powered

Small business AI implementation is no longer a luxury—it’s a necessity for staying competitive in 2025 and beyond. By following this step-by-step guide, calculating your ROI, and learning from real-world examples, you can successfully integrate AI into your operations and unlock significant growth opportunities.

Remember, the goal isn’t to implement AI for its own sake, but to solve real business problems and create measurable value. Start small, measure results, and scale what works.

Ready to explore how AI can transform your small business? The journey begins with a single step—and the competitive advantages await those bold enough to take it.

Need help implementing AI in your small business? RavSam Web Solutions specializes in artificial intelligence consulting for small and medium businesses. Contact us for a free AI readiness assessment and discover how we can help you leverage AI for growth.

Related Resources:

• Small Business AI Tools Comparison Chart
• AI Implementation Checklist Template
• ROI Calculator Spreadsheet

Contents

• Prerequisites
• Reading App Information Files
• Creating an App Information Component
• Conclusion

Prerequisites

For this tutorial, it is assumed that you have already set up a Nuxt app and have a manual or automated way of adding .version and .last-updated-at files to your project.

We build our Nuxt app using Github Actions. In our workflow, we have set up a system that automatically determines the next release version and adds it to the .version file. At the same time, it also creates a .last-updated-at file and adds to it the build date and time.

Reading App Information Files

The first step is to be able to read the contents of .version and .last-updated-at files. The only place this can be done is the nuxt.config.js.

To read the files on the file system, first, you need to install the fs NPM package. To do so, open your terminal, navigate to your project directory and run the following command:

npm install fs

Next, add the following code at the start of the nuxt.config.js file:

import fs from 'fs'

// 1
let appVersion
try {
  appVersion = fs.readFileSync('./.version', 'utf8')
} catch (err) {
  appVersion = 'dev'
}

// 2
let appLastUpdatedAt
try {
  appLastUpdatedAt = fs.readFileSync('./.last-updated-at', 'utf8')
} catch (err) {
  appLastUpdatedAt = new Date()
}

In the above code:

1. You try to read the .version file using the fs.readFileSync method and assign the result to appVersion. In case the .version file doesn’t exist, an error occurs, so appVersion is set to dev.
2. In the same way, you try to read the .last-updated-at file using the fs.readFileSync method and assign the result to appVersion. In case the .last-updated-at file doesn’t exist, an error occurs, so appLastUpdatedAt is set to the current time (new Date()).

Finally, in the export default object of the nuxt.config.js, add the appVersion and appLastUpdatedAt variables to the publicRuntimeConfig object:

export default {
  ...

  // environment variables used by nuxt
  publicRuntimeConfig: {
    appVersion,
    appLastUpdatedAt,
  },
  ...
}

By adding variables to publicRuntimeConfig, you can access them anywhere - both client and server side - in the Nuxt app using $config.appVersion and $config.appLastUpdatedAt.

Creating an App Information Component

Now that your configuration is set, it’s time to create an app information component.

First, create an AppInfo.vue file in the components directory and add the following template code to it:

<template>
  <div>
    Version: <b>{{ $config.appVersion }}</b>
    <br />
    Updated at: <b>{{ $config.appLastUpdatedAt }}</b>
  </div>
</template>

Next, you can import this component in a layout or in a page by adding the following code:

<template>
  <app-info />
</template>

Finally, restart your Nuxt app by running the following command in your terminal:

npm run dev

Open your app in the browser and you’ll get something like this:

We have skipped the styling part as you can style the app information component as per your liking.

Conclusion

That’s it! You have successfully implemented an app information component in your Nuxt app. In the same way, you can add things like Changelog, What’s New, and more to your app by taking the help of publicRuntimeConfig in a Nuxt app.

Contents

• Getting Started
• Creating a New Project
• Launching an Emulator Device
• Building UI
  • Adding a Form for User Input
  • Adding a Container for Calculations
• Calculating Tip and Total Amount
  • Updating State
  • Updating UI on User Input
• Testing the App Manually
• What’s Next?

Getting Started

Flutter lets you create your project on many operating systems. For example, macOS, Linux, Windows, or even Chrome OS.

Before getting started with this project, you’ll need the following things:

• Flutter - This tutorial uses Flutter 2.5
• IDE - VS Code or Android Studio - This tutorial uses VS Code.
• Dart - This tutorial uses Flutter 2.13

You can download the code used in this tutorial from this GitHub repository.

Creating a New Project

The first step is to create a new Flutter project. Open your terminal, navigate to a path of your choice and run the following command:

flutter create tip_calculator

Once your project is set up, navigate into the project directory and open it in your IDE. For VS Code, you can run the following commands:

cd tip_calculator
code .

Locate lib/main.dart file and you’ll find a lot of boilerplate code written for you. You are here to learn to write code on your own, so replace the file contents with the following code:

import 'package:flutter/material.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({Key? key}) : super(key: key);
  
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Tip Calculator',
      theme: ThemeData(primarySwatch: Colors.green),
      home: const FormView(),
    );
  }
}

As you can see in the above code, you need a FormView screen as the home page of your app. So in the lib/main.dart, add the following code:

class FormView extends StatefulWidget {
  const FormView({Key? key}) : super(key: key);
  
  @override
  _FormViewState createState() => _FormViewState();
}

class _FormViewState extends State<FormView> {
  @override
  void initState() {
    super.initState();
  }
  
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Tip Calculator'),
      ),
    );
  }
  
  @override
  void dispose() {
    super.dispose();
  }
}

At this point, you have a MyApp class which is a Stateless widget, and a FormView class which is a Stateful widget.

You use a stateful widget when you want to keep track of the state of your app. The UI of a stateful widget is always the function of the state of the widget. For example, a cart page in an eCommerce app. In all other cases, a stateless widget is often handier. It always builds the same UI regardless of the state of the app. For example, the logo for your app on an appbar.

The beauty of Flutter is you can compose Stateful widgets in Stateless widgets. As you develop more and more Flutter apps, you’ll learn to use Stateless widgets more often.

Launching an Emulator Device

At this point, you have enough code to launch your app without any build errors. The next thing you need to do is to connect to a physical device or an emulator. In this tutorial, you’ll work on an emulator.

In VS Code, open the Command Palette by pressing Control-Shift-P, type Flutter: Launch Emulator, and press Enter. Select a Mobile Device emulator and wait for it to initialize.

Once your emulator is up and running, press F5 to build and run your Flutter app in debug mode. You’ll see the following screen pop up on your emulator:

This screen contains an app bar with your app title.

Building UI

Now your Flutter app is up and running, it is time to build the UI of the app. This app will have a Form with two Text fields and a Column for showing Tip Amount and Total Amount.

Adding a Form for User Input

Update the build function of the _FormViewState class by adding body for your FormView as in the following code:

body: Container(
  padding: const EdgeInsets.all(16.0),
  child: Form(
    child: Column(
      children: [
        TextFormField(
          decoration: const InputDecoration(labelText: 'Bill Amount'),
          keyboardType: const TextInputType.numberWithOptions(
            decimal: true,
          ),
        ),
        const SizedBox(height: 16),
        TextFormField(
          decoration: const InputDecoration(labelText: 'Tip Percentage'),
          keyboardType: const TextInputType.numberWithOptions(
            decimal: true,
          ),
        ),
        const SizedBox(height: 32),
        // todo
      ],
    ),
  ),
),

Save your progress by pressing Control-S and you’ll experience the Hot Reload feature of Flutter. Whenever you update your code, Flutter only rebuilds the part of the widget tree which is dependent upon the changed code rather than rebuilding the entire app. This feature in Flutter is called Hot Reload which lets you develop applications rapidly.

Build and run:

At this point, you have a Form with two TextFormField widgets for Bill Amount and Tip Percentage.

One of the specifications of the app is to have default values of 0 and 15 for the Bill Amount and Total Amount fields respectively.

So, in the _FormViewState class, add the following two class variables:

double _billAmount = 0;
double _tipPercentage = 15;

Update the TextFormField widget for Bill Amount as in the following snippet:

initialValue: _billAmount.toString(),

Then, update the TextFormField widget for Tip Percentage as in the following snippet:

initialValue: _tipPercentage.toString(),

This will assign a default value to both fields. Since initialValue needs to be a string, so you need to parse the double to a string.

At this point, if you try to do a Hot Reload, it won’t update your app for the changes you have made. This is because the global and static fields relate to the state and Hot Reload excludes any changes made to the app state. In this case, you need to Hot Restart your app.

In VS Code, build and run by pressing Control-Shift-F5 for Hot restart:

At this point, you have successfully rendered your form with two text fields for taking the user input.

Adding a Container for Calculations

Your form UI is complete at this stage. Next, you need to add some Text widgets to show the calculations for Tip Amount and Total Amount.

Add the following widget to the build function of the _FormViewState:

Column(
  children: [
    Row(
      children: [
        const Text('Tip Amount: '),
        Text(
          _totalTip.toString(),
          style: const TextStyle(fontWeight: FontWeight.bold),
        ),
      ],
    ),
    const SizedBox(height: 16),
    Row(
      children: [
        const Text('Total Amount: '),
        Text(
          _totalAmount.toString(),
          style: const TextStyle(fontWeight: FontWeight.bold),
        ),
      ],
    ),
  ],
),

If you try to build and run your project, you’ll get some build errors. This is because, in the Text widgets, you are referencing the _tipAmount and _totalAmount variables which you haven’t declared yet.

So, in the _FormViewState class, add the following two class variables:

double _totalTip = 0;
double _totalAmount = 0;

These variables store the calculations related to Tip Amount and Total Amount.

Build and run your project:

At this point, you have successfully rendered a column containing two text labels to show calculations.

Calculating Tip and Total Amount

The app’s UI is complete at this stage. Next, you need to write business logic for calculating Tip Amount and Total Amount.

Updating State

In the _FormViewState class, add the _updateAmounts function as in the following code snippet:

void _updateAmounts() {
  setState(() {
    _totalTip = _billAmount * _tipPercentage / 100;
    _totalAmount = _billAmount + _totalTip;
  });
}

You might ask what is setState? Well, setState is a function provided by a Stateful widget using which you can update the state of your app. Whenever you call setState, Flutter executes the build function associated with the Stateful widget. This updates the UI of your app.

In the setState function, you have used some basic maths for calculating the total tip and total amount.

In this app, you don’t have to worry about government tax. It is better to keep governments out when you are learning something.

Updating UI on User Input

One requirement of this app is to calculate Tip Amount and Total Amount as soon as the user starts typing in the form fields. For this effect, you can use the onChanged callback provided by the TextFormField widget. It runs whenever the user types or deletes anything in a form field. It provides the current value of a form field as a function parameter.

Add the following parameter to the TextFormField widget for Bill Amount:

onChanged: (val) {
  _billAmount = double.tryParse(val) ?? 0;
  _updateAmounts();
},

Then, add the following parameter to the TextFormField widget for Tip Percentage:

onChanged: (val) {
  _tipPercentage = double.tryParse(val) ?? 0;
  _updateAmounts();
},

Here what’s going on in the code above:

• You cannot assign the val variable to the _billAmount variable as the former is a string and the latter is a double. Hence, you use the double.tryParse function to parse a string to a double.
• Since user input can be empty, so val can be empty, hence double.tryParse can return a null value. So, you use a null check operator(??) to assign _billAmount to 0 when the user input is empty.
• After determining the _billAmount, you call the _updateAmounts function. It calculates the Tip Amount and Bill Amount and updates the UI of the app.

The same procedure applies to the working of the Tip Percentage text field.

Testing the App Manually

The coding part of your app is complete and the final step is to test whether it is doing the right calculations.

A good test covers some common use cases. You can test each of the below three test cases and make sure the app’s output matches the required output.

Before testing, make sure to use Hot Restart to build and run your app:

Congratulations! The app is showing accurate results. You are ready to use it when you go out for lunch and tip the waiter.

What’s Next?

In this tutorial, you learned about creating UI in Flutter, Stateless and Stateful widgets, Hot Reloading, managing state, and updating UI. You can add more features to your app, like a Number of Friends field, which you can use to divide the total amount between your friends.

In this tutorial, you’ll learn to implement a progress bar in a Next.js app.

Contents

• Installing NProgress
• Understanding Basic Usage
• Results

Installing NProgress

The first thing you need to do is to install nprogress NPM package.

To install nprogress, run the following command in your terminal:

npm i nprogress

Understanding Basic Usage

In the pages/_app.js, import the following modules:

import Router from 'next/router'
import NProgress from 'nprogress'

Now, you need to add some router events to control the behaviour of the progress bar.

In the pages/_app.js, add the following code:

Router.events.on('routeChangeStart', () => NProgress.start())
Router.events.on('routeChangeComplete', () => NProgress.done())
Router.events.on('routeChangeError', () => NProgress.done())

Depending upon your use case, you can remove the default loading spinner.

NProgress.configure({ showSpinner: false })

The final code for pages/_app.js will look like this:

import Router from 'next/router'
import NProgress from 'nprogress'

Router.events.on('routeChangeStart', () => NProgress.start())
Router.events.on('routeChangeComplete', () => NProgress.done())
Router.events.on('routeChangeError', () => NProgress.done())

NProgress.configure({ showSpinner: false })

function MyApp({ Component, pageProps }) {
  return <Component {...pageProps} />
}

export default MyApp

Results

At this point, you are done with the code and the final step is to test your app.

Go to your Next.js app and navigate to a new route. Your progress bar will be displayed like this:

Contents

• 1. Installing Bootstrap
• 2. Creating a Custom SCSS
• 3. Configuring Next Config
• 4. Importing Bootstrap

1. Installing Bootstrap

Let us get started by installing the required NPM packages. We will install bootstrap and optionally react-bootstrap.

Since we are going to create custom SCSS files, we also need to install node-sass.

npm install bootstrap react-bootstrap
npm install node-sass --save-dev

2. Creating a Custom SCSS

Let us now create a custom scss file in the styles/scss directory, and name it global.scss. In this file, we need to import Bootstrap’s bootstrap.scss. For the sake of simplicity, let us override the default colour system provided by Bootstrap.

$theme-colors: (
  'primary': #145bea,
  'secondary': #833bec,
  'success': #1ce1ac,
  'info': #ff7d50,
  'warning': #ffbe0b,
  'danger': #ff007f,
  'light': #c0ccda,
  'dark': #001738,
);

@import '/node_modules/bootstrap/scss/bootstrap.scss';

3. Configuring Next Config

The best part about the newer versions of Next is that they provide built-in SASS/SCSS support. All we need to tell Next is where our styles are stored by configuring the next.config.js and adding the following piece of code:

const path = require('path')

module.exports = {
  
  ...

  sassOptions: {
    includePaths: [path.join(__dirname, 'styles')],
  },
}

4. Importing Bootstrap

The final step is to import our custom Bootstrap into our project. Based on where we need to use the custom styles, we can import our global.scss. In this example, let us configure it to be used by the entire project.

In pages/_app.js file, we need to add the following code:

import 'styles/scss/global.scss' // added

function MyApp({ Component, pageProps }) {
  return <Component {...pageProps} />
}

export default MyApp

We have done it. We have set up Bootstrap in our Next project.

In this tutorial, you’ll learn to use VS Code Tasks by taking the example of pre-release commands and ensure that no step is missed along the way.

Contents

• Prerequisites
• Writing Pre Release Script
• Setting Tasks
• Running Tasks
• Conclusion

Prerequisites

• A Local Git Repository
• VS Code Editor
• Linux Environment

Writing Pre Release Script

The first thing you need to do is to create a script - in this case, a bash script. In this script, you’ll define what steps you need to perform as a part of your pre-release operation.

Assume that before releasing, you do two operations. First, you create a .version file and add today’s date to it. Then you create an empty commit with a message - do-production-release.

With the steps determined, create a pre-release.sh in .vscode directory and add the following code:

#!/bin/sh

date > .version
git commit --allow-empty -m "do-production-release"

You can test the above script by doing:

bash .vscode/pre-release.sh

Make sure to give proper permissions to the script before running it.

Setting Tasks

Now comes the most interesting part of the tutorial. VS Code allows you to specify tasks in tasks.json. The beauty of the VS Code tasks is that you can run them directly from VS Code Command Palette which is especially helpful for non-technical members of your team.

Create a tasks.json file in the .vscode directory and add the following contents in the file:

{
    "version": "2.0.0",
    "tasks": [
        {
            "label": "Pre-Release Setup",
            "type": "shell",
            "command": "bash",
            "args": ["${workspaceFolder}/.vscode/pre-release.sh"]
        }
    ]
}

It is important to understand what you are doing so that you can customize the workflow according to your needs.

label is used to identify the script in the VS Code Command Palette.

"label": "Pre-Release Setup"

type is set to shell since you need to execute a shell script.

"type": "shell"

command is used the specify the base command to which the arguments can be passed.

"command": "bash"

args is an array that provides arguments to the command. ${workspaceFolder} is the internal variable provided by the VS Code. It is the absolute path to your project’s root directory.

"args": ["${workspaceFolder}/.vscode/pre-release.sh"]

Running Tasks

Open the VS Code Command Palette by pressing Ctrl + Shift + P, type Tasks: Run Task and press Enter.

You’ll be presented with a list of tasks that you specified in the tasks.json. Next, select the Pre-Release Setup and press Enter. You’ll see the task output in VS Code Integrated Terminal.

Conclusion

You now have a good overview of how you can use VS Code tasks to run your scripts as tasks in a better way. You can also add more tasks like running pre-staging release, running pre-dev release, etc.

Contents

• 1. Vetur
• 2. Vue Discovery
• 3. Vue Peek
• 4. HTML CSS Class Completion
• 5. Import Cost
• 6. Internationalization
• 7. Path Intellisense
• 8. SVGO

1. Vetur

Vetur is the king of all extensions you need as a Vue/Nuxt Developer. It is a Vue tooling for VS Code. It comes with Vue Language Server and other features like syntax highlighting, formatting, intellisense, debugging, and more.

2. Vue Discovery

Vue Discovery is a great plugin that adds to the powers of Vetur. This extension discovers Vue components in your workspace and provides IntelliSense for them. It provides intellisense for components in the template section, allows you to automatically import, register, and expand required props, and more.

In Short: Vue component name completion across a project

3. Vue Peek

Vue Peek allows you to go to the definition for your Vue components. It allows you to look under the hood of the Vue component declarations. It allows you to quickly jump to or peek into files that are referenced as components (from template), or as module imports (from a script).

The extension supports all the normal capabilities of symbol definition tracking and does it for CSS selectors - classes and IDs - as well.

In Short: Peek inside Vue SFCs

4. HTML CSS Class Completion

HTML CSS Class Completion is an amazing Visual Studio Code extension that provides CSS class name completion for the HTML class attribute based on the definitions found in your workspace or external files referenced through the link element. It is extremely handy while designing the UI of the application as it gives you quick access to the CSS classes available.

In Short: CSS class completion in your HTML template

5. Import Cost

As a developer, your primary concern is to make sure that the application size doesn’t go beyond a certain limit. Import Cost extension displays the size of the imported package inline in the editor.

It currently supports

• Default importing: import Func from 'utils';
• Entire content importing: import * as Utils from 'utils';
• Selective importing: import {Func} from 'utils';
• Selective importing with alias: import {orig as alias} from 'utils';
• Submodule importing: import Func from 'utils/Func';
• Require: const Func = require('utils').Func;
• Both Javascript and Typescript

In Short: Tells you the size of your npm imports

6. Internationalization

Internationalization or i18n allows you to write your application text in different languages for different regions.

i18n supports multi-root workspaces, remote development, many popular frameworks, linked locale messages, and eliminates the need to use JSON files for i18n as is done traditionally.

In Short: i18n toolset for multilingual support, works great with vue-i18n

7. Path Intellisense

One of the VS Code extensions that we use at RavSam is Path Intellisense. It provides autocompletion for file paths present in your current VS Code workspace.

In Short: File path completion

8. SVGO

SVGO Extension for Visual Studio Code is built on the top of SVGO NPM module. It allows you to minify and prettify the SVG file in place.

In Short: Minimize SVG files in two keystrokes

Managing a single piece of software is easy but as a developer, we often have to deal with more than one. And this is exactly where maintenance gets hard. The best way to handle Maintenance debt is to upgrade the dependencies on which our project depends regularly.

All these problems can be solved by automation. At RavSam, we use Github for our code handling and Github Apps and Github Actions for CI/CD purposes.

Contents

• Renovate - Automated Dependency Updates
• Imgbot - Automated Image Optimization
• RavSam Bot - A Github Probot App

Renovate - Automated Dependency Updates

Renovate is one of those apps that make our idea of automated maintenance a reality. It is a free, open-source, customizable GitHub app that helps us to automatically update our dependencies in software projects by receiving pull requests and that too for multiple languages.

The best part is that you can write a single config and use it for all of your projects in your GitHub organization. Here is a Renovate bot config that we use at RavSam:

{
  "extends": ["config:base", "group:monorepos"],
  "dependencyDashboard": false,
  "automergeType": "branch",
  "major": {
    "enabled": false
  },
  "packageRules": [
    {
      "matchUpdateTypes": ["minor", "patch", "pin", "digest"],
      "automerge": true,
      "labels": ["dependencies"]
    },
    {
      "depTypeList": ["devDependencies"],
      "schedule": ["before 9am on the first day of the month"],
      "matchUpdateTypes": ["minor", "patch", "pin", "digest"],
      "automerge": true,
      "labels": ["dev-dependencies"]
    }
  ],
  "prCreation": "not-pending",
  "schedule": ["before 9am every weekend"],
  "stabilityDays": 3,
  "timezone": "Asia/Kolkata"
}

We have configured Renovate to run the development dependencies updation process only on the first day of the month to prevent noise and distractions. We have enabled auto-merge when the update type is one of the following: minor, patch, pin, or digest.

Imgbot - Automated Image Optimization

The performance of a Web App is often dependent on the images. Hence it is crucial to optimize images or else lose customers. Another advantage of optimized images is that it reduces the bandwidth costs for us as well as our visitors.

We love Imgbot app. It optimizes the images and creates a pull request against our default branch - master. Imgbot is verified by GitHub which means there is no point worrying about the security.

RavSam Bot - A Github Probot App

We have built our custom serverless GitHub Probot - RavSam Bot, our employee #1. It helps us automate various tasks like managing issues by raising their priority, assigning confirmed issues to developers, assigning reviewers to the pull requests, auto-merging them once the changes have been approved, and many more things.

A fun fact about this bot is that it has made more commits than the actual humans.

Probot apps are easy to write, deploy, and share. We have deployed our probot app on Netlify Functions and it spends the entire day doing mundane tasks for us tirelessly.

In this article, you’ll build a serverless bot and deploy it to Netlify Functions. The advantage of using Netlify Functions is that it is free for up to 125,000 requests per month which is more than enough for a startup or a small organization.

Contents

• Prerequisites
• Writing Application Logic
• Deploying on Netlify Functions
• Updating Webhook URL
• Results

Prerequisites

• You can follow this guide on how to set up Probot.

Writing Application Logic

Once your Probot is set up, you need to do some changes to your directory structure to deploy it to Netlify Functions.

Create an src directory and add the following code in a new file - app.js:

/**
 * This is the main entrypoint to your Probot app
 * @param {import('probot').Probot} app
 */

module.exports = (app) => {
  app.log.info('App has loaded');

  app.on('issues.opened', async (context) => {
    context.octokit.issues.createComment(
      context.issue({
        body: 'Thanks for opening this issue!',
      })
    );
  });
};

In the above code whenever a new issue is opened, it creates an issue comment thanking the issue author.

Netlify Functions are AWS Lambda functions but their deployment to AWS is handled by Netlify. For deploying your Probot on Netlify, you can use the AWS Lambda adapter for Probot.

In your terminal, execute the following command:

npm install @probot/adapter-aws-lambda-serverless

The next thing you need to do is to create a functions directory that will be used by Netlify to deploy your serverless functions. Every JS file in the functions directory is deployed as an individual function which can be accessed at <domain>/.netlify/functions/<function_name>.

In the functions directory, create an index.js file and add the following code:

const { createLambdaFunction, createProbot } = require('@probot/adapter-aws-lambda-serverless');
const app = require('../src/app');

module.exports.handler = createLambdaFunction(app, {
  probot: createProbot(),
});

At this point, your code is finally done and the next step is to deploy your application to Netlify.

Deploying on Netlify Functions

Before proceeding with setup for deployment, there are some issues to be addressed. You need to create a configuration file, netlify.toml at the root of the project, and tell some important things to Netlify to consider when deploying your bot.

Add the following code in the netlify.toml:

[build]
command = "npm install --production"
functions = "./functions"

You are telling Netlify to run npm install before deploying your functions which are present in the functions directory.

To deploy on Netlify, you can use Netlify Dev. For that you need to install netlify-cli by doing:

npm install netlify-cli -g

Next, log in to your Netlify account by doing:

netlify login

Once you are logged in, connect your local project directory to Netlify Functions. You can either connect to an existing one or create a new one by doing:

netlify init

Once your site is connected, you can build your site locally and deploy it to Netlify by doing:

netlify build
netlify deploy --prod

You can also connect your GitHub Repository to your Netlify project or use GitHub Actions to deploy your bot to Netlify. {.alert alert-info}

Updating Webhook URL

Once you have deployed your Probot, you need to update the Webhook URL to tell Github where to send the event payloads. To do so, visit [https://github.com/settings/apps/<app-name>](https://github.com/settings/apps/<app-name>) and update the Webhook URL with your Netlify website URL.

Results

You are done with developing and deploying your Probot and now need to test it by creating an issue on a repository where you installed your GitHub app and see whether your bot responds back or not.

Awesome! You can see that your bot welcomed you with a message that you wrote in your code.

There are many things to automate on Github like auto assigning developers to the issues, auto assigning reviewers to a pull request, auto merging pull requests created by dependabot alerts, and much more.

Contents

• 1. Create a Non-Root User
• 2. Create a Public-Private Key Pair
• 3. SSH as a new user
• 4. Add SSH Key to Authorized Keys
• 5. Configure Firewall
• 6. Remove Apache and Install Nginx
• 7. Install Node Using NVM
• 8. Install PM2
• 9. Install Database (MariaDB/MySQL)
• 10. Create Nginx Server Blocks
• 11. Setup DNS
• 12. Install SSL
• 13. Run Strapi App

Prerequisites

To follow along, make sure you have the following

• Hostinger VPS Plan 1
• Ubuntu 20.04

Replace all the values in <> with your own values while following this tutorial.

1. Create a Non-Root User

It is a good idea to create a non-root user with sudo privileges. All the commands will be run through this user. The first step is to log in as the root user.

ssh root@<VPSIPADDRESS>

The very first thing to do on a new machine is to update the packages and remove the older ones. To do so, run the following commands:

sudo apt update -y && sudo apt upgrade -y && sudo apt autoremove -y

Now your machine is up to date and you need to create a new user and log out of the session.

adduser <NEWUSER>
usermod -aG sudo <NEWUSER>
exit

2. Create a Public-Private Key Pair

It is great to use Public-Private key pair to SSH into a remote server. You can create a new one by doing:

ssh-keygen

or copy the existing one’s public key onto your clipboard by running the following command:

xclip -selection clipboard -in ~/.ssh/hostinger_rsa.pub

3. SSH as a new user

Next, SSH as a new user using password authentication.

ssh <NEWUSER>@<VPSIPADDRESS>

Once you are logged in, you need to create a directory for the new user identified by its name.

mkdir -p <NEWUSER>
cd <NEWUSER>

4. Add SSH Key to Authorized Keys

Register your public key by adding it to your authorized keys so that you can log in using a private key.

mkdir -p  ~/.ssh/
sudo echo "<COPIED_PUBLIC_KEY>" >> ~/.ssh/authorized_keys

5. Configure Firewall

Now is the time to set up a firewall. A firewall is essential while setting up VPS to restrict unwanted traffic going out or into your VPS. Install ufw and configure a firewall to allow SSH operations by doing:

sudo apt install ufw -y
sudo ufw allow OpenSSH
sudo ufw enable -y
sudo ufw status

6. Remove Apache and Install Nginx

Nginx is a much better server than Apache. It is lightweight, easy to set up, and allows you to set up proxies.

Before installing Nginx, you can remove Apache which is available by default in Ubuntu 20.04 by running the following commands:

sudo systemctl stop apache2 && sudo systemctl disable apache2
sudo apt remove apache2 -y && sudo rm /var/www/html/index.html
sudo apt autoremove -y

Now install Nginx by doing:

sudo apt install nginx -y
sudo systemctl start nginx
sudo systemctl status nginx

Next, configure the firewall to allow HTTP and HTTPS traffic to pass through it.

sudo ufw allow 'Nginx Full'
sudo ufw enable -y
sudo ufw status

You can also allow either HTTP or HTTPS by using:

sudo ufw allow 'Nginx HTTP'
# or 
sudo ufw allow 'Nginx HTTPS'

To verify Nginx installation, visit the IP address of the VPS.
You can find IP address by curl -4 icanhazip.com.

7. Install Node Using NVM

Next, it is time to install Node using NVM. The following code helps you find the current nvm version:

nvmversion=$(curl --silent "https://api.github.com/repos/nvm-sh/nvm/releases/latest" | grep '"tag_name":' | sed -E 's/.*"([^"]+)".*/\1/')
curl -o- "https://raw.githubusercontent.com/nvm-sh/nvm/$nvmversion/install.sh" | bash

Some NPM packages require to refer to numerous packages needed for building software in general. So you’ll need to install the build-essential package by doing:

sudo apt install build-essential -y

8. Install PM2

PM2 is a process manager built for production-level apps. It can help you run your Strapi app when the server restarts. It can watch for file changes and restart the server automatically for us.

npm i -g pm2@latest
cd ~
pm2 startup systemd

Follow the rest of the instructions as specified on the terminal and then do pm2 save.

9. Install Database (MariaDB/MySQL)

MariaDB is a fork of MySQL with lots of performance gains. So, install this database server by doing:

sudo apt install mariadb-server -y
sudo mysql_secure_installation

Follow all the instructions and complete the setup.

Once your MariaDB server is installed, you need to create a non-root user with root privileges for database operations.

sudo mariadb

GRANT ALL ON *.* TO '<NEWUSER>'@'localhost' IDENTIFIED BY '<PASSWORD>`' WITH GRANT OPTION;
FLUSH PRIVILEGES;
EXIT;

Once this is done, restart your database server by doing:

sudo systemctl restart mariadb

10. Create Nginx Server Blocks

It is always a good idea to server blocks rather than to change the default Nginx configuration. This helps you to host multiple websites on the same server. To create a server block, run the following command:

sudo nano /etc/nginx/sites-available/<YOUR_DOMAIN>

Then, add the following configuration code in it:

upstream <YOUR_DOMAIN> {
  server 127.0.0.1:1337;
  keepalive 64;
}

server {
  server_name <YOUR_DOMAIN>;
  access_log /var/log/nginx/<YOUR_DOMAIN>-access.log;
  error_log /var/log/nginx/<YOUR_DOMAIN>-error.log;
  location / {
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_set_header Host $http_host;
    proxy_set_header X-NginX-Proxy true;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
    proxy_pass http://<YOUR_DOMAIN>;
    proxy_redirect off;
    proxy_http_version 1.1;
    proxy_cache_bypass $http_upgrade;
  }
}

server {
  listen 80;
  server_name <YOUR_DOMAIN>;
}

This configuration assumes that your Strapi app will run on 127.0.0.1:1337.

Once your configuration is set up, you need to enable your website by creating a symbolic link for your configuration file. To do so, run the following command:

sudo ln -s /etc/nginx/sites-available/<YOUR_DOMAIN> /etc/nginx/sites-enabled/

This is optional but if you are serving multiple domains or subdomains from your server, you need to edit your nginx.conf by uncommenting this line server_names_hash_bucket_size 64; using:

sudo nano /etc/nginx/nginx.conf

Quickly check that your configurations are error-free by running:

sudo nginx -t

The output will tell you whether an error exists or not. If any error comes up, you need to resolve it and then finally restart the server by doing:

sudo systemctl restart nginx

11. Setup DNS

In your domain provider, you need to add an A record to point your subdomain to the VPS as follows:

The DNS propagation can take upto 24 hours.

12. Install SSL

The final step is to issue an SSL certificate for your Strapi app. You can automate the process of issuing certificates to your domain using certbot. Running the following commands will help you issue a Let’s Encrypt SSL certificate for your domain.

sudo apt install certbot python3-certbot-nginx -y
sudo certbot --nginx -d <YOUR_DOMAIN>

Follow all the instructions on the terminal. Use the Redirect option to redirect HTTP traffic to HTTPS.

The advantage of the above commands is that the certbot process runs twice a day to check if any certificates will expire within a month. It automatically renews the certificates so you don’t have to worry about certificate expiration. You can verify this by running:

sudo systemctl status certbot.timer

13. Run Strapi App

Now that your server setup is complete and it is time to run your Strapi app using PM2 by running the following commands:

cd ~
cd api
pm2 start ecosystem.config.js

At this point, visit your Strapi domain and verify that your Strapi app is running.

In this blog, you’ll see how to set up GitHub Actions workflows for static analyzing your code before merging it with your production codebase.

Contents

• Prerequisites
• Basic Analysis Options
• Setting up GitHub Actions
• Results

Prerequisites

Before getting started, make sure to have a Dart project ready. For this tutorial, you can follow along with:

• A Sample Dart Project

Basic Analysis Options

Static Analysis helps you to find problems in your code before executing it. It’s a great tool that you can integrate into your development environment to prevent bugs and ensure that your code conforms to styling guidelines especially when you are working in a team.

analysis_options.yaml is a YAML file that you can use to specify the lint rules. Create this file at the root of your project and add the following code to it:

include: package:lint/analysis_options.yaml

analyzer:
  errors:
    avoid_function_literals_in_foreach_calls: ignore
    avoid_print: ignore
    omit_local_variable_types: ignore
    overridden_fields: ignore
    prefer_collection_literals: ignore
    unnecessary_await_in_return: ignore
    unnecessary_this: ignore
    use_setters_to_change_properties: ignore

Setting up GitHub Actions

Next, create a GitHub Actions workflow for doing a static analysis of your project’s source code and even run some tests. This workflow will run on each push and pull request made to the master branch.

Create a ci.yml file in the .github/workflows directory and add the following code to it:

name: CI

on:
  push:
    branches: [master]
  pull_request:
    branches: [master]

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - name: Set up Repository
        uses: actions/checkout@v2
      
      - name: Set up Dart
        uses: dart-lang/setup-dart@v1

      - name: Install Pub Dependencies
        run: dart pub get

      - name: Verify Formatting
        run: dart format --output=none --set-exit-if-changed .

      - name: Analyze Project Source
        run: dart analyze
      
      - name: Run tests
        run: dart test

In the above workflow, you are using a stable version of Dart. However, if you want to set up a different Dart configuration, you can use sdk input with dart-lang/setup-dart action as in the following code:

- name: Set up Dart
  uses: dart-lang/setup-dart@v1
  with:
    sdk: 2.10.3

# or

- name: Set up Dart
  uses: dart-lang/setup-dart@v1
  with:
    sdk: dev

Results

At this stage, you can push directly to the master branch and check out the execution of your GitHub Action.

So, you have been able to set up your lint pipeline in less than two minutes. This power of GitHub Actions can help any team to achieve better developer workflow and faster releases.

In this blog, you’ll take a look at how you can convert a Google Sheet into a REST API and access it publicly from any app you want.

Contents

• Setting up a Spreadsheet
• Creating a Google Apps Script
• Converting Data to JSON format
• Creating a Web App
• Results

Setting up a Spreadsheet

The first task is to set up a Spreadsheet and initialize it with some data.

Creating a Google Apps Script

The next step in your journey is to be able to access the data in the Google Sheet. So, from Tools, select Script Editor. This will create a new Apps Script project.

In your newly created Apps Script project, create a Code.gs file and add the following code to it:

function json(sheetName) {
  const spreadsheet = SpreadsheetApp.getActiveSpreadsheet()
  const sheet = spreadsheet.getSheetByName(sheetName)
  const data = sheet.getDataRange().getValues()
  const jsonData = convertToJson(data)
  return ContentService
        .createTextOutput(JSON.stringify(jsonData))
        .setMimeType(ContentService.MimeType.JSON)
}

In the above function:

1. You get the current active spreadsheet to which this Apps Script project is linked with.
2. You get your specific sheet by its name.
3. You retrieve the data in that sheet.
4. You convert the data to JSON format using convertToJson function and store it in jsonData variable.
5. Finally, you return the JSON response.

Converting Data to JSON format

The data returned by the sheet.getDataRange().getValues() is of the following format:

[
  ['name', 'age', 'role'],
  ['John', 28.0, 'Front End Engineer'],
  ['Marry', 21.0, 'Staff Engineer'],
  ['Jackson', 22.0, 'Backend Engineer']
]

In the above snippet, you can see that there is a custom function convertToJson that needs to be written. To convert your sheet data with headers into JSON format, add the following code in Code.gs file:

function convertToJson(data) {
  const headers = data[0]
  const raw_data = data.slice(1,)
  let json = []
  raw_data.forEach(d => {
      let object = {}
      for (let i = 0; i < headers.length; i++) {
        object[headers[i]] = d[i]
      }
      json.push(object)
  });
  return json
}

Creating a Web App

To access your Google Sheet as a REST API, you need to deploy your Google Apps Script as a Web App. This web app will handle the GET requests.

In the Code.gs file, add the following code:

function doGet(e) {
  const path = e.parameter.path
  return json(path)
}

Once you are done with this, the final step is to publish your Apps Script as a Web App. You can simply create a New Deployment and set the Execute As to me and Who has access to Anyone. These settings allow your Web App to be publicly accessible.

Results

To the webapp, you can send a GET request to it by using Postman. The path for the GET request would be your Web App’s URL and query parameter path would be your Google Sheet’s name.

In this case, the URL is https://script.google.com/macros/s/AKfycbw9gpHbIauF8obidyDjxe3_L9qA-Ww-e8bv6pvNNGavAv-xxxxxxxxxxxxxxxxxxxxxxx/exec?path=people.

Alright! You can see that you have transformed your Google Sheet into a REST API in under five minutes using the above code.

You can add more sheets in your spreadsheet and access them simply using the sheet name in the path query parameter when sending a GET request.

In this tutorial, you’ll learn to add an Unsubscribe link in your emails sent using Google Apps Script.

Contents

• Setting Up a Spreadsheet
• Writing a Hash Function
• Writing Email Template
• Writing Unsubscribe Code
• Results

Setting Up a Spreadsheet

The first task is to set up a Spreadsheet. For this:

1. Create a new Google Spreadsheet and name the sheet as emails.
2. Add the following fields in the first row of your spreadsheet.

Writing a Hash Function

To provide a secure way to unsubscribe, you need to create a unique token for each of your subscribers. Google Apps Script provides you with utility functions to create a hash of a string using the MD5 hashing algorithm. The following function is used to create a hash of the string value, provided as a parameter:

function getMD5Hash(value) {
  const digest = Utilities.computeDigest(Utilities.DigestAlgorithm.MD5,
                                         value,
                                         Utilities.Charset.UTF_8)
  let hash = ''
  for (i = 0; i < digest.length; i++) {
    let byte = digest[i]
    if (byte < 0) byte += 256
    let bStr = byte.toString(16)
    if (bStr.length == 1) bStr = '0' + bStr
    hash += bStr
  }
  return hash
}

Since no two strings in the world have the same hash, this is the right way to provide unsubscribe tokens to your subscribers in your marketing campaigns or newsletters.

However, there is a security issue involved. If anyone knows the email of your subscriber, the attacker can easily compute the hash and unsubscribe the subscriber from your email list. So, to make the hash impossible to guess, you can add some randomness to your email string. You can create a random string and append it to your original email string.

The following snippet of code will help you to achieve your purpose:

function getMD5Hash(value) {
  value = value + generateRandomString(8) // added this
  const digest = Utilities.computeDigest(Utilities.DigestAlgorithm.MD5,
                                         value,
                                         Utilities.Charset.UTF_8)
  let hash = ''
  for (i = 0; i < digest.length; i++) {
    let byte = digest[i]
    if (byte < 0) byte += 256
    let bStr = byte.toString(16)
    if (bStr.length == 1) bStr = '0' + bStr
    hash += bStr
  }
  return hash
}

function generateRandomString(length) {
  const randomNumber = Math.pow(36, length + 1) - Math.random() * Math.pow(36, length)
  const randomString = Math.round(randomNumber).toString(36).slice(1)
  return randomString
}

Writing Email Template

You can use a basic HTML template for testing your Google Apps Script for the unsubscribing feature:

<!DOCTYPE html>
<html>
  <head>
    <base target="_top">
  </head>
  <body>
    <h1>We are testing our unsubscribe feature</h1>
    <a href="{{WEBAPP_URL}}?email={{EMAIL}}&unsubscribe_hash={{TOKEN}}">Unsubscribe</a>
  </body>
</html>

This email template contains the link for unsubscribing. You have also provided two parameters, email and unsubscribe_hash. When the subscriber will tap this link, it will send a GET request to your Google Apps Script deployed as a Web App.

Make sure to replace the values in curly braces.

Writing Unsubscribe Code

The final step to bring your workflow together is to write a code that handles your unsubscribe functionality.

In your Main.gs, add the following code to handle the GET request made to your Apps Script web app:

function doGet(e) {
  const email = e.parameter['email']
  const unsubscribeHash = e.parameter['unsubscribe_hash']
  const success = unsubscribeUser(email, unsubscribeHash)
  if (success) {
    return ContentService.createTextOutput().append('You have unsubscribed')
  }
  return ContentService.createTextOutput().append('Failed')
}

In the above script, you retrieve the email and unsubscribe_hash from the query parameters and pass them to your unsubscribeUser function. Based on the output of your function, you return an appropriate response.

Next, add the implementation for unsubscribeUser function in the Main.gs file:

function unsubscribeUser(emailToUnsubscribe, unsubscribeHash) {  
  // get the active sheet which contains your emails
  const sheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName('emails')

  // get the data in it
  const data = sheet.getDataRange().getValues()
  
  // get sheet headers i.e. top row of the sheet
  const headers = data[0]

  // get the index for each header
  const emailIndex = headers.indexOf('email')
  const unsubscribeHashIndex = headers.indexOf('unsubscribe_hash')
  const subscribedIndex = headers.indexOf('subscribed')
  
  // iterate through the data, starting at index 1
  for (let i = 1; i < data.length; i++) {
    const row = data[i];
    const email = row[emailIndex];
    const hash = row[unsubscribeHashIndex];

    // if the email and unsubscribe hash match with the values in the sheet
    // then update the subscribed value to 'no'
    if (emailToUnsubscribe === email && unsubscribeHash === hash) {
      sheet.getRange(i+1, subscribedIndex+1).setValue('no')
      return true;
    }
  }
}

In the above function, you simply iterate over your sheet using the for loop and check for the details for every subscriber. If the subscriber’s email and unsubscribeHash match with those sent as a query parameter, you unsubscribe the subscriber by updating the value in the sheet.

Results

For testing the script, send a test email to one of your subscribers specified in the Google Sheet. You can see that you have received an email with an option to Unsubscribe.

At this point, click the Unsubscribe link and check whether your sheet gets updated.

Oo Yea! You can see that the value for the subscribed field changed to no.

Using this workflow, you can provide your subscribers with an option to opt out of your mailing list for newsletters or marketing emails.

Contents

• Creating a Form Template
• Writing Vuex Code
• Writing Computed and Watch properties
• Results

Creating a Form Template

First, you need to create a simple form that will help you to understand the concepts of computed and watch properties. In your index.vue file in the pages directory, add the following form template:

<template>
  <form>
    <label>Name</label>
    <input v-model='form.name' />

    <label>Age</label>
    <input v-model='form.age' />

    <button :disabled="!changed">Save</button>
  <form>
</template>

In the above template, you have bounded your form data model to form inputs using v-model. The Save button will be disabled if the form fields have not changed.

Writing Vuex Code

In this example, you’ll use Vuex Store’s state, actions, and mutations to store state and fetch your form data. In your index.js file in the store directory, add the following code:

// initialize the state variables
export const state = () => ({
  form: {}
})

export const actions = {
  // action to setup form data
  // you can also do an api call as well
  init({ commit }) {
    const data = {
      name: 'Ravgeet',
      age: '21',
    }

    // add a commit mutuation for changing the state
    commit('setFormData', data)
  }
}

export const mutations = {
  // mutation to change the state
  setFormData(state, data) {
    state.form = data
  }
}

Writing Computed and Watch properties

At this point, your template and store are set. Next, you need to implement your application logic in your template’s script. In the pages/index.vue file, add the following code below the template:

<script>
import { cloneDeep, isEqual } from 'lodash'

export default {
  data() {
    return {
      changed: false, // useful for storing form change state
      form: {}, // data variable to store current form data binding
    }
  },

  computed: {
    // store the original form data
    originalForm() {
      return this.$store.state.form
    }
  },
  
  watch: {
    // by watching the original form data
    // create a clone of original form data
    // and assign it to the form data variable
    originalForm() {
      this.form = cloneDeep(this.originalForm)
    },

    // watch the changes on the form data variable
    form: {
      handler() {
        // using lodash to compare original form data and current form data
        this.changed = !isEqual(this.form, this.originalForm)
      },
      // useful to watch deeply nested properties on a data variable
      deep: true,
    },
  },

  created() {
    // dispatch an action to fill the store with data
    this.$store.dispatch('init')
  }
}
</script>

In your terminal, run the following command to install lodash:

$ npm install lodash

In the above code:

1. When the component is created, the init action is dispatched using the created hook. This action causes a mutation in the store and fills the form state variable.
2. The value of the computed property, originalForm is calculated as it is dependent upon the form state variable.
3. As the value of originalForm is being watched using the watch hook, the code inside it is executed. A deep clone of originalForm is made and assigned to the form data variable.
4. Since the value of form is being watched, you use a handler and deep property to run your business logic. You simply check whether the form and originalForm variables are equal using Lodash.

At first, it looks like something very complex is going on but once you break down the things it makes sense.

Results

Navigate to your browser and check whether you have been able to achieve your purpose of disabling the form submit button if the form fields have not changed at all.

Voila! You have successfully implemented your workflow. This adds to the UX of your application and saves the user from frustration especially in long forms.

In this tutorial, you’ll look at how can you display a toast notification in a Nuxt/Vue app whenever the user goes offline or online. This will also help you to understand how to use computed and watch properties together.

Contents

• Prerequisites
• Using $nuxt helper
• Writing Code
• Results

Prerequisites

Before getting started, make sure that you have correctly setup Nuxt and BootstrapVue.

Using $nuxt helper

Nuxt provides a great way to access its helper class, $nuxt. To get the current network connection status, you can do two things:

<template>
  <p>$nuxt.isOffline</p>
  <p>$nuxt.isOnline</p>
</template>

<script>
export default {
  created() {
    console.log(this.$nuxt.isOffline)
    console.log(this.$nuxt.isOnline)
  }
}
</script>

Yes, it is as simple as that.

Now in BootstrapVue, you can create toasts on-demand using this.$bvToast.toast() function. So you can implement the notification behavior using computed and watch properties provided by Vue.

Writing Code

The best place to add the following piece of code is in your layouts/default.vue because doing so can help you to implement a universal kind of notification behavior.

<template>
  <Nuxt />
</template>

<script>
export default {
  computed: {
    connectionStatus() {
      return this.$nuxt.isOffline
    },
  },
  watch: {
    connectionStatus(offline) {
      if (offline) {

        // hide the online toast if it exists
        this.$bvToast.hide('online')

        // create a new toast for offline notification
        // that doesn't hide on its own
        this.$bvToast.toast('You are now offline', {
          id: 'offline',
          toaster: 'b-toaster-bottom-right',
          noCloseButton: true,
          solid: true,
          noAutoHide: true,
          variant: 'danger',
        })
      } else {

        // hide the offline toast if it exists
        this.$bvToast.hide('offline')

        // create a new toast for online notification
        // that auto hides after a given time
        this.$bvToast.toast('You are now online', {
          id: 'online',
          toaster: 'b-toaster-bottom-right',
          noCloseButton: true,
          solid: true,
          autoHideDelay: 5000,
          variant: 'success',
        })
      }
    },
  },
}
</script>

In the above code, you first create a computed property, connectionStatus. In connectionStatus, you return the value of this.$nuxt.isOffline. Now in Vue, whenever a property, a computed is dependent upon changes, the computed property also changes. So whenever this.$nuxt.isOffline changes, connectionStatus gets a new value.

Next, you watch the changes in the value of connectionStatus and perform actions based on its new value, offline. In this case, you check whether the changed value of connectionStatus is true, you display your toast notification using BootstrapVue functions.

Results

To test the functionality of your app, go to your browser and check whether the above code works or not. Open the Network tab in Developer Tools, and toggle the network connection status.

Hurray! Toast notifications are working perfectly fine.

So using the combined magic of computed and watch properties, you can create outstanding workflows and take your Nuxt/Vue app to next level.

In this tutorial, you’ll check the value of a locally stored boolean variable to dynamically decide the home route. You can use any method for writing your authentication logic, like checking the validity of the API token, but for the sake of simplicity, you’ll explore a simple logic.

Contents

• Prerequisites
• Installing Dependencies
• Writing Code
• Results

Prerequisites

Before proceeding, make sure to set up a Flutter app with at least two different screens.

Installing Dependencies

For this tutorial, add the following dependencies in your pubspec.yaml:

dependencies:
  shared_preferences: ^0.5.12+4
  async: ^2.4.2

Make sure to add the latest version of the dependencies from pub.dev.

After adding these dependencies, it is now time to install them. In your terminal, execute the following command:

flutter pub get

Shared Preferences is a Flutter plugin for reading and writing key-value pairs to the local storage. Async contains the utility functions and classes related to the dart:async library.

Writing Code

In the lib/main.dart, add the following code:

import 'package:flutter/material.dart';
import 'package:shared_preferences/shared_preferences.dart';

void main() async {

  // handle exceptions caused by making main async
  WidgetsFlutterBinding.ensureInitialized();

  // init a shared preferences variable
  SharedPreferences prefs = await SharedPreferences.getInstance();
  
  // get the locally stored boolean variable
  bool isLoggedIn = prefs.getBoolean('is_logged_in');
  
  // define the initial route based on whether the user is logged in or not
  String initialRoute = isLoggedIn ? '/' : 'login';

  // create a flutter material app as usual
  Widget app = MaterialApp(
    ...
    initialRoute: initialRoute,
  );

  // mount and run the flutter app
  runApp(app);
}

In the above code, you are getting the value of the is_logged_in boolean variable, and based on it decide the value of the initialRoute and pass it to the MaterialApp widget.

One important thing in the above code is the use of the async-await pattern. You can also use then but it makes the code a little messy and that’s what you should try to avoid here. Making your main() function asynchronous can cause some exceptions, so to solve this, you need to add WidgetsFlutterBinding.ensureInitialized().

Results

That’s it. You have successfully written a code that allows you to redirect the user to the Dashboard page if they are logged in, otherwise to the Login page.

Contents

• Installing Bootstrap
• Creating a Custom SCSS
• Importing Bootstrap Vue
• Configuring Nuxt.js Config

Installing Bootstrap

Before starting, you need to install the required NPM packages. You’ll need to install bootstrap and optionally bootstrap-vue if you want to use Bootstrap Vue components.

Also, you need to customize the Bootstrap by adding custom SCSS files, you need to install some dev dependencies as well. In this case, you’ll need to install sass-loader and node-sass.

Visit your project directory, open your terminal and execute the following commands:

npm install bootstrap bootstrap-vue
npm install sass-loader node-sass --save-dev 

Creating a Custom SCSS

Next, create a custom.scss file in the assets/scss directory. In this file, you need to import Bootstrap’s bootstrap.scss. Add the following styling to change the default color system of Bootstrap.

$theme-colors: (
  'primary': #145bea,
  'secondary': #833bec,
  'success': #1ce1ac,
  'info': #ff7d50,
  'warning': #ffbe0b,
  'danger': #ff007f,
  'light': #c0ccda,
  'dark': #001738,
);

@import '~/node_modules/bootstrap/scss/bootstrap.scss';

Instead of importing the entire bootstrap.scss, you can import individual scss files but as the project grows you may need to use all the modules. It is of course a good idea to only import what is needed. So instead of worrying about increased module size, you can use PurgeCSS plugin for Nuxt.js to remove unused CSS from your project when you build it for production.

Importing Bootstrap Vue

Next, you need to configure Bootstrap-Vue in your project. You need to create a plugin and install it via Vue.use() to access Vue components globally in your project.

Create a bootstrap.js file in the plugins directory and add the following code to it:

import Vue from 'vue'
import { BootstrapVue, IconsPlugin } from 'bootstrap-vue'
Vue.use(BootstrapVue)
Vue.use(IconsPlugin)

Importing IconsPlugin is optional. You can skip it in case you prefer to use FontAwesome icons or any other icon library.

Configuring Nuxt.js Config

The final step is to configure some settings in nuxt.config.js. Change your config to look like this:

export default {
  
  ...

  // add your custom sass file
  css: ['@/assets/scss/custom.scss', ...],

  // add your plugin
  plugins: ['~/plugins/bootstrap.js', ...],

  // add bootstrap-vue module for nuxt
  modules: ['bootstrap-vue/nuxt', ...],

  // specify module rules for css and scss
  module: {
    rules: [
      {
        test: /\.s[ac]ss$/i,
        use: ['style-loader', 'css-loader', 'sass-loader'],
      },
    ],
  },
  
  // use these settings to use custom css
  bootstrapVue: {
    bootstrapCSS: false,
    icons: true,
  },

  ...
}

That’s it. You have set up your Nuxt.js project to use customized Bootstrap settings. You can override any Bootstrap defaults and customize the look and feel of your project to your advantage.

Being a GSoCer with GNOME Foundation and now a part of their Web Team, I get a lot of requests related to GSoC preparation, how to get started, how to approach GSoC mentors, and many related queries, especially during this part of the year.

So, we have decided to start a newsletter, Insight, where we will be sending short-form posts every 2nd day to help the aspirants prepare for the Google Summer of Code 2021.

We will bring Organization mentors and former Summer of Code students to share their views and experiences with this program and how Google Summer of Code has helped them become who they are. There will be a Q&A session with each of our guests in which you can clear your doubts and prepare yourself for the adventure. We will try to provide you access to top-quality content and guidance throughout the GSoC season.

If you are a student or a mentor, you can sign up for our Google Summer of Code newsletter which we will best be starting up very soon. We have already received 200+ signups in the last 24 hours and expect more in the coming days. See you soon!

Github has this feature natively that sends an email when a Github Action fails. It works efficiently when you are working on an individual project. However, when working in a team, you often want to notify more than one team member about the possible failure of the workflow.

In this blog, you’ll see how you can build a workflow that allows you to achieve this purpose.

Contents

• Creating a Sample Workflow
• Adding Send Email Action
• Results

Creating a Sample Workflow

Let’s write a simple Github Actions workflow that prints the infamous Hello World. Create a new file build.yml in .github/workflows directory and add the following code to it:

name: Build

on:
  push:
    branches: main

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2

      - name: Hello World
        run: echo Hello, world!

Commit and push your code to Github and run the above Github Action.

Adding Send Email Action

Dawid Dziurla has published a Github action that allows you to configure a lot of aspects related to sending the emails. In build.yml, add the following step to your workflow:

- name: Send mail
  if: always()
  uses: dawidd6/action-send-mail@v2
  with:
    # mail server settings
    server_address: smtp.gmail.com
    server_port: 465
    # user credentials
    username: ${{ secrets.EMAIL_USERNAME }}
    password: ${{ secrets.EMAIL_PASSWORD }}
    # email subject
    subject: ${{ github.job }} job of ${{ github.repository }} has ${{ job.status }}
    # email body as text
    body: ${{ github.job }} job in worflow ${{ github.workflow }} of ${{ github.repository }} has ${{ job.status }}
    # comma-separated string, send email to
    to: johndoe@gmail.com,doejohn@gmail.com
    # from email name
    from: John Doe

You can use echo "${{ toJson(github) }}" to get more workflow context variables.

The if: always() directive tells the Github Actions to always run this step regardless of whether the preceding steps have been executed successfully or not. You use the workflow’s context variables to build your email subject and body. Don’t forget to add your username and password as Github Action secrets.

Make sure to use the App-Specific password for the above action. Learn how to create an app-specific password for GMail.

Results

Before testing the action in use, deliberately fail the action. All you need to do is update the Hello World step’s run command to echo Hello, world! && exit 1. This sets an exit status of 1 which tells the Github Actions that some error has occurred.

Commit and push your code to Github and see what happens. You can see that the Send mail step was executed even though the previous step failed.

Check your inbox for the email about the failure.

Sweet! You can see that the email notification was sent to the recipients specified in the Send mail step. The subject and body were also populated with the appropriate repository and workflow.

Github Actions is a great CI/CD tool. By using the right actions, you can build workflows that can help in boosting team productivity at any workspace.

In this article, you will:

• Build your website on Github Actions
• Push the build directory to the website-build branch
• Configure Netlify to use the website-build branch to deploy your website

Contents

• Creating a Demo Website
• Creating a Build Branch
• Building Website using Github Actions
• Configuring Netlify
• Results

Creating a Demo Website

You’ll be using Jekyll to create a website for this demo. You can use any framework to build your website because, in the end, you will just create a build directory that you will push to another branch on your Github repository.

# create a boilerplate jekyll website
jekyll new my-awesome-site

# change the directory
cd my-awesome-site

# git add all the unstaged files
git add .

# give a good commit message
git commit -m "feat: first website commit"

# push to the origin
git push origin master

Alright. Now you have your website code in your Github Repo.

Creating a Build Branch

Since you are going to push your website build to the website-build branch, first you need to create a new branch. In your terminal, run the following commands:

# create a new branch
git checkout --orphan website-build

# remove all files from the staging area
git rm -rf .

# create an empty commit to initialize branch
git commit --allow-empty -m "root commit"

# push branch to origin
git push origin website-build

Building Website using Github Actions

Now that your branch and website are set up, the next step is to write a Github Action. In your terminal, run the following commands:

# switch back to master branch
git checkout master

# create a directory for github actions
mkdir -p .github/workflows

# create a workflow file for github actions
touch .github/workflows/netlify.yml

Add the following script in netlify.yml:

name: Build

on:
  push:
    branches:
      - master

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
        uses: actions/checkout@v2
        with:
          ref: master

      - name: Set up Ruby
        uses: actions/setup-ruby@v1
        with:
          ruby-version: 2.7

      - name: Install Dependencies
        run: |
          gem install bundler
          bundle install

      - name: Create Build
        run: bundle exec jekyll build -d public

      - name: Upload artifacts
        uses: actions/upload-artifact@v1
        with:
          name: public
          path: public

  commit-build:
    needs: build
    runs-on: ubuntu-latest
    steps:
      - name: Clone the repoitory
        uses: actions/checkout@v2
        with:
          ref: website-build

      - name: Configure Git
        run: |
          git config --global user.email ${GITHUB_ACTOR}@gmail.com
          git config --global user.name ${GITHUB_ACTOR}

      - name: Download website build
        uses: actions/download-artifact@v1
        with:
          name: public
          path: public

      - name: Commit and Push
        run: |
          if [ $(git status --porcelain=v1 2>/dev/null | wc -l) != "0" ] ; then
            git add -f public
            git commit -m "gh-actions deployed a new website build"
            git push --force https://${GITHUB_ACTOR}:$@github.com/${GITHUB_REPOSITORY}.git HEAD:website-build
          fi

The above action does two jobs.

In the build job, you check out your current repository, set up Ruby since you are using Jekyll, install dependencies, build the website, and add upload the public directory as an artifact.

In the commit-build job, you wait for the build job to finish, then check out the website-build branch, configure Git settings, download your build artifact, and finally push the public directory if any changes are found.

Next, execute the following commands in your terminal to push this Github Action to the upstream repository.

# add the new files
git add .

# create a new commit with a descriptive message
git commit -m "feat: added netlify build workflow"

# push github actions workflow file to the origin
git push origin master

Once the git operation is complete, visit the Actions tab on Github.

Configuring Netlify

The final thing you need to do is to configure Netlify. You need to change two things to make sure everything runs smoothly.

First, change your Branch to Deploy to website-build. Second, update your Publish Directory to artifacts. Now, whenever a push will be made to the website-build branch, Netlify will automatically deploy your website from the website-build branch.

Results

So that was easy. Using this workflow, you can also deploy your websites on Github Pages. There are a lot of developers complaining about issues with Jekyll plugins that are not supported by Github Pages. You can use Github Actions and commit your build to another branch and configure Github Pages to use that branch for deploying your website.

In this blog, you’ll learn about some of the best Netlify plugins that you can use to offer a great web experience to your website visitors.

Contents

• 1. Checklinks
• 2. Deployment Hours
• 3. HTML Validate
• 4. Lighthouse
• 5. Minify HTML

1. Checklinks

Broken links on your website can result in embarrassment and a huge dropout rate. You can manually check for broken links on your website but it is better if you can automate this process. Checklinks helps to keep all the assets references correct and avoid 404 links to the internal pages, as well as the external pages your website links to. It can also report on inefficient redirect chains and potential mixed content warnings.

2. Deployment Hours

Sometimes, in the middle of the night, one of your team members can trigger a new deployment which can by chance break the website. What next? You receive a call and you have to fix the bug at the time you were about to sleep. So to block deployments that happen outside of the specified deployment hours range, you can use the Deployment Hours Netlify plugin.

3. HTML Validate

HTML Validate is a Netlify plugin allows you to validate your HTML website build. It is extremely important to test the validity of the HTML because not only it can break your website’s design structure but also affect the SEO as the search engine crawlers like GoogleBot won’t be able to parse your website correctly. For example,

<p>
  <button>Click me!</button>
  <div id="show-me">
    Lorem ipsum
  </div>
</p>

The validation of the above HTML will produce the following error in the terminal:

1:1  error  Element <p> is implicitly closed by adjacent <div>  no-implicit-close
2:2  error  Button is missing type attribute                    button-type
6:4  error  Unexpected close-tag, expected opening tag          close-order

4. Lighthouse

Lighthouse is a Netlify plugin using which you can run an automated audit of your website after every build. You can set threshold values for each of the categories tested by Lighthouse that include performance, accessibility, best practices, SEO, and PWA if required. A new website build is only deployed if all the threshold values are met.

5. Minify HTML

When the website is built using a Static Site Generator like Jekyll, or Hugo, lots of whitespaces can creep into the HTML generated after the build. This whitespace means that the user has to download more bytes and you also waste your bandwidth. By minifying the HTML generated by your build, you can remove the redundant bytes from your website. This plugin minifies all HTML files in your publish directory before Netlify deploys them to its global CDN.

In this blog, you’ll learn about some of the best tools to increase team productivity within the organization.

Contents

• 1. Send with Us
• 2. Loom
• 3. Typeform
• 4. Zapier
• 5. Intercom
• 6. Slack
• 7. Google Apps Script
• 8. Promo
• Conclusion

1. Send with Us

Every company does email marketing. It is a great way to reach out to your customers and leads. But how do you ensure that your email template is responsive and optimized for all screens? Send with Us is a great service by Dyspatch.io. It allows you to build email design, templates, and AMP emails as well.

Check out Send with Us.

2. Loom

Loom is a great product that allows you to record video messages on your screen, camera, or both at the same time. It can be hugely beneficial when you have to send a report to a customer. You can record yourself explaining the report metrics which allows the customer to understand them better.

Check out Loom

3. Typeform

Typeform is one of the best services in the world for building forms and surveys in no time. Good-looking forms keep the audience engaged. You get more thoughtful responses and higher completion rates. The best part is that even a non-developer team member can easily create forms on their own.

Check out Typeform.

4. Zapier

Zapier allows you to connect apps and create automation workflows by sending data from one endpoint to the other. It allows you to create a Zap in the form of a trigger, condition, and action.

Check out Zapier.

5. Intercom

Intercom is more than just a chat widget. It’s a full customer service suite that can be integrated into any digital product you want. It aims to give customers a conversational experience they’ll remember and come back for.

Check out Intercom.

6. Slack

There is no life without Slack. It is not only great for internal organizational communication, but also for building bots, which can be used to automate processes and do a lot of other cool stuff.

Check out Slack.

7. Google Apps Script

Google Apps Script is a Javascript-based development platform that allows you to connect apps that integrate with Google Workspace(formerly G-Suite). As a developer, you don’t have to deal with access keys and tokens as authentication is baked right into the platform. We use Google Apps Scripts extensively to automate customer-related and internal processes at RavSam.

Check out Google Apps Script.

8. Promo

Promo is an online video maker that gives you everything you need to make high-performing videos that will boost your business. It comes with ready to use templates for any kinds of business types and it fits all types of contents. With Promo, you can also make video advertisements freely and easily. Promo helps you to promote your business or products, improves brand awareness, widen your reach, and engage your customers.

Check out Promo.

Conclusion

You can achieve even more profit by connecting these tools. For example, we can create a Slack bot that creates a Typeform and send it to your customers via Send with Us. Such workflows can be designed using Zapier or Google Apps Script.

Contents

• Knowing Flutter
• Skills Required to be a Flutter Developer
• Why Learn Flutter?
• What’s next

Knowing Flutter

Flutter is Google’s latest innovation for building beautiful, natively compiled apps for mobile, web, and desktop from a single codebase. It is a UI toolkit with fast development, expressive and flexible UI, and native performance. It comes with an extremely useful feature called Hot Reloading which renders the UI on the device in seconds helping in decreasing the development time.

Skills Required to be a Flutter Developer

To be a Flutter Developer, the first thing you need to learn is Dart. Dart is a programming language developed by Google. It is a beautiful language that supports Object-Oriented design patterns. It has borrowed some of the best features from other programming languages such as C++, Javascript, etc. If you are comfortable in any programming language, then you can easily understand Dart and start developing Flutter apps.

Once you are comfortable with Dart, the next step is to learn Flutter itself. Everything in Flutter is a Widget. It means that you can add any widget into another widget and build widget trees. These widgets trees are then rendered by the Flutter engine and painted on the screen. Once you get an idea of how to build the layouts using widgets, you will be surprised by how easy it is to build the apps using Flutter.

Why Learn Flutter?

Now comes the main question, what is so special about Flutter that it could be a job with a salary of $1 Million per year? The answer is hidden in the Flutter itself, Write once, Build for anywhere.

Let us take an example of a company that has a brilliant product used by millions of users around the world. Their product is available as a Web App, Android app, iOS app, Windows app, Linux app, and macOS app as well. Currently, they have a Frontend Engineer who works on the Web App. In their mobile team, they have an Android developer, an iOS developer, and a tester who writes an automated test for both apps. Coming to their desktop app ecosystem, they have four more developers and one more tester working in a collaborative environment. All are very talented in what they do but implementing a new feature is very tedious as it has to be implemented in each of the apps. Also as the product functionality is increasing after every release, maintenance is becoming a problem. They pay a collective of $800k to the developers in their company, plus the overhead maintenance cost.

Now let us imagine what would happen if there was a technology using which you could write the code and tests only once, and then compile it into multiple builds for different environments. Instead of hiring multiple individuals, the company could get a Flutter developer on board who would be responsible to develop this cross-platform functionality. Since you have to write the code only once, you know exactly what to test as well.

What’s next

The Web and Desktop apps designed in Flutter are still not up to the mark but the Google team is making Flutter better with each release. The community-backed plugin ecosystem is a huge advantage as it provides the developers a way to add functionality to their app which is not provided by the Flutter itself.

If you are a student, then definitely you should learn the Flutter. You can also become Google Developer Expert. Once you are done with flutter, you can upskill yourself by learning the backend development or Firebase. In this way, you could be the next Full Stack Developer with Flutter as a specialty.

In this article, you’ll learn to use Jekyll and Liquid syntax to create a JSON feed for your blog.

Contents

• Prerequisites
• Creating a feed.json File
• Writing Liquid Code
• Adding Feed URL to Head
• Result

Prerequisites

Before proceeding, make sure that:

• Your Jekyll blog is already set up.
• Your blogs live at the _blogs directory.

Creating a feed.json File

First, create a feed.json file at the root of your website and add the following front matter to it:

permalink: /blog/feed.json

This will make your blog feed available at the /blog/feed.json path.

Writing Liquid Code

In the feed.json file, add the following Jekyll code:

{
    "version": "https://jsonfeed.org/version/1.1",
    "title": {{ 'JSON Feed' | xml_escape | jsonify }},
    "description": {{ site.description | jsonify }},
    "favicon": {{ '/assets/images/logos/favicons/apple-touch-icon.png' | absolute_url | jsonify }},
    "language": "en",
    "home_page_url": {{ '/' | absolute_url | jsonify }},
    "feed_url": {{ page.permalink | absolute_url | jsonify }},
    "user_comment": "This feed allows you to read the blogs from this site in any feed reader that supports the JSON Feed format.",
    "items": [{% for blog in site.blogs reversed %}
        {
            "id": {{ blog.url | absolute_url | jsonify }},
            "url": {{ blog.url | absolute_url | jsonify }},
            "language": "en",
            "title": {{ blog.title | jsonify }},
            "summary": {{ blog.description | jsonify }},
            "content_html": {{ blog.content | jsonify }},
            "date_published": {{ blog.date | date_to_xmlschema | jsonify }},
            "date_modified": {{ blog.last_modified_at | date_to_xmlschema  | jsonify }},
            "image": "{{ blog.image.path }}",
            "banner_image": "{{ blog.image.path }}",
            "authors": [{{ blog.author | jsonify }}],
            "categories": {{ blog.categories | jsonify }},
            "tags": {{ blog.tags | jsonify }}
        }
        {% unless forloop.last %},{% endunless %}{% endfor %}
    ]
}

The above feed uses the most recent version of JSON Feed specifications.

Adding Feed URL to Head

The final step is to add a reference to your JSON feed in the head tag of your website so that anyone looking for your blog feed can find it out from here.

<link rel="alternate" type="application/json" title="JSON Feed" href="https://www.ravsam.in/blog/feed.json" />

Result

To check the JSON feed, run the following command in your terminal:

bundle exec jekyll serve

Then, check out your feed at http://localhost:4000/blog/feed.json.

You can see a JSON feed created for your blog. You can submit this blog feed to a JSON Feed Reader.

We can also create JSON feeds for podcasts, microblogs, and submit them to content aggregators. As we move into the future, you’ll see more and more blogs migrating to the JSON feed as it is extremely easy to consume and set up.

In this article, you’ll take a look at some of those plugins which can be used almost in any Flutter app and enhance the User Experience to a great extent.

Contents

• 1. Share
• 2. Geolocator
• 3. URL Launcher
• 4. Shimmer
• 5. Connectivity

1. Share

Share is a plugin that you can use to share the app content via other apps using the platform’s share dialog. It works on both Android and iOS and can be used in a social media app. According to its developers, a backward-compatible 1.0.0 version will be released soon as the plugin has reached a stable API.

Stats on Pub.dev

2. Geolocator

Geolocator is one of the must-use plugins if you are building an app that shows content based on the location of the user. It provides an easy-to-implement API that can be used to access platform-specific location services. You can access the last known location, current location of the device, and even get continuous location updates. This plugin is of great use in Cab Booking apps, Food Delivery apps, and many more.

Stats on Pub.dev

3. URL Launcher

URL Launcher is one of the most famous plugins which can be used on almost every production Flutter app. It is a plugin for launching different URL schemes like:

• https://example.com
• mailto:foo@bar.com
• tel:9876543210.

It supports every platform that Flutter targets such as iOS, Android, Web, Windows, macOS, and Linux.

Stats on Pub.dev

4. Shimmer

Shimmer is a brilliant plugin to enhance the UI/UX of an app while the content is loading. It is visually appealing as it gives the user an indication that the content is being fetched from the Internet. This package provides a widget for adding a shimmer effect in the Flutter project.

Stats on Pub.dev

5. Connectivity

There may be times when a user opens your app but is not connected to the WiFi or Mobile Internet connection. In circumstances like these, you can add this plugin to your Flutter app for discovering network connectivity and deciding the UI state accordingly. This plugin provides the developers with a great way to distinguish between Mobile and WiFi connections. According to its developers, a backward-compatible 1.0.0 version will be released soon as the plugin has reached a stable API.

Stats on Pub.dev

To attribute the team behind the project, there is a thing called humans.txt

Contents

• What is humans.txt?
• Humans.txt Example
• Should we always add humans.txt?
• Who to mention on humans.txt?
• Where should I add humans.txt?

What is humans.txt?

Humans.txt is a great initiative for listing the individuals who worked on a project. It’s an initiative for knowing the people behind a website. Basically, it is just a .txt file that contains information about individuals and their roles in a particular project.

Humans.txt Example

/* TEAM */
    Project Lead: John Smith
    Contact: johnsmith [at] gmail.com
    Twitter: @johnsmith
    From: New York, USA

    UI Designer: Tim Jacob
    Contact: timjacob [at] gmail.com
    Twitter: @timjacob
    From: New York, USA

    Project Lead: Jennifer Jaine
    Contact: jenniferjaine [at] gmail.com
    Twitter: @jenniferjaine
    From: Toronto, Cananda

/* SITE */
    Last update: 2020/10/05
    Language: English
    Doctype: HTML5
    IDE: VSCode
    Technologies: Jekyll, Python

Should we always add humans.txt?

Humans.txt is completely optional. It is not related to SEO. But it is a way to tell the world about the individuals who worked hard on a particular website project.

Who to mention on humans.txt?

You can mention anyone on the humans.txt. You can attribute your designers, developers, SEOs, Project Manager, .etc. For an Open Source project, you can add all the contributors in the humans.txt by automating it through CI/CD.

Where should I add humans.txt?

Humans.txt lives at the root of the website. Then, you can add a <link> tag in the <head> of your website.

<link type="text/plain" rel="author" href="http://example.com/humans.txt">

I hope that you will use the humans.txt in your projects and attribute your team to the work they do.

Contents

• Creating a Google Doc
• Writing Code
• Handling HTTP Requests
• Results

Creating a Google Doc

First of all, create a new Google Doc in which you’ll store your logs. Get its ID that you’ll be using in your Google Apps Script project code.

Writing Code

First, create a new Google Apps Script Project. Once you have created a new project, create a Main.gs file and add the following code to it:

function logEvent(eventString, eventType='info') {

  // get google docs to store the logs
  const body = DocumentApp.openById('google-docs-id').getBody()
  
  // get current time
  const time = new Date().toUTCString()
  
  // create a log string
  const log = time + ' - ' + eventString
  
  // add log string to the google docs
  body.appendParagraph(log)
}

In the above code, you have created a logEvent(eventString, eventType='info') function which takes in two parameters eventString, and eventType. In this function, you get the body of a Google Doc in which you want to store your logs. After that, you create a new string that contains the current time and the event string and append this log to the body of your Google Doc. At this point, you can try to run your function manually to see if anything happens at all.

It would be great if you can color code your logs to identify the type of event just by looking at them. Modify the logEvent function as in the following code:

function logEvent(eventString, eventType='info') {

  // get google docs to store the logs
  const body = DocumentApp.openById('google-docs-id').getBody()
  
  // get current time
  const time = new Date().toUTCString()
  
  // create a log string
  const log = time + ' - ' + eventString
  
  // add log string to the google docs
  const par = body.appendParagraph(log)
  
  // create a style object and add font size property
  let style = {}
  style[DocumentApp.Attribute.FONT_SIZE] = 12
  
  // based on the event type and font color property
  switch(eventType) {
    case 'info':
      style[DocumentApp.Attribute.FOREGROUND_COLOR] = '#0000ff'
      break
    case 'success':
      style[DocumentApp.Attribute.FOREGROUND_COLOR] = '#06ad00'
      break
    case 'warning':
      style[DocumentApp.Attribute.FOREGROUND_COLOR] = '#e67e00'
      break
    case 'error':
      style[DocumentApp.Attribute.FOREGROUND_COLOR] = '#ff0000'
      break
    default:
      style[DocumentApp.Attribute.FOREGROUND_COLOR] = '#000000'
      break
  }

  // apply the custom style the log string
  par.setAttributes(style)
}

In the above code, based on the value of eventType, you apply the styling to your log string. By default, each new event is associated with the info type.

Handling HTTP Requests

You are done with the core code of your script. The last step is to handle HTTP requests which you can make from any type of app like React Web App or a Flutter App.

Add the following code to the Main.js file:

// handles the get request to the server
function doPost(e) {
  try {
    // get query parameters
    const eventString = e.parameter['event_name']
    const eventType = e.parameter['event_type']

    // log the event
    logEvent(eventString, eventType)

    // return json success result
    return ContentService
          .createTextOutput(JSON.stringify({'result': 'success'}))
          .setMimeType(ContentService.MimeType.JSON)
    }
  }
  catch (e) {
    // return json failure result
    return ContentService
          .createTextOutput(JSON.stringify({'result': 'failure'}))
          .setMimeType(ContentService.MimeType.JSON)
    }
  }
}

The above code handles the POST request made to the Google Apps Script. Based on the script execution, a JSON response is sent back to the requesting app.

Once this is done, you can deploy the script as a Web App and use the Web App URL in your requesting app.

Results

Let’s see how well this custom serverless logging system works.

Awesome! Those color codings make the logs user-friendly. This kind of custom logging system can help you to debug your apps in production mode as well. You can also configure email or slack notification functionality for a particular kind of event so that your team gets notified of any irregularities in your apps.

In this blog, you’ll learn to send a notification to your Slack channel whenever your Github Action fails. To solve this issue, you’ll use the notify-slack-action published by us.

Contents

• Getting a Webhook URL
• Using notify-slack-action
• Results

Getting a Webhook URL

To send notifications to your Slack channel, you need to create a Slack App. You can follow this easy tutorial that includes tips to create your own Slack App and get a webhook URL. Once you have a webhook URL, you need to add it to the Github Actions secrets with the name - ACTION_MONITORING_SLACK

Using notify-slack-action

Let’s assume that you already have a Github Action that fails often and you need to monitor it. Add the following step as the last step in your Github Action workflow:

- name: Report Status
  if: always()
  uses: ravsamhq/notify-slack-action@v1
  with:
    status: ${{ job.status }}
    notify_when: 'failure'
  env:
    SLACK_WEBHOOK_URL: ${{ secrets.ACTION_MONITORING_SLACK }}

Besides the inputs given above, you can provide plenty of inputs to the notify-slack-action and make your notification more informative.

status: ${{ job.status }} # required
notify_when: 'failure'
notification_title: '{workflow} has {status_message}'
message_format: '{emoji} *{workflow}* {status_message} in <{repo_url}|{repo}>'
footer: 'Linked to Repo <{repo_url}|{repo}>'
notify_when: 'failure'
mention_users: 'U0160UUNH8S,U0080UUAA9N'
mention_users_when: 'failure,warnings'
mention_groups: 'SAZ94GDB8'
mention_groups_when: 'failure,warnings'

You can find and read more about the action at Github Marketplace.

This is all you need to monitor your Github Actions workflow. If you want to monitor each run of your Github Action workflow even when it succeeds, you can simply change the notify_when parameter value to success,failure,warnings.

Results

Open your Github Action and fail it deliberately to test your Github Actions monitoring.

Alright! You can see that a notification message was sent to the Slack channel stating the commit and repository it failed in.

This is extremely useful when you have multiple projects using Github Actions and you want to keep a check on your Github Actions workflow. I strongly feel that this action will increase the productivity of any team at any workspace.

Contents

• Prerequisites
• Adding Status Column
• Writing Email Tracking Code
• Deploying as Web App
• Adding Tracking Pixel in Email
• Results

Prerequisites

Before getting started, follow all the steps discussed in setup Email Marketing using Google Apps Script.

Adding Status Column

Once you have set up the Google Sheet, add a status column to it. This column will be used to track the email openings.

Writing Email Tracking Code

Now is the time to add some code to the script from the previous blog.

You will add an <img> tag in your HTML file and specify its width="0" and height="0". You’ll add your script URL along with some query parameters in the src attribute. This kind of image is known as tracking pixel.

When the recipient will open the email, a GET request will be sent to the URL specified in the src attribute. You’ll handle this GET request in your Google Apps Script and update the Google Sheet based on the query parameters.

In the Main.gs, add template.email = email after template.name = name line in the sendEmails function:

function sendEmails(mail_template='content',
                    subject='Testing my Email Marketing') {
  
  // get the active spreadsheet and data in it
  const id = SpreadsheetApp.getActiveSpreadsheet().getId()
  const sheet = SpreadsheetApp.openById(id).getActiveSheet()
  const data = sheet.getDataRange().getValues()
  
  // iterate through the data, starting at index 1
  for (let i = 1; i < data.length; i++) {
    const row = data[i]
    const email = row[0]
    const name = row[1]
    
    // check if you can send an email
    if (MailApp.getRemainingDailyQuota() > 0) {
        
      // populate the template
      let template = HtmlService.createTemplateFromFile(mail_template)
      template.name = name
      template.email = email // add this line
      const message = template.evaluate().getContent()
      
      GmailApp.sendEmail(
        email, subject, '',
        {htmlBody: message, name: 'RavSam Team'}
      )
    }
  }
}

Then, add code for tracking the email opening:

// handles the get request to the server
function doGet(e) {
  const method = e.parameter['method']
  switch (method) {
    case 'track':
      const email = e.parameter['email']
      updateEmailStatus(email)
    default:
      break
  }
}

The above code handles the GET request. If the value of the query parameter method is track, then you get the value of the query parameter email, and pass it to the updateEmailStatus function.

Next, add the updateEmailStatus function to your script file:

function updateEmailStatus(emailToTrack) {
  
  // get the active spreadsheet and data in it
  const id = SpreadsheetApp.getActiveSpreadsheet().getId()
  const sheet = SpreadsheetApp.openById(id).getActiveSheet()
  const data = sheet.getDataRange().getValues()
  
  // get headers
  const headers = data[0]
  const emailOpened = headers.indexOf('status') + 1

  // iterate through the data, starting at index 1
  for (let i = 1; i < data.length; i++) {
    const row = data[i]
    const email = row[0]
    
    if (emailToTrack === email) {      
      // update the value in sheet
      sheet.getRange(i+1, emailOpened).setValue('opened')
      break
    }
  }
}

The comments in the code explain it well. You just loop over the data in the Google Sheet and compare the emails with the emailToTrack variable. Once you have found the match, the status column corresponding to the email is set to opened.

Deploying as Web App

To handle the GET request, you need to deploy your script as a Web app. To deploy as a Web app, go to Publish > Deploy as web app…. Set Who has access to the app: to Anyone, even anonymous and click Update.

Adding Tracking Pixel in Email

In the content.html, add a tracking pixel:

<!DOCTYPE html>
<html>
  <head>
    <base target="_top">
  </head>
  <body>
    <!-- add this img tag -->
    <img src="https://script.google.com/macros/s/AKfycbxyhzk8JpzP1S-vXp6UVAOtQzN9qKqHLaKxiHr2cxxxxxxxxxxx/exec?method=track&email=<?= email ?>" width="0" height="0"> 
    
    Hi <?= name ?>. you are testing your beta features for email marketing.
  </body>
</html>

The <?= name ?> and <?= email ?> are called template variables and they will be populated by the sendEmails function.

Make sure to raplace the image src URL by your script URL.

Results

Alright, you have done all the necessary setup to start a successful email marketing campaign which can be tracked as well. Execute the sendEmails function and check your inbox on behalf of users.

Next, check whether you were successful in implementing tracking email openings or not. Let’s open the inbox and then check whether the Google Sheet was updated or not.

Woah! You can see that the Google Sheet was automatically updated when the recipient opened the email. This is the power of Google Apps Script. It is not widely used but many things can be implemented with them.

In this blog, you will learn about email marketing. You will set up custom email marketing purely using Google Apps Script. The advantage is you can take control of your email marketing campaign and create your own automated workflows.

Contents

• Creating a Spreadsheet
• Creating a Google Apps Project
• Writing Code
• 4. Running the Script
• Results

Creating a Spreadsheet

First of all, you need a Google Sheet where you can store all of your email addresses to whom you want to send the emails. So, first create a new spreadsheet.

Creating a Google Apps Project

Next, you need to connect your Google Sheet to a Google Apps Script. From Tools, select the Script Editor.

Writing Code

Finally, it is time to write some code.

a.) Main.gs

Add the following code to this file:

function sendEmails(mail_template='content',
                    subject='Testing my Email Marketing') {
  
  // get the active spreadsheet and data in it
  const id = SpreadsheetApp.getActiveSpreadsheet().getId()
  const sheet = SpreadsheetApp.openById(id).getActiveSheet()
  const data = sheet.getDataRange().getValues()
  
  // iterate through the data, starting at index 1
  for (let i = 1; i < data.length; i++) {
    const row = data[i]
    const email = row[0]
    const name = row[1]
    
    // check if you can send an email
    if (MailApp.getRemainingDailyQuota() > 0) {
        
      // populate the template
      let template = HtmlService.createTemplateFromFile(mail_template)
      template.name = name
      const message = template.evaluate().getContent()
      
      GmailApp.sendEmail(
        email, subject, '',
        {htmlBody: message, name: 'RavSam Team'}
      )
    }
  }
}

The comments have been included in the file for a proper description of the above function.

Always use GmailApp.sendEmail instead of MailApp.sendEmail. It is a more stable and reliant function.

b.) content.html

Since the Main.gs uses an HTML file and populates it, you need to create an HTML template file. Add the following code to content.html:

<!DOCTYPE html>
<html>
  <head>
    <base target="_top">
  </head>
  <body>
    Hi <?= name ?>. You are testing your beta features for email marketing.
  </body>
</html>

The <?= name ?> template variable gets auto-filled by the email marketing script.

4. Running the Script

You have done all the necessary setup to start a successful email marketing campaign. Before you execute your code, you need to grant permissions to your script:

Results

Let’s check the inbox to see if any email is received. Awesome! You can see that the email was delivered successfully to the user’s inbox.

You can create more beautiful and custom HTML templates and manage your email marketing campaigns around them. In the next blog, you will learn to track whether a user opens your emails or not.

Contents

• Prerequisites
• Installing Clasp
• Creating a New Repository
• Adding Important Files
• Setting up Github Actions
• Adding Github Actions Secrets
• Results

Prerequisites

Before getting started, make sure that you have set up the following:

• A Google Apps Script Project
• A Github Account

Installing Clasp

Clasp is a Google tool to develop Apps Script projects locally. It is short for Command-Line Apps Script Projects. You can follow this amazing guide by Google to get your login credentials, which you will be using later while setting up Github Actions.

Once you have successfully logged in, use the following command to get the content of the credentials file.

cat ~/.clasprc.json

Creating a New Repository

Depending upon your requirement, create a new public/private repository in Github. Once you have created a new repository, add a .gitignore file with the following content:

.*.json

This prevents your credential file to be committed to the repository.

Adding Important Files

Now it’s time to add some new files to the repository.

a.) setup.sh

This script will prevent you from logging in again by using your already logged in credentials from Github Actions secrets, which you will be setting up later. Add the following bash code to the file:

#!/bin/sh

LOGIN=$(cat <<-END
    {
        "token": {
            "access_token": "$ACCESS_TOKEN",
            "refresh_token": "$REFRESH_TOKEN",
            "scope": "https://www.googleapis.com/auth/cloud-platform https://www.googleapis.com/auth/drive.file https://www.googleapis.com/auth/service.management https://www.googleapis.com/auth/script.deployments https://www.googleapis.com/auth/logging.read https://www.googleapis.com/auth/script.webapp.deploy https://www.googleapis.com/auth/userinfo.profile openid https://www.googleapis.com/auth/userinfo.email https://www.googleapis.com/auth/script.projects https://www.googleapis.com/auth/drive.metadata.readonly",
            "token_type": "Bearer",
            "id_token": "$ID_TOKEN",
            "expiry_date": 1595752666211
        },
        "oauth2ClientSettings": {
            "clientId": "$CLIENT_ID",
            "clientSecret": "$CLIENT_SECRET",
            "redirectUri": "http://localhost"
        },
        "isLocalCreds": false
    }
END
)

echo $LOGIN > ~/.clasprc.json

Replace the value of scope key with value in your ~/.clasprc.json.

b.) scripts.json

This script will contain the id and name of the Google Apps Script projects. You can add single or multiple projects here depending upon your backup strategy. Add the following JSON object to the file:

[
    {
        "id": "google-apps-script-project-id",
        "name": "google-apps-script-project-name"
    },
    {
        "id": "google-apps-script-project-id",
        "name": "google-apps-script-project-name"
    }
]

c.) clone.sh

This script will use Clasp’s clone command to download all the scripts that you provided in the scripts.json file. This script will delete all the previous projects committed to the repository. This is an important step to reflect the deleted files in Github. Add the following bash code to this file:

#!/bin/sh

# remove all the pre-existing projects
rm -r -f */

content=$(cat scripts.json)
for row in $(echo "${content}" | jq -r '.[] | @base64'); do
    _jq() {
      echo ${row} | base64 --decode | jq -r ${1}
    }

    # get name and id for project
    name=$(_jq '.name')
    id=$(_jq '.id')

    # create a project directory
    mkdir $name
    cd $name

    # clone the project using the clasp
    clasp clone $id

    # come out of the directory
    cd ..
done

Setting up Github Actions

Now comes the best part of the project. You can automate the whole backup process using Github Actions. You can schedule the script to run every midnight using Cron job syntax.

Create a directory path at .github/workflows. In this path, create a backup.yml file and add the following code to it:

name: Backup

on:
  schedule:
    - cron: '0 0 * * *'

jobs:
  backup:
    runs-on: ubuntu-latest

    env:
      ACCESS_TOKEN: ${{ secrets.ACCESS_TOKEN }}
      REFRESH_TOKEN: ${{ secrets.REFRESH_TOKEN }}
      CLIENT_ID: ${{ secrets.CLIENT_ID }}
      CLIENT_SECRET: ${{ secrets.CLIENT_SECRET }}
      ID_TOKEN: ${{ secrets.ID_TOKEN }}
      REMOTE_BRANCH: master

    steps:
      - name: Setup repository
        uses: actions/checkout@v2

      - name: Setup Node
        uses: actions/setup-node@v1
        with:
          node-version: '12'

      - name: Install Clasp
        run: npm install -g @google/clasp

      - name: Install jq
        run: |-
          sudo apt update -y
          sudo apt install jq -y

      - name: Setup Logins
        run: bash setup.sh

      - name: Clone Scripts
        run: bash clone.sh

      - name: Update Progress
        run: |
          if [ $(git status --porcelain=v1 2>/dev/null | wc -l) != "0" ] ; then
            git config user.name "GitHub Actions"
            git config user.email noreply@github.com
            git add .
            git commit -m "github-actions: took backup"
            git push origin master --force
          fi

The workflow setups the repository, installs Node, installs Clasp, runs Clasp Setup, clones the Google Apps Scripts, checks whether there are any new changes, and if so commits them back to the repository as with a pre-defined commit message.

Adding Github Actions Secrets

You can get your Action Secrets values from the ~/.clasprc.json and add them accordingly.

Results

Hurray! You can see that the Github Action workflow completed with success at 00:00 UTC.

Let us check the repository to confirm that the backup was taken successfully.

You can see that the Google Apps Scripts projects were committed back to the repository with a commit message github-action: took backup.

Using this workflow, you can stay connected with both Google Apps Script and Github.

In this blog, you will learn to use amazing Google Apps Scripts as backend and Google Spreadsheets for data persistence to collect the form responses from your static website. This approach can help you set up forms on Github Pages, Netlify, or any other hosting provider. As a bonus, you will also add a webhook to notify your Leads team on Slack whenever a new form is filled.

Contents

• Creating a Google Spreadsheet
• Creating a Slack Bot
• Creating a Google Apps Script Project
• Deploying a Google Apps Script Project
• Setting up a HTML Form
• Setting up Javascript
• Results

Creating a Google Spreadsheet

1. Create a new Google Spreadsheet and name the sheet as Sheet1.
2. Add the following fields in the top row of your spreadsheet. Make sure you name them correctly because you will be using these names in your HTML form.

Creating a Slack Bot

To notify your Leads team on the Slack, you need to create a Slack bot.

1. Go to https://api.slack.com/apps and click Create New App.
2. Give your app a name and choose your Development Workspace from the dropdown.
3. Once you have created an app, you need to turn on the Incoming Webhook feature and create a new webhook URL.
4. Create a new webhook by clicking Add New Webhook to Workspace and choose the channel you want the notifications to be posted in. Your webhook URL should look like this https://hooks.slack.com/services/T0160Uxxxxx/B0187Nxxxxx/4AZixxswHVxxxxxxxxxxxxxx. If you have access to a terminal, you can test the webhook as well by sending a POST request using cURL.

curl -X POST -H 'Content-type: application/json' --data '{'text':'Hello, World!'}' https://hooks.slack.com/services/T0160Uxxxxx/B0187Nxxxxx/4AZixxswHVxxxxxxxxxxxxxx

Creating a Google Apps Script Project

Now comes the most important and interesting part of the project. Google Apps Script is written in Javascript. So even if you have basic Javascript knowledge, setting up Google Apps will be a breeze for you.

1. Create a new project at https://script.google.com/home.
2. Create a new script file from File > New > Script, name it as Form.gs add the following code to it:

// new property service
const SCRIPT_PROP = PropertiesService.getScriptProperties()

function doGet(e) {
  return handleResponse(e)
}

function handleResponse(e) {
  // this prevents concurrent access overwritting data
  // you want a public lock, one that locks for all invocations
  const lock = LockService.getPublicLock()
  lock.waitLock(30000)  // wait 30 seconds before conceding defeat
  
  try {
    // next set where you write the data - you could write to multiple/alternate destinations
    const doc = SpreadsheetApp.openById(SCRIPT_PROP.getProperty('key'))
    const sheet = doc.getSheetByName(SHEET_NAME)
    
    const headRow = 1
    const headers = sheet.getRange(1, 1, 1, sheet.getLastColumn()).getValues()[0]
    const nextRow = sheet.getLastRow() + 1 // get next row
    const row = [] 
    
    // loop through the header columns
    for (i in headers) {
      switch (headers[i]) {
        case 'timestamp':
          row.push(new Date())
          break
        default:
          const str = e.parameter[headers[i]]
          row.push(str.trim().substring(0, CHARACTER_LIMIT))
          break
      }
    }
    
    // add data to the spreadsheet
    sheet.getRange(nextRow, 1, 1, row.length).setValues([row])
    
    // send thanks email to customer
    const emailStatus = notifyCustomer(row)
    
    // send notification to slack
    postToSlack(row, emailStatus)
    
    // return json success results
    return ContentService
          .createTextOutput(JSON.stringify({'result': 'success'}))
          .setMimeType(ContentService.MimeType.JSON)
  }
  catch (e) {
    // if error then log it and return response
    Logger.log(e)
    return ContentService
          .createTextOutput(JSON.stringify({'result': 'error'}))
          .setMimeType(ContentService.MimeType.JSON)
  }
  finally {
    // release lock
    lock.releaseLock()
  }
}

function setup() {
    const doc = SpreadsheetApp.getActiveSpreadsheet()
    SCRIPT_PROP.setProperty('key', doc.getId())
}

Don’t forget to run the setup function. It is important to connect your project with the Google Spreadsheet and gain the right permissions.

1. Create a new script file from File > New > Script and name it as Email.gs. In this file, you will write the code that sends an email back to the customer on your behalf.
2. Add the following code to this script file:

function notifyCustomer(data) {
  const name = data[1]
  const message = 'Hi' + name + '. Your response has been received. you will get in touch with you shortly.'
  
  // check if you can send an email
  if (MailApp.getRemainingDailyQuota() > 0) {
    const email = data[2]
    
    // send the email on your behalf
    MailApp.sendEmail({
      to: email,
      subject: 'Thanks for contacting RavSam Web Solutions.',
      body: message
    })

    return true
  } 
}