DEV Community: Denis Sinyukov

How to Connect to MySQL through SSH Tunnel

Denis Sinyukov — Wed, 10 Jan 2024 23:00:21 +0000

🚀 Dive into the world of secure database management! 🛡️✨ Unlock the secrets of connecting to MySQL through an SSH tunnel - your key to safeguarding data and managing databases with confidence. 💻🔒 Our step-by-step guide makes it easy for beginners and pros alike! Ready to elevate your MySQL game? Check out the details and leave your questions in the comments. Let's master tech together! 👩‍💻👨‍💻 #MySQL #SSHConnection #TechMastery #DatabaseSecurity #LearnTech

Enhancing Authentication in Laravel: Creating a Custom Driver

Denis Sinyukov — Wed, 03 Jan 2024 16:35:19 +0000

🚀 Exciting News for Laravel Developers! 🚀

Enhance your Laravel projects with the power of Custom Auth Drivers! 🔐✨

Unleash unparalleled flexibility in authentication methods tailored to your app's unique demands. 🛠️ Dive into the world of creating and integrating custom drivers with our latest guide.

📖 Learn step-by-step: Link to the Guide

Empower your applications with robust security and take control of user access structures. 💪 Don't settle for one-size-fits-all – customize your authentication journey!

The text of the article provides a comprehensive guide to developing custom authentication drivers in Laravel, addressing the need for tailored security measures beyond standard solutions.

Article starts with an overview of Laravel's authentication mechanisms, delving into guards and providers. It then explains creating custom drivers, particularly viaRequest, offering code examples and steps for implementation.

The guide outlines a step-by-step process to create and integrate a custom driver, emphasizing the importance of choosing or creating guards and user providers. It demonstrates the integration process and configuration changes required in Laravel, concluding with practical usage examples, tips, and security best practices.

The article concludes by highlighting the value of custom drivers in meeting complex authentication needs, fostering security, reliability, and the potential for innovative solutions in Laravel-based applications.

🔒 Laravel Custom Auth Drivers: Elevate your authentication game! #Laravel #WebDevelopment #CustomAuthDrivers #SecurityMatters

Laravel Package Development : Key Steps to Building an Effective Tool

Denis Sinyukov — Tue, 28 Nov 2023 12:26:47 +0000

You may have already seen or used Laravel packages such as Sanctum, Passport, Nova and many others. But have you ever wondered how you can package and deploy your development into a package, of any logic, and share it with other developers in the Laravel community?

One of the key features, of the Laravel framework, is the ecosystem of packages, which provide amazing opportunities to build high quality applications.

Packages are the primary way to add any kind of functionality to Laravel projects. This can be anything from a set of styles and scripts to complex business logic and API integrations.

Package code can be standalone or serve as an add-on for a particular framework and can be developed and maintained by different developers.

In this article, we will focus on writing packages for the Laravel framework.

The concept of package development includes concepts like ServiceProvider, Facades, Contracts. All these elements ensure the stable operation of applications from testing to production.

ServiceProvider is the point of contact between the application container and your package. All application resources are managed through it. Dependency injection is the best thing you can think of.

Why Develop and Use Packages in Laravel?

Often developers need to reuse code together or separately from the main application. Extracting some of the code into packages is the best solution. Ease of integration and code reuse is the hallmark of the package ecosystem.

Packages are one of the whales of the framework's popularity, as they contribute to the active development of the Laravel community and are a great way to increase the visibility and appeal of the PHP language and the framework as a whole.

Packages are an integral part of the framework's strong architecture.

Advantages and Disadvantages of using packages

As is usually the case, there is a spoonful of tar in the honey barrel. Package development in Laravel has its own nuances as well.

Pros:

scaling projects
improve project structure
encapsulate business logic
promotes code reuse and sharing

Cons:

package dependencies may not be to your liking
a widely used package may have features you clearly don't need.
end of developer support
version incompatibility: programming language, dependencies, frameworks

Package Preparation and Development

Creating a proper package structure including directories, configuration files and ServiceProvider classes is also an important part.

All framework dependencies are managed through the package manager composer. Composer has the main role of creating a new package.

Hopefully developers understand the disadvantages of ignoring the package manager.

Basic folder structure within a package

Having a Laravel application, the package directory structure will look like:

├── packages
│   └── coderden
│       └── jwt-auth
│           ├── src

Let's look at each catalog separately:

packages is a directory to store all the packages you have created.
coderden is the vendor that develops the package/s (e.g. like laravel, spatie). One vendor can have many packages and all of them will be in this directory.
jwt-auth - the main directory of the package.
src - will contain the source code of our package, as an app directory in the framework. Directories with configuration, migrations and additional logic will also be located at this level.

To start developing a package, first create a packages directory inside an existing Laravel project.

Then initialize a new composer.json configuration file in the newly created directory to enter package details such as name, description, type, and other useful information that will describe your package.

mkdir -p packages/coderden/jwt-auth && composer init

Package name (<vendor>/<name>): coderden/jwt-auth
Description []: JWT auth package
Author: Denis Sinyukov <dnsinyukov@gmail.com>
Minimum Stability []: dev
License []: MIT
Would you like to define your dependencies (require) interactively [yes]? no
Would you like to define your dev dependencies (require-dev) interactively [yes]? no
Do you confirm generation [yes]? yes

cd packages/coderden/jwt-auth && mkdir src

After doing all the steps, you have a new composer.json file. This is the cover page for your package.

{
    "name": "coderden/jwt-auth",
    "description": "JWT auth package",
    "type": "library",
    "license": "MIT",
    "autoload": {
        "psr-4": {
            "Coderden\\JwtAuth\\": "src/"
        }
    },
    "authors": [
        {
            "name": "Denis Sinyukov",
            "email": "dnsinyukov@gmail.com"
        }
    ],
    "minimum-stability": "dev",
    "require": {}
}

After initializing the package, we need to inform the application kernel about the new piece of code to be integrated. To do this, we need to create a ServiceProvider. It will be our bridge to deliver resources to the main container.

In the src directory we will create a file JWTServiceProvider.php, the boot() and register() methods will load the package resources and register connections in the IoC container (views, configuration and localization files, migrations, etc).

To test the performance, let's add a test function - dd().

<?php

namespace Coderden\JwtAuth;

use Illuminate\Support\ServiceProvider;

class JWTServiceProvider extends ServiceProvider
{
    public function boot()
    {
        dd('Hello Package!');
    }
}

So, the skeleton of our package is almost written, but the Laravel application still doesn't know the novelty. To do this, we need to tell the package manager to install it and specify the correct namespace.

Let's add the repositories argument to the main file composer.json, the one from Laravel, and run the package installation on the prescribed path.

composer require coderden/jwt-auth:dev-main

"repositories": [
    {
        "url": "packages/coderden/jwt-auth",
        "type": "path"
    }
],

By doing this we have linked the Laravel application and the created package. The repositories option says that there is a new repository at the url path, and composer require - already installs it.

Package discovery

But how do we know that Laravel is using our package? Earlier we said that the entry point to the created package is the JWTServiceProvider. Install installed it, but it's not called anywhere.

There are several ways to do this:

The main service provider registration file is config/app.php, where the providers parameter defines the list of service providers to be loaded by laravel and their order. After installing the package, you can write JWTServiceProvider to the providers section.

 'providers' => [
        // TODO Core Service Providers

        /*
         * Package Service Providers...
         */
        \Coderden\JwtAuth\JWTServiceProvider::class,
    ],

By running the composer dump command you will see our greeting text.

"Hello Package!" // packages/coderden/jwt-auth/src/JWTServiceProvider.php:11

Recommended method. To automatically add the provider to the call list, you can define the provider in the extra file section of your composer.json package. By running the composer dump command you will see the same result as in the first example.

// packages/coderden/jwt-auth/composer.json

"extra": {
    "laravel": {
        "providers": [
            "Coderden\\JwtAuth\\JWTServiceProvider"
        ]
    }
}

Conclusion

In this article we have considered the reasons, advantages and disadvantages of creating packages for local use, using Laravel packages as an example.

We have created a skeleton for a package that will be filled with logic that the developer wanted to share in the Laravel community or for personal use, tired of duplicating code from project to project.

Creating your own packages is easy enough following all the tips in this article.

In the next articles we will create a package filled with logic and publish it in the Packagist repository.

Using the TinyMCE comments with the Vue.js & Laravel frameworks

Denis Sinyukov — Sat, 04 Nov 2023 22:08:52 +0000

TinyMCE is a cool text formatting editor that gives users the ability to create structured HTML content. It has good support, documentation and the ability to extend it with various plugins, both from official developers and proprietary ones. One such plugin is comments within HTML content.

In this article we will consider the principle, features and some difficulties of TinyMCE comments when integrated into applications written in Vue and Laravel.

Comments plugin overview and features

It's worth mentioning right away that the plugin is a paid one and is included in the Essential subscription. You will have to pay about $700 per year for the subscription.

A full list of features for that money can be found at pricing.

The editor's user interface allows users to collaborate on content by creating and responding to comments.

Main Features

Create comment
Edit comment
Reply to comment
Lookup a comment
Resolve a comment thread
Delete а comment/s

The plugin has two modes of operation: Callback mode and Embedded mode. Each has its own features. We will be interested in Callback mode, because we want to store comments on our server in our database and be able to manage them from our application.

The principle of operation of this mode is based on callback functions, which is what its name says. To integrate the plugin we need to implement the following callback functions inside our application:

tinycomments_create
tinycomments_reply
tinycomments_edit_comment
tinycomments_delete_comment
tinycomments_delete
tinycomments_delete_all
tinycomments_lookup

Getting started

To integrate with our Vue application, we will use a ready-made component from the editor developer himself, which is focused on it.

npm install --save tinymce "@tinymce/tinymce-vue@^5".

The component has already been written for us, we just need to configure it correctly. If you look in the source code of the package you can find the component itself.

import { Editor } from './components/Editor';.

So, to get the plugin started it should, first of all:

Copy the API key from the TinyMCE personal cabinet and write it in the .env file.

VITE_TINY_API_KEY=api_key_value.

Write in main.js

app.provide('tinyApiKey', import.meta.env.VITE_TINY_API_KEY)

You can access environment variables (prefixed with VITE_) from your Vue application using the import.meta.env object.

Add our domain to the whitelist, also from your personal cabinet. To remove the annoying inscription inside the editor.

Import the Editor component and specify our API key.
Enable the comments premium plugin by writing in init.plugins the value tinycomments, as well as add in init.toolbar - addcomment showcomments, to be able to open the sidebar to create and show comments.
Create an dummy function for other comments functions.
Declare tinycomments_mode and define callback functions

Let's fill in tinycomments_author by hand, for starters

The final code will look like this:

<script setup>
import Editor from '@tinymce/tinymce-vue';

import { inject, ref } from 'vue';

const tinyApiKey = inject('tinyApiKey');
const content = ref('Hello, CoderDen!');

const noop = () => {};
</script>

<template>
    <main>
        <Editor
            :api-key="tinyApiKey"
            v-model="content"
            :init="{
                plugins: 'lists link image table code wordcount tinycomments',
                toolbar: 'undo redo | bold italic underline strikethrough | fontfamily fontsize blocks | addcomment showcomments',
                tinycomments_mode: 'callback',
                tinycomments_author: 'Denis Sinyukov',
                tinycomments_create: noop,
                tinycomments_reply: noop,
                tinycomments_edit_comment: noop,
                tinycomments_delete: noop,
                tinycomments_delete_all: noop,
                tinycomments_delete_comment: noop,
                tinycomments_lookup: noop,
            }"
        />
    </main>
</template>

Create comment

The plugin uses the tinycomments_create function to create a comment. The function receives as input a request object (req), a done callback, and a fail callback.

The req argument has the following fields:

content - The content of the comment to create.
createdAt - The date the comment was created.

After successful creation it returns a unique conversation identifier via the Done callback, otherwise the fail function is called.

Creating a comment on the server

Laravel and MySQL was chosen as the backend.

Let's design a simple database table to store comments.A polymorphic table conversations is used to store comments, which can be used for different entities.

Create Laravel web routes to work with comments

Route::get('/editor/conversations', [EditorController::class, 'getConversations']);
Route::post('/editor/conversations', [EditorController::class, 'createConversation']);

Create the logic for saving the conversation. entityId - id of the entity to which the comment belongs.

public function createConversation(Request $request): JsonResponse
{
    $payload = $request->validate([
        'content' => 'required|string',
        'entityId' => 'required|numeric',
    ]);

    $user = $request->user();
    $userId = $user->id;

    $conversationId = app(ConversationRepository::class)->create([
        'user_id' => $userId,
        'content' => $payload['content'],
        'entity_type' => EntityType::Template->value, // php8 enum 'template'
        'entity_id' => $payload['entityId'],
        'uuid' => $conversationUid = Str::uuid(),
    ]);

    return response()->json([
       'data' => [
           'conversationId' => $conversationId,
           'conversationUid' => $conversationUid
       ],
        'meta' => [
            'code' => 200
        ]
    ]);
}

Example of a successful server response:

{
  "meta": {
    "code": 200
  },
  "data": {
    "conversationId": 1,
    "conversationUid": "4ae419e1-79d5-44f0-9c96-ca842959f7a4"
  }
}

Let's create a function to receive comments

public function getConversations(Request $request): JsonResponse
{
    $payload = $request->validate([
        'entityId' => 'required|numeric',
    ]);

    $conversations = DB::table('conversations', 'c')
        ->selectRaw( 'c.*')
        ->selectRaw('u.first_name, u.last_name, u.email')
        ->join('users as u', 'u.id', 'c.user_id')
        ->where('entity_id', $payload['entityId'])
        ->where('entity_type', EntityType::Template->value)
        ->get();

    $conversations = $conversations->map(fn($conversation) => [
        'id' => $conversation->id,
        'uuid' => $conversation->uuid,
        'author' => trim($conversation->first_name . ' ' . $conversation->last_name),
        'content' => $conversation->content,
        'created_at' => $conversation->created_at,
        'updated_at' => $conversation->updated_at,
        'entity_id' => $conversation->entity_id,
        'entity_type' => $conversation->entity_type,
    ]);

    return response()->json([
        'data' => [
            'conversations' => $conversations,
        ],
        'meta' => [
            'code' => 200
        ]
    ]);
}

Creating a comment on the client

Let's create our comment creation function that will send the created comment to our backend.

Replace the function in init.tinycomments_create with createComment.

:init="{
    ...
    tinycomments_create: createComment,
    ...
}"

We will use the axios utility to send data to the server.

After that we need to declare the createComment function, which will have the following form:

const createComment = (ref, done, fail) => {
    ref.entityId = 1; // You can substitute any identifier here.

    axios.post('/editor/conversations', ref, {
        headers: {
            'Accept': 'application/json',
            'Content-Type': 'application/json'
        },
    })
        .then(response => response.data?.data)
        .then(response => {
            let conversationUid = response.conversationUid;
            conversations.value.push({
                id: response.conversationId,
                author: 'Denis Sinyukov', // skip logic
                content: ref.content,
                uuid: conversationUid,
                entity_id: ref.entityId,
                updated_at: ref.createdAt,
                created_at: ref.createdAt,
            });
            done({conversationUid: conversationUid});
        })
        .catch((e) => {
            fail(e);
        });
};

The point is that after successful execution of tinycomments_create - tinycomments_lookup is called to display it. Now let's do it, let's create the lookupComment function and get the list of comments from the server.

We get a list of comments before the component is rendered.

import { inject, ref, computed, onBeforeMount } from 'vue';
const conversations = ref([]);
...

const getConversations = () => {
    axios.get('/editor/conversations', {
        params: {
            entityId: 1
        },
        headers: {
            'Accept': 'application/json',
            'Content-Type': 'application/json'
        },
    })
        .then(response => response.data?.data)
        .then(response => conversations.value = response.conversations);
}


onBeforeMount(() => {
    getConversations();
});

const mappedConversations = computed(() => {
    return conversations.value.map(conversation => {
        return {
            author: conversation.author || '',
            createdAt: conversation.created_at || new Date().toISOString(),
            content: conversation.content,
            modifiedAt: conversation.created_at || new Date().toISOString(),
            uid: conversation.uuid
        };
    })
});

It is important to adapt the format of our data so that the editor learns to understand it. mappedConversations - Format the data to fit the editor's display format.

Display the created comment

After successful creation, the array with comments goes to the tinycomments_lookup function and looks for us newly created comment.

const lookupComment = ({conversationUid}, done, fail) => {

    const conversation = mappedConversations.value.find(c => c.uid === conversationUid);

    if (!conversation) {
        fail();
    }

    done({
        conversation: {
            uid: conversationUid,
            comments: [
                conversation,
            ]
        }
    })
}

If we look at the HTML source code of the editor content, we see a data attribute with the uid of our comment -data-mce-annotation-uid="425cb9a8-6fdc-4739-8331-be63e0b08dbf".

This attribute is used to show where the comments were created and highlight them.

The Bottom Line

The article covered the basic workings of using comments and integrating the plugin into existing applications written in Vue and Laravel.

TinyMCE comment plugin integration makes your applications look more functional without much wasted development time. The plugin facilitates commenting, reviewing and collaboration between application users.

The full Vue component:

<script setup>
import Editor from '@tinymce/tinymce-vue';

import { inject, ref, computed, onBeforeMount } from 'vue';
import axios from "axios";

const tinyApiKey = inject('tinyApiKey');
const content = ref('Hello, CoderDen!');
const conversations = ref([]);

const noop = () => {};
const createComment = (ref, done, fail) => {
    ref.entityId = 1; // You can substitute any identifier here

    axios.post('/editor/conversations', ref, {
        headers: {
            'Accept': 'application/json',
            'Content-Type': 'application/json'
        },
    })
        .then(response => response.data?.data)
        .then(response => {

            let conversationUid = response.conversationUid;
            done({conversationUid: conversationUid});

            conversations.value.push({
                id: response.conversationId,
                author: 'Denis Sinyukov',
                content: ref.content,
                uuid: conversationUid,
                entity_id: ref.entityId,
                updated_at: ref.createdAt,
                created_at: ref.createdAt,
            });
        })
        .catch((e) => {
            fail(e);
        });
};

const lookupComment = ({conversationUid}, done, fail) => {

    const conversation = mappedConversations.value.find(c => c.uid === conversationUid);

    if (!conversation) {
        fail();
    }

    done({
        conversation: {
            uid: conversationUid,
            comments: [
                conversation,
            ]
        }
    })
}

const getConversations = () => {
    axios.get('/editor/conversations', {
        params: {
            entityId: 1
        },
        headers: {
            'Accept': 'application/json',
            'Content-Type': 'application/json'
        },
    })
        .then(response => response.data?.data)
        .then(response => conversations.value = response.conversations);
}

const mappedConversations = computed(() => {
    return conversations.value.map(conversation => {
        return {
            author: conversation.author || '',
            createdAt: conversation.created_at || new Date().toISOString(),
            content: conversation.content,
            modifiedAt: conversation.created_at || new Date().toISOString(),
            uid: conversation.uuid
        };
    })
});

onBeforeMount(() => {
    getConversations();
});

</script>

<template>
    <main>
        <Editor
            :api-key="tinyApiKey"
            v-model="content"
            :init="{
                plugins: 'lists link image table code wordcount tinycomments',
                toolbar: 'undo redo | bold italic underline strikethrough | fontfamily fontsize blocks | addcomment showcomments',
                tinycomments_mode: 'callback',
                tinycomments_author: 'Denis Sinyukov',
                tinycomments_create: createComment,
                tinycomments_reply: noop,
                tinycomments_edit_comment: noop,
                tinycomments_delete: noop,
                tinycomments_delete_all: noop,
                tinycomments_delete_comment: noop,
                tinycomments_lookup: lookupComment,
            }"
        />
    </main>
</template>

Macros & Mixins in Laravel and additional development features | Macroable

Denis Sinyukov — Sun, 29 Oct 2023 21:01:42 +0000

One of the features of Laravel is the ability to extend functionality through custom methods thanks to a concept called "macros".

In this article, we will look at what they are, how to create them, and how they can improve our development.

Understanding Macros

A macro is the injection of custom code into the core of a framework, without the need for complex inheritance or modification.

To implement macros we use the Macroable trait, which has two main methods macro() and mixin().

The point is that by using PHP's magic methods __call and __callStatic, we add additional methods to existing application classes at runtime without changing the core.

Advantages of macros and mixins

Code reuse: By encapsulating custom logic in macros, you can apply it to different parts of your project without duplicating code.
Code cleanliness: Macros help keep your code clean and user-friendly by bringing logic into separate service classes.
Improved performance: Macros allow you to extend Laravel core functionality more efficiently and maintain compatibility with future framework updates, reducing implementation time.

Creating Macro & Where should I define them?

It is a good idea to add this to the App\Providers\AppServiceProvider method in the boot() method, since it is called after all other service providers are registered and you have access to all other services.

Str::macro('toLower', fn($str) => strtolower($str));

The second way is to create a new service provider App\Providers\MacroableServiceProvider and register it in AppServiceProvider. For example,

class MacroableServiceProvider extends ServiceProvider
{
    /**
     * Bootstrap any application services.
     */
    public function boot(): void
    {
        // TODO
    }
}

class AppServiceProvider extends ServiceProvider
{
    /**
     * Register any application services.
     */
    public function register(): void
    {
       $this->app->register(MacroableServiceProvider::class);
    }
}

Macros can be defined in any class that defines Macroable. The framework provides the ability to extend the capabilities of a large number of classes.

Proprietary classes also have this capability, just add a few lines of code.

use Illuminate\Support\Traits\Macroable;

$class = new class {
    use Macroable;

    public function hello()
    {
        return 'world';
    }
};

$class::macro('hey', fn() => 'girl!');

dd(
    $class->hello(), // world
    $class->hey(), // girl!
);

Below is a list of popular classes from Laravel core that utilize the concept of macros:

Illuminate\Http\Request
Illuminate\Http\Response
Illuminate\Support\Arr
Illuminate\Support\Collection
Illuminate\Support\Str
Illuminate\Routing\Router
Illuminate\Validation\Rule
Illuminate\Database\Query\Builder

The list is not complete. You can use the project search with the keyword use Macroable to find more.

Mixin & Strong Macro

The concept of macros allows multiple user-defined functions to be registered at once via a mixin class. Each method of which must return a closure. The name of the method acts as the name of the macro.

Registration of mixins is done in the same way as with a macro, using the mixin() method from the base class.

Let's look at the user authentication rule extension for an example.

public function boot(): void
{
    \Illuminate\Auth\RequestGuard::mixin(new class {

        public function loginUsingId(): \Closure
        {
            return function($id) {
                /** @var Authenticatable $loggedInUser */
                $loggedInUser = $this->authenticate();

                // TODO 
            };
        }
    });
}

Grouping macros into separate classes, according to some principles, will help to understand the project more easily and make it easier to mashup.

Conclusion

Whether you are building a small website or a complex web application, Laravel macros can be a valuable addition to a developer's toolkit.

Fun and Useful CLI Tools for Linux

Denis Sinyukov — Wed, 18 Jan 2023 18:39:48 +0000

Not all terminal commands perform productive tasks and know how to value. Some are here for fun and to bring a smile to your face.

Here's my list of favorite useless command line applications that are sure to make working with the terminal more fun.

1. Cowsay

Judging by its name, cowsay is a customizable talking cow.

Cowsay generates an ASCII image of a cow that speaks a user-defined message to standard output. The utility provides several modes that change the cow's appearance and emotional state with the passed arguments. You can use different flags to play with the cow and more.

If you are not a fan of cows, Cowsay can also show other creatures. Cowsay uses cowfiles , which serve as templates for your output.

For a complete list of output templates: cowsay -l.
To test a template, just pass it with the -f flag.

cowsay -f <cowfile> "Hello Cowfile"

I have counted 47 available templates. I think you will find your favorite.

Cowsay is available for Linux and Mac and installation is easy.

sudo apt install cowsay

2. Figlet - Installing ASCII banners

We often write scripts to do a variety of tasks. But sometimes you want to show status messages in a fancy way. You will have to create Linux or Mac banners with figlet.

Need to change font, size, italics? - Not a problem. The tool knows how to do this simply with argulet.

Look at the list of available fonts: ls -ltr /usr/share/figlet|grep -i flf.

3. sl - ahead of the rest

The sl command is a classic play on UNIX and will show you a steam locomotive passing through the terminal. You can even shout out phrases from it.

4. fortune - your fate is in my hands

The following command displays jokes, quotes and even poems in the terminal, in the style of "fortune cookies". As they say, let the computer tell your fortune and fortune will help you with that.

By the way, if you combine cowsay with fortune, the cow will tell your fortune. The animal, at your choice, will start throwing out quotes, sometimes appropriate.

If you're interested in more details, welcome to the fortune site.

5. Telnet - you can see everything

Connecting to a remote port and setting up an interactive channel to send commands or receive data is all possible with the telnet utility. It is sometimes called the universal terminal browser because it can handle different protocols.

But this command also knows how to show Star Wars. Connect to the server and enjoy watching the new season.

telnet towel.blinkenlights.nl

In fact, there are many resources that telnet works with as entertainment.

What's your favorite command?

Guide to TMUX - Terminal That Remembers Everything

Denis Sinyukov — Thu, 05 Jan 2023 21:49:34 +0000

What’s tmux?

TMUX is a so-called terminal multiplexer, which allows you to run multiple terminals within one window.

I.e. we can open several terminals in one window and work in them at once, see what happens within one window or several terminals.

In tmux you can create sessions and when we disconnect from them, and after some time reconnect again - the session continues to live and everything will be exactly as we left this session.

So there will be the same open windows, all the history, all the messages and so on. This is very cool because, for example, when we connect to the server via ssh and we need to run some long command. Then we run it and if the connection is broken or just disconnected, we resume the running tmux session and we see exactly what was running there.

The utility can be used on linux, unix, mac os servers.

Installing tmux

The installation of tmux is quite simple in most operating systems, just run a single command: sudo apt-get install tmux (Ubuntu/Debian) or brew install tmux (Mac OS), sudo yum install tmux (CentOS)

Starting Your First Session

A new session is created with the new-session command or simply new. To set a name for the session, use the -s flag.

After starting the first session, the tmux server starts and the first client becomes the new session.

The new session will have one window and one pane with index 0.

The basic tmux commands start with the combination C-b, which means Ctrl key and b, followed by the command name.

For example <C-b 0>, having 2 active windows, switch to the first one (0) by pressing Ctrl+B+0.

Create new windows

Tmux has a wide variety of commands and acronyms. The command new-window neww is used to create a new window. The command does the same and creates a new window.

Splitting Panes

So, we have created our first session. By default, tmux creates one window and one pane inside. Each pane can be divided horizontally and vertically into n panes.

To split the pane into two vertically, you have to do <C-b %> (CTRL+B+%);
To split the pane into two horizontally, you must execute <C-b "> (CTRL+B+");
tmux split-window - is an alternative to the commands above, takes arguments to split horizontally -h and vertically -v.

Thus, we get two windows that are absolutely full and all this works absolutely independently and lives its own life.

Navigating Panes

To move the cursor between panes use the command <C-b + arrow key>.

To delete a pane use the command <C-b x>. After confirmation the selected pane will be deleted.

Closing panes

There are several ways to close a panes. By typing exit or by executing the command <C-b d>.

Note: The session will still live.

Session handling

When you are done with a session, you can either get rid of it or save the session in the background for later use.

To reconnect to the session and continue, you need to determine which session you want to connect to first. List the current session using tmux ls.

To resume the session: tmux attach -t <session_name>. And we see that everything here is left exactly as we left it. This is very cool, very handy and really helps out in many cases.

Configuration files

After starting the server, tmux executes the instructions from the .tmux.conf file in the user's home directory. If the file does not exist, create one.

New commands will only work for new sessions. For old sessions, old instructions will be applied.

Let's tweak tmux a bit, so that we can change the size of each panel with the mouse, both for vertical and horizontal panels. Open the .tmux.conf file and insert the command.



# Enable Mouse Support
set -g mouse on

Here's a good source for more in-depth tuning .tmux.conf

Conclusion

Great tool tmux, I advise everyone to put it and have a look at it for a while. The tool is really very handy and very useful and helps in many cases.

Particularly when you need to run multiple servers, it's convenient to run it in a single window to keep track of collateral, what's happening and what's down and so on. It is convenient to be able to run some long procedures on the server and then return to these procedures to see all the saved history, all logs and messages that fell into the terminal.

How to Synchronize Google Events with Laravel

Denis Sinyukov — Mon, 02 Jan 2023 22:33:18 +0000

In the previous article, we learned the general principles of resource synchronization from Google and wrote code that synchronizes calendars for Google account.

In this article, we will bind events to calendars. Let's look at what parameters should be sent and what they mean.

When syncing events, it's important to understand what to do after receiving the data: create, update, or delete an event, to keep the data up to date and valid.

Concept of Synchronization

Google Event - is an object or resource that is associated with a specific date or time period. It often has additional parameters such as location, description, time zone, status, attachments, etc.

Remember when you log into your email client and are asked if you are coming?

This attribute stores your answer, but has nothing to do with sync status, as we will pay attention to a bunch of factors when we sync.

Types of events

There are only 2 types of events: single and recurring events.

Single events are tied to a single date or time period, as opposed to recurring events which happen several times on a regular schedule (holidays, rallies, birthdays) and have a recurrence rule (RFC 5545).

We will work with an API which will return all the events together, we will not pay attention to this when saving the events.

The parameter singleEvents is responsible for expanding the events. The distinguishing feature of a repeating event is the recurrence parameter, and of all child events is the recurringEventId parameter.

Database shema for Google Events

We will not enter all of the existing fields, only those that are meaningful at this point. The structure of the database table will look like:

Schema::create('calendar_events', function (Blueprint $table) {
    $table->id();
    $table->string('calendar_id');
    $table->string('summary')->nullable();
    $table->string('provider_id');
    $table->string('provider_type');
    $table->longText('description')->nullable();
    $table->boolean('is_all_day')->default(false);
    $table->timestamp('start_at')->nullable();
    $table->timestamp('end_at')->nullable();
    $table->timestamps();

    $table->foreign('calendar_id')->references('provider_id')->on('calendars')->onDelete('CASCADE');
});

Synchronizing Google Events

Following the ProviderInterface interface, we have defined a synchronize function that creates a resource synchronization object GoogleSynchronizer.

 public function synchronize(string $resource, Account $account);

This object, in the previous article, helped us to perform calendar synchronization. Let's add the implementation of event synchronization work for calendar.

For synchronization, we need a calendar ID. You can use the special value calendarId primary - it is a reference to the user's main calendar, which is used by default.

public function synchronizeEvents(Account $account, array $options = [])
{
    $token = $account->getToken();
    $accountId = $account->getId();
    $calendarId = $options['calendarId'] ?? 'primary';
    $pageToken = $options['pageToken'] ?? null;
    $syncToken = $options['syncToken'] ?? null;

    $now = now();

    $query = Arr::only($options, ['timeMin', 'timeMax', 'maxResults']);
    $query = array_merge($query, [
        'maxResults' => 25,
        'timeMin' => $now->copy()->startOfMonth()->toRfc3339String(),
        'timeMax' => $now->copy()->addMonth()->toRfc3339String()
    ]);

    /** @var CalendarRepository $calendarRepository */
    $calendarRepository = $this->repository(CalendarRepository::class);

    if ($token->isExpired()) {
        return false;
    }

    if (isset($syncToken)) {
        $query = [
            'syncToken' => $syncToken,
        ];
    }

    /** @var EventRepository $eventRepository */
    $eventRepository = $this->repository(EventRepository::class);

    $eventIds = $eventRepository
        ->setColumns(['provider_id'])
        ->getByAttributes([
            'calendar_id' => $calendarId,
            'provider_type' => $this->provider->getProviderName()
        ])
        ->pluck('provider_id');

    $url = "/calendar/{$this->provider->getVersion()}/calendars/${calendarId}/events";

    do {
        if (isset($pageToken) && empty($syncToken)) {
            $query = [
                'pageToken' => $pageToken
            ];
        }

        Log::debug('Synchronize Events', [
            'query' => $query
        ]);

        $body = $this->call('GET', $url, [
            'headers' => ['Authorization' => 'Bearer ' . $token->getAccessToken()],
            'query' => $query
        ]);

        $items = $body['items'];

        $pageToken = $body['nextPageToken'] ?? null;

        // Skip loop
        if (count($items) === 0) {
            break;
        }

        $itemIterator = new \ArrayIterator($items);

        while ($itemIterator->valid()) {
            $event = $itemIterator->current();

            $this->synchronizeEvent($event, $calendarId, $eventIds);

            $itemIterator->next();
        }

    } while (is_null($pageToken) === false);

    $syncToken = $body['nextSyncToken'];
    $now = now();

    $calendarRepository->updateByAttributes(
        ['provider_id' => $calendarId, 'account_id' => $accountId],
        [
            'sync_token' => Crypt::encryptString($syncToken),
            'last_sync_at' => $now,
            'updated_at' => $now
        ]
    );
}

This function gets the access token from the sync account and generates a query to request resources from Google API. Endpoint to retrieve the data looks like:

GET /calendars/v3/calendars/example@gmail.com/events?maxResults=25&timeMin=2023-01-01T00:00:00+00:00&timeMax=2023-02-02T20:54:27+00:00"

To get the second page of data, the query will look like this:

GET /calendars/v3/calendars/example@gmail.com/events?pageToken=CiAKGjBpNDd2Nmp2Zml2cXRwYjBpOXA"

Once we have the resource page, we process each event separately with the synchronizeEvent function. As a result we have 3 scripts for each event.

Delete Events

If the event status is cancelled we should delete it if it exists in our database.

if ($event['status'] === 'cancelled') {

    if ($eventIds->contains($eventId)) {
        $eventRepository->deleteWhere([
            'calendar_id' => $calendarId,
            'provider_id' => $eventId,
            'provider_type' => $this->provider->getProviderName(),
    ]);
    }

    return;
}

Update Events

Before performing the API query, we got the list of existed IDs associated with the given calendar within the account. We must check if the Event ID is present in the database, we should update it, since Event ID is a unique field.

if ($eventIds->contains($eventId)) {

    $eventRepository->updateByAttributes(
        [
            'calendar_id' => $calendarId,
            'provider_id' => $eventId,
            'provider_type' => $this->provider->getProviderName()
        ],
        [
            'summary' => $event['summary'],
            'is_all_day' => $isAllDay,
            'description' => $event['description'] ?? null,
            'start_at' => $eventStart,
            'end_at' => $eventEnd,
            'updated_at' => new \DateTime(),
        ]
    );
}

Create event

If this event is not found in the database, we need to create it.

$eventRepository->insert([
    'calendar_id' => $calendarId,
    'provider_id' => $eventId,
    'provider_type' => $this->provider->getProviderName(),
    'summary' => $event['summary'],
    'description' => $event['description'] ?? null,
    'start_at' => $eventStart,
    'end_at' =>  $eventEnd,
    'is_all_day' => $isAllDay,
    'created_at' => new \DateTime(),
    'updated_at' => new \DateTime(),
]);

Note that events come with the specified timezone, but we convert them to UTC before saving them. Also, all-day events use the start.date and end.date fields to specify their time of occurrence, while temporary events use the start.dateTime and end.dateTime fields. To do this we will use the date conversion function.

protected function parseDateTime($eventDateTime): Carbon
{
    if (isset($eventDateTime)) {
        $eventDateTime = $eventDateTime['dateTime'] ?? $eventDateTime['date'];
    }

    return Carbon::parse($eventDateTime)->setTimezone('UTC');
}

When the synchronization is complete, we save the synchronization token (syncToken) to the calendar record, for future use and optimization.

Sync Calendar Events command

To check the synchronization result, we will use a command in Laravel. Let's call the command synchronize:events.

The commands will retrieve all calendars of the selected account from the database and synchronize their events.

public function handle()
{
    $accountId = $this->argument('accountId');

    $accountModel = app(AccountRepository::class)->find($accountId);

    throw_if(empty($accountModel), ModelNotFoundException::class);

    /** @var GoogleProvider $provider */
    $provider = app(CalendarManager::class)->driver('google');

    $calendars = app(CalendarRepository::class)->getByAttributes([
        'account_id' => $accountId
    ]);

    $account = tap(new Account(), function ($account) use ($accountModel) {

        $token = Crypt::decrypt($accountModel->token);
        $syncToken = '';

        if (isset($accountModel->sync_token)) {
            $syncToken = Crypt::decryptString($accountModel->sync_token);
        }

        $account
            ->setId($accountModel->id)
            ->setProviderId($accountModel->provider_id)
            ->setUserId($accountModel->user_id)
            ->setName($accountModel->name)
            ->setEmail($accountModel->email)
            ->setPicture($accountModel->picture)
            ->setSyncToken($syncToken)
            ->setToken(TokenFactory::create($token));
    });

    foreach ($calendars as $calendar) {
        $options = ['calendarId' => $calendar->provider_id];

        if (isset($calendar->sync_token)) {
            $options['syncToken'] = Crypt::decryptString($calendar->sync_token);
        }

        $provider->synchronize('Event', $account, $options);
    }
}

Conclusion

We looked at the event as a resource and configured the synchronization of calendars and their events. Next, we look at refresh access tokens of google accounts to automate the entire process. The full code of the article can be found in the commit.

Verifying Git commits using GPG

Denis Sinyukov — Sun, 01 Jan 2023 21:06:17 +0000

Digital Signatures are used to sign texts, letters and other messages. Git is no exception, but why do we need it?

Why to sign Git commits

When we fill out documents, we sign to acknowledge that we have read the document and take responsibility for its contents.

In git, we need to make it clear that I wrote the code and everything in the commit was written by me. But why?

Git solves a lot of development problems, but there are just as many loopholes for spoofing.

Git commits are based on trust, and most commit developers use simple credentials to identify the commit author, such as user.name and user.email.

Unfortunately, this data can easily be spoofed by someone else knowing your name and email. When submitted to a remote repository, the commit will show something other than your name and a link to your profile.

Keep in mind that the author on the commit is just an indication of the author, not proof that this person did the work.

Sounds strange, doesn't it? We use our repository account to submit, not just email. Unlike change push, commits don't take into account who the author or committer is, they use a configuration setting.

How do you prove you're a committer and not a liar?

Signing your commit solves this problem. Now no one can impersonate you and give away someone else's code as yours. All you need to do is have the encryption key and use it when you commit.

In addition you get a nice green Verified sign next to your commit.

GnuPG is an excellent tool for encrypting and signing your data. GPG creates a key pair: private and public keys. You'll need the public one to sign it. We will export this public key into our GitHub and GitLab accounts later.

The more you value the security of your application, the more you have to pay attention to your code and its authors.

You can set up your projects so that pushing into protected branches requires all commits to be signed.

View the list of existing keys on the system:

gpg --list-secret-keys --keyid-format LONG

B38EC0C87C413474 - fingerprint of the private key.

If you do not have a key, you can generate it with the command:

gpg --full-generate-key

Read the GPG article to learn more about the creation and use cases.

To upload a public key to GitHub and GitLab, you'll have to export it.

gpg --armor --export B38EC0C87C413474

The result is that we now have the contents of the public key, which we copy and use for our account.

Note that you copy the entire key, with the BEGIN PGP PUBLIC KEY BLOCK and the END PGP PUBLIC KEY BLOCK

Setting up Git to sign commits

You can set up a Git signature with a pair of keys from gpg signing:

git config --global user.signingkey B38EC0C87C413474

You can now sign commits with a key if you specified the -S flag when you created them.

git commit -S

You can also tell Git to automatically sign all your commits:

git config --global commit.gpgSign true

Adding the GPG key to GitHub

Add GPG key (public key) to the SSH and GPG settings page, which will link it to your account.

Adding the GPG key to GitLab

Add GPG key (public key) to the GPG settings page, which will link it to your account.

Conclusion

Signing tags and commits is a wonderful idea, without a doubt, but if you decide to incorporate it into your daily workflow, you need make sure that everyone on your team is familiar with the process.

Have you signed your commits yet?

Compact Guide: How to sync Google calendar with Laravel

Denis Sinyukov — Sat, 24 Dec 2022 23:47:03 +0000

Concept of Synchronization

For proper synchronization of your resources is important to understand the principles of Google API. These principles work the same for all Google resources, but will be different for Outlook. We will figure out how and why to use query parameters and study the best practices.

For optimized performance the API uses for important parameters as syncToken and pageToken.

The API data in most cases is returned with pagination, so as not to burden the network and allocate resources on the network and their caching.

Resource pagination - pageToken

When there is more than one page in the response, you can see the nextPageToken field, which stores the data received about the next page.

Do not forget to save the nextPageToken field in case you get an error when synchronizing one of the pages and do not want to retrieve successfully saved resources, but only starting from a certain page.

When you want to get the next page of data, you must specify the pageToken with the value of nextPageToken. You don't need to send additional parameters, because the token already has everything.

An example looks like this:

1. GET /calendars/primary/events

// Response
"items": [...]
"nextPageToken":"CiAKGjBpNDd2Nmp2Zml2cXRwYjBpOXA"

The following query takes the value from nextPageToken and sends it as a value for pageToken.

2. GET /calendars/primary/events?pageToken=CiAKGjBpNDd2Nmp2Zml2cXRwYjBpOXA

You can control the number of displayed resources in the response through the maxResults parameter.

Synchronization Marker - nextSyncToken

During the first synchronization, an initial query is performed for each resource in the collection that you want to synchronize.

The synchronization token is represented as a field named nextSyncToken in the list operation response.

The nextSyncToken is an important field for optimizing the synchronization of your resources, saving bandwidth. It allows you to retrieve only new data from when the token was first issued.

Don't forget to save this nextPageToken to retrieve resource items from the last received page.

For example, if you create a new event in your calendar, you don't need to retrieve the whole list of events and check and process each one, instead you get only the updated data.

An example looks like this:

1. GET https://www.googleapis.com/calendar/v3/users/me/calendarList

// Response 
...
"items": [...]
"nextSyncToken": "CPDAlvWDx70CEPDAlvWDx70CGAU=",

The nextSyncToken field will be only in the response on the last page, because all requests are given on a page-by-page basis and will contain the nextPageToken parameter.

The following query takes the value from nextSyncToken and sends it as a value for syncToken.

2. GET https://www.googleapis.com/calendar/v3/users/me/calendarList?syncToken=CPDAlvWDx70CEPDAlvWDx70CGAU=

// Response 
...
"items": [...]
"nextSyncToken": "v7GC9pHgvO6kpTHAxRx71KebukwS=",

In cases where your syncToken is no longer valid, you should remove it from the database and re-request the entire resource collection.

Synchronizing Google calendars

In the previous post, we set up authorization via oauth2, after which the Google Account data is written to the database.

After successful authorization, you should get the list of available calendars of the user from the account.

public function callback(string $driver): RedirectResponse
{
    /** @var ProviderInterface $provider */
    $provider = $this->manager->driver($driver);

    /** @var Account $account */
    $account = $provider->callback();

    $accountId = app(AccountService::class)->createFrom($account, $driver);

    $account->setId($accountId);

    // Sync calendars of user account
    $provider->synchronize('Calendar', $account);

    return redirect()->to(
      config('services.' . $driver . '.redirect_callback', '/')
    );
}

For calendars records and their basic information let's design a table in the database, which looks like:

Schema::create('calendars', function (Blueprint $table) {
    $table->id();
    $table->string('summary')->nullable();
    $table->string('timezone')->nullable();
    $table->string('provider_id');
    $table->string('provider_type');
    $table->text('description')->nullable();
    $table->text('page_token')->nullable();
    $table->text('sync_token')->nullable();
    $table->timestamp('last_sync_at')->nullable();
    $table->boolean('selected')->default(false);
    $table->unsignedBigInteger('account_id');
    $table->foreign('account_id')->references('id')->on('calendar_accounts')->onDelete('CASCADE');
    $table->index(['provider_id', 'provider_type']);
    $table->timestamps();
});

The table will store information about the calendar, tokens for synchronization and pagination for events, as well as links to his account.

To perform synchronization, add some logic to our calendar driver - GoogleProvider.php.

public function synchronize(string $resource, Account $account, array $options = [])
{
    $resource = Str::ucfirst($resource);

    $method = 'synchronize' . Str::plural($resource);

    $synchronizer = $this->getSynchronizer();

    if (method_exists($synchronizer, $method) === false) {
        throw new \InvalidArgumentException('Method is not allowed.', 400);
    }

    return call_user_func([$synchronizer, $method], $account, $options);
}

The getSynchronizer() function will return us the synchronizer class, which will mediate the resources. Which has method: synchronizeCalendars().

public function synchronizeCalendars(Account $account, array $options = [])
{
    $token = $account->getToken();
    $accountId = $account->getId();
    $syncToken = $account->getSyncToken();

    if ($token->isExpired()) {
        return false;
    }

    $query = array_merge([
        'maxResults' => 100,
        'minAccessRole' => 'owner',
    ], $options['query'] ?? []);

    if (isset($syncToken)) {
        $query = [
            'syncToken' => $syncToken,
        ];
    }

    $body = $this->call('GET', "/calendar/{$this->provider->getVersion()}/users/me/calendarList", [
        'headers' => ['Authorization' => 'Bearer ' . $token->getAccessToken()],
        'query' => $query
    ]);

    $nextSyncToken = $body['nextSyncToken'];
    $calendarIterator = new \ArrayIterator($body['items']);

    /** @var CalendarRepository $calendarRepository */
    $calendarRepository = app(CalendarRepository::class);

    // Check user calendars
    $providersIds = $calendarRepository
        ->setColumns(['provider_id'])
        ->getByAttributes(['account_id' => $accountId, 'provider_type' => $this->provider->getProviderName()])
        ->pluck('provider_id');

    $now = now();

    while ($calendarIterator->valid()) {
        $calendar = $calendarIterator->current();
        $calendarId = $calendar['id'];

        // Delete account calendar by ID
        if (key_exists('deleted', $calendar) && $calendar['deleted'] === true && $providersIds->contains($calendarId)) {
            $calendarRepository->deleteWhere([
                'provider_id' => $calendarId,
                'provider_type' => $this->provider->getProviderName(),
                'account_id' => $accountId,
            ]);

        // Update account calendar by ID
        } else if ($providersIds->contains($calendarId)) {
            $calendarRepository->updateByAttributes(
                [
                    'provider_id' => $calendarId,
                    'provider_type' => $this->provider->getProviderName(),
                    'account_id' => $accountId,
                ],
                [
                    'summary' => $calendar['summary'],
                    'timezone' => $calendar['timeZone'],
                    'description' => $calendar['description'] ?? null,
                    'updated_at' => $now,
                ]
            );
        // Create account calendar
        } else {
            $calendarRepository->insert([
                'provider_id' => $calendarId,
                'provider_type' => $this->provider->getProviderName(),
                'account_id' => $accountId,
                'summary' => $calendar['summary'],
                'timezone' => $calendar['timeZone'],
                'description' => $calendar['description'] ?? null,
                'selected' => $calendar['selected'] ?? false,
                'created_at' => $now,
                'updated_at' => $now,
            ]);
        }

        $calendarIterator->next();
    }

    $this->getAccountRepository()->updateByAttributes(
        ['id' => $accountId],
        ['sync_token' => Crypt::encryptString($nextSyncToken), 'updated_at' => $now]
    );
}

The code above fetch list of user calendars where it has owner access. After each calendar is checked for consistency in the database and actions are taken to delete, update or create.

As a result, we remember the synchronization token for the current account in the database.

Code Notes

Refresh token will be implemented in the following articles.
Google API return 100 calendars by default. Let's omit the point that we include more.
We get calendars where the user can read and modify events and access control lists.
The presence of syncToken in the request does not allow other parameters. Throws exception.
nextSyncToken is encoded before writing to the database.

Performance tips

To get a gzip-encoded response, you need to do:

Set the Accept-Encoding header
Change your user agent so that it contains the gzip string.

Each request to api google will contain these headers.

protected function headers(array $headers = []): array
{
    return array_merge([
        'Content-Type' => 'application/json',
        'Accept-Encoding' => 'gzip',
        'User-Agent' => config('app.name') . ' (gzip)',

    ], $headers);
}

Sync calendar command

To test the synchronization result, we will use the commands in Laravel. let's call it synchronize:calendars.

Commands will retrieve all accounts from the database and still synchronize the list of calendars.

public function handle()
{
    /** @var GoogleProvider $provider */
    $provider = app(CalendarManager::class)->driver('google');

    $accounts = app(AccountRepository::class)->get();

    foreach ($accounts as $accountModel) {
        $provider->synchronize('Calendar', tap(new Account(), function ($account) use ($accountModel) {

            $token = Crypt::decrypt($accountModel->token);
            $syncToken = '';

            if (isset($accountModel->sync_token)) {
                $syncToken = Crypt::decryptString($accountModel->sync_token);
            }

            $account
                ->setId($accountModel->id)
                ->setProviderId($accountModel->provider_id)
                ->setUserId($accountModel->user_id)
                ->setName($accountModel->name)
                ->setEmail($accountModel->email)
                ->setPicture($accountModel->picture)
                ->setSyncToken($syncToken)
                ->setToken(TokenFactory::create($token));
        }));
    }
}

Bottom line

In this article, we looked at how to sync google calendars to your Laravel app. We looked at the basic parameters for getting api resources. Created code and optimized it.

Some aspects of the implementation were omitted, but the entire list of changes can be seen at the link.

In the next article we will see how to synchronize google events.

How to Securely Store Passwords with GPG & PASS

Denis Sinyukov — Thu, 15 Dec 2022 22:50:46 +0000

If we want to encrypt data, in particular passwords, we have a lot of tools to choose from that allow us to encrypt data. There are a large number of opensource and closed source solutions, both paid and not.

If we want to store or encrypt some information safely, it has to be an opensource solution. They allow us a minimum hope that our data will belong only to us.

Why trust opensource solutions:

There is a guarantee that there is no special hacker code in it. Because we can see for ourselves what it consists of.
Mass testing and fixing the source code.

A large number of people use the same password for different accounts and services. That is the reason why so much stolen information is sold on the Internet in the form of databases.

That's why passwords should always be different for all services. They must be complex, of such length that it is hard to remember. Passwords should be changed at least once every six months, and it's hard to do without a password manager.

All this leads us to the idea of using special tools to store passwords.

Today we will talk about password management and data encryption. This will be a popular opensource solution,that you can trust.

Encrypting

We will encrypt the data using GnuPG, a program for encrypting information. GnuPG can encrypt information and create electronic digital signatures.

The program is released under the GNU General Public License which gives us the ability to freely use and securely encrypt our data.

Installing GPG

sudo apt install -y gpg

Create encryption keys with which we will encrypt everything.

gpg --full-generate-key

The encryption algorithms are RSI (1).
The default keysize is 3072 bits. We recommend setting the maximum key length to 4096 bits. The longer the key length, the more secure it is.
The lifetime of the key we will make the key - indefinite.
Passphrase does not replace keys. It is an additional mechanism for additional protection of our data.

As a result, we have a couple of keys generated and can start working with them. Let's add a few add-ons beforehand to make gpg work.

Configuration file

Create a gpg.conf configuration file and edit it. gpg.conf is the standard configuration file read by gpg on startup.

touch ~/.gnupg/gpg.conf

# Prohibit the inclusion of the version string in the ASCII armored output
no-emit-version

# disallow including a comment line in plain text signatures and ASCII armored messages
no-comments

# Display long keyid-formats
keyid-format 0xlong

# Do not include key id's in encrypted packets
throw-keyids

View public keys. pub and sub primary and sub key.
gpg -k
View private keys. sec and ssb master and sub key
gpg -K

Exporting and importing GPG keys

We have successfully generated two keys and can use them to encrypt our data. Keeping a bunch of keys only on the computer is not safe, because it can break, get lost, etc. We need to define a place to back up the keys.

GPG allows us to export the public and private keys just to a file which we can take anywhere and then import it back into gpg.

Exporting a GPG keyring

The command exports the public key for the specified keyring (example@email.com).

gpg --export -a example@email.com > public.gpg

The command exports the private key for the specified keyring (example@email.com).

gpg --export-secret-key -a example@email.com > secret.gpg

Now we can save the keys to a flash drive or somewhere else, and then import them back at any time.

Importing a GPG keyring

gpg --import public.gpg
gpg --import secret.gpg

This way we can import and export our keys.

We generate the keys, encrypt the data, export the keys and import them to any other computer.

Working with Passwords

GPG does a great job with passwords and for that there is a pass utility that runs on top of gpg. Pass is a password manager which uses gpg to encrypt data.

Installing the pass app

sudo apt install -y pass

To start working with the utility, you need to initialize the password store with the argument - the keychain id.

pass init example@email.com

We have created a directory~/.password-store.

Pass will work so that each password is stored in a separate file. For example, let's save the role for dev.to.

pass insert social/dev.to.
To view the list of created passwords, use the command which shows one created entry:

pass

Let's do the tree ~/.password-store command, which outputs the whole tree. Our password is in the file ~/.password-store/Social/dev.to.gpg which stores the binary data.

To view the password, use the command: pass social/dev.to. After entering the password, we will get a plain-text password.

Pass also knows how to generate passwords with the command:

pass generate 16

Given that all of our data is just stored in a directory, we can make that directory a git repository and simply push our changes there. All the passwords we create will be stored in the repository, in encrypted form.

Conclusion

I hope you now know about pass and will use it to store your passwords. The utility solves the problem of password management and works safely and securely from the console.

How To Integrate Google Calendar API and friendship with Laravel. Part 2

Denis Sinyukov — Sat, 10 Dec 2022 23:39:32 +0000

In the previous article we created a project in the Google Cloud Console, as well as configured the access keys through the API.

In this article we'll create a project in Laravel that will authorize through Google and save access token to database. You will learn the basic queries to Google via the OAuth 2.0 protocol.

Let's skip creating the basic skeleton of a Laravel framework and start immediately with creating code to work with the Google API.

Creating the application

First, we need to install the necessary libraries to work with the API. The library allows us to work with Google API Services without unnecessary actions. You can also use a simple Guzzle or CURL client.



composer require google/apiclient

The next step is to add the following variables to your .env file and add configuration to services.php:



.env

GOOGLE_CLIENT_ID= #from .json file
GOOGLE_CLIENT_SECRET= #from .json file
GOOGLE_REDIRECT_URI= #from .json file
GOOGLE_REDIRECT_CALLBACK=https://localhost/oauth2 #redirect URL after fetching userinfo
GOOGLE_APPROVAL_PROMPT=force
GOOGLE_ACCESS_TYPE=offline



services.php

return [
    'google' => [
        'client_id' => env('GOOGLE_CLIENT_ID'),
        'client_secret' => env('GOOGLE_CLIENT_SECRET'),
        'redirect_uri' => env('GOOGLE_REDIRECT_URI'),
        'redirect_callback' => env('GOOGLE_REDIRECT_CALLBACK'),
        'scopes' => [
            \Google_Service_Calendar::CALENDAR_EVENTS_READONLY,
            \Google_Service_Calendar::CALENDAR_READONLY,
            \Google_Service_Oauth2::OPENID,
            \Google_Service_Oauth2::USERINFO_EMAIL,
            \Google_Service_Oauth2::USERINFO_PROFILE,
        ],
        'approval_prompt' => env('GOOGLE_APPROVAL_PROMPT', 'force'),
        'access_type' => env('GOOGLE_ACCESS_TYPE', 'offline'),
        'include_granted_scopes' => true,
    ],
];

OAuth process

After creating and setting up our service, we need to log in through the OAuth process. To do that, we need to generate auth URL and redirect the user to the Google OAuth 2.0 server to begin the authentication and authorization process.

You can use OAuth 2.0 Scopes for Google APIs:

The first column indicates the name of the scope, a list of which we have defined in the settings. Google will require consent for each when you authorize.

In our services.php, we requested permission to:



openid
https://www.googleapis.com/auth/userinfo.email
https://www.googleapis.com/auth/userinfo.profile
https://www.googleapis.com/auth/calendar.events.readonly
https://www.googleapis.com/auth/calendar.readonly

Google as a Driver

We'll create a service to work with the Google API that will complement and encapsulate the way the app works and add some polymorphism to it.

A little later, we will expand the work of calendars to other providers, such as Outlook.

Create a Marker Interface (Tag Interface). In the future we will supplement it with the necessary methods.

Marker Interfaces are empty interfaces, i.e, they do not have any variables or methods declared in them.



interface ProviderInterface {}

Polymorphism will help us create an adaptive application.

Let's create a basic service to work with all popular calendars.




abstract class AbstractProvider implements ProviderInterface
{
    protected $providerName;
    protected $request;
    protected $httpClient;
    protected $clientId;
    protected $clientSecret;
    protected $redirectUrl;
    protected $scopes = [];
    protected $scopeSeparator = ' ';
    protected $user;

    /**
     * Create a new provider instance.
     */
    public function __construct(Request $request, string $clientId, string $clientSecret, string $redirectUrl, array $scopes = [])
    {
        $this->request = $request;
        $this->clientId = $clientId;
        $this->redirectUrl = $redirectUrl;
        $this->clientSecret = $clientSecret;
        $this->scopes = $scopes;
    }

    /**
     * @return RedirectResponse
     * @throws \Exception
     */
    public function redirect(): RedirectResponse
    {
        $this->request->query->add(['state' => $this->getState()]);

        if ($user = $this->request->user()) {
            $this->request->query->add(['user_id' => $user->getKey()]);
        }

        return new RedirectResponse($this->createAuthUrl());
    }

    /**
     * @return User
     */
    public function getUser(): User
    {
        if (isset($this->user)) {
            return $this->user;
        }

        try {
            $credentials = $this->fetchAccessTokenWithAuthCode(
                $this->request->get('code', '')
            );

            $this->user = $this->toUser($this->getBasicProfile($credentials));
        } catch (\Exception $exception) {
            report($exception);
            throw new \InvalidArgumentException($exception->getMessage());
        }

        $state = $this->request->get('state', '');

        if (isset($state)) {
            $state = Crypt::decrypt($state);
        }

        return $this->user
            ->setRedirectCallback($state['redirect_callback'])
            ->setToken($credentials['access_token'])
            ->setRefreshToken($credentials['refresh_token'])
            ->setExpiresAt(
                Carbon::now()->addSeconds($credentials['expires_in'])
            )
            ->setScopes(
                explode($this->getScopeSeparator(), $credentials['scope'])
            );
    }

    abstract protected function createAuthUrl();
    abstract protected function fetchAccessTokenWithAuthCode(string $code);
    abstract protected function getBasicProfile($credentials);
    abstract protected function toUser($userProfile);
}

Our first implementation will be a service for the work of Google, let's create it.




class GoogleProvider extends AbstractProvider
{
    protected $providerName = 'google';

    public function createAuthUrl(): string
    {
        return $this->getHttpClient()->createAuthUrl();
    }

    public function redirect(): RedirectResponse
    {
        if ($redirectCallback = config('services.google.redirect_callback')) {
            $this->request->query->add(['redirect_callback' => $redirectCallback]);
        }

        return parent::redirect();
    }

    protected function fetchAccessTokenWithAuthCode(string $code): array
    {
        return $this->getHttpClient()->fetchAccessTokenWithAuthCode($code);
    }

    /**
     * @return array
     */
    protected function getBasicProfile($credentials)
    {
        $jwt = explode('.', $credentials['id_token']);

        // Extract the middle part, base64 decode it, then json_decode it
        return json_decode(base64_decode($jwt[1]), true);
    }

    /**
     * @param Userinfo $userProfile
     * @return void
     */
    protected function toUser($userProfile)
    {
        return tap(new User(), function ($user) use ($userProfile) {
            $user->setId($userProfile['sub']);
            $user->setName($userProfile['name']);
            $user->setEmail($userProfile['email']);
            $user->setPicture($userProfile['picture']);
        });
    }

    /**
     * @return Client
     */
    protected function getHttpClient(): Client
    {
        if (is_null($this->httpClient)) {

            $this->httpClient = new \Google\Client();
            $this->httpClient->setApplicationName(config('app.name'));
            $this->httpClient->setClientId($this->clientId);
            $this->httpClient->setClientSecret($this->clientSecret);
            $this->httpClient->setRedirectUri($this->redirectUrl);
            $this->httpClient->setScopes($this->scopes);
            $this->httpClient->setApprovalPrompt(config('services.google.approval_prompt'));
            $this->httpClient->setAccessType(config('services.google.access_type'));
            $this->httpClient->setIncludeGrantedScopes(config('services.google.include_granted_scopes'));

            // Add request query to the state
            $this->httpClient->setState(
                Crypt::encrypt($this->request->all())
            );
        }

        return $this->httpClient;
    }
}

The only thing missing is a manager to work with our service. Now we can safely inherit from our base class AbstractProvider and implement new drivers.



use Illuminate\Support\Manager;

class CalendarManager extends Manager 
{
    protected function createGoogleDriver(): ProviderInterface
    {
        $config = $this->config->get('services.google');

        return $this->buildProvider(GoogleProvider::class, $config);
    }

    protected function buildProvider($provider, $config): ProviderInterface
    {
        return new $provider(
            $this->container->make('request'),
            $config['client_id'],
            $config['client_secret'],
            $config['redirect_uri'],
            $config['scopes']
        );
    }
}

The business logic for getting the data about the Google user and access tokens is almost ready. All that remains is to test it in a live environment.

All that's left to do is make our services accessible by creating new routes and controllers.



Route::name('oauth2.auth')->get('/oauth2/{provider}', [AccountController::class, 'auth']);
Route::name('oauth2.callback')->get('/oauth2/{provider}/callback', [AccountController::class, 'callback']);

The provider parameter will be dynamically inserted and checked against the CalendarManager class.

Let's start by redirecting the user to the Google consent screen using AccountController@auth() function. Click on the link https://localhost/oauth2/google/.




    public function auth(string $driver): RedirectResponse
    {
        try {
            return app(CalendarManager::class)->driver($driver)->redirect();
        } catch (\InvalidArgumentException $exception) {
            report($exception);

            abort(400, $exception->getMessage());
        }
    }

The CalendarManager will find the right provider from the URL and create the necessary driver to work with Google and will send a request for an authorization grant. (Step 1,2)

As soon as the user logs in and agrees with the scopes of our app (reading profile, email, calendars, events), they are redirected back to our AccountController@callback, which we specified in the .env file, we get a code in the body of our response from the Google Auth server.

The getUser() method, based on the code will request an access token and a refresh token with which we can retrieve the data.



public function getUser():

$credentials = $this->fetchAccessTokenWithAuthCode(
    $this->request->get('code', '')
);

Next, the access token allows you to request private info (step 5,6). At the first request we need to get information about the owner of the account, his name, email and ID.



$this->user = $this->toUser($this->getBasicProfile($credentials));

We encode the access token and refresh tokens via jwt, and store them in the database along with the profile data. The JWT token will store all token validity information.



public function encode(array $payload): string
    {
        $config = config('app');

        $tokenId = base64_encode(random_bytes(16));
        $issuedAt = new \DateTimeImmutable();

        $jwtPayload = [
            'iat'  => $issuedAt->getTimestamp(),
            'jti'  => $tokenId,
            'iss'  => $config['name'],
            'nbf'  => $issuedAt->getTimestamp(),
            'exp'  => $payload['expires_at']->getTimestamp(),
            'data' => [
                'access_token' => $payload['access_token'],
                'refresh_token' => $payload['refresh_token'],
                'provider' => $payload['provider'],
                'scopes' => $payload['scopes'],
                'email' => $payload['email'],
                'account_id' => $payload['account_id'],
            ]
        ];

        return JWT::encode($jwtPayload, $config['key'], $this->alg);

And save everything in the database for later use.



Schema::create('oauth2_accounts', function (Blueprint $table) {
    $table->id();
    $table->string('account_id', 100);
    $table->string('name');
    $table->string('email')->index();
    $table->string('picture');
    $table->string('provider')->nullable();
    $table->unsignedBigInteger('user_id')->nullable();
    $table->text('token')->nullable();
    $table->dateTime('expires_at')->nullable();
    $table->timestamps();
});



UserService.php

    public function saveFromUser(User $user, string $provider)
    {
        $payload = [
            'account_id' => $user->getId(),
            'email' => $user->getEmail(),
            'name' => $user->getName(),
            'picture' => $user->getPicture(),
            'provider' => $provider,
            'access_token' => $user->getAccessToken(),
            'refresh_token' => $user->getRefreshToken(),
            'scopes' => implode(' ', $user->getScopes()),
            'expires_at' => $user->getExpiresAt(),
            'created_at' => now(),
            'updated_at' => now()
        ];

        $payload['token'] = $this->encrypter->encode($payload);

        unset($payload['access_token'], $payload['refresh_token'], $payload['scopes']);

        if (DB::table('oauth2_accounts')
            ->where('account_id', $payload['account_id'])
            ->where('provider', $provider)
            ->exists()
        ) {
            unset($payload['created_at']);

            DB::table('oauth2_accounts')
                ->where('account_id', $payload['account_id'])
                ->where('provider', $provider)
                ->update($payload);
        } else {
            DB::table('oauth2_accounts')->insert($payload);
        }
    }

Bottom Line

In this article we created the application and the driver to work with the Google API, as well as authorized the user through OAuth 2 from Google and got tokens to access the server. We will need tokens to get data at any time. This approach will allow us to use access to API in any application, be it WEB or mobile.

You can find the full source code in the Laravel package at the GitHub.

DEV Community: Denis Sinyukov

How to Connect to MySQL through SSH Tunnel

Enhancing Authentication in Laravel: Creating a Custom Driver

Laravel Package Development : Key Steps to Building an Effective Tool

Why Develop and Use Packages in Laravel?

Advantages and Disadvantages of using packages

Pros:

Cons:

Package Preparation and Development

Basic folder structure within a package

Package discovery

Conclusion

Related links

Using the TinyMCE comments with the Vue.js & Laravel frameworks

Comments plugin overview and features

Main Features

Getting started

Create comment

Creating a comment on the server

Creating a comment on the client

The Bottom Line

Related links

Macros & Mixins in Laravel and additional development features | Macroable

Understanding Macros

Advantages of macros and mixins

Creating Macro & Where should I define them?

Mixin & Strong Macro

Conclusion

Fun and Useful CLI Tools for Linux

1. Cowsay

2. Figlet - Installing ASCII banners

3. sl - ahead of the rest

4. fortune - your fate is in my hands

5. Telnet - you can see everything

Guide to TMUX - Terminal That Remembers Everything

What’s tmux?

Installing tmux

Starting Your First Session

Create new windows

Splitting Panes

Navigating Panes

Closing panes

Session handling

Configuration files

Conclusion

How to Synchronize Google Events with Laravel

Concept of Synchronization

Types of events

Database shema for Google Events

Synchronizing Google Events

Delete Events

Update Events

Create event

Sync Calendar Events command

Conclusion

Related Links

Verifying Git commits using GPG

Why to sign Git commits

How do you prove you're a committer and not a liar?

Setting up Git to sign commits

Adding the GPG key to GitHub

Adding the GPG key to GitLab

Conclusion

Compact Guide: How to sync Google calendar with Laravel

Concept of Synchronization

Resource pagination - pageToken

Synchronization Marker - nextSyncToken

Synchronizing Google calendars

Code Notes

Performance tips

Sync calendar command

Bottom line

Related links

How to Securely Store Passwords with GPG & PASS

Encrypting

Installing GPG

Configuration file

Exporting and importing GPG keys

Exporting a GPG keyring

Importing a GPG keyring