Forem: Gurpreet Kait

Building My First Side Project : Daily Expense Tracker – A Journey

Gurpreet Kait — Fri, 01 Nov 2024 21:18:54 +0000

The Beginning: A Personal Problem

Every month-end felt like a mystery. Where did my money go? Sure, I was using spreadsheets and notes apps, but they were cumbersome and easy to forget. My friend had the same problem – we’d often discuss how we needed something simpler, something that would take seconds to record an expense.

That’s when it hit me: why not build something ourselves?

The Vision

I wanted to create something that would be:

Lightning fast to use (under 5 seconds to add an expense)
Mobile-first (because who carries a laptop to record coffee expenses?)
Simple enough that we’d actually use it daily
Smart enough to give insights about our spending

The Tech Stack

As a self-taught developer working at a tech startup, I chose technologies I was comfortable with:

Frontend : Vue.js with Tailwind CSS for a clean, mobile-friendly interface
Backend : Laravel for robust API development
PWA Features : Service workers for offline capability
Database : MySQL for reliable data storage

Key Features

Quick Add : Add expenses in seconds with smart categorization
Insights Dashboard : Visual breakdown of where your money goes
PWA Installation : Install on your phone like a native app
Offline Support : Add expenses even without internet
Multi-currency : Support for different currencies

Challenges Faced

Challenge #1: Making It Lightning Fast

The biggest challenge was speed. If it took more than 5 seconds to add an expense, we knew we wouldn’t use it. The solution? A minimalist interface focused on quick input with smart defaults.

Challenge #2: PWA Implementation

Getting the PWA to work smoothly across different devices was tricky. Service workers, caching strategies, and offline support took several iterations to get right.

Challenge #3: User Experience

Making something simple is hard. I went through multiple iterations of the UI, constantly asking:

Can this be simpler?
Can we remove this step?
Is this really necessary?

Real-World Testing

The best part about building this was having immediate feedback. My friend and I used it daily, which led to quick iterations based on real usage:

Found that category selection needed to be faster
Added quick shortcuts for common expenses
Improved the dashboard based on actual needs

Current State and Future Plans

The app (dailyexpensetracker.in) is now live and being used daily. Future plans include:

AI-powered insights for better financial decisions
Bank API integration for automatic tracking
Smart receipt scanning
Cloud backup for data security

Lessons Learned

Start Small : Having just two users (my friend and me) was perfect for initial development
Real Problems > Perfect Code : Solving a real problem is more important than having perfect code
User Feedback is Gold : Daily usage by real users provides invaluable insights
Simple > Feature-rich : People prefer simple solutions that work well over complex ones with many features

For New Developers

If you’re just starting out, here’s my advice:

Build something you’ll actually use
Start with a small, specific problem
Launch early, iterate often
Don’t worry about scaling until you need to
Focus on speed and simplicity

Try It Out

The app is free to use at dailyexpensetracker.in. I’m actively developing it and would love feedback from the community. Whether you’re a developer interested in the technical aspects or someone looking for a simple expense tracker, feel free to check it out.

Remember, every big journey starts with a small step. This is my first step into building products that solve real problems, and I’m excited to keep improving and building more.

Have feedback or suggestions? Feel free to reach out to gurpreetkait.codes@gmail.com or contribute to making the app better!

The post Building My First Side Project : Daily Expense Tracker – A Journey appeared first on Larachamp.

Why Use Laravel Data?

Gurpreet Kait — Sat, 03 Aug 2024 21:05:21 +0000

I’ve been using Laravel Data for the last 1 month and I found that it’s a time saver if you don’t want to debug your arrays when passing into functions/methods as parameters.

In this blog post, we’ll explore its key features, and why you should consider using it in your next Laravel project.

What is Laravel Data?

Spatie developed this package to simplify data transfer and transformation within Laravel applications. It allows you to easily manage data coming into and going out of your application, ensuring that it is properly formatted, validated, and transformed as needed.

Understand By Example

As always let’s take an example to understand how Laravel Data works. So, let’s say we are going to store users from a request Route::post('user',[UserController::class,'store']) now, let’s see how Laravel Data can handle this request.

We will create a Data(DTO – Data Transfer Object) File (a simple PHP file which extends to the base class).

App -> Data -> UserData.php

Now let’s see how UserData will work.

<?php

namespace App\Data;

use Spatie\LaravelData\Data;
use Spatie\LaravelData\Optional;

class UserData extends Data
{
    public function __construct(
        public string $username,
        public int $mobile,
        public int|Optional $age,
        public bool|Optional $is_student,
        public bool|Optional $is_teacher,
    )
    {

    }
}

Now we can directly use it in our controller instead Request.

<?php

namespace App\Http\Controllers;

use App\Data\UserData;
use App\Models\User;
use Illuminate\Http\Request;

class UserController extends Controller
{
    public function store(UserData $data)
    {
        User::create($data->toArray());
    }
}

So, now you should be worried about how you gonna pass extra rules to it? I mean, if you want to validate the max, min, email, etc. Yes, we easily can do that we just need to modify our UserData Class.

 public function __construct(
        #[Max(20)] // you can add these attributes
        public string $username,
        #[Digits(10)] // you can add these attributes
        public int $mobile,
        public int|Optional $age,
        public bool|Optional $is_student, // you can use Optional to avoid validation
        public bool|Optional $is_teacher, // you can use Optional to avoid validation
    )

If you think that you want to add multiple attributes then you can explore Required() and ofcourse you’ll not be satisfied by these examples. I’ll suggest to you to explore Laravel Data Validation Attributes.

Installation

You can easily install the Laravel Data Package by using the mentioned command.

composer require laravel-data/laravel-data

Benefits Of Using LaravelData

Cleaner Code : DTO helps us to keep code organized by using Data Transfer Objects (DTOs) to manage data, making it easier to read and maintain.

Easy Validation : You can simplify data validation by defining validation rules directly in your DTOs, ensuring that data is correct before processing it.

Automatic Data Transformation : DTO automatically transforms data between different formats, saving the time and reducing errors when working with APIs.

Type Safety : By defining data types in DTOs, it helps catch errors early, ensuring that your data is always in the expected format.

Simplified Serialization : It makes serializing and deserializing data easy, so you can quickly convert data to and from formats like JSON, without writing extra code.

Conclusion

So, in short, this package (DTO) simplifies and enhances data management in Laravel applications.

The post Why Use Laravel Data? appeared first on Larachamp.

Password Protected Zip File Creation in PHP

Gurpreet Kait — Thu, 11 Apr 2024 17:13:24 +0000

Hello readers, today we will learn about a little bit different topics. We will see how we can create a password-protected zip in PHP.

Since a few days back, I’ve been trying to write less theory, just to save time from both sides.

Create A PHP File

Yes, you read it right, we just need a single PHP file to create a password-protected zip file. Let’s see how.

Use the below code :

<?php

$password = 'password';
$zipFileName = 'protected';
$filesToZip = ['test.py', 'test.txt'];
shell_exec('zip -jrq -P ' . $password . ' ' . $zipFileName . '.zip ' . 'test.py');

//for multiple files use space between file name 
shell_exec('zip -jrq -P ' . $password . ' ' . $zipFileName . '.zip ' . 'test.txt test.py');

Code Description

zip: This is the command-line tool used to create zip archives.
-j: This flag tells zip to store just the file, not its directory structure. It’s useful if you want to add files from different directories without retaining their original directory structure.
-r: This flag stands for “recursive” and includes all files and directories within the specified directory.
-q: This flag stands for “quiet” and suppresses the output of the zip command, making the process less verbose.
-P: This flag specifies the password for the zip file.
$password: This is the variable containing the password for the zip file.
$zipFileName . '.zip': This is the name of the zip file you want to create. The .zip extension is appended to the variable $zipFileName.
'test.py': This is the file or directory you want to add to the zip archive.

So, in summary, the command is creating a zip archive named $zipFileName.zip (with the password specified by $password) and adding the file test.py to it, while ignoring the directory structure (-j flag) and including all files and directories within test.py (-r flag).

For Laravel: Creating Password-Protected Zip Files In Laravel

Conclusion

Implementing password protection for zip files in PHP is now simple and secure. Customize the code as needed for dynamic file lists or user authentication.

The post Password Protected Zip File Creation in PHP appeared first on Larachamp.

5 Must Laravel Packages For 2024

Gurpreet Kait — Tue, 02 Apr 2024 19:26:22 +0000

Hey everyone, today we are going to see what are the most packages that we should have while we are developing a laravel application. Well, this isn’t just for 2024 it will be a kind of ever-green packages. If they will be maintained properly. HAHAHAHA!

Well, Apart from fun. Let’s see the packages and I’ll be sharing the overview of the package and the creator’s profile as well. So, that you can follow the person on X.com so that you will be connected for upcoming updates. Also in general you should follow top creators like Spatie (contributors) because you’ll be up to date in the community.

Laravel Debugbar

The Laravel Debugbar package is a powerful tool designed to enhance the debugging experience for Laravel developers. It provides a comprehensive overview of various aspects of your application’s performance and functionality, including queries, routes, views, and more. With its user-friendly interface, the Debugbar enables developers to identify and troubleshoot issues quickly, leading to more efficient development workflows and higher-quality code.

Read this for more info.

Note: Make sure you set the debugging mode to true if you want to use the debugger after installation

Creator: Barry vd. Heuvel

// 
.env
APP_DEBUG=true

Laravel Log Viewer

Log Viewer is a package for Laravel that allows you to easily navigate, read, and download the logs. You can see all the other logs from Horizon, Apache, Nginx, Redis, Supervisor, Postgres, and more.

Creator : Arunas Skirius

Yajra DataTables

Yajra data tables package is one of my favorite packages on my list. I use this package almost in every project I do from scratch. It’s a Laravel package for handling server-side works of DataTables jQuery Plugin via AJAX option by using Eloquent ORM, Fluent Query Builder, or Collection. You gonna enjoy this package. Under the hood, you can modify the base class to enjoy more flexibility as I do.

Creator: X Profile

Laravel Media Library

Imagine you’re working on your Laravel website, dealing with files can be a bit of a headache. But then you discover the Laravel Media Library package, and suddenly, managing files becomes super easy.

Here’s the cool part: instead of just treating files like random attachments, you can actually think of them as proper Models in your code. That means they have a special place and purpose.

So, what’s the benefit? Well, normally when you upload a file, it’s tied to a specific part of your website, like adding a profile picture during sign-up or attaching a document to a form. With the Media Library package, you can do all this without the hassle of managing each file in your database manually. The package takes care of that by setting up the right structure for you.

In simple terms, the Laravel Media Library package makes handling files in your Laravel app way easier and organized. It’s like having a neat filing system for all your digital stuff!

Creator: Spatie

Laravel Backup

Here’s how it works: the package creates a backup of your entire application, bundling everything into a handy zip file. This zip file includes all the files from the directories you specify, alongside a database dump for good measure.

Conclusion

In conclusion, Laravel offers a rich ecosystem of packages that can significantly enhance your development experience and add valuable features to your applications. The top five packages highlighted—Laravel Debugbar, Laravel Log Viewer , Yajra Datatables , Laravel Media Library, and Laravel Backup—cover a wide range of functionalities.

The post 5 Must Laravel Packages For 2024 appeared first on Larachamp.

WhereAll and WhereAny In Laravel 10.47 Update

Gurpreet Kait — Thu, 07 Mar 2024 19:29:01 +0000

Today I’m going to share an update of the Laravel 10.47 version in which we have two new Laravel Eloquent methods that make conditions easier to write most of the time in case of searching for something. We going to see how we can use these methods.

Before explaining the methods I’m gonna show you that If I use the search input box in my laravel app to search for something in DB. It can be by name, email, age, etc. I used to do something as mentioned below in the code.

// a simple search query 
$orders->where('email', 'like', "%$search%")->where('name','like',"%$search%");

But now you can enjoy this new method called whereAll instead.

WhereAll Method

This method can replace this whole line of code and can act easily in one syntax as mentioned in the below code.

// syntax
whereAll($columns, $operator = null, $value = null, $boolean = 'and')

//Usage
$orders->whereAll(['email','name'],'like',"%$search%");

//Query
select * from "orders" where (name like "shantu" AND email like "shantu")

WhereAny Method

whereAny() method adds or instead of and expression in a query.

// syntax
whereANy($columns, $operator = null, $value = null, $boolean = 'and')

//Usage
$orders->whereAny(['email','name'],'like',"%$search%");

//Query
select * from "orders" where (name like "shantu" OR email like "shantu")

I’m gonna link the original commit here Add whereAll and whereAny methods to the query builder

I hope you find this update helpful.

The post WhereAll and WhereAny In Laravel 10.47 Update appeared first on Larachamp.

Upload Files Using Filepond In Laravel

Gurpreet Kait — Fri, 08 Dec 2023 19:30:08 +0000

Today we are going to learn a new and I like the Ux of the filepond library. The way it uploads the files and actions provides the functionalities like editing images as well. You can explore the library here on filepond website.

We will use File Pond with Laravel here. I am working on a product where I had to upload multiple images. I chose File Pond because it provides a very convenient way to interact while uploading.

I first watched the video for File Pond On the Laravel Daily YouTube channel. I’ll embed the video so you can watch also you can go to the repo where I have implemented this functionality.

file pond library with laravel

Installing File Pond And Initial Setup

First of all, to start using File Pond we have to use the File Pond Cdn. We also can install this via npm. I’ll go with CDN for now.

Requirements

Installed Laravel
Jquery
File pond cdn (I have linked in the snippet below)
Controller ( Temporary File Handler)
Model ( Temporary File Handler)

I have created a welcome.blade.php file where I have used an input to represent file pond actions.

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>File Pond Upload</title>
</head>
<link href="https://unpkg.com/filepond/dist/filepond.css" rel="stylesheet">
<link href="https://unpkg.com/filepond-plugin-image-preview/dist/filepond-plugin-image-preview.css" rel="stylesheet">

<body>
    <form action="">
        <input type="file" name="filepond" id="filepond">
    </form>
    {{-- Jquery Library --}}
    <script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
    {{-- File Pond Js Cdn --}}
    <script src="https://unpkg.com/filepond/dist/filepond.js"></script>
    {{-- File Pond Jquerys Cdn --}}
    <script src="https://unpkg.com/jquery-filepond/filepond.jquery.js"></script>
    {{-- File Pond Image Preview Cdn --}}
    <script src="https://unpkg.com/filepond-plugin-image-preview/dist/filepond-plugin-image-preview.js"></script>
    <script>
    FilePond.registerPlugin(FilePondPluginImagePreview);

    $("#filepond").filepond({
        allowImagePreview: true,
        allowImageFilter: true,
        imagePreviewHeight: 100,
        allowMultiple: true,
        allowFileTypeValidation: true,
        allowRevert: true,
        acceptedFileTypes: ["image/png", "image/jpeg", "image/jpg"],
        maxFiles: 5,
        credits: false,
        server: {
            headers: {
                "X-CSRF-TOKEN": $('meta[name="csrf-token"]').attr("content"),
            },
            url: "/temp/upload",
            process: false,
            // revert: true,
            restore: "temp/upload/delete",
            fetch: false,
        },
    });

    </script>
</body>

</html>

Creating Controller And Model

We will create a controller TemporaryFileController and Model TemporaryFile to represent temporary_files table. We also need a migration to create uploaded files.

Migration

You will get to know soon why we need this table.

php artisan make:migration create_temporary_files_table

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    /**
     * Run the migrations.
     */
    public function up(): void
    {
        Schema::create('temporary_files', function (Blueprint $table) {
            $table->id();
            $table->string('folder');
            $table->string('filename');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     */
    public function down(): void
    {
        Schema::dropIfExists('temporary_files');
    }
};

In FIle Pond when we choose a file after processing it uploads directly to the server. So, in that case, this will return whatever you send in response and keep that until the form is saved in file input.

You can see in the controller below the post method.

Model

php artisan make:model TemporaryFile

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class TemporaryFile extends Model
{
    use HasFactory;

    protected $fillable = ['folder','filename'];
}

Controller

php artisan make:controller TemporaryFileController

<?php

namespace App\Http\Controllers;

use App\Models\TemporaryFile;
use Illuminate\Http\Request;
use Illuminate\Support\Arr;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;

class TemporaryFileController extends Controller
{
    /**
     * Display a listing of the resource.
     */
    public function index(Request $request)
    {
        if ($request->isMethod('delete')) {
            $filepond = $request->json()->all();
            $folder = $filepond['folder'];
            $tempFile = TemporaryFile::query()->where('folder', $folder)->first();
            $path = storage_path('app/orders/temp/' . $folder);
            if (is_dir($path) && $tempFile) {
                DB::beginTransaction();

                try {
                    unlink($path . '/' . $tempFile->filename);
                    rmdir($path);
                    $tempFile->delete();
                    DB::commit();

                    return response()->json(['message' => 'success']);
                } catch (\Exception $e) {
                    DB::rollBack();
                    Log::error('Error deleting directory: ' . $e->getMessage());
                    return response()->json(['message' => 'failed'], 500);
                }
            }
            return response()->json(['message' => 'failed'], 500);
        }
        if ($request->hasFile('filepond')) {
            $files = $request->file('filepond');
            foreach ($files as $key => $file) {
                $filename = $file->getClientOriginalName();
                $folder = uniqid() . '-' . time();
                $file->storeAs('orders/temp/' . $folder, $filename);
                TemporaryFile::query()->create(['folder' => $folder, 'filename' => $filename]);
                // Arr::add($folders, $key, $folder);
                return response()->json(['folder' => $folder], 200);
            }
        }
    }
}

In Controller we are checking if filepond exists then get the file and then we have created a folder name. Now we gonna save this uploaded file in this folder and will return the name of the folder. Well, there’s a reason behind returning in json. I was getting some error because of debugbar I guess.

Web.php

<?php

use App\Http\Controllers\TemporaryFileController;
use Illuminate\Support\Facades\Route;

/*
|--------------------------------------------------------------------------
| Web Routes
|--------------------------------------------------------------------------
|
| Here is where you can register web routes for your application. These
| routes are loaded by the RouteServiceProvider and all of them will
| be assigned to the "web" middleware group. Make something great!
|
*/

Route::get('/', function () {
    return view('welcome');
});

Route::controller(TemporaryFileController::class)->group(function(){
    Route::match(['post','delete'],'temp/upload','index')->name('temporary.upload');
});

Error Handling

If you see this kind of error.

That means we are not sending the csrf token in request.

Make sure you have <meta name="csrf-token" content="{{ csrf_token() }}"> this tag in your head so that any time you get this in your js with $('meta[name="csrf-token"]').attr("content"), this syntax.

Now you have to fix this. Update your welcome.blade.php with this tag.

Below is the output:

Conclusion

Repo URL: https://github.com/robinkashyap-01/filepond-fileupload-laravel

File Pond is an amazing library you should use it if you want to enhance the experience of your application. Thanks.

The post Upload Files Using Filepond In Laravel appeared first on Larachamp.

The Importance of Unit Testing in PHP Applications

Gurpreet Kait — Wed, 01 Nov 2023 17:39:24 +0000

In the world of web development, PHP remains a popular and powerful scripting language. PHP applications power numerous websites, from e-commerce platforms to content management systems. While PHP’s flexibility and versatility are undeniable, ensuring the reliability and stability of PHP applications is equally important. This is where unit testing comes into play. In this blog post, we’ll explore the significance of unit testing in PHP applications and how it contributes to building robust, error-free software.

The Foundation of Quality PHP Code

Unit testing is an essential practice in software development. It involves testing individual components or units of code in isolation to ensure they work as expected. These units can be functions, methods, or even classes. For PHP developers, unit testing forms the foundation of high-quality code. Here’s why it’s crucial:

1. Catching Bugs Early

Unit tests act as a safety net. They catch bugs and issues in your code before they snowball into more significant problems. By identifying and addressing issues early in the development process, you save time and effort in the long run.

Let’s assume you have a PHP function that calculates the total price of items in a shopping cart. Without unit tests, a bug could go unnoticed, leading to incorrect calculations.

// shopping_cart.php

function calculateTotalPrice($items) {
    $total = 0;
    foreach ($items as $item) {
        $total += $item['price'];
    }
    return $total;
}

A corresponding PHPUnit test for this function can catch potential issues:

// shopping_cart_test.php

class ShoppingCartTest extends PHPUnit\Framework\TestCase {
    public function testCalculateTotalPrice() {
        $items = [
            ['price' => 10],
            ['price' => 20],
        ];

        $total = calculateTotalPrice($items);

        $this->assertEquals(30, $total);
    }
}

This test ensures that the calculateTotalPrice function correctly calculates the total price. It’s your safety net, detecting issues like incorrect sums or unexpected behavior.

Code Refactoring

Suppose you’re working on a PHP class responsible for user authentication. You want to refactor the code to use a more secure hashing algorithm.

// auth.php

class UserAuth {
    public function login($username, $password) {
        // Existing authentication logic
    }

    public function resetPassword($user) {
        // Existing password reset logic
    }
}

By having unit tests, you can confidently refactor this code and ensure existing functionality remains intact.

// auth_test.php

class UserAuthTest extends PHPUnit\Framework\TestCase {
    public function testLogin() {
        // Test the login method
    }

    public function testResetPassword() {
        // Test the resetPassword method
    }
}

As you refactor the UserAuth class, these tests guarantee that user login and password reset functionality continue to work as expected.

Improved Collaboration

In a team environment, unit tests enhance collaboration. They define how different parts of your PHP application should behave and help prevent misunderstandings.

// order.php

class Order {
    public function createOrder($items, $user) {
        // Create an order and return details
    }
}

Unit tests for this class act as documentation and enable multiple developers to work together efficiently.

// order_test.php

class OrderTest extends PHPUnit\Framework\TestCase {
    public function testCreateOrder() {
        // Test the createOrder method
    }
}

When developers join the project, these tests provide clear examples of how to use and interact with the Order class.

Enhanced Documentation

Unit tests serve as documentation for your code. They demonstrate how individual parts of your application should behave, making it easier for developers to understand and use your code.

Example: When a new developer joins your project, unit tests provide clear examples of how to use and interact with different PHP classes and functions. This helps onboard new team members quickly.

Learning Testing in PHP

Imagine embarking on a journey to master unit testing in PHP. Along the way, you encounter a magical course that simplifies the complex world of testing. The “Testing in PHP by Gary Clarke” course takes you on an enchanting adventure, teaching you how to write effective tests and leverage PHP testing frameworks.

Why you should Enroll :

Testing is an essential skill that can only advance your career
Your code will become more predictable and reliable
The information is current and relevant to the market
Promotion. To become a senior PHP developer ** you will need to understand testing strategies**
Flexible. You can work at your own pace. Take as long as it takes.

The course is designed for both beginners and experienced PHP developers, providing valuable insights and best practices for writing clean, maintainable code.

Learn more about the course hereand begin your adventure today.

Conclusion

Unit testing is not just a good practice; it’s a necessity in the world of PHP application development. By catching bugs early, facilitating code refactoring, and improving collaboration, unit tests contribute to the creation of stable and reliable software.

The post The Importance of Unit Testing in PHP Applications appeared first on Larachamp.

Simple Query Builder

Gurpreet Kait — Mon, 30 Oct 2023 18:44:51 +0000

Maybe you know that in Laravel Framework we build queries by using a very convenient approach to build queries. Which is called query builder. Yes, so the same I am trying to do with simple-query-builder in PHP. If you have a core php application then easily you can install the library and use it in your project.

This provides a simple interface to build select, insert, update, or delete queries. You can also use it for queries where we require you to use Joins.

Repository Url: simple-query-builder

Installation

 composer require robinksp/simple-query-builder

How to Get Connection

It’s simple to build a connection in simple-query-builder

// file: app/connection.php

<?php

use robinksp\querybuilder\Connection;

require 'vendor/autoload.php';

$config = [
    'hostname' => 'localhost',
    'username' => 'root',
    'password' => 'password',
    'database' => 'test'
];
$connection = (new Connection($config))::connect();

How to build a basic query

$selectQuery = (new Query($connection))
    ->table('award_icons')
    ->select('*')
    ->where('id', '=', 33)
    ->get();

The post Simple Query Builder appeared first on Larachamp.

How To Send Bulk Email Using Laravel

Gurpreet Kait — Tue, 24 Oct 2023 13:48:17 +0000

Hey there, If you are building something interesting and looking to send bulk emails using your application’s in-built power provided by Laravel itself. You can do that easily.

You can use SMTP or external services like Mailgun or Sendgrid as well.

In this blog, I’ll walk through the process step-by-step, and I’ll provide example code snippets along the way.

Prerequisites

Installation

Make sure you have a laravel application up and running.

composer create-project --prefer-dist laravel/laravel bulk_email_app
cd bulk_email_app

Configure Mail Credentials

Now you have to go to your .env file and add your email credentials.

MAIL_MAILER=smtp
MAIL_HOST=mailpit
MAIL_PORT=1025
MAIL_USERNAME=null
MAIL_PASSWORD=null
MAIL_ENCRYPTION=null
MAIL_FROM_ADDRESS="hello@example.com"
MAIL_FROM_NAME="${APP_NAME}"

Seeder

In my case, I have seeded a few emails to perform the bulk email action. But in your case, you may be uploading via CSV or you may be just entering them in the tables manually. But at the end when we have emails in the db the case is the same to send them.

I’ll be using Mailtrap for email testing.

Set Up the Queue Driver

Mostly we use database the driver. You can configure it in your .env file:

QUEUE_CONNECTION=database

Create An Artisan Command

Create an Artisan command that will dispatch a job to send the bulk emails. Run the following command to create the job:

php artisan make:command SendBulkEmails

In the SendBulkEmails command, dispatch a job to send the emails:

<?php

namespace App\Console\Commands;

use App\Jobs\SendBulkEmailJob;
use App\Models\User;
use Illuminate\Console\Command;

class SendBulkEmails extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'app:send-bulk-emails';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Command description';

    /**
     * Execute the console command.
     */
    public function handle()
    {
        $users= User::query()->select('email')->get();
        $data['emails'] = $users;
        $data['subject'] = 'Newsletter Email';
        $data['content'] = 'This is newsletter email';
        SendBulkEmailJob::dispatch($data);
    }
}

Create Mail

I have created a mail called NewletterEMail which we will represent a particular mail template. In view you can pass your view template/blade file.

//app/Mail/NewsletterEmail.php

<?php

namespace App\Mail;

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Mail\Mailable;
use Illuminate\Mail\Mailables\Content;
use Illuminate\Mail\Mailables\Envelope;
use Illuminate\Queue\SerializesModels;

class NewsletterEmail extends Mailable
{
    use Queueable, SerializesModels;

    /**
     * Create a new message instance.
     */
    public function __construct(
        public string $content,
        public $subject
    )
    {

    }

    /**
     * Get the message envelope.
     */
    public function envelope(): Envelope
    {
        return new Envelope(
            subject: $this->subject,
        );
    }

    /**
     * Get the message content definition.
     */
    public function content(): Content
    {
        return new Content(
            view: 'mail'
        );
    }

    /**
     * Get the attachments for the message.
     *
     * @return array<int, \Illuminate\Mail\Mailables\Attachment>
     */
    public function attachments(): array
    {
        return [];
    }
}

Create a Job for Sending Bulk Emails

We have to create a job to send bulk emails.

php artisan make:job SendBulkEmailJob

<?php

namespace App\Jobs;

use App\Mail\NewsletterEmail;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldBeUnique;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Illuminate\Support\Facades\Mail;

class SendBulkEmailJob implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    /**
     * Create a new job instance.
     */
    public function __construct(
        protected array $data
    )
    {
        $this->data = $data;
    }

    /**
     * Execute the job.
     */
    public function handle(): void
    {
        $emailContent = $this->data['content'];
        $subject = $this->data['subject'];
        $emailList = $this->data['emails'];

        foreach ($emailList as $email) {
            Mail::to($email->email)->send(new NewsletterEmail($emailContent, $subject));
        }
    }
}

Migrate Job Table

// it will generate table for queued jobs
php artisan queue:table

// migrate
php artisan migrate

Schedule the Email Sending Task

Now, let’s set up the Laravel scheduler to run the email-sending task periodically. Edit the app/Console/Kernel.php file and add the following code to the schedule method:

// app/Console/Kernel.php

use App\Console\Commands\SendBulkEmails;

    protected function schedule(Schedule $schedule): void
    {
        // $schedule->command('inspire')->hourly();
        $schedule->command('app:send-bulk-emails')->dailyAt('16:41');
    }

Perform

Now, you can run the below command to test the whole process.

php artisan queue:listen

That’s it! You have set up a scheduled task to send bulk emails in the background using Laravel’s task scheduling and the queue system. Make sure to customize the code and configuration according to your specific needs and requirements.

The post How To Send Bulk Email Using Laravel appeared first on Larachamp.

What Is a PWA and How to Build One

Gurpreet Kait — Thu, 19 Oct 2023 12:57:46 +0000

PWA is a web term that means (progressive web apps) PWA is a special kind of website that you can use over the internet on any device you want, make sure the browser supports the PWA. Maybe some browsers don’t understand them but on Chrome, Firefox, and Safari you can use the PWA.

So, the cool thing about PWA you don’t need to go to any app store or Play store to download it. You just have to go to the website and you can easily access this on your home screen.

So, in simple words, a PWA is a special website that you can put on your home screen and use like an app. It’s kind of like magic!

In the above image, you can see the download button first icon in the row on the right side. That means the website is a PWA you can even install it on your computer as an app and on your mobile.

Building A Simple PWA Website

If you are ready for a practical experience let’s open your code editor and create these files.

Index.html
manifest.js
service-worker.js
logo.png

I have created it now it’s your term.

I have created this dummy content HTML file.

Now, we need manifest.json to make our application a PWA. Install this package PWA-asset-generator which will also generate the different sizes of logo for your app and manifest.json as well.

npm install pwa-asset-generator

Now let’s try this.

Now you have to specify the source file which means the logo and the output folder where it will be creating all the different sizes of images.

npx pwa-asset-generator [source-file] [output-folder]

This is will also return a manifest.json file content that you can use.

As you can see it has created the images directory and different size of logo images.

Don’t forget to include your manfest.json in the head of your main layout.

  <link rel="manifest" href="manifest.json">

So, manifest.json will be

{
  "name": "Simple PWA",
  "short_name": "PWA",
  "description": "A simple Progressive Web App",
  "start_url": "http://localhost/pwa-web/",
  "display": "standalone",
  "background_color": "#ffffff",
  "theme_color": "#3498db",
  "icons": [
    {
      "src": "images/manifest-icon-192.maskable.png",
      "sizes": "192x192",
      "type": "image/png",
      "purpose": "any"
    },
    {
      "src": "images/manifest-icon-192.maskable.png",
      "sizes": "192x192",
      "type": "image/png",
      "purpose": "maskable"
    },
    {
      "src": "images/manifest-icon-512.maskable.png",
      "sizes": "512x512",
      "type": "image/png",
      "purpose": "any"
    },
    {
      "src": "images/manifest-icon-512.maskable.png",
      "sizes": "512x512",
      "type": "image/png",
      "purpose": "maskable"
    }
  ]
}

Now our PWA is ready.

Service Worker For Caching?

We also need to implement the service-worker for caching.

service-worker.js

self.addEventListener('install', (e) => {
    e.waitUntil(
        caches.open('my-cache').then((cache) => {
            return cache.addAll([
                '/',
                '/manifest.json',
                '/logo.png'
            ]);
        }).catch((error) => {
            console.log('cache error', error);
        })
    );
});

self.addEventListener('fetch', (e) => {
    e.respondWith(
        caches.match(e.request).then((response) => {
            return response || fetch(e.request);
        })
    );
});

And the below script you have to add to your index.html file or whatever main layout file you are using default.

<script>
    if ('serviceWorker' in navigator) {
        navigator.serviceWorker.register('service-worker.js')
            .then((reg) => {
                console.log('Service Worker registered with scope:', reg.scope);
            })
            .catch((error) => {
                console.error('Service Worker registration failed:', error);
            });
    }
</script>
//Before your body tag
</body>

Conclusion

So, In conclusion, PWA is most likely an all-in-one package for the web that doesn’t require any kind of different distributions or bundling we can easily have an app-like experience by installing it.

And more you will get to know when you’ll be using it. Thanks for reading.

Let’s connect: Robin

The post What Is a PWA and How to Build One appeared first on Larachamp.

Use Yajra DataTables In Laravel – Simple Guide

Gurpreet Kait — Tue, 10 Oct 2023 14:23:08 +0000

In the daily dev requirement, we usually show data on the front end, and with Datatables it looks more interactive and smooth. In the same way, we are going to explore Yajra Datatables in the Laravel ecosystem and how we can use them.

Yajra Datatables is a package that makes it easy to create dynamic server-side data tables with ease. It can be an easy add-on for your next Laravel project.

If you are new to this concept don’t worry, I’ll explain everything that will help you to use this easily.

How To Install

In Laravel, this can be installed with the following command:

composer require yajra/laravel-datatables-oracle:"^10.3.1"

You can go to their Installation page where you can see all the requirements stuff, I don’t want to repeat that.

For configuration you can see the configuration section otherwise in the short do these steps after installation.

Step - 1
// config/app.php

'providers' => [
    // ...
    Yajra\DataTables\DataTablesServiceProvider::class,
],

Step - 2

php artisan vendor:publish --tag=datatables

Why Yajra Datatable

Practically, I will say that it has a lot of things that make it easier to use Datatables once you get comfortable with defining columns and all, you will see it makes life easier.

So, I’ll list down all the concepts that I saw really provide value to the developer and not extra theoretical lines here.

It has the ability to modify columns by building Eloquent queries in it. Let me show you a small example of my code.

 /**
     * Get the query source of dataTable.
     */
    public function query(ImportedAttendance $model): QueryBuilder
    {
        $request = $this->request();
        // Log::info('request in payroll: '. json_encode($request->all(['designation','employee_company_id','employee_id','department','month','year'])));
        $designation = $request->designation ?? '';
        $employeeCompany = $request->employee_company_id ?? '';
        // $employeeId = $request->employee_id ?? '';
        $department = $request->department ?? '';
        $month = $request->month ?? '';
        $year = $request->year ?? '';
        // return $model->newQuery()->with(['employeeDetails', 'employeeDetails.user']);
        $query = $model->newQuery();
        $query->whereHas('employeeDetails', function ($query) use ($designation, $employeeCompany, $department) {
            if ($designation !== 'all') {
                $query->where('designation_id', $designation);
            }

            if ($employeeCompany !== 'all') {
                $query->where('client_id', $employeeCompany);
            }

            // if ($employeeId !== 'all') {
            // $query->where('employee_details.user_id', $employeeId);
            // }

            if ($department !== 'all') {
                $query->where('department_id', $department);
            }
        });
        $firstDayOfNextMonth = Carbon::createFromDate($year, $month, 1)->addMonth();
        $lastDayOfMonth = $firstDayOfNextMonth->subDay();
        $lastDayOfMonthString = $lastDayOfMonth->format('Y-m-d');
        $query->where('month', $lastDayOfMonthString)->with(['employeeDetails.user']);
        return $query;
    }

When we use query builder / Eloquent Models in it, It becomes more handy to show data on fronted instead of tackling all of these in the blade file.
it comes with an HTML builder, you can build the columns in it. In my point of view, it makes the blade much more clear because everything goes from the DataTable Class to our view file.

There are a lot of other things that you will understand when you use it.

Use Case Example – How to use Yajra Datatables

Now let’s see how can you use this Datatable package practically in your Project.

So, the installation guide is already explained now. It provides an artisan command with which we can create a Datatable Class.

php artisan datatable:make Dummy #it will automatically add DataTable in the end of the name

I have already created a Datatable class let me take you there. It’s a simple crud for companies Table.

CompanyController –
CompanyDataTable
CompanyModel
companies/index.blade.php

These are the above files I’m gonna use for this small Crud Operation.

I am assuming that you can create a model/controller.

DataTable Class

I’m assuming that you have created the Datatable class. Doesn’t matter what the main thing is the concept should be clear in mind.

<?php

namespace App\DataTables;

use App\Models\EmployeeCompany;
use Illuminate\Database\Eloquent\Builder as QueryBuilder;
use Yajra\DataTables\EloquentDataTable;
use Yajra\DataTables\Html\Builder as HtmlBuilder;
use Yajra\DataTables\Html\Button;
use Yajra\DataTables\Html\Column;
use Yajra\DataTables\Html\Editor\Editor;
use Yajra\DataTables\Html\Editor\Fields;
use Yajra\DataTables\Services\DataTable;

class EmployeeCompanyDataTable extends DataTable
{
    /**
     * Build the DataTable class.
     *
     * @param QueryBuilder $query Results from query() method.
     */
    public function dataTable(QueryBuilder $query): EloquentDataTable
    {
        return (new EloquentDataTable($query))
            ->addIndexColumn()
            ->addColumn('action', function ($row) {
                $action = '<div class="task_view">
                    <div class="dropdown">
                        <a class="task_view_more d-flex align-items-center justify-content-center dropdown-toggle" type="link"
                            id="dropdownMenuLink-" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">
                            <i class="icon-options-vertical icons"></i>
                        </a>
                        <div class="dropdown-menu dropdown-menu-right" aria-labelledby="dropdownMenuLink-" tabindex="0">';
                $action .= '<a class="dropdown-item openRightModal" href="' . route('company.edit', [$row['id']]) . '">
                                <i class="fa fa-edit mr-2"></i>
                                ' . trans('app.edit') . '
                            </a>';
                $action .= '<a class="dropdown-item delete-table-row" href="javascript:;" data-company-id="' . $row['id'] . '">
                                <i class="fa fa-trash mr-2"></i>
                                ' . trans('app.delete') . '
                            </a>';
                $action .= '</div>
                    </div>
                </div>';
                return $action;
            })
            ->setRowId('id')
            ->rawColumns(['action']);
    }

    /**
     * Get the query source of dataTable.
     */
    public function query(Company $model): QueryBuilder
    {
        return $model->newQuery();
    }

    /**
     * Optional method if you want to use the html builder.
     */
    public function html(): HtmlBuilder
    {
        return $this->builder()
            ->setTableId('company-table')
            ->columns($this->getColumns())
            ->minifiedAjax()
            //->dom('Bfrtip')
            ->orderBy(1)
            ->selectStyleSingle()
            ->buttons([
                // Button::make('create'),
                // Button::make('export'),
                // Button::make('print'),
                // Button::make('reset'),
                Button::make('reload')
            ]);
    }

    /**
     * Get the dataTable columns definition.
     */
    public function getColumns(): array
    {
        return [
            Column::make('id'),
            Column::make('name'),
            Column::make('email'),
            Column::make('phone'),
            Column::make('website'),
            Column::make('gst_number'),
            Column::computed('action')
                ->exportable(false)
                ->printable(false)
                ->width(60)
                ->addClass('text-center'),
        ];
    }

    /**
     * Get the filename for export.
     */
    protected function filename(): string
    {
        return 'Company_' . date('YmdHis');
    }
}

Let’s understand the above Datatable Class now. I have tried going a little deeper into the methods. So, I can explain but few things I don’t know how to work under the hood. And also not important.

Method dataTable() returns the query instance with the result and performs an action with we can use each data in rawColumns.
There’s a method called computed() which says that this column needs some extra modifications that we define in dataTable() method.
In query() method we can build queries for our uses, Maybe you want to use relations between models and joins so, you need to define in the query() method and then you can access that in your dataTable() method.
getColumns() You have Column::make('id'), a static method that makes () accept name of the field as in the table of the database.
If you want to you can add a title to the make(‘this_name_can_be_defined_in_datatable_method’)->title(custom_title__for_the_column)->data(field_name_as_in_table).

Things should be much more clear for now. In the next blog, I’ll be explaining more about Yajra Tables.

Controller Class

Once you have created the controller go to the index method(). And use your DataTable Class.

public function index(CompanyDataTable $datatables)
    {
        $somedata = Somedata::all();
        return $datatables->render('employees-companies.index', compact('somedata'));
    }

compact() functions accept the string as a variable name. //output will be ['somedata' => $somedata]

If you want to send data to the view file, You can use the above way in render() method in the second parameter you can add whatever data you want.

<strong>render()</strong> method renders the view file with data that has been returned from dataTable.

View Implementation

In your view file, you can use it simply as mentioned below in the snippet.

 {!! $dataTable->table(['class' => 'table table-hover border-0 w-100']) !!}

Conclusion

I hope that it will help you understand the basic use cases of Yajra Datatables. You will understand more once you start using this in your own projects. Thanks.

The post Use Yajra DataTables In Laravel – Simple Guide appeared first on Larachamp.

Boost Your Productivity with Essential PHPStorm Shortcuts

Gurpreet Kait — Sun, 27 Aug 2023 06:31:46 +0000

As a PHP developer, your choice of tools can significantly impact your productivity and coding experience. PHPStorm, a feature-rich integrated development environment (IDE), offers a plethora of keyboard shortcuts that can help you streamline your workflow and accomplish tasks with ease. In this blog, we’ll dive into some of the most valuable PHPStorm shortcuts that every developer should know. Let’s unlock the power of keyboard magic!

General Shortcuts: Save Time and Effort

Efficiency begins with the basics. These general shortcuts are the foundation of navigating and managing your code effortlessly:

Ctrl + S – Instantly save your work to avoid losing any changes.
Ctrl + Z and Ctrl + Shift + Z – Correct mistakes or backtrack through your changes easily.
`Ctrl + C, Ctrl + X, Ctrl + V – Manage your code snippets efficiently.
Ctrl + D – Create duplicates without repetitive typing.
Ctrl + Alt + Left/Right – Jump between recently visited code locations.

Navigation Shortcuts: Find Your Way Around

PhpStorm provides many shortcuts for navigation. Navigating through your codebase quickly is crucial for maintaining your flow. These shortcuts help you zip around effortlessly:

Ctrl + N – Quickly locate a specific class.
Ctrl + Shift + N – Instantly find and open files in your project.
Ctrl + B or Ctrl + Click – Easily navigate to a class or method’s definition.
Ctrl + F12 – Get an overview of the current file’s structure.

Code Editing Shortcuts: Write Code Faster

As a PHP developer, I would say that PhpStrom helps in many ways in creating classes and building a SOLID code base. You should use editing shortcuts that enhance your development experience. These shortcuts empower you to edit your code swiftly and accurately:

Ctrl + Space and Ctrl + Shift + Space – Utilize smart code completion to speed up your typing.
Ctrl + P – See parameter details within a function or method call.
Ctrl + F and Ctrl + R – Locate and replace text within your current file.
Ctrl + W (multiple presses) and Ctrl + Shift + W – Select code blocks quickly.
Ctrl + Alt + L – Automatically format your code to adhere to coding standards.

Code Generation and Refactoring: Elevate Your Code Quality

Writing and maintaining clean code is essential. These shortcuts help you generate and refactor your code efficiently:

Alt + Insert – Quickly create getters, setters, constructors, and more.
Ctrl + O and Ctrl + I – Override methods and implement interfaces seamlessly.
Shift + F6 – Rename variables, classes, and methods with ease.
Ctrl + Alt + M and Ctrl + Alt + V – Refactor your code by extracting methods and variables.

Version Control (Git) Shortcuts: Manage Your Codebase

Integrating version control into your workflow is essential. These Git shortcuts simplify version control tasks:

Ctrl + K – Commit your code changes directly from the IDE.
Ctrl + T – Fetch and update your project from the version control system.
Ctrl + Shift + K – Push your committed changes to the remote repository.
Ctrl + Alt + Z – Roll back unwanted changes with ease.

Debugging Shortcuts: Debug with Precision

Debugging is a critical part of development. These shortcuts make the debugging process more efficient:

Shift + F8 – Add or remove breakpoints for debugging
F9 – Continue program execution while debugging.
F7 and Shift + F7 – Step into functions or smart step into relevant code.

Conclusion: Embrace Efficiency with PHPStorm Shortcuts

In the fast-paced world of PHP development, mastering shortcuts is like having a secret weapon in your arsenal. PHPStorm offers a treasure trove of shortcuts that can significantly enhance your coding speed and overall efficiency. By incorporating these shortcuts into your workflow, you’ll be navigating, editing, and debugging your code like a pro in no time. Happy coding!

Array Map Function In PHP

What Is Dependency Injection

The post Boost Your Productivity with Essential PHPStorm Shortcuts appeared first on Larachamp.