Magento Archives - Kpyxal Solutions LLP https://www.kpyxal.com/category/magento/ Fri, 06 Sep 2024 13:44:38 +0000 en hourly 1 https://wordpress.org/?v=6.1.7 https://www.kpyxal.com/wp-content/uploads/2024/07/cropped-48x48_logo-32x32.webp Magento Archives - Kpyxal Solutions LLP https://www.kpyxal.com/category/magento/ 32 32 Mutation in GRAPHQL https://www.kpyxal.com/magento/mutation-in-graphql/ https://www.kpyxal.com/magento/mutation-in-graphql/#respond Mon, 20 Feb 2023 16:04:27 +0000 https://www.kpyxal.com/?p=92 In the world of GraphQL, queries and mutations play distinct but complementary roles.Specifically, While GraphQL queries are designed to perform read operations, mutations handle the task of modifying data. Essentially, a mutation allows you to create, update, or delete objects and fields, functioning similarly to POST, PUT, and DELETE requests in REST terminology. Moreover, Understanding […]

The post Mutation in GRAPHQL appeared first on Kpyxal Solutions LLP.

]]> Mutation in GRAPHQL

In the world of GraphQL, queries and mutations play distinct but complementary roles.Specifically, While GraphQL queries are designed to perform read operations, mutations handle the task of modifying data. Essentially, a mutation allows you to create, update, or delete objects and fields, functioning similarly to POST, PUT, and DELETE requests in REST terminology. Moreover, Understanding the structure and function of mutations is crucial for effective data manipulation and application management. Therefore, In this context, let’s delve into the components that make up a Mutation in GRAPHQL and see how they contribute to its functionality.

Structure of a mutation

Mutations consist of several key elements:

  • First, you need the keyword ‘mutation.
  • An operation name for your local implementation. Consequently, this name is required if you include variables. On the other hand, it is optional.
  • The mutation name
  • The input object or attributes.In particular, Most mutations require an input object that contains data or individual attributes for the application server to process. However, on the other hand, some mutations, such as createEmptyCart, do not require an input object. In this particular case, therefore, the authorization token passed with the request provides the needed context.
  • The output object, which specifies which data the mutation returns.

Example of mutation graphql

Here in this example, we are, indeed, adding data to the database using a GraphQL mutation.

Step 1 :- You Create registration.php file

<?php
/**
 * @author KPYXAL
 * @copyright Copyright (c) 2023
 * @package Kpyxal_MutationGraphql
 */

\Magento\Framework\Component\ComponentRegistrar::register(
    \Magento\Framework\Component\ComponentRegistrar::MODULE,
    'Kpyxal_MutationGraphql',
    __DIR__
);

Step 2 :- create etc/module.xml file

<?xml version="1.0"?>
<!--
/**
 * @author KPYXAL
 * @copyright Copyright (c) 2023
 * @package Kpyxal_MutationGraphql
 */
-->

<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:noNamespaceSchemaLocation="urn:magento:framework:Module/etc/module.xsd">
    <module name="Kpyxal_MutationGraphql" setup_version="2.0.0">
        <sequence>
            <module name="Magento_Backend"/>
            <module name="Magento_GraphQl"/>
        </sequence>
    </module>
</config>

Step 3 :- GraphQL queries are declared under etc/schema.graphqls

type Mutation {
    dataFormSubmit(input: FormInput!): FormOutput @resolver(class: "\\Kpyxal\\MutationGraphql\\Model\\Resolver\\FormDataSave") @doc(description:"Contact us form")
}

input FormInput {
    name: String @doc(description: "Get Name")
    number: String @doc(description: "Get Number")
    email: String @doc(description: "Get Email")
    password: String @doc(description: "Get Password")
    gender: Int @doc(description: "Get Gender")
    bdate: String @doc(description: "Get Birth Date")
}

type FormOutput {
   success_message: String @doc(description: "Success Message")
}

Explanation of graphql :-

  • type Mutation > declares Mutation operations of our module.
  • dataFormSubmit > name of our Mutation.
  • FormInput > it is input value and type.
  • FormOutput > declares output message.

Step 4 :- Create Resolver Class Model/Resolver/FormDataSave.php

<?php

namespace Kpyxal\MutationGraphql\Model\Resolver;

use Magento\Framework\Exception\NoSuchEntityException;
use Magento\Framework\GraphQl\Config\Element\Field;
use Magento\Framework\GraphQl\Exception\GraphQlInputException;
use Magento\Framework\GraphQl\Exception\GraphQlNoSuchEntityException;
use Magento\Framework\GraphQl\Query\ResolverInterface;
use Magento\Framework\GraphQl\Schema\Type\ResolveInfo;
use Kpyxal\MutationGraphql\Api\TestRepositoryInterface;
use Kpyxal\MutationGraphql\Api\Data\TestInterface;


class FormDataSave implements ResolverInterface
{
    private $contactusDataProvider;

    /**
     * @param
     */
    public function __construct(
        TestRepositoryInterface $testRepository,
        TestInterface $testInterface
    ) {
        $this->_testRepository=$testRepository;
        $this->_testModel = $testInterface;
    }

    /**
     * @inheritdoc
     */
    public function resolve(
        Field $field,
        $context,
        ResolveInfo $info,
        array $value = null,
        array $args = null
    ) {

        $name = $args['input']['name'];
        $number = $args['input']['number'];
        $email = $args['input']['email'];
        $password = $args['input']['password'];
        $gender = $args['input']['gender'];
        $bdate = $args['input']['bdate'];

        $this->_testModel->setName($name);
        $this->_testModel->setNumber($number);
        $this->_testModel->setEmail($email);
        $this->_testModel->setPassword($password);
        $this->_testModel->setGender($gender);
        $this->_testModel->setBdate($bdate); 
        $thanks_message = [];

        try {
            $this->_testRepository->save($this->_testModel);
            $thanks_message['success_message']="Successfully Added";
        } catch (CouldNotSaveException $e) {
            $thanks_message['success_message']="Something went wrong.";
        }
        return $thanks_message;
    }
}

Here in above resolver file we used:-


Kpyxal\MutationGraphql\Api\TestRepositoryInterface;
Kpyxal\MutationGraphql\Api\Data\TestInterface;

Additionally, the repository and interface file are designed to save fields such as email, name, and number.
Step 6 :- Final step you check output. Run this query

mutation {
    contactusFormSubmit(
        input:{
            name: "KPYXAL"
            number: "+123456798"
            email: "TEST@TEST.COM"
            password: "pass@123"
            gender: "1"
            bdate: "28/08/2222"       
        }
    ){
        success_message
    }
}

To sum up, mutations in GraphQL are essential for altering data within your application. They not only allow for the creation, update, or deletion of objects but also offer flexibility through various elements such as operation names and input objects. While mutations function akin to POST, PUT, and DELETE requests in REST, their integration with GraphQL’s robust query language provides a powerful toolset for managing data efficiently. As we continue to explore GraphQL, ultimately, understanding these components will help, significantly, in harnessing the full potential of this dynamic query language.
Happy Coding ..! 😉

Check more blogs like this:

The post Mutation in GRAPHQL appeared first on Kpyxal Solutions LLP.

]]> https://www.kpyxal.com/magento/mutation-in-graphql/feed/ 0 Magento2 Query in GRAPHQL https://www.kpyxal.com/magento/graphql/query-in-graphql/ https://www.kpyxal.com/magento/graphql/query-in-graphql/#respond Mon, 20 Feb 2023 05:32:36 +0000 https://www.kpyxal.com/?p=84 Magento2 Query in GRAPHQL retrieves data from the application server similar to a REST GET call. Additionally, Adobe Commerce and Magento Open Source GraphQL queries enable mobile apps or browsers to display a diverse range of information, including: Implementation Magento2 Query in GRAPHQL Built into Magento 2.4, GraphQL support simplifies data retrieval. The following sections […]

The post Magento2 Query in GRAPHQL appeared first on Kpyxal Solutions LLP.

]]> Magento2 Query in GRAPHQL retrieves data from the application server similar to a REST GET call. Additionally, Adobe Commerce and Magento Open Source GraphQL queries enable mobile apps or browsers to display a diverse range of information, including:

  • A set of products to be displayed. This can include the entire catalog or those that match customer-specified criteria.
  • A customer token allows a query to access basic information, billing and shipping addresses, wish lists, order history, and other sensitive data. Moreover, GraphQL can also retrieve shopping cart contents for both guest and logged-in customers
  • Shopping cart contents. GraphQL supports both guest and logged-in customer carts.
  • Store configuration values, including theme and CMS settings, the currency code, and supported countries.

Implementation Magento2 Query in GRAPHQL

Built into Magento 2.4, GraphQL support simplifies data retrieval. The following sections will detail the step-by-step implementation process and provide an example of a Magento2 Query in GRAPHQL.

Step 1 :- You Create registration.php file

<?php
/**
 * @author KPYXAL
 * @copyright Copyright (c) 2021
 * @package Kpyxal_GraphqlQuery
 */

\Magento\Framework\Component\ComponentRegistrar::register(
    \Magento\Framework\Component\ComponentRegistrar::MODULE,
    'Kpyxal_GraphqlQuery',
    __DIR__
);

Step 2 :- create etc/module.xml file

<?xml version="1.0"?>
<!--
/**
 * @author KPYXAL
 * @copyright Copyright (c) 2021
 * @package Kpyxal_GraphqlQuery
 */
-->

<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:noNamespaceSchemaLocation="urn:magento:framework:Module/etc/module.xsd">
    <module name="Kpyxal_GraphqlQuery" >
        <sequence>
            <module name="Magento_Customer"/>
            <module name="Magento_Authorization"/>
            <module name="Magento_GraphQl"/>
        </sequence>
    </module>
</config>

Step 3 :- GraphQL queries are declared under etc/schema.graphqls

type Query {
    formdata: [Formdata] @resolver(class:"Kpyxal\\GraphqlQuery\\Model\\Resolver\\ProductsResolver") @doc(description:"The formdata query returns information about a customer")
}
type Formdata @doc(description: "Formdata defines the customer name and other details") {
    name: String @doc(description: "Get Name")
    number: String @doc(description: "Get Number")
    email: String @doc(description: "Get Email")
    password: String @doc(description: "Get Password")
    gender: Int @doc(description: "Get Gender")
    bdate: String @doc(description: "Get Birth Date")
}

In the above file, the file specifies that ‘type Query’ declares the query operations for our module; furthermore, it highlights the structure and functionality that are essential for proper implementation.

‘formdata’ represents the query name, while ‘type Formdata’ outlines the query’s structure, including the resolver (@resolver) class and documentation (@doc).

formdata: [Formdata]  :  if we need array of data than need to put identity in array like:-
name of query = [ Identity name ].
Here identity name is Formdata same name which we are use in : type Formdata 

Step 4 :- Create Resolver Class Model/Resolver/ProductsResolver.php

<?php
declare(strict_types=1);

namespace Kpyxal\GraphqlQuery\Model\Resolver;

use Magento\Framework\Exception\NoSuchEntityException;
use Magento\Framework\GraphQl\Config\Element\Field;
use Magento\Framework\GraphQl\Exception\GraphQlInputException;
use Magento\Framework\GraphQl\Exception\GraphQlNoSuchEntityException;
use Magento\Framework\GraphQl\Query\ResolverInterface;
use Magento\Framework\GraphQl\Schema\Type\ResolveInfo;
use Kpyxal\GraphqlQuery\Model\ResourceModel\Test\Collection;

/**
 * Product collection resolver
 */
class ProductsResolver implements ResolverInterface
{
    public function __construct(
        \Magento\Framework\Api\SearchCriteriaBuilder $searchCriteriaBuilder,
        Collection $collection
    ) {
        $this->searchCriteriaBuilder = $searchCriteriaBuilder;
        $this->collection = $collection;
    }

    /**
     * @inheritdoc
     */
    public function resolve(
        Field $field,
        $context,
        ResolveInfo $info,
        array $value = null,
        array $args = null
    ) {
        $alldata = $this->getAllData();
        $arraydata= [];
        if (count($alldata) > 0):
            foreach ($alldata as $data):
                 $arraydata[] = array(
                            'name'=>$data->getName(),
                            'number'=>$data->getNumber(),
                            'email'=>$data->getEmail(),
                            'password'=>$data->getPassword(),
                            'gender'=>$data->getGender(),
                            'bdate'=>$data->getBdate()
                        );
            endforeach;
        endif;
        return $arraydata;
    }

    /**
     * @return Collection
     */
    public function getAllData()
    {
        return $this->collection;
    }
}

The resolver file utilizes

Kpyxal\GraphqlQuery\Model\ResourceModel\Test\Collection

to gather data. This data is then assigned to variables including name, number, and email.

{
    formdata{
        name
        number
        email
        password
        gender
        bdate
    }
}

In conclusion, Magento2 Query in GRAPHQL offer a powerful way to retrieve data from the application server, similar to a REST GET call. They provide flexibility in accessing a wide range of information; consequently, enabling mobile apps or browsers to render content efficiently, making it an ideal solution for modern, headless commerce applications.

Happy Coding ..! 😉

Check More Like This

–Magento 2.4.5 Installation on ubuntu

The post Magento2 Query in GRAPHQL appeared first on Kpyxal Solutions LLP.

]]> https://www.kpyxal.com/magento/graphql/query-in-graphql/feed/ 0 Magento 2.4.5 Installation on ubuntu https://www.kpyxal.com/magento/magento-2-4-5-installation-on-ubuntu/ https://www.kpyxal.com/magento/magento-2-4-5-installation-on-ubuntu/#respond Wed, 15 Feb 2023 16:32:27 +0000 http://www.kpyxal.com/?p=7 Magento 2.4.5 Installation on Ubuntu: First, check Magento 2 requirements. Subsequently, based on the requirements, install third-party software dependencies. After that, here, we install Magento 2.4.5 with sample data. Here’s a step by step procedure will probably save you a headache. let’s start… 1. Apache Installation (Version 2.4) To begin with, run the following commands […]

The post Magento 2.4.5 Installation on ubuntu appeared first on Kpyxal Solutions LLP.

]]> Magento 2.4.5 Installation on ubuntu

Magento 2.4.5 Installation on Ubuntu: First, check Magento 2 requirements. Subsequently, based on the requirements, install third-party software dependencies. After that, here, we install Magento 2.4.5 with sample data.

Here’s a step by step procedure will probably save you a headache. let’s start…

1. Apache Installation (Version 2.4)

To begin with, run the following commands to install Apache on your system:

sudo apt update

sudo apt install apache2

check apache version:

apache2 -v

2. PHP Installation (Version 8.1)

Next, run the following commands to install PHP on your system:

sudo apt-get install software-properties-common
sudo add-apt-repository ppa:ondrej/php
sudo apt update
sudo apt install php8.1 php8.1-common php8.1-mysql php8.1-gmp php8.1-curl php8.1-intl php8.1-mbstring php8.1-xmlrpc php8.1-gd php8.1-xml php8.1-cli php8.1-zip php8.1-soap php8.1-bcmath php8.1-fpm

Note: Additionally, ensure that there are no extra spaces while running the above command.

3. Download Curl, GIT and composer(Version 2.2)

First, run the following commands to install curl and git on your system. Additionally, ensure these tools are up-to-date to avoid any potential issues during the installation process.

sudo apt install curl git

Next, install Composer (version 2.2) using the following command. After installation, verify the Composer version to ensure it is correctly set up and ready for use.

curl -sS https://getcomposer.org/installer | sudo php -- --install-dir=/usr/local/bin --filename=composer

4. Elasticsearch Installation and configuration(Version 7.17)

Follow the below command one by one:

sudo apt install curl
sudo curl -sSfL https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo gpg --no-default-keyring --keyring=gnupg-ring:/etc/apt/trusted.gpg.d/magento.gpg --import
sudo sh -c 'echo "deb https://artifacts.elastic.co/packages/7.x/apt stable main" > /etc/apt/sources.list.d/elastic-7.x.list'
sudo chmod 666 /etc/apt/trusted.gpg.d/magento.gpg
sudo apt update
sudo apt install elasticsearch

5. MySQL Installation (Version 8.0)

Then, run the following commands to install MySQL on your system. After installation, first, configure MySQL settings in order to optimize performance and secure your database environment.

-> sudo apt update
-> sudo apt install mysql-server

If MySQL is already installed on your system, first check its version using the following command. This step, therefore, ensures you are working with a compatible version for your setup and, in turn, can help avoid any version-related issues.

-> sudo mysql;

If you are using older version then requirement, then upgrade it using the Following command in terminal.

=> wget -c https://dev.mysql.com/get/mysql-apt-config_0.8.11-1_all.deb
=> sudo dpkg -i mysql-apt-config_0.8.11-1_all.deb
=> sudo apt-get update
=> sudo apt-get install mysql-server

Now, you have required MySql version in your system.

6. Create DB for Magento

After installing MySql, create a new DataBase and its user for magento website. Firstly, follow the below steps:
=> Go to the mysql shell without password: 

sudo mysql -u root

=> Once you are logged in, then start creating database.

mysql> CREATE DATABASE magentodb;

7. Magento 2.4.5 Installation and Downloading on ubuntu

Go to your directory where you want to install your magento. In this case, we are installing it in /var/www/html directory using below command:
-> cd /var/www/html
We are going to install Magento 2.4.4 using composer. Firstly, you will require an access key for the next step.

Create an account at magento MarketPlace and create an access key. Once you have an access key, then run the command in the terminal in order to Magento 2.4.5 Installation on ubuntu.

-> sudo composer create-project --repository-url=https://repo.magento.com/ magento/project-community-edition=2.4.5 magento2.4.5


This will ask username and password. Additionally, you have your access key which you taken from market place. Therefore, enter it.
username = public key
password = private key
Now, you have a magento2.4.5 folder in /var/www/html directory. Therefore, go to the Magento 2.4.5 directory:
-> cd magento2.4.5

After download, Start running the following command to install magento2.4.5.

->sudo bin/magento setup:install --base-url-secure=https://local.magento.com/ --db-host=localhost --db-name=magentodb --db-user=root --db-password= --admin-firstname=Admin --admin-lastname=User --admin-email=admin@example.com --admin-user=admin --admin-password=admin123 --language=en_US --currency=USD --timezone=America/Chicago --use-rewrites=1

Give the permission using below command:

-> sudo chown -R www-data:www-data /var/www/html/magento2.4.5
-> sudo chmod -R 755 /var/www/html/magento2.4.5

8. Configuring Apache for Magento:

Run following command to create virtual host:

-> sudo nano /etc/apache2/sites-available/local.magento.com.conf

Now, add file content in the space that you see.

<VirtualHost *:80>
ServerAdmin webmaster@localhost
DocumentRoot /var/www/html/magento2.4.5
ServerName local.magento.com
ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
<Directory "/var/www/html/magento2.4.5">
AllowOverride all
</Directory>
</VirtualHost>

Next, run below command to enable site:
-> sudo a2ensite local.magento.com.conf

Restart Apache2 using following command:
-> sudo systemctl restart apache2

Open gedit and update file content using following steps:
-> sudo gedit /etc/hosts
-> add content :-> 127.0.0.1 local.magento.com

Open URL: local.magento.com
To deploy Magento without sample data, you can set up the website using the standard installation process.However, If you later decide to add sample data then run the following command to deploy it. Consequently, This allows you to customize the initial setup and integrate sample data as needed.

-> bin/magento sampledata:deploy

9. Full deployment

Complete Magento 2.4.5 Installation on ubuntu using following commands:

-> bin/magento setup:upgrade
-> bin/magento setup:di:compile
-> bin/magento setup:static-content:deploy -f
-> bin/magento cache:flush
-> bin/magento cache:clean
-> bin/magento indexer:reindex

Happy Coding ..! 😉

Check more like this:

– Mutation in GRAPHQL

–Query in GRAPHQL

The post Magento 2.4.5 Installation on ubuntu appeared first on Kpyxal Solutions LLP.

]]> https://www.kpyxal.com/magento/magento-2-4-5-installation-on-ubuntu/feed/ 0