Forem: Shanika Wickramasinghe

What’s an Example of Good E-Commerce Database Design?

Shanika Wickramasinghe — Sun, 18 Apr 2021 18:02:06 +0000

What's an Example of Good E-Commerce Database Design?

Databases are vital tools for storing, managing and retrieving information, and they are critical for building an e-commerce system. A well-structured database is the heart of a good e-commerce system that manages all the interactions of the system.

A good e-commerce database design should include the following characteristics.

Simple and Functional Database Structure
The database table structure should be relatively simple but needs to cover all the required functionality without compromising the user experience.

High Performance
The database queries should execute fastly and efficiently to facilitate live customer interactions and provide a satisfactory shopping experience. Therefore, the selected database should consist of good indexing and performance optimization options.

High Availability and Scalability
A good database design should be highly available with automatic snapshots and enable automatic scaling to support future platform growth as well as sudden traffic spikes.

Based on the above characteristics, an e-commerce database design boils down into three major aspects as the following.

The Scope of the Database.
Type of the Database.
Database Infrastructure.

The scope refers to the planned functionality of the database. The underlying table structure of the database, its relationships, and indexes all depend on the functionality of the e-commerce platform. The database type can vary from a relational database to a NoSQL database or a hybrid approach depending on the requirements and the underlying data structure.

The Scope of the Database.

The main consideration when designing the database is identifying the functionalities offered by the e-commerce platform. These functionalities can be further divided as core-functions and extra-functions (additional-functions).

Core-functions are the functions that are necessary for facilitating the day-to-day operations of the e-commerce platform.

User Management
Product/Inventory Management
Shopping Cart Function
Payment Management
Shipping/Logistics Management

Extra/Additional functions are the nice-to-have functions for the e-commerce platform that will enhance the user experience for both end-users (customers) and administrators (business). Following are some functions that come under this category.

Marketing Functions
Help Desk/Support
Advanced Analytics
Third-Party Integrations

Database Structure for Core-Functions

In this section, let's see how to structure the database to facilitate the core functions. The below table structure is an example of a database design that covers the core functionality of an e-commerce platform.

This example covers all the basics of an e-commerce platform. There, the table fields and indexes depend on the design of the overall platform, and it contains three separate sections for user management, product management, and shopping process. Let's have a closer look at each section.

User Management

We have created a user table that contains all the user details along with user_payment and user_address tables to store multiple addresses and payment details of users. This structure offers more granular control over data while eliminating duplicate records.

Another way to manage users is by creating two separate user tables for end-users and administrators and assigning relationships according to their requirements, as shown below.

Product Management

Managing products is not simply about maintaining a list of products. You also have to manage the inventory, discounts, categories, and other attributes of the products. So, always focus on simplifying the data structure while reducing duplicates. In the above table structure, the main product table contains information about the products.

There are two other separate tables called discount, product_inventory, and product_category that are connected to it through database relationships. This approach provides the greatest level of flexibility to the database. For instance, we can simply query the product_inventory table to check for inventory without going through all the data associated with other related tables. This is also a good place to utilize indexes to increase the performance of the database.

Shopping Process

This is the most critical and complex part when it comes to designing the database. The shopping process will guide a user to search the products, add the desired products to the shopping cart, and finally complete the transaction using a payment provider.

The heart of the e-commerce process connects users with products. A good chunk of design effort should be exhausted to streamline the shopping process. In the above example, there are shopping_session and cart_item as temporary data stores that only store the shopping session information of the current user until the order is confirmed and the data is moved to permanent storage tables with the payment details. (order_details, order_items, and payment details.). You can check out this article for a detailed explanation of how to design a shopping cart database.

As shown in this section, the scope of the database structure is determined by the overall functionality of the platform. Therefore, it is paramount that you properly define the required functionality before diving into designing the database. This way, you can create a clearly defined data structure with enough flexibility to support future expansions.

Type of the Database

The next consideration is to determine the type of database. To have the best e-commerce database design, you must first consider two main database types: RDBMS or NoSQL databases.

Relational database: This is similar to spreadsheets and uses tables, columns, and rows to organize and retrieve data. It is built using the standard query language (SQL), and all the data is related to each other.

Example: MySQL, PostgreSQL, MariaDB, Microsoft SQL, Amazon RDS, Azure SQL Database

Non-relational or NoSQL database: This is a nontabular database with a flexible schema that works well for storing unstructured data. Contrary to its name, a non-relational database can store related data. It does so by nesting related data within a single data structure instead of splitting them between tables. There are various NoSQL databases, and the most popular ones are document stores and key stores.

Example: MongoDB, Apache Cassandra, Amazon DynamoDB, Azure CosmosDB, Couchbase.

Both these database types are solid options for any e-commerce platform, and the choice is up to the designer and depends on the requirements of the platform. A relational database will provide a simple and robust platform to create the database, while NoSQL offers better data flexibility, scalability, and slightly better performance. In the coming section, we'll explore an example of e-commerce database design for each type.

E-Commerce Database Design Examples

Relational Database Design

Many e-commerce sellers use a relational database design centered around the following tables:

Products table
Customers/Users table
Orders table

Additional tables can be added as required to support shipping, categories, product reviews, etc. We have covered the database structure in the previous section, where the scope of the database was defined.

Below, you can see a diagram of a simple e-commerce database design built using MySQL.

MySQL e-commerce database design

While a standard relational database design will work for many e-commerce stores, there are situations where it is advantageous for retailers to follow another approach.

NoSQL database design

Most of the world's largest online retailers, including Walmart and eBay, use NoSQL databases to power their e-commerce systems. The reason is NoSQL databases providing the required performance and scalability to effectively manage large catalogs and unstructured data like user data and images.

A good example of an e-commerce database built using NoSQL technology is CouchBase, which uses a document store as its database type. With a document database, data is simpler and easier to access as an entire product can be stored in a single document instead of storing across multiple tables.

Below, you can see an example of data modeling for different products with CouchBase's NoSQL database.

CouchBase NoSQL data structure

source

Hybrid Database

Another exciting option is to use a combined solution utilizing an RDBMS for structured data such as user details, order details, payment details, and a NoSQL database for unstructured data such as product details or marketing information.

Hybrid database structure

Creating a Hybrid database structure is relatively more complex than using traditional database types (RDBMS or NoSQL) as a hybrid approach will utilize the application to combine data from both sources. This allows the developer to combine the strengths of both database types. However, this kind of approach is only suitable for truly complex application architectures that offer users a myriad of functions. For instance, if your purpose is to speed up an RDBMS, it's easier to configure a caching server such as Memcached rather than going for a hybrid approach.

Database Infrastructure

It is possible to select a database type and design the data structure, but we also need infrastructure to run the database. It depends on the deployment of the e-commerce platform. One option is to provision a server, install the database software and then manage all the aspects from security to maintenance. The other option is to use a managed database service like Amazon RDS, Azure SQL for RDBMS, Amazon DynamoDB, or Azure CosmosDB for NoSQL. Among these two options, the managed approach saves time and does not require any maintenance as these are SaaS offerings.

Suppose you need complete control over your data, database configurations, and server security policies or deploy the database on a private network. In that case, the only option is to configure and maintain the database manually. However, with more and more businesses utilizing cloud providers nowadays, the best option would be to use a managed database. It is more applicable for an e-commerce platform where scalability and availability play a vital role in the success of the platform. So, it's almost always advisable to use a SaaS database.

A managed database will offer peace of mind for any developer as it is backed by a reputed cloud provider with a service level agreement to provide maximum uptime. It will also enable the developer/administrators to focus more on creating and optimizing the database without dealing with server or database maintenance. A slight downside of a managed platform would be the higher cost associated with it when compared to managing own servers. However, when considering the total cost of ownership (TCO) and operational expenditure (OpEx), a SaaS solution is the ideal option for a growing e-commerce database.

PIM Software for Multichannel Sellers

Product Information Management (PIM) is a critical component of the core functionality of any good e-commerce platform. It provides a flexible solution for managing all your product data inside a single database in the cloud. Moreover, PIM is an excellent option for retailers looking to sell on multiple channels. Having a centralized database in the cloud, PIM allows easy management and delivery of product information to other marketplaces.

Another main advantage of PIM is the ability to collect and organize data in a variety of formats. Different platforms have their own catalog structure, and PIM automatically sends data to these channels in the proper format.

Fabric's PIM is one of the best examples of e-commerce database design using PIM software. It serves as a single source for centralizing all your data in the cloud, allowing businesses to benefit from increased productivity while ensuring all information is accurate and up to date across various channels.

How Do You Design a Shopping Cart Database for E-Commerce?

Shanika Wickramasinghe — Fri, 16 Apr 2021 00:07:11 +0000

An e-commerce shopping cart serves as a virtual cart that allows customers to add and hold items until they complete the purchase. It accepts payments of customers, organizes and distributes all order information to the merchant, customer, and other relevant parties.

This process requires a database to store and retrieve the relevant data while supporting the functionality of the shopping cart. A shopping cart database will contain all the critical information about products, orders, and customers and allow users to perform real-time changes reflected in their shopping session.

Designing the Database

A shopping cart database should be highly available, fault-tolerant, and highly responsive to provide customers a smooth shopping experience 24x7. When designing a shopping cart database, it can be divided into three main components for better categorization and understanding of the underlying data structure.

Static Data
Session Data
Processed Data

Static Data

This component will include somewhat static data that the customer needs only to retrieve while interacting with a shopping cart. The data is stored in the following types of tables:

product table
discount table
user table

Session Data

This is the most important component of the shopping cart database where all the live interactions (session details) are stored when the client is interacting with the shopping cart.

shopping_session table
cart_item table

Processed Data

Once the customer completes a transaction, we need to permanently store the order information by moving the Session Data into permanent storage. Additionally, we need to store the payment details.

order_details table
order_items table
payment_details table

Table Relationships in Database

The following diagram demonstrates the relationships within the above-mentioned tables inside the database using a sample fieldset. The fields in the tables may depend on the requirements of the specific e-commerce platform and can range from a simple to complex list of fields.

When designing the database, we need to have a good balance between simplicity and covering the required functionality.

Let's dig a bit deeper into the structure of the shopping cart database.

Static Data Component

In a shopping cart, tables like product and discount are only required to reference the product, inventory, and pricing details. They will only get SELECT queries when a customer adds an item to the shopping cart. The only time the product table gets updated is when a purchase is completed and needs to update the inventory of the products (UPDATE statement). Regular updates for these tables are made by the administrators of the e-commerce platform and should be a part of the product information management system.

The user table is only needed in the shopping cart to link the orders and sessions with the registered users. This allows the e-commerce platform to map the orders with the relevant users. The user details table is updated only when a new user is created, or when a user updates their details. This functionality is out of the scope of the shopping cart. Within the shopping cart, we only map the order/session with the user.

Since we only retrieve the data and limit write queries to updating inventory, the product table is considered a static data component in the shopping cart.

Example Table Structure (Product Table)

    CREATE TABLE `shopping_cart`.`product` (
        `id` INT(10) NOT NULL AUTO_INCREMENT,
        `name` VARCHAR(100) NOT NULL,
        `desc` TEXT NOT NULL,
        `SKU` VARCHAR(50) NOT NULL,
        `category` VARCHAR(50) NOT NULL,
        `price` DECIMAL(6) NOT NULL,
        `discount_id` INT(5) DEFAULT '0',
        `created_at` TIMESTAMP NOT NULL,
        `modified_at` TIMESTAMP,
        UNIQUE KEY `prod_index` (`id`) USING BTREE,
        UNIQUE KEY `sku_index` (`id`,`SKU`) USING BTREE,
        PRIMARY KEY (`id`),
        CONSTRAINT `fk_prod_discount`
            FOREIGN KEY (`discount_id`)
            REFERENCES `shopping_cart`.`discount` (`id`)
            ON DELETE SET NULL
            ON UPDATE SET NULL
    ) ENGINE=InnoDB;

Session Data

This component contains the highly active tables within the database, facilitating the real-time functionalities of the shopping cart. The purpose of the shopping_session and cart_item tables is to act as highly efficient and temporary storage to support the live interactions of a customer with the shopping cart. When a customer visits the e-commerce platform, a session is created (shopping_session), and each item added to the cart is captured in the cart_item table linked to the specific session.

This enables us to capture the state of the shopping cart regardless of the customer interactions in the e-commerce platform. Combining these details with website cookies enables us to provide previous shopping cart details even if the customer navigates out of the e-commerce platform.

A considerable architectural effort is required to streamline these tables to support all kinds of live queries (SELECT, UPDATE, DELETE) made to the database without hindering the user experience. This data set also allows the retailers to understand any inefficiencies in their shopping experience by identifying the behavioral patterns of the customers. For example, if some customers are dropping out at the payment stage, the platform developers can drill down and identify any issues with the payment processing.

Example Table Structure (shopping_session table)

    CREATE TABLE `shopping_cart`.`shopping_session` (
        `id` INT(30) NOT NULL AUTO_INCREMENT,
        `user_id` INT(10) DEFAULT NULL,
        `total` DECIMAL(10) NOT NULL DEFAULT '0.00',
        `created_at` TIMESTAMP NOT NULL,
        `modified_at` TIMESTAMP,
        UNIQUE KEY `session_index` (`id`,`user_id`) USING BTREE,
        PRIMARY KEY (`id`),
        CONSTRAINT `fk_shopping_user`
            FOREIGN KEY (`user_id`)
            REFERENCES `shopping_cart`.`user` (`id`)
            ON DELETE SET NULL
            ON UPDATE SET NULL
    ) ENGINE=InnoDB;

Processed Data

The processed data contains the completed order details with the associated payment details. When a transaction is completed, we move the relevant data set from the shopping_session to order_details table and cart_item to order_item table and delete those records from the shopping_session and cart_item tables as they are no longer needed.

We can use a single table group (shopping_session/cart_item or order_details/cart_item) with an extra field (e.g. order_status) to indicate whether the order has been completed. However, this will create a bloated data set and negatively impact the performance of the e-commerce platform.

By separating the data into two distinct groups, we can keep track of the completed order in a separate table. This method allows maintaining the history of the orders while reducing the load of the shopping_session and cart_item tables to only contain data that needs to facilitate live interactions.

The combination of order_details and the order_item tables with the payment_details table creates the complete order details and enables the e-commerce platform to arrange the post-processing and distribution of the products or services.

Another advantage of the processed data component is that it can be used for analytics purposes. Matching the data with relevant users of the e-commerce platform enables us to provide suggestions based on previous purchases and carry out targeted marketing campaigns.

Example Table Structure (order_details table)

    CREATE TABLE `order_details` (
        `id` INT(20) NOT NULL AUTO_INCREMENT,
        `user_id` INT(10),
        `total` DECIMAL(10) NOT NULL,
        `payment_id` INT(20) NOT NULL,
        `created_at` TIMESTAMP NOT NULL,
        `modified_at` TIMESTAMP,
        UNIQUE KEY `order_index` (`id`) USING BTREE,
        UNIQUE KEY `customer_order_index` (`id`,`user_id`) USING BTREE,
        PRIMARY KEY (`id`),
        CONSTRAINT `fk_shopping_user_order`
            FOREIGN KEY (`user_id`)
            REFERENCES `shopping_cart`.`user` (`id`)
            ON DELETE SET NULL
            ON UPDATE SET NULL,
        CONSTRAINT `fk_order_payment`
            FOREIGN KEY (`payment_id`)
            REFERENCES `shopping_cart`.`payment_details` (`id`)
            ON DELETE SET NULL
            ON UPDATE SET NULL
    ) ENGINE=InnoDB;

Expanding the Scope of the Database

Shopping cart databases are only a single part of a vast e-commerce experience. This section will briefly explain how to extend the database to cover additional functionalities by introducing new tables and fields to the existing database.

User Details

A User table can be extended with other tables such as user_address and user_payment to store user preferences. Thus, it enables a smooth shopping experience by providing the stored details of the user for a faster checkout process.

Product Details

Combining additional tables like inventory and category to the products table enables us to expand the functionality of product management. This is a key consideration when expanding the e-commerce platform to integrate Product Information Management (PIM) functionalities.

A shopping cart database can be extended further to support any requirement. The database can act as a standalone database powering the complete e-commerce platform or a part of a database cluster focused on shopping cart functionality. The possibilities are limited only by the development effort and the user requirements.

In all instances, it is advisable to decouple the tables and create separate tables other than creating a few large tables. This increases the flexibility and the overall performance of the database while reducing data redundancy.

As an additional note, it's a good idea to plan a reliable backup and disaster recovery strategy to the database from the initial deployment of the database. It will increase the resilience of the database and offer peace of mind to the platform administrators.

OMS Software and Shopping Cart APIs

Order Management Software (OMS) provides everything needed to receive, track, and fulfill customer orders online. These solutions expose the shopping cart database through an API and allow e-commerce platform administrators to ensure that all order and inventory data is up to date.

For instance, with Fabric OMS, you can streamline the way of managing orders using a single dashboard and track inventory and orders across multiple channels.

OMS software also comes with shopping cart APIs that add flexibility to the shopping experience by enabling customers to edit their cart, apply promotional codes, and specify shipping and billing information.

For example, a user can use PATCH /cart/{cartId}/items to modify their cart, and the API endpoint is designed to ensure the cart is up to date at any given point. Below, you can see two sample requests for a registered and guest user.

Registered User (Logged in User)

    {
        "cartId": 604638499041,
        "userAuthToken": "6^t@CDm6DY7FZZq3E!0lT3rxb02d7&",
        "registeredUser": true,
        "items": [
            {
                "itemId": "1000000122",
                "quantity": 2,
                "group": [
                    "5e31a1f9fcc2b500089c10e8"
                ],
                "price": {
                    "sale": 0,
                    "base": 120,
                    "discount": {
                        "price": 0
                    },
                    "currency": "USD"
                    },
                "extra": {}
            }
        ]
    }

Guest User

    {
        "cartId": 604638499041,
        "userAuthToken": null,
        "registeredUser": false,
        "items": [
            {
                "itemId": "1000000015",
                "quantity": 5,
                "group": [
                    "LPCUsIdKqZhjHoA1Ok3tMCsc"
                ],
                "price": {
                    "sale": 10,
                    "base": 50,
                    "discount": {
                        "price": 0
                    },
                    "currency": "USD"
                    },
                "extra": {}
            },
            {
                "itemId": "1002200074",
                "quantity": 1,
                "group": [
                    "3NXSiwNoKbQxe5pbM9hc10lb"
                ],
                "price": {
                    "sale": 0,
                    "base": 450,
                    "discount": {
                        "price": 0
                    },
                    "currency": "USD"
                    },
                "extra": {}
            }
        ]
    }

The Order Management System API provides different endpoints that reflect different functionalities. Below are some of the functionalities available through the Fabric Cart API.

Merge guest cart with user cart
Get cart by cartId or userId
Add Ship-To to line items
Get cart by Ship-To Id
Apply/Remove Promo
Create Bill-To records (billing details)

Building vs Buying the Shopping Cart

OMS technology available from e-commerce SaaS vendors like Fabric features robust APIs that provide almost limitless functionality. Designing a shopping cart database using them from the ground up may not be the best use of resources. However, if you want to build a shopping cart database from scratch for one reason or another, this article should point you in the right direction.

For further assistance, you can check out this guide on creating a database from start to finish using Microsoft Access and have an in-depth look at data modeling for e-commerce applications.

The Best Open Source PIM Platforms

Shanika Wickramasinghe — Fri, 16 Apr 2021 00:02:50 +0000

A Product Information Management (PIM) platform is designed to collect and manage product information which is an integral part of any standard e-commerce operation. It acts as a central repository to manage and store all your product data. Another responsibility of a good PIM platform is enriching product data and distributing it through appropriate sales channels.

An open source PIM platform provides a cost-effective and highly customizable solution to this type of data management and distribution. However, selecting an open source solution requires a good deal of research. It also requires the due diligence of comparing open source PIM platforms with platforms from third party, software-as-a-service (SaaS) providers.

This article explores some of the best available open source PIM solutions, compares them with one another, and compares them with SaaS options like Fabric PIM.

PIM Platforms: Open Source Vs SaaS

When considering a PIM platform, there are two available options. Either go for an open source option or a SaaS option. In this section, let's compare the differences between them.

	Open Source	SaaS
Customization	Yes (Code-Level Customization)	Yes (Granularity Dependent on Provider)
Database Access / Management	Yes	No
Infrastructure Configuration	Yes	No
Infrastructure Maintenance	Yes	No
Setup / Configuration Difficulty	Medium / High	Low (Out of the Box Solution)
Technical Expertise	High	Low / Medium
Features	Community Dependent	Platform Dependent
Integrations	Yes	Yes
Licensing/ Subscription Fees	No (Free Solution)	Yes
Security/Compliance	Unmanaged (User Responsibility)	Managed (Provider Responsibility)
Support	Community-Based	Dedicated Support

Bottom line: Open source platforms provide a free solution with a greater level of customization for complex configurations and management requirements. On the other hand, SaaS platforms are a paid solution that enable faster time to value and require less resources to fully utilize.

PIM Platforms: Best Open Source Options

In this section, let's go through some popular open source product information management platforms and compare their features. Following is the list of platforms we will compare and briefly review.

	Pimcore	Ergonode	AtroPIM	Akeneo	OpenPIM
Data Modeling / Data Management	✅	✅	✅	✅	✅
Product Relationship	✅	✅	✅	✅	✅
Custom Entities / Variants	✅	✅	✅	✅	✅
Custom Logic / Custom UI	✅	✅	✅	✅	✅
Data Import / Export	✅	✅	✅	✅	✅
Omnichannel Publishing Support	✅	✅	✅	✅	✅1
Multilingual Support	✅	✅	✅	✅	✅1
External Integrations	✅	✅	✅	✅	❌
API Availability	✅2	✅	✅	✅	❌
Docker/K8 Support	✅	✅	❌	✅	✅
Premium Offering	✅	✅	✅	✅	❌3

Limited support
The Pimcore REST API is deprecated since version 6.4 and will be removed from version 7; the Pimcore Datahub is the preferred method for data delivery and consumption using GraphQL
Implementation/support is available only as a premium option

Pimcore

Pimcore, specifically its community edition, is a free product information management platform offered under the Open Source GPLv3 license. It is developed using PHP utilizing the Symphony framework. This platform follows the MVC (Model, View, Controller) pattern in its development and supports a wide range of databases like MariaDB, MySQL, and AWS Aurora.

What differentiates Pimcore from other platforms is that it is not just a PIM platform. It is also a complete data management and customer experience management solution offering multiple products from PIM, DAM (Digital Asset Management), to DXP (Digital Experience Platform). Pimcore supports deployments such as SMEs, enterprises, and B2B operations, and more than 100000 companies across 56 countries utilize this platform in their day-to-day operations.

Pimcore is developed with a cloud-first and developer-focused mindset offering a robust and highly extensible platform to manage all the functionality. It supports on-premise, hybrid, and cloud deployments and provides native images for all the major cloud service providers like Azure and AWS. Besides offering a simple REST API, Pimcore has created a separate module called data hub and offers a centralized platform for data delivery and consumption using GraphQL. It increases the functionality of the API and allows developers to interface with external software such as ERP and e-commerce solutions.

Pimcore GitHub

Pimcore Data-Hub GitHub

Let's look at a sample GraphQL request to obtain a document through the API (Data Hub). All the queries there adhere to the GraphQL structure. The documentation for the data hub is available here.

    {
      getDocument(id: 251) {
        ... on document_page {
          fullpath
          editables {
            ...on document_editableDate {
              _editableName
              # unix timestamp
              timestamp
              # as formatted string
              formatted(format:"Y-m-d")
            }
          }      
        }
      }
    }

Ergonode

The Ergonode platform is relatively a newcomer as an open source PIM platform. According to the Ergonode team, it aims to provide the first human-centric PIM platform that supports both retail and B2B businesses. Ergonode is distributed under the OSL-3.0 License and powered by Vue.js and Symfony frameworks.

The Ergonode architecture is built based on Domain Driven Design Approach adhering to the Command Query Responsibility Segregation (CQRS) and Event Sourcing. This approach has enabled a greater degree of flexibility in developing each module leading to a stable, feature-rich, and extensible platform. Moreover, Ergnode provides product, catalog, and asset management functionality with a robust workflow and user management support.

The Ergonode platform can be broken down into two main components as the independent backend and the frontend. These two components are connected through the REST API. Due to the headless nature of this platform, it offers increased performance. On top of that, the front end is designed to be easily adapted as a Desktop Progressive Web App.

Ergonode Frontend GitHub

Ergonode Backend GitHub

The Ergonode platform supports API requests via nuxt/axios library. Following is a sample javascript API request to get all the product details with a limit of 1000 products ordered by ascending order.

    export const getAll = ({
        $axios,
        params = {
            limit: 1000,
            offset: 0,
            view: 'list',
            field: 'name',
            order: 'ASC',
        },
    }) => $axios.$get('languages', {
        params,
    });

AtroPIM

AtroPIM is a product information management platform based on the AtroCore software platform, which is distributed under the GPL-3.0 license. It is based on EspoCRM and utilizes PHP7, backbone.js, composer, and some Zend framework libraries. This platform is a single-page application (SPA) with an API-driven approach and a service-oriented architecture (SOA).

This PIM platform is one of the easiest platforms to get the system up and running since it offers many out-of-the-box features encapsulated in a responsive, highly customizable and user-friendly UI. AstroPIM has a multitude of features, such as advanced product management functionality and product data quality management. Another advantage of this platform is that it provides digital asset management (DAM) functionality through its AtroDAM module without depending on other tools or extensions.

AtroPIM also consists of a wide range of connectors and extensions to extend the functionality and connect with external tools and platforms. Its REST API enables developers to integrate AtroPIM with third-party systems and create specialized applications to meet various user needs such as mobile or hybrid web applications.

AtroPIM GitHub

AtroPIM offers a robust API. The following python code block demonstrates a simple API request to obtain asset details.

    import requests

    payload = {'entityId': '25'}
    headers = {'Accept': 'application/json'}
    response = requests.get('https://atropim.com/AssetCategory/', 
                                                headers=headers,
                                                params=payload)
    print(response.text)

Akeneo

The Akeneo PIM community edition is a part of the Akeneo product family, aiming to provide a free and feature-rich product information management platform. It is distributed under the open software license v3.0. This platform leverages the Symfony3 framework with backbone.js and React JS for client-side development. The server side of this platform utilizes Doctrine 2 as ORM, MySQL, and ElasticSearch. The combination of this technology stack leads to a highly scalable, flexible, and adaptable platform.

With Its global community of over 3,000 active members, the Akeneo community edition is constantly under development to fix bugs, improve performance and implement new features while supporting users to get the best out of the platform.

The Akeneo marketplace consists of various connectors and extensions developed by the community. They can be used to connect to different applications and add more functionality to the default Akeneo PIM platform. Due to its well-documented and robust API, any developer can easily integrate third-party solutions like DAM, ERP, e-commerce platforms, etc., with the Akeneo PIM platform using the API.

Akeneo PIM GitHub

Akeneo PIM offers a dedicated PHP API client that can be used to interact with the Akeno API. We can utilize this client to query the API easily. The following example shows how to query for a product using user credentials.

    $clientBuilder = new \Akeneo\Pim\ApiClient\AkeneoPimClientBuilder('http://akeneo/');
    $client = $clientBuilder->buildAuthenticatedByPassword('client_id', 'secret', 'admin', 'admin');

    $product = $client->getProductApi()->get('perfume one');
    echo $product['identifier'];

OpenPIM

The OpenPIM platform is a simple solution to provide an easy-to-use PIM platform for small to medium businesses. It is an entirely free solution without a commercial version. However, it offers premium support for implementing and configuring the platform.

OpenPIM is distributed under the Apache-2.0 license and developed using the Vue.js framework. Having the target audience of SMEs, the OpenPIM platform provides all the necessary features such as complete product information management (Data Modeling, Hierarchies, Custom Entries, Relations, etc.) functionality and the ability to create custom actions to quickly get your PIM platform to a production environment.

One of the interesting features of this platform is the support for the query language. It can be used in PIMInput and PIMRownInput components, creating dashboards, and with an extended search functionality to query the data and configure conditions and filters. This query language is based on the JSON format and supports logical and comparison operators. For more information on this, refer to the OpenPIM documentation.

OpenPIM GitHub

Following are a couple of examples of OpenPIM query language.

Simple query to get an item by name (en refers to the English language)

    {"name": { "en" : "product one"} }

Query to specify the logical operator OR to get an item by item type (typeId) or internal item id (id)

    {
        "OP_or": [
            { "Id": "0021" },
            { "typeId": "055" }
        ]
    }

PIM Platforms: Best SaaS Option

The fastest and the simplest way to get a PIM platform up and running is to go for a SaaS solution. It mitigates the complexities encountered when configuring an open source platform and handles all the maintenance and security tasks at the cost of licensing or subscription fees.

Furthermore, a SaaS solution provides an out-of-the-box experience with all the core features already configured and available to the user. The SaaS solutions might provide advanced features that are not available in community editions, such as analytics that would greatly help your business process.

Fabric PIM

Fabric is an e-commerce SaaS provider that not only offers a PIM platform but a complete solution to cater to any e-commerce requirement. With its storefront, experience management, subscription, and loyalty management features, Fabric helps to boost the productivity of your business. Additionally, the headless nature and the powerful API of Fabric allow developers to customize the platform to suit user needs.

Top 6 Tools to Test Rest APIs

Shanika Wickramasinghe — Fri, 09 Apr 2021 09:31:07 +0000

REST APIs

Rest APIs are a vital part of every digital application nowadays. It’s crucial to verify that APIs are working fine before applications are delivered to end-users. Rest APIs testing is carried out manually as well as automatically. When testing Rest APIs, we send various HTTP/S requests using GET, POST, PUT, PATCH, and DELETE methods to ensure that the functionality is working great. Rest APIs testing also includes validating response versus the defined inputs, checking the accuracy of response, and checking HTTP status codes and error codes.

There are many open source and commercial testing tools that can be used to test Rest APIs. Within this article, let’s analyze the best fit among them for your testing demands.

Testerum

Testerum is one of the latest tools in the automation testing field. This tool is free & open-source, and very convenient to use due to its user-friendly UI. It uses behavior-driven development (BDD) to illustrate test scenarios and does not require any programming skills.

When it comes to testing APIs, the best advantage of Testerum is that you can create complex API flows using it. How Testerum defines HTTP Requests is similar to Postman, but it provides an easy and innovative way that doesn’t require programming knowledge to verify the HTTP Responses.

The Testerum UI will increase the efficiency and effectiveness of the learning process, allowing newcomers to get started with the tool easily. Ultimately, it will help to reduce the cost of training employees.

Moreover, Testerum can be integrated with any CI/CD environment. Docker images are available and can be used to run Testerum tests easily in any CI/CD environment. It helps developers to maintain continuous integrations and development without distracting the existing development process. Since Testerum is extensible with all JVM languages, it allows developers and testers to create their own integrations.

Testerum has a centralized reports server and provides quality reports and statistics about test data and test results. While being an interesting tool, Testurum is still very young in the field and has only a small community around it. There’s also a lack of documentation and online helping community due to its novelty.

Katalon Studio

Katalon Studio is another test automation tool that supports testing Rest APIs. It is a free tool built on Appium and Selenium. However, it’s not open-source and can be run on multiple OSs like Windows, macOS, and Linux. This tool has a moderate learning curve and requires basic programming skills for using it. It can be integrated into CI/CD environments using Docker. Furthermore, it generates reports and statistics about test data. In contrast to Testerum, Katalon has a big community to help with difficulties.

Some of the most significant advantages of the Katalon Studio are having hundreds of built-in keywords for creating test cases and supporting one of the most powerful assertion libraries, AssertJ, to build fluent assertion with BDD style.

Katalon also has few downsides, such as the need to have programming skills for testers and buy a training pack to implement the tool in a large team even though it’s a free tool. Finally, it’s not an extensible tool like Testerum.

Rest-Assured

Rest-Assured is an open-source testing tool built on top of Java. With this tool, users don’t have to write codes from scratch since it has a bunch of baked-in functionalities. It can also be integrated with Maven and CI/CD. On top of that, Rest-Assured supports BDD Given/When/Then syntax so that users don’t need to have much expertise in HTTP to use the tool. That syntax makes code more readable and cleaner.

Rest-Assured can also be integrated with the serenity automation framework enabling testers to combine both UI and REST tests into one framework and generate reports.

The most important thing about Rest-Assured is that it has methods to fetch data from every single part of the request and response no matter how complex the JSON structures are. Therefore, this tool is very simple and straightforward.

However, two main drawbacks of this tool are the need for sound Java programming knowledge to use it and not having an inbuilt report generation facility.

Postman

Postman is a scalable API testing tool that can be used for both automated and exploratory testing. This tool supports Windows, macOS, and Linux and has the ability to mock APIs. Furthermore, Postman can be integrated with the CI/CD environment, and developers use it as an API development environment. This tool does not require coding knowledge so that it can be used smoothly by both developers and testers for API testing.

The run, test, document, and monitoring feature of Postman allows testers to share the knowledge with the team easily. It is done by enabling them to package up all the requests and expected responses and then sharing them with team members. Postman offers extended support for GraphQL requests and schemas. Besides, testers can submit the request as a JSON, text, JavaScript HTML, and XML request as well as form data.

Apart from the above advantages, Postman also has some downsides. It doesn’t offer a good solution for monitoring test cases. Verifying HTTP responses is very difficult with Postman as it requires advanced programming knowledge.

Karate DSL

Karate is the only open-source tool to combine API test automation, mocks, performance testing, and even UI automation into a single, unified framework. The BDD syntax popularized by Cucumber is language-neutral and easy for even non-programmers. It includes multiple steps with Given/When/Then/And/But syntax. Therefore, users can start testing very quickly without writing step definitions.

Karate DSL comes with the report generation facility and facilitates configuration switching/staging and multithreaded parallel execution.

SoapUI

SoapUI is a leading API testing tool designed by SmartBear. It supports data-driven testing and comes as a free as well as a pro version. The Pro version supports native CI/CD integrations and asynchronous testing. It has a very user-friendly GUI and convenient for functional testing as users can test complex scenarios without writing any background scripts. SoapUI also facilitates options for test debugging that lets users monitor the execution step by step.

However, SoapUI requires programming knowledge to verify API responses and script automation. Therefore, it is very complicated for beginners. Not enabling complex flows for testing is another downside of SoapUI.

Conclusion

This article has discovered the top testing tools which help to achieve the best Rest APIs testing performance. Not every testing tool fits your application. Using this, you should be able to select the most suitable testing tool for your demand.

Deploy and Manage PostgreSQL on Kubernetes

Shanika Wickramasinghe — Thu, 01 Apr 2021 15:37:42 +0000

PostgreSQL database is an enterprise-grade, open-source object-relational database system focused on providing a highly scalable and robust platform while conforming to SQL standards. Kubernetes is an open-source container orchestration platform designed to be easily deployable in any environment. It enables users to easily deploy and manage containerized applications.

Utilizing Kubernetes to deploy a PostgreSQL instance allows users to leverage the strengths of both platforms. Furthermore, it enables users to create a highly portable and scalable PostgreSQL instance in a Kubernetes cluster. In this article, we will discuss how to easily deploy a PostgreSQL pod in Kubernetes.

What options are available to deploy PostgreSQL?

When it comes to deploying PostgreSQL on Kubernetes, there are two options. One is to create a Kubernetes deployment from scratch, and the other is to use a helm chart to carry out the deployment.

Option 01 - Creating deployment configuration from scratch

This option requires the user to set up the ConfigMaps, create and set up persistent storage volumes and then create the PostgreSQL deployment and service. This process involves a higher degree of planning and technical knowledge to get the service up and running. Therefore, only use this option if you have specific requirements that require custom configurations from the ground up.

Therefore, only use this option if you have specific requirements that require custom configurations such as complex persistent storage configurations, network and security policies, multi cluster connectivity etc...

Option 02 - Use a helm chart

Helm charts can be considered a type of package that can be used to easily deploy applications to Kubernetes clusters. These charts can be used in any kind of deployment, from a single pod application to complex applications consisting of multiple pods with different software and services.

In this article, we will focus on using a helm chart to deploy a PostgreSQL instance. Before that, we should know what Helm is and how to configure Helm in a development environment.

What is Helm?

Helm is considered as the package manager for Kubernetes. It is an open-source project started with the goal of providing a more efficient way to manage Kubernetes YAML files created when deploying an application.

Currently, Helm has evolved into a fully-fledged package manager that streamlines the installation, upgrading, dependency management, and configuration of applications on a Kubernetes cluster using simple CLI commands (Helm Client).

Helm Architecture

Helm creates packages by creating helm charts that bundle one or more Kubernetes manifests (YAML files). These charts contain all the dependencies of the project and allow users to deploy an application with a single command. Additionally, charts can be versioned so that users can create different configurations for the same helm chart under different versions.

Helm is composed of three main concepts

Chart - Contains Information required to create an application instance in Kubernetes
Config - Contains the configuration information that can be merged with a chart to create a releasable object.
Release - A running instance of a chart, combined with a specific config.

Helm executable can be broken down into two components as follows;

The Helm Client: A command-line tool used by end-users to create and manage helm charts and interfaces with the Helm library.
The Helm Library: Interfaces with the Kubernetes API and executes all the helm operations.

Both of these are written in the Go programming language. To connect with Kubernetes, Helm utilizes the Kubernetes client library using REST API.

How to Install Helm

Before installing Helm, we need to have a Kubernetes cluster configured and running. It is recommended to use the latest stable release of Kubernetes.

Installing Helm is a simple process. You can use a package manager like Homebrew for Mac, Chocolatey/Scoop for Windows, or apt/Snap for Debian/Ubuntu. Another way to install Helm is by downloading the binary for the related operating system.

The following example demonstrates how to install Helm using the chocolatey package manager in a windows environment.

choco install kubernetes-helm

RESULT

That’s it, and you have completed installing Helm. Next, let’s verify the installation by checking the helm version using the command below.

helm version

RESULT

Finding Helm Charts

You have the option to create helm charts from scratch. However, there are also prebuilt charts that can be deployed instantly for popular software like PostgreSQL. There, Helm charts are stored and shared using a chart repository.

Artifact Hub is the official distributed community Helm chart repository. For third-party repositories, we need to add the repository to our local environment before we can use it.

Available PostgreSQL charts

First, we have to find a suitable PostgreSQL helm chart for deployment. For that, we can search the Artifact Hub using the following command in the CLI interface.

helm search hub postgresql

RESULT

The above command will search for all the available charts in the Artifact Hub for a PostgreSQL chart. The “hub” parameter points to the Artifact Hub.

To search in a third-party repository, first, we need to add the repository to our helm installation. It can be done through the “repo add” command. The following example shows how to add the bitnami repository to our helm installation and search for the repository.

helm repo add bitnami https://charts.bitnami.com/bitnami

helm search repo bitnami

RESULT

In the above search command, we use the parameter “repo” to carry out the search in the newly added repository apart from the artifact hub. Now let’s search for PostgreSQL instances in this repo using the following command.

helm search repo postgresql

RESULT

Installing Helm Charts

By now, we have located a helm chart, and the next step would be to install the chart using the “helm install command,” as shown below.

Syntax
helm install <Pod Name> <Chart Name>

Code
helm install postgresql-dev bitnami/postgresql

RESULT

Wait till the installation is completed. Then, check the Kubernetes environment, and you will see that a PostgreSQL instance has been deployed successfully.

kubectl get all

RESULT

Now we have deployed a PostgreSQL container. The next step would be to connect to the database, and it can be done using the following commands.

We need to extract the password of the instance and save it as an environmental variable. That password will be used to create the connection.

export POSTGRES_PASSWORD=$(kubectl get secret --namespace default postgresql-test -o jsonpath="{.data.postgresql-password}" | base64 --decode)

kubectl run postgresql-test-client --rm --tty -i --restart='Never' --namespace default --image docker.io/bitnami/postgresql:11.11.0-debian-10-r31 --env="PGPASSWORD=$POSTGRES_PASSWORD" --command -- psql --host postgresql-test -U postgres -d postgres -p 5432

RESULT

After connecting to the database successfully, we can verify our installation by checking the server version.

Configuration Options

Depending on the selected helm chart, the available configuration options may differ. The bitnami PostgreSQL chart offers a whole host of options from simple user creation to complex security configurations like setting up certificates and policies. All the available options are listed on the helm chart GitHub page.

Let's look at some common options, such as changing the username, password, database name, and port. This can be done by providing the following parameters while installing the helm chart.

helm install postgresql-test01 bitnami/postgresql --set
global.postgresql.postgresqlUsername=testadmin --set
global.postgresql.postgresqlPassword=testadmin123 --set
global.postgresql.postgresqlDatabase=testdb --set
global.postgresql.servicePort=5555

RESULT

The above output indicates that the new port is configured, and a new user is created. If we export the password for the “testadmin” user, it will return the user-defined password.

export POSTGRES_PASSWORD=$(kubectl get secret --namespace default postgresql-test01 -o jsonpath="{.data.postgresql-password}" | base64 --decode)

RESULT

Another common scenario is to configure persistent storage for PostgreSQL deployment. We need to create persistent storage volume before installing the helm chart. The below code block shows how to create a simple storage volume and a volume claim and then attach it to the PostgreSQL deployment.

test-pv.yaml

apiVersion: v1
kind: PersistentVolume
metadata:
  name: postgresql-pv
  labels:
    type: local
spec:
  storageClassName: manual
  capacity:
    storage: 10Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/mnt/data"

test-pvc.yaml

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: postgresql-pv-claim
spec:
  storageClassName: manual
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi

Create the volume and claim
kubectl apply -f test-pv.yaml
kubectl apply -f test-pvc.yaml

kubectl get pvc

RESULT

Then, we can attach the persistent volume claim to the helm chart using the following command. We will set the “volumePermissions.enabled” to true for mitigating any permission issues that can occur when writing to the storage volume.

helm install postgresql-test02 bitnami/postgresql --set
persistence.existingClaim=postgresql-pv-claim --set
volumePermissions.enabled=true

RESULT

Upgrading Helm Chart

When upgrading the PostgreSQL helm, it is essential to provide the existing postgresqlPassword and replication.password parameters. It will ensure these values are not updated with random details, which will lead to an inaccessible database.

Syntax

helm upgrade <Pod Name>  <Chart Name> --set
postgresqlPassword=<POSTGRESQL_PASSWORD> --set
replication.password=<REPLICATION_PASSWORD>

Code

helm upgrade postgresql-test bitnami/postgresql --set
postgresqlPassword=testadmin123 --set
replication.password=12345

RESULT

Deleting a Helm Chart

We can simply delete a helm chart by providing the chart name with the delete command, as shown below.

Syntax
helm delete <Chart Name>

Code
helm delete postgresql-test

RESULT

However, this would not delete any PVC associated with the chart. So we need to delete the unused PVCs manually.
kubectl get pvc

kubectl delete pvc data-postgresql-test-postgresql-0

RESULT

Conclusion

In this article, we learned how to deploy a PostgreSQL database in a Kubernetes cluster using a helm chart, change the configurations, and upgrade and delete the PostgreSQL chart. Using helm charts is a relatively straightforward method to deploy commonly used applications in a Kubernetes cluster. This frees up the users to concentrate on the development of the database without having to create complex Kubernetes configurations.

The Best Open Source E-Commerce Platforms

Shanika Wickramasinghe — Mon, 29 Mar 2021 14:11:51 +0000

The world has become more digitally interconnected and the web is the connectivity platform. Online e-commerce platforms are one of the most evolving sectors of the web, with more retailers trying to evolve their online presence or completely shift operations online.

E-commerce platforms facilitate digital retail and operations. They give businesses greater visibility into e-commerce growth and help teams coordinate merchandising, marketing, sales, and fulfillment efforts across channels.

Whether you’re a high-growth brand or an established business trying to improve digital sales and experiences, there are dozens of e-commerce platforms to choose from. In this post, we’ll review the best open source e-commerce platforms and list the pros and cons of open source and software-as-a-service options.

Open Source Vs SaaS E-Commerce Platforms

When selecting an e-commerce platform, one of the main challenges is choosing between an open source and software-as-a-service option. Below we look at the differences between each option.

	Open Source	SaaS
Customization	Yes (Code-Level Customization)	Yes (Granularity Dependent on Provider)
Database Management	Yes	No
Infrastructure Configuration	Yes	No
Infrastructure Maintenance	Yes	No
Setup Difficulty	Medium/High	Low
Technical Expertise	High	Low/Medium
Features	Community Dependent	Platform Dependent
Security and Compliance	Unmanaged (User Responsibility)	Managed (Provider Responsibility)
External Integrations	Yes	Yes
Licensing/Subscription Fees	No	Yes
Support	Community Based Support	Dedicated Support

The main takeaway is that open source options give you complete control but require more resources to configure and maintain; SaaS options take care of these requirements for you while still giving you the ability to create robust backend systems and unique frontend shopping experiences.

Open Source E-Commerce Platforms

In this section, we will go through the best available open source e-commerce platforms and compare their features. The following platforms will be used for the comparison:

	nopCommerce	Shopware	CubeCart	Sylius	Solidus
Multi-Store and Multi-Vendor	✅	✅1	❌	✅6	✅
Mobile support	✅	✅	✅5	✅	✅
Product Management	✅	✅	✅	✅	✅
Multiple Payment Providers	✅	✅2	✅	✅	✅
Shipping/Logistic Management	✅	✅	✅	✅	✅
Integrated Marketing/ Analytics	✅	✅	✅5	✅	✅
3rd Party Integrations/Plugins	✅	✅	✅	✅	✅
Internationalization	✅	✅	✅	✅	✅
API Availability (Headless)	❌	✅	❌	✅	✅
Docker/K8 Support	✅	✅3	❌4	✅	✅
Premium Offering	✅	✅	✅	✅	❌

1 - Multi-Vendor is supported via plugins
2 - Direct integration with PayPal and others through plugins
3 - Docker installation is not recommended for macOS due to performance
issues
4 - Third-party docker containers are available
5 - Supported via plugins
6 - Premium Feature

nopCommerce

nopCommerce is an ASP.NET-based e-commerce platform released in 2008 with the purpose of providing a feature-rich, free, and open source e-commerce platform. nopCommerce is designed to support SMBs to perform enterprise-level operations.

nopCommerce is an out-of-the-box solution for all your B2B and B2C commerce needs. It provides a wide array of features such as multi-vendor / multi-store configurations, product management, payment and tax management, and customer services. This platform also supports the widest range of third-party integrations for payment modules, shipping management, marketing, and administration. Another strength is the sheer amount of customization, from simple themes to the customization of individual functions to suit the exact requirements of the user.

nopCommerce is fully compliant with PCI DSS to provide a secure payment platform to all the integrated payment methods. It meets all the requirements for GDPR compliance in the European Union and actively keeps the compliance up to date as a secure and trustworthy e-commerce platform.

Shopware

Shopware was introduced in 2000 to provide an e-commerce platform that can help businesses move their operations online. The current implementation of Shopware utilizes Twig and Bootstrap to power the storefront while using Vue.js and twig.js to power the administration interface. This open source project is distributed under the MIT license.

Shopware provides the services through REST APIs and offers rich user interfaces enabling developers and administrators alike to use their preferred method to interact with the platform. This platform is developed using retailer feedback to better cater to user requirements

Shopware allows users to easily make an online e-commerce presence due to its minimal learning curve and simple and intuitive design. It supports integrations with different sales channels and social media platforms to increase visibility to customers. Both B2C and B2B business modules are supported under this platform. Furthermore, Shopware is designed to be performance-centric and highly scalable. The Plugin Manager functionality of Shopware enables users to extend this e-commerce platform with other tools and services effortlessly.

CubeCart

CubeCart is one of the most straightforward solutions, aiming to provide a stable and secure e-commerce platform. It is a free and open source platform distributed under the GPL 3.0 license, and its security is audited by Netsparker.

CubeCart is actively developed on a regular basis and is backed by a thriving community. Moreover, it utilizes the Smarty Template Engine to create a template-driven responsive frontend. This platform provides various functionalities such as product, payment, and logistical management to fulfill all your e-commerce needs.

One of the best features of this platform is its extensive log functionality, from simple transaction logs to server error and request logs. These logs enable the platform administrators to be aware of the complete behavior of the storefront. Furthermore, CubeCart provides inbuilt support for Google Analytics and SEO tools and can be further extended using free and paid extensions.

Sylius

Sylius is a headless e-commerce platform targeting mid-market and enterprise customers that require custom e-commerce solutions. It is built on top of the Symfony framework and developed using full stack Behavior-Driven-Development with phpspec and Behat.

This open source platform is freely available and distributed under the MIT license. Sylius is designed to be the nexus of your e-commerce stack. Due to the headless nature of the platform, developers are given the freedom to build custom interfaces to suit the desired sales channel whether it’s a mobile platform, point of sale kiosk, or a progressive web app.

Sylius can be used out-of-the-box with its provided functionality or can be integrated into an existing PIM, CRM, or Automation software using the powerful REST API. The platform can be extended further using Sylius plugins which add more functionality from simple content and customization options to complex reporting and analytics features.

Solidus

The Solidus e-commerce platform is developed using Ruby on Rails. The project started its life as a fork of the Spree Commerce platform and gradually evolved into a fully-featured e-commerce platform.

This platform is targeted towards digitally native brands and fast-growing online businesses with a high focus on stability, flexibility, and scalability. What sets this platform apart from others is its adherence to the open source mindset. It consists of a well-defined and public roadmap for development and receives transparent funding through the Open Collective Solidus community.

Solidus offers both RESTful API and GraphQL API to make a truly headless e-commerce experience. The three main components of Solidus are Product Catalog, Payment, and Logistics. The product section provides inventory and product management, while the payment component manages payment integrations, subscriptions, and taxations. Finally, the logistic management tackles the shipping, returns, and exchanges.

E-Commerce Platforms: Best SaaS Option

The best option to gain a truly out-of-the-box experience without worrying about complex configurations or infrastructure would be a SaaS e-commerce solution. SaaS solutions will take care of complex, time-consuming, and mundane tasks such as server management, security patching, and system maintenance, and allow business users to focus on providing the best possible e-commerce experience to customers.

Among numerous available SaaS solutions is Fabric, a headless commerce platform.It offers robust functionality with specialized features such as a Product Information Manager and Order Management System to provide a comprehensive, all-in-one platform.

It also offers tailored features like Storefront to fast track development of a digital store and Experience Manager to create user- and channel-specific experiences. Additionally, a fully customizable API enables developers to extend the functionality to match their requirements.

Fabric also offers a service to get your application up and running at every stage of the development process. By choosing a SaaS platform like Fabric, you can enjoy all these benefits without having to worry about infrastructure and complex technical considerations.

The best online JS tools can be found at HTML-CSS-JS.com: script beautifier, compressor, cheat sheet or just read the blog.

The Best Open Source Headless CMS Software

Shanika Wickramasinghe — Fri, 19 Mar 2021 02:08:47 +0000

Traditional content management systems (CMS) are built around serving content with a web-oriented framework combining both the frontend and backend. However, this monolithic approach does not support modern web environments. The headless CMS addresses this issue by providing a decoupled approach to content management.

The headless CMS provides a backend to manage your content while providing an API to serve the content. This API allows developers to use any presentation layer to effectively display content across multiple channels. It also offers them unlimited options to structure and deliver content.

If you’re considering using a headless CMS to scale content management across channels, you can choose an open source headless CMS or a headless CMS from a software-as-a-service (SaaS) provider. In this article, we will present the pros and cons of each. We will then present the best open source headless CMS options.

Open Source Vs. SaaS Headless CMS

Let’s look at the core factors to consider when comparing and contrasting open source and SaaS options for a headless CMS.

Ease of Implementation

The first consideration is the ease of getting the service up and running. With most open source options, you must set up the infrastructure first and then configure the functionality. Even though this provides a high level of control over your deployment, it’s time consuming and requires technical expertise.

On the other hand, SaaS solutions provide a more user-friendly configuration. You can launch your headless CMS with minimal effort. SaaS options also alleviate infrastructure management requirements, allowing developers to focus more on CMS customization.

Platform Maintenance

SaaS platforms do not require much maintenance. The only requirement is to maintain the content within the headless CMS. The platform provider is responsible for the underlying infrastructure and performance. Additionally, you will have a dedicated support option to contact for mitigating any issues within the platform.

In an open source platform, you are responsible for infrastructure maintenance, and the only support option is asking the open source community that contributes to the project. This approach is more risky, but provides greater control over platform performance and allows you to fine tune the platform based on your unique needs.

Security

A SaaS provider manages the security and compliance of the headless CMS. In an open source implementation, most projects are dependent on the contributors to adhere to compliance and security standards. Therefore, the security implications are solely on the shoulders of developers. Like platform maintenance, this approach is riskier and more time consuming.

Customization

An open source platform is only limited by the developer’s imagination and skillset to customize the application to suit any requirement. You have complete access to the source code, and you can even add features or extend existing features. In contrast, a SaaS platform is limited to the feature set and customization options offered by the provider. However, some Saas platforms like Fabric offer unique features like “experience management” from the get-go.

Integrations

This is the point where both open source and SaaS platforms offer an equal amount of flexibility. Both options provide the ability to integrate with third-party platforms like payment gateways, ERP platforms, message brokers, social media, and more. The only difference is that, in an open source platform, you have the option to create a new connector to facilitate a new integration with the help of the community.

The summary of all the points above is illustrated in the table below.

	Open Source	SaaS
Infrastructure Configuration	Yes	No
Infrastructure Maintenance	Yes	No
Setup Difficulty	Medium/High	Low
Technical Expertise	High	Low/Medium
Security and Compliance	Unmanaged (User Responsibility)	Managed (Provider Responsibility)
Features	Community Dependent	Platform Dependent
Customization	Yes (High)	Yes (Granularity Dependent on Provider)
Integrations	Yes	Yes

Open Source Headless CMS Options

Here we will explore some of the best available open source headless CMS options. We will mainly focus on the features offered by each option and the differences between them. The following options will be used for this comparison.

Note: GraphCMS is not open source but we have included it because it’s a popular tool and there is a free community version.

The following table illustrates a comparison of the main features of some of the best open source headless CMS options.

	Ghost	strapi	cockpit	Apostrop	Directus	GraphCMS
Rich Content Editing	✅	✅	✅	✅	✅	✅
Secure Authentication	✅	✅	✅	✅	✅	✅
Email & Messaging	✅	✅	✅ 3	✅	✅	✅
User Analytics	✅	❌	❌	✅4	✅ 3	✅
Multilingual Support	✅	✅	✅	✅	✅	✅
RESTful API	✅	✅	✅	✅	✅	❌
GraphQL	❌	✅	❌	❌	✅	✅
SQL Support	✅	✅	✅ 2	❌	✅	❌ 1
NoSQL Support	❌	✅	✅ 2	✅	❌	❌ 1
Webhooks	✅	✅	✅	✅ 4	✅	✅
Docker/K8 Support	✅	✅	✅	❌	✅	❌
CLI	✅	✅	✅	✅ 4	✅	❌
Premium Offering	✅	✅	❌	✅	✅	✅

Offers their own database solutions
Limited to SQLite and MongoDB
Limited Support
Through Plugins or Extensions

Ghost

The Ghost platform (GitHub) under the Ghost Foundation is a headless CMS focused on providing a publishing platform from individuals to businesses. The platform is developed using Javascript (Node.js) and is distributed under the MIT license. Ghost offers a suite of modern publishing tools, a fully-featured content editor, multi-author, multi-language content creation, and chronological content.

Having its primary focus on publishing, Ghost provides inbuilt support for subscription and membership management. Additionally, Ghost provides support for global payments through Stripe and provides a user analytics function.

Ghost can also be integrated with existing tools like Zapier, Slack, and Mailchimp to extend the workflows and provide a unified experience. It is used by prominent services like Mozilla, DigitalOcean, Airtable, and Tinder to power their publishing platforms.

Moreover, Ghost provides a JavaScript library to interact with the Content API, making it easier to interact with the content without creating manual API calls.

Sample Query

    const api = new GhostContentAPI({
        // Ghost DEMO site
        host: 'https://demo.ghost.io',
        // Authentication via API Keys
        key: '22444f78447824223cefc48062',
        version: "v3"
      });

      // fetch 5 posts, including related tags and authors
      api.posts.browse({
          filter: 'tag:fiction+tag:fiction'
      })
      .then((posts) => {
          posts.forEach((post) => {
              console.log(post.title);
          });
      })
      .catch((err) => {
          console.error(err);
      });

Strapi

Strapi (GitHub) is an open source headless CMS designed to work with all Jamstack sites. This developer-focused platform gives developers a flexible and extensible platform to manage and distribute content using their favorite tools and platforms. Strapi supports both relational and non-relational databases and is frontend agnostic, allowing developers to use it with any frontend framework (React, Angular, Vue).

Strapi can be used to build simple websites, mobile applications, to fully-featured e-commerce platforms. It also provides support for both RESTful and GraphQL to interact with the API. Its powerful CLI module lets you create and manage projects easily within seconds.

This platform can be further extended using third-party integrations like Redism, Sentrym, and Mailgun. Another major feature of Strapi is that it’s secure by default, providing various configuration options like CROS, CSP, and XSS out of the box. The following code samples show you how to query the Strapi API using the Axios library.

Sample Query

     import axios from 'axios';

      const token = '';

      // Request API.
      axios
        .get('http://localhost:1337/posts', {
          headers: {
            Authorization: `Bearer ${token}`,
          },
        })
        .then(response => {
          // Handle success.
          console.log('Data: ', response.data);
        })
        .catch(error => {
          // Handle error.
          console.log('An error occurred:', error.response);
        });

Cockpit

Cockpit (GitHub) is one of the simplest headless CMS platforms. With its API-first approach, Cockpit aims to provide a simple yet powerful backend to manage content that can be delivered through multiple channels.

Developed in 2013, the goal of the Cockpit project was to provide a comprehensive platform for managing structured and reusable content while maintaining the simplicity of functionality needed to provide data through the API in JSON format. The main features of the Cockpit CMS are the ability to manage flexible content modes, a simple uncluttered backend user interface, and high scalability.

The Cockpit CMS can be easily integrated into any project without having to build scripts or include any advanced PHP libraries. It is also tested on both Apache and Nginx servers for smooth operation.

The interactions with the API are authenticated using an API token. The following example demonstrates a simple GET request to retrieve posts from the Cockpit CMS using the fetch method.

Sample Query

        fetch('/api/collections/get/posts?token=', {
            method: 'post',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({
                filter: {published:true},
                fields: {fieldA: 1, fieldB: 1},
                limit: 10,
                skip: 5,
                sort: {_created:-1},
            })
        })
        .then(res=>res.json())
        .then(res => console.log(res));

ApostropheCMS

Unlike all other open source CMS software, Apostrophe (GitHub) is a fully-featured open source CMS built with Node.js and MongoDB. Apostrophe offers a headless option through apostrophe-headless, enabling developers to integrate it with any jamstack and provide content through a RESTful API. This combined approach allows developers to mix and match the functionality of a traditional CMS and a headless CMS to meet their exact requirement.

Apostrophe is geared towards a rapid, agile development cycle reducing the “software time to market.” Furthermore, Apostrophe breaks its functionality into different components, enabling developers to customize the CMS platform and build a solution that suits their needs.

You can extend Apostrophe using extensions and Integrations such as Salesforce Personas, Redis Caching, Stagecoach, Webhook notifications, and more.

As apostrophe-headless is an extension to the Apostrophe, you need to activate the package by installing the npm package and activating and exposing the required content using the REST API. The authentication can be done via API Keys or Bearer Tokens.

Sample Configuration

        modules: {
            'apostrophe-headless': {
                apiKeys: [ '' ],
            },
            'products': {
                //Other configurations
                // Expose via API
                restApi: true
            }
          }

The code below enables you to query for data in Apostrophe using the REST API.

    // Get all products
    const { results } = await $axios.$get('/api/v1/products')

Directus

Being the most data-driven headless CMS platform, Directus (GitHub) is all about data. This open source headless CMS platform is built using Node.js and utilizes Vue.js to provide the administration interface. It’s distributed under the GPLv3 license.

Directus can connect to a preexisting database or create a new database to complement your project and provide the necessary content using the RESTful or GraphQL API. This CMS platform has the widest support for relational database software with free solutions like MariaDB and SQLite as well as commercial solutions like MS-SQL and Oracle DB. This enables developers to select the ideal database to match their requirements.

Directus provides a fully-featured administrative interface to manage the above-mentioned databases. Another major factor of this headless CMS is its sheer customizability from full-text search, translations, workflows, and event hooks.

Furthermore, Directus supports creating custom API endpoints and offers a command-line interface to create and manage projects. It also provides a JavaScript SDK which acts as a wrapper around the Axios library tailored to interact with the API.

You can see how to utilize the Directus SDK to authenticate a user and return required items in the following code block. With the help of SDK, Directus simplifies the development lifecycle by offering prebuilt functionality for API interactions.

Sample Query

        import DirectusSDK from '@directus/sdk-js';

        const directus = new DirectusSDK('https://api.example.com/');

        async function getData() {
            // Authentication using email and password.
            await directus.auth.login({ email: 'admin@example.com', password: 'password' });

            // Obtain all the articles.
            return await directus.items('articles').read();
        }

        getData();

GraphCMS

GraphCMS is a native GraphQL headless content management system. The objective of this headless cms platform is to provide users with an exceptional digital experience while simplifying content management. GraphCMS is frontend agnostic and is developed by GraphCMS GmbH.

One of the best features of GraphCMS is its Digital Asset Handling which allows developers to transform their digital assets into different formats and structures. For instance, GraphCMS natively supports resizing image assets and converting files into different types.

Another powerful feature of GraphCMS is its approach to content personalization and flexible content modeling. It enables developers to create dynamic content for target audiences and tailor the content to match the user requirements by modeling the content.

On top of that, GraphCMS uses Authentication Tokens to authorize the API requests. The following code block illustrates a simple query to obtain published posts about dogs, ordered by their created timestamp.

Sample Query

        {
            posts(
              where: { title_contains: "Dog" }
              orderBy: createdAt_DESC
              stage: PUBLISHED
            ) {
              id
            }
        }

Headless CMS: Best SaaS Option

Going open source is an option only if you have enough time to invest in configuring and setting up the headless CMS solution to meet your exact needs. If that is not the case, the best option is to choose a SaaS platform. It provides you with an out-of-the-box solution that can be adapted to fit your requirements with just a few modifications or configuration changes.

Fabric XM

Among numerous available SaaS solutions, Fabric is one of the best SaaS headless CMS options. It offers tailored features like Storefront to fast track development of an interface and Experience Manager to create user- and channel-specific experiences. Additionally, a fully customizable API enables developers to extend the functionality to match their requirements.

In addition to offering support, Fabric also offers a service to get your application up and running at every stage of the development process and keep your application in optimal condition to provide a unified experience to any user across the globe. By choosing a SaaS platform like Fabric, you can enjoy all these benefits without having to worry about infrastructure or complex technical considerations.

Best SSL certificate providers

Shanika Wickramasinghe — Thu, 24 Oct 2019 08:44:51 +0000

In the digital era nowadays, SSL certificates are needed to provide for security when transacting online. It is the method to verify webpages and domains to ensure that all the information and transactions are secure. However, you must pick a good SSL provider and make it easier for you, we have bought 10 providers that we think is worth considering.

1- Comodo SSL

Comodo SSL provides the highest level of encryption compared to other providers. Since it is automated online, there is no need for any paperwork and causes no delays as well. It costs around US$7.27 a year making it quite affordable too. It also has a 99.9% browser recognition and also provides an SSL certificate management tool. There are a PCI scanning and a trusted logo that helps for customer conversion too. Comodo also provides a ‘premium SSL’ solution that costs around US$56 for 4 years which also includes a 256 — bit encryption. ComodoSSL also provides a free site seal.

2 — DigiCert

DigiCert is not very affordable and costs around US $188 a year. It provides free SSL tools and unlimited reissues as well. You can also expect world-class customer service when dealing with DigiCert as they are very patient and can guide you through a step by step process. It has both strong encryption and high authentication along with other options like Wildcard SSL and multi-domain SSL. the user interface is very easy and its’ speed is one of the key highlights.

3- Entrust Datacard

Entrust Datacard has been around since 1994 and is one of the most trusted providers. It provides tools and resources to install SSL properly and can manage many certificates as well. Entrust Datacard also has a wide selection such as ID card printers, credit card printers and PKI as well. However, the SSL certificate is their best product. The standard SSL for one site costs around $174 whereas the wildcard SSL is $609 a year. It can cover an unlimited amount of servers and sub-domains.

4 — GeoTrust

GeoTrust provides services in three areas which are signing services, SSL certificates and enterprise services. Owned by Symantec, it price costs around US $87 a year and is the best place to secure your website as they have discount rates and a 30- day money-back guarantee as well. They also provide 256-bit encryption and a free site seal. The issuance speed is usually less than an hour which is acceptable.

5- GlobalSign

GlobalSign is another trusted provider found back in 1996. You can secure from a single website to multiple domains with this provider. Thus, it is very flexible and scalable. Apart from strong encryption, it also has added value features such as free SSL tools and PKI solutions as well. It also provides phishing detection, malware scans and comes with a 2048 bit SSL. however, unlike others, GlobalSign is not cheap and costs around $250 for a single site. GlobalSign also has a secure site seal so that clients or visitors have more confidence.

6 — GoDaddy

Using an SSL certificate from GoDaddy will show that your site is authentic and trustworthy. SSL certificates from GoDaddy provides a 128- bit encryption for standard and 256- bit encryption for a higher grade. The cost for a single site is usually $79 a year and a domain costs $370 a year. Using this domain, you get a McAfee secure seal and a 2048 encryption. Like others, GoDaddy also provides a 30- day money-back guarantee and unlimited free reissues. There is also 24/7 unlimited security support.

7 — Network Solutions

Just like GoDaddy, Network Solutions also provides other services apart from SSL certificates like e-commerce solutions. It gives a 256- bit encryption and ensures data is safe from the hands of hackers. It costs around $59.9 for a single site which is for two years. However, it doesn’t provide a lot of technical support if you are looking for such. All the SSL certificates with an ‘https’ and the closed padlock so that your site is seemingly secure and places confidence in users, particularly when transacting. The green address bar is only there in the extended version but the site seal is there in every version except the Xpress. They also provide 24/7 live support as well.

8 — RapidSSL

RapidSSL is a cheaper solution which costs around $17 a year for a single site. Although its cost is low, its provided by a leading certificate authority since it is a subsidiary of GeoTrust. It is also very fast, easy to install with a step by step guide and also provides 256-bit encryption. RapidSSL also provides its users with 24/7 web and mail support and also has a 30-day money-back guarantee like many other providers. Just like other providers, issuance speed is quite rapid and it also has a 99% browser support.

9 — SSL.com

provides everything from SSL, wildcard, UCC, SAN, and EV certificates as well. The basic SSL costs around $36 a year for one domain. The Enterprise EV UCC/SAN SSL is the highest that costs $320 a year which allows multiple domains, subdomains and a green bar which ensures confidence.

However, the basic is also worth as it trusted with almost 99% of the browsers and has a 2048 bit SHAA 2 encryption. They have a strong customer service with a 24/7 chat, email, and phone support. The prices are affordable as well and also gives free lifetime certificate reissues.

10 — Thawte

is another solid option if you are thinking of getting an SSL certificate. It is a global SSL provider with a history of 17 years. Thus, it is surely a reliable platform. The cheapest certificate costs around $47. It comes with a 21-day free trial and also has a Thawte site seal logo. It has 99% browser compatibility and has a 256- bit encryption. They also have a support team via chat, phone or email which is very reliable. There is also a NetSure warranty for all the SSL plans and are also compatible with Internationalized domain names.

Final thoughts

In conclusion, SSL certificates are essential to ensure encryption and authentication. Most providers have similar features but it varies a little. Having a certificate will ensure that your site is reliable, safe and secure. However, choosing the right provider depends on your requirements and needs. Thus, go through this article and choose the provider that you think is the perfect choice for you!

jQwidgets Grid with React Features

Shanika Wickramasinghe — Fri, 09 Aug 2019 10:14:33 +0000

React is a light-weighted library, which is widely used for UI/UX designs of web pages. It provides one of the responsive and flexible grids which display the data in tabular form using jQWidgets.

This article covers the basic steps to create a jQWidgets grid for React using typescript.

Installation of React:

React is an interactive library which renders the right components while the data changes. To install React we will first need to install node.js 8.10 or later versions. Check for node.js and npm versions.

Create React App:

Using npm we will create an application for React as given below. This creates the folder structure and the directory called my-app. Once my-app is created, cd to my-app and type npm start. The project opens in http://localhost:3000.

npm i -g create-jqwidgets-react-app
npx create-jqwidgets-react-app my-app --typescript
cd my-app
npm install jqwidgets-script –save--dev
npm start

The folder structure is as below:

Create a Simple jQWidgets Grid Component for React:

Once the required folders and files are created we will work on the settings and imports needed for jQWidgets grid component of React.

App.htm file:

We will add the below links to the section of App.html page.

<link rel="canonical" href="https://www.jqwidgets.com/react/react-grid/" />
<link rel="stylesheet" href="../jqwidgets/styles/jqx.base.css" type="text/css" />
<script type="text/javascript" src="../scripts/demos.js"></script>
<script src="./../node_modules/react/umd/react.production.min.js"></script>
<script src="./../node_modules/react-dom/umd/react-dom.production.min.js"></script>

App.tsx file:

In App.tsx file we will first import jqxGrid from jqwidgets-react. This will provide the jqxGrid component created for React library. We will use a few CSS files for styling the grid.

import 'jqwidgets-scripts/jqwidgets/styles/jqx.base.css';
import 'jqwidgets-scripts/jqwidgets/styles/jqx.material-purple.css';
import JqxGrid, { IGridProps, jqx } from 'jqwidgets-scripts/jqwidgets-react-tsx/jqxgrid';

Next, we will create the App class using jqxGrid, we will first construct the properties by setting the grid with source properties like data field, datatype, id, record, etc. Later we will set the state for this grid.

export class App extends React.PureComponent<{}, IGridProps> {
    constructor(props: {}) {
        super(props);
        const source: any = {
            datafields: [
                { name: 'Name', type: 'string' },
                { name: 'Sex'  , type: 'string' },
                { name: 'City', type: 'string' },
                { name: 'Address', type: 'string },
            ],
            datatype: 'xml',    
            id: 'NameID',
            record: 'Name',
            root: 'Name',
            url: './../sampledata/Details.xml'
        };  
//set the state for widget.
    this.state = {
        columns: [
            { text: 'Name', datafield: 'Name', width: 250 },
            { text: 'Sex', datafield: 'Sex', width: 100 },
            { text: 'City', datafield: 'City', width: 80 },                                                      { text: 'Address', datafield: 'Address', width: 350 },
        ],
        source: new jqx.dataAdapter(source)
    }
}
public render() {
    return (
        <JqxGrid
        // @ts-ignore
            width={this.state.width} source={this.state.source} columns={this.state.columns} autoheight={true} altrows={true}
        } />
      )
    }  
}

After you define all your properties and state to the grid we will render this component using the render(). Once you run this sample example your grid would look like below.

Grid Features for React:

jQWidgets Data Grid for React is built for professional use with features like sorting, filtering, grouping, paging, editing, drag-drop, nested grids, etc. Before we will look into how to enable these features for better user experience, we need to add bundle.js files for respective features in App.html eg: adding bundle files for sorting in App.htm file

<div id="app"></div>
<script src="../dist/grid_sorting.bundle.js"></script>

Sorting:

The sortable property enables or disables the data sorting. In the code example below, the Grid data sorting is enabled:

<JqxGrid ref={this.myGrid} onSort={this.myGridOnSort}
    width={getWidth('grid')} height={450} source={this.state.source} columns={this.state.columns} sortable={true} altrows={true} filterable={true} selectionmode={'multiplecellsadvanced'} />
</JqxGrid>

To enable or disable the sorting of a Grid column, you can set its sortable property to false. Also when the sorting data type is Date, Number or Boolean, the 'type' property in the 'datafield' array should be set.
The 'sortcolumn' property specifies the default Grid sort column, i.e. when the grid is displayed, the data will be sorted. The 'sortdirection' property specifies the sort order of the sort column.

sortcolumn: 'ColumnName',
sortdirection: 'asc'

The “sortby” function can be used to sort the Grid through the API. This function should be called when the grid data is fully loaded. The first parameter is the Column's DataField. The second parameter is the sort order - 'asc' or 'desc'.

Filtering:

To enable the filtering feature, you need to set the 'filterable' property to true. When the value of the filterable property is true, the grid displays a filtering panel in the columns popup menus. Filtering can be done in background or can be customized.

<JqxGrid ref={this.myGrid} onFilter={this.onFilter}
     width={getWidth('grid')} source={this.state.source} columns={this.state.columns}
    filterable={true} sortable={true} ready={this.state.ready} autoshowfiltericon={true} />

Grid Grouping:

The jqxGrid component supports data grouping against one or more columns. Grouping is allowed if the 'groupable' property is set to true. End-users can group data by dragging the column headers to the Group Panel.
The code example below shows a Grid template with one grouping column:

<JqxGrid ref={this.myGrid}
    onGroupexpand={this.onGroupExpand} onGroupcollapse={this.onGroupCollapse}
                    // @ts-ignore
    width={getWidth('grid')} groupable={true} columns={this.state.columns}
    source={this.state.source} groups={['Country']} />

Grid Paging:

The built-in paging capability gives an additional edge to display a large amount of data in tabular format. The pageable property is set to true, to make the paging available.

<JqxGrid ref={this.myGrid}
    onPagechanged={this.onPageChanged}  onPagesizechanged={this.onPageSizeChanged}
          // @ts-ignore
          width={getWidth('grid')} source={this.state.source}   columns={this.state.columns}
          pageable={true} sortable={true} columnsresize={true}
          autoheight={true} selectionmode={'multiplerowsextended'} />

Pagechanged or pagesizechanged events are raised when the page is changed or page size is changed.

private onPageChanged(event: any): void {
        this.eventsLog.current!.style.display = 'block';
        const loggedElements = document.getElementsByClassName('logged');
        if (loggedElements.length >= 5) {
            this.myPanel.current!.clearcontent();
        }
        const args = event.args;
        const eventData = 'pagechanged <div>Page:' + args.pagenum + ', Page Size: ' + args.pagesize + '</div>';
        this.myPanel.current!.prepend('<div class="logged" style="margin-top: 5px;">' + eventData + '</div>');
        // get page information.
        const paginginformation = this.myGrid.current!.getpaginginformation();
        this.pagingInfo.current!.innerHTML = '<div style="margin-top: 5px;">Page:' + paginginformation.pagenum + ', Page Size: ' + paginginformation.pagesize + ', Pages Count: ' + paginginformation.pagescount + '</div>';
    }
    private onPageSizeChanged(event: any): void {
        this.eventsLog.current!.style.display = 'block';
        this.myPanel.current!.clearcontent();
        const args = event.args;
        const eventData = 'pagesizechanged <div>Page:' + args.pagenum + ', Page Size: ' + args.pagesize + ', Old Page Size: ' + args.oldpagesize + '</div>';
        this.myPanel.current!.prepend('<div style="margin-top: 5px">' + eventData + '</div>');
        // get page information.
        const paginginformation = this.myGrid.current!.getpaginginformation();
        this.pagingInfo.current!.innerHTML = '<div style="margin-top: 5px;">Page:' + paginginformation.pagenum + ', Page Size: ' + paginginformation.pagesize + ', Pages Count: ' + paginginformation.pagescount + '</div>';
    }

The grid paging also displays the drop-down list component in the pager area. By default, the size options are 5, 10 and 20. The "pager" property enables you to set different modes to display the pagination for a grid. You have two modes for “pager” settings, default and simple.

Grid Cell Editing:

Grid cell editing is one of the important features for interactiveness of the grid. This feature resembles the data entering experience in an Excel Spreadsheet – once you select a grid cell, you can enter data when you start typing text. The Grid's 'editable' property specifies whether the editing is enabled or not.
The Grid has APIs for showing and hiding the cell editors. The ‘cellBeginEditEvent’ method allows you to put a specific cell into edit mode.

this.cellBeginEditEvent = this.cellBeginEditEvent.bind(this);
this.cellEndEditEvent = this.cellEndEditEvent.bind(this);

The ‘cellEndEditEvent’ method ends the edit operation and confirms or cancels the changes.

public render() {
        return (
            <div>
                <JqxGrid onCellbeginedit={this.cellBeginEditEvent} onCellendedit={this.cellEndEditEvent}
                    // @ts-ignore
                    width={getWidth('grid')} source={this.state.source} columns={this.state.columns}
                    editable={true} enabletooltips={true} selectionmode={'multiplecellsadvanced'} />
                <div style={{ fontSize: '12px', fontFamily: 'Verdana', marginTop: '30px' }}>
                    <div ref={this.beginEdit} />
                    <div ref={this.endEdit} style={{ marginTop: '10px' }} />
                </div>
            </div>
        );
    }
    private cellBeginEditEvent(event: any): void {
        const args = event.args;
        this.beginEdit.current!.innerHTML = 'Event Type: cellbeginedit, Column: ' + args.datafield + ', Row: ' + (1 + args.rowindex) + ', Value: ' + args.value;
    }
    private cellEndEditEvent(event: any): void {
        const args = event.args;
        this.endEdit.current!.innerHTML = 'Event Type: cellendedit, Column: ' + args.datafield + ', Row: ' + (1 + args.rowindex) + ', Value: ' + args.value;
    }

To confirm the edit mode, we will have to press the Esc key. The grid can be customized to display the validation popup message when the new cell's value is not valid for any column or grid.

Summary:

jQWidgets grid for React is a very flexible and powerful tool to allow you to add lots of data with multiple pages. This article demonstrates the basic steps to create the jQWidgets grid for React using typescript. We have also discussed a few interactive features which are basic and are needed for UI of any website. There are a lot more features of the grid, you will have to explore a bit of these features and use the best needed for the UI/ UX design of your page.