Build Custom Admin Panels With Backpack for Laravel

 

Backpack for Laravel is a collection of packages which allows you to create admin panels for any web app quickly. It provides a set of useful packages divided into three categories that will make the process of creating a highly customizable admin panel easier.

Installation

The fastest way to take a look at Backpack is by using the ready-made demo app which comes with all the packages preinstalled. If you want to use it in a real app, read the manual installation documentation which will be more suitable; you will only choose the packages you need.

To use the demo app, clone the demo repo by running the following command:

git clone https://github.com/Laravel-Backpack/demo.git backpack-demo

Then, customize your database information in the .env file.

Next, install the package through Composer by running:

composer install

Now, migrate the database by running the following command:

php artisan migrate

If you are using Valet, you can access the demo admin panel by visiting http://backpack-demo.dev/admin in your browser.

Create a new user by clicking the register button on the top nav and filling in the form with your credentials. After you’ve logged in, you will see the Dashboard page:

Overview

Backpack comes with three different types of packages: core packages, ready-made CRUDs, and extensions.

Core Packages

There are two core packages. The first is Backpack\Base which consists of the AdminLTE theme integrated with an alert component and some views for login, register, forgotten passwords, and errors pages.

The second package is Backpack\CRUD which is accelerating the process of building CRUDs for admin panels. It provides more than 44 field types, DataTables integration, file browsing, and creating form requests for backend validation.

You can use Backpack\CRUD for building CRUDs manually like in this example in the docs, but we will take a look at a faster way for automatic CRUDs generation using Backpack\Generators later in this article.

Ready-Made CRUDs

Backpack provides five already built CRUDs which target the most commonly used CRUDs in web apps. Let’s take a look:

Backpack PermissionManager:

A CRUD for managing users, roles, and permissions so you can assign a user multiple roles and permissions.

Backpack Settings

An interface for easily changing the application settings, it provides different types of settings such as email, check boxes, text, numbers, etc. Be aware it does not include an interface for adding new settings, so you should add them directly to the database. If you want to retrieve any a setting’s value you can use Config::get('settings.admin_name').

Backpack PageManager

It’s a CRUD for creating pages for your website using predefined templates with any fields you want and ability to use various fields types. To define your templates, open app/PageTemplates.php file and add your template like this:

Now, you can create a new page using our new template like this:

Backpack NewsCRUD

It’s a CRUD for quickly creating anything related to news; you create articles, tags, categories with support for nesting categories and reordering them.

Add article interface:

Categories management page:

Backpack MenuCRUD

A CRUD for adding, editing, deleting, reordering, and nesting menu items. It provides the ability to use internal or external links, and you can link to a page from Backpack\PageManager.

Extensions Packages

Currently, there are three extension packages for Backpack; let’s take a look at each of them:

Backpack BackupManager:

An interface for creating and managing backups for files and database, it provides support for various drivers like S3, Dropbox, Google Drive, Box, etc. For more details, check out the package readme at github.

Backpack LogManager

An interface for dealing with Laravel log files. You can download, preview, or delete without accessing your server through SSH.

Backpack Generators

The generator is an essential package as it will accelerate the process of creating CRUDs and make it as simple as running a single command!

Let’s assume that we want to create a CRUD for products, so we want the following:

• A database table called products.
• A model app/Models/Product.php
• A controller app/Http/Controllers/Admin/ProductCrudController.php
• A request app/Http/Requests/ProductCrudRequest.php
• A new route

To make that with Backpack\Generators:

• First, make the migration file:

php artisan make:migration:schema create_products_table --schema="name:string:unique" --model=0

• Then, migrate to the database:

php artisan migrate

• After that, use Backpack\Generators to create the CRUD:

php artisan backpack:crud product

• Last, open your routes/web.php to add the following route:

Route::group(['prefix' => config('backpack.base.route_prefix', 'admin'), 'middleware' => ['web', 'auth']], function () {
    CRUD::resource('product', 'Admin\ProductCrudController');
});

Now, if you use Valet, open http://backpack-demo.dev/admin/product in your browser and access the Products CRUD page so you can add and manage products easily:

Backpack Pricing

Backpack has two tiers of pricing. A free non-commercial license which includes personal use, non-profits, testing, and students. There is a commercial license priced at $19 if you are going to use it to generate income, such as being used by freelancers, employees, or companies.

Read More

Easily Create Stripe Tokens and Cards For Testing

 When you are building a payment flow with Stripe there are a lot of different flows for you to test. These include successful charges and a plethora of failed options. Such as invalid CVC, invalid address, expired cards, declines, and more.

To make testing all these different flows easier, Jacob Bennett created a StripeTestToken package so you can easily create tokens for each case.

Testing Successful Charges

To test successful charges you can use one of the following methods from the package:

• validVisa
• validVisaDebit
• validMastercard
• validMastercardDebit
• validMastercardPrepaid
• validAmex
• validDiscover
• validDinersClub
• validJCB

Here is an example using the StripeTestToken::validVisa() method to create a valid Visa card token and allows the charge to go through successfully.

use JacobBennett\StripeTestToken;
use Stripe\Charge;

StripeTestToken::setApiKey('your_stripe_secret_test_key');

Charge::create([
        'amount' => 500,
        'curreny' => 'usd',
        'source' => StripeTestToken::validVisa(),
]);

Testing Failed Transactions

Testing failed transactions work in a similar fashion, but you will want to wrap it in a try/catch so you can consume the Stripe exception:

try {

        Charge::create([
                'amount' => 500,
                'curreny' => 'usd',
                'source' => StripeTestToken::cvcFail(),
        ]);

} catch (\Stripe\Error\Card $e) {
        // handle errors
}

Other failed methods include:

• addressZipFail
• addressFail
• zipFail
• addressZipUnavailable
• cvcFail
• customerChargeFail
• successWithReview
• declineCard
• declineFraudulentCard
• declineIncorrectCvc
• declineExpiredCard
• declineProcessingError
• declineIncorrectNumber

Generating Test Card Numbers

If you are utilizing browser testing you may want to test the checkout flow using card numbers and this feature is included as well. Instead of calling StripeTestToken::validVisa() you utilize StripeCardNumber::validVisa().

This StripeTestToken package looks like a great addition to your testing workflow when you are working with Stripe.

Read More

Laravel Countries and Currencies Package

 

Antonio Carlos Ribeiro recently launched a new package that gives you a powerful setup for dealing with the different Countries of the world, all through a comfortable Laravel syntax using Collections.

The package does a lot. Everything from geology and topology, to states, currencies, and time zones.

As I was reviewing it I tried to think of some common use cases that almost every app needs and here are a few examples:

Generate a list of Countries

Need a list of all the countries in the world? It’s as simple as calling:

Countries::all()->pluck('name.common');

[
    "Aruba",
    "Afghanistan",
    "Angola",
    "Anguilla",
    "Åland Islands",
    ....

Generate a list of States

In a lot of registration forms, you need to allow people to pick their state.

Countries::where('name.common', 'United States')
    ->first()
    ->states
    ->sortBy('name')
    ->pluck('name', 'postal')

This gives you a result of the states that can then be used in a select list:

{
    "AL": "Alabama",
    "AK": "Alaska",
    "AZ": "Arizona",
    "AR": "Arkansas",
    "CA": "California",
    ....

Get the timezone for a State

Another typical pattern is figuring out a timezone. If you already have the users country and state it’s now super easy:

return Countries::where('name.common', 'United States')->first()->timezone->NC;

Returns:

America/New_York

Get a countries currency

Need to get information on a specific countries currency? With this package it’s very easy:

Countries::where('name.common', 'United States')->first()->currency;

Which returns:

[{
    "alternativeSigns": [],
    "ISO4217Code": "USD",
    "ISO4217Number": "840",
    "sign": "$",
    "subunits": 100,
    "title": "U.S. dollar",
    ....

These examples are just the basics of what can be done. It supports the following countries, states, and currencies:

• Countries
  • name (common and native)
  • currency
  • languages
  • states
  • timezone
  • flags (sprites, flag icons, svg)
  • tld
  • multiple ISO codes
  • calling code
  • capital
  • alternate spellings
  • region & sub region
  • translations (country name translated to some other languages)
  • latitude and logitude
  • borders (countries) – you can hydrate those borders (like relatioships)
  • area
  • topology
  • geometry
• Currencies
  • sign
  • ISO codes
  • title
  • subunits
  • usage (dates)
• States
  • adm codes
  • name & alt name
  • type (state, city, province, canton, department, district, etc.)
  • latitude & longitude
  • language
  • (and many more)

For more information on this package check out the GitHub repo.

Read More