Showing posts with label Reactjs. Show all posts
Showing posts with label Reactjs. Show all posts

Friday, 19 January 2024

How to Use jQuery Datatables in React.js using PHP with Server-side Processing


Introduction:


In the dynamic landscape of web development, harnessing the power of React.js along with jQuery DataTables can elevate your project's user interface and functionality. This tutorial will walk you through the seamless integration of jQuery DataTables in React.js, using PHP for efficient server-side processing. Follow these steps to enhance your web application's performance and deliver a smoother user experience.


How to Use jQuery Datatables in React.js using PHP with Server-side Processing




Step 1: Setting up Your React.js Project


Start by creating a new React application, so here in this tutorial, we have already describe step by step to install React JS Application under this React JS CRUD Application tutorial.

Step 2: Installing jQuery DataTables


Once we have set up React JS application in our computer, so next we have to download and install necessary dependencies in our React.js Application. So here we have to install jQuery, jQuery DataTables, Bootstrap 5 and Bootstrap 5 theme for DataTables. So for download and install this dependencies, we have goes to terminal and then after goes into our directory and run this NPM command.






npm install jquery
npm install bootstrap
npm install datatables.net
npm install datatables.net-bs5


Step 3: Creating a React Component for DataTables


Create a new component for DataTables integration. This component will serve as the foundation for displaying and managing your data:

src/Component/Datatables.jsx

import React, { useEffect } from 'react';

import $ from 'jquery';
import 'bootstrap/dist/css/bootstrap.min.css';
import 'datatables.net-bs5/css/dataTables.bootstrap5.min.css';
import 'datatables.net-bs5';

const Datatables = () => {

	useEffect(() => {

		const dataTable = $('#datatable').DataTable({
			serverSide : true,
			processing : true,
			ajax : {
				url : 'http://localhost/tutorial/php-react-js-datatables/api/get.php',
				type : 'POST'
			},
			columns : [
				{ title : 'ID', data : 'user_id' },
				{ title : 'Name', data : 'user_name'},
				{ title : 'Email', data : 'user_email' }
			]
		});

		return () => {
			dataTable.destroy();
		};

	}, []);

	return (
		<div className="container">
			<h1 className="mt-5 mb-5 text-center"><b>DataTables in React JS with PHP MySQL Server-Side Processing</b></h1>
			<div className="card">
				<div className="card-header">DataTables in React JS with PHP MySQL Server-Side Processing</div>
				<div className="card-body">
					<table className="table table-bordered" id="datatable">
						<thead>
							<tr>
								<th>ID</th>
          						<th>Name</th>
          						<th>Email</th>
							</tr>
						</thead>
						<tbody></tbody>
					</table>
				</div>
			</div>
		</div>
	);

};

export default Datatables;


Step 4: Import DataTables Component


Let's add the DataTables component to the App.jsx file in your React.js project.

src/App.jsx

import { useState } from 'react'
/*import reactLogo from './assets/react.svg'
import viteLogo from '/vite.svg'
import './App.css'*/
import Datatables from './Component/Datatables';

function App() {
  

  return (
    <div>
        <Datatables />
    </div>
  )
}

export default App



In this tutorial, we import the DataTables and use it within the App component. This way, your DataTables component will be rendered when you run your React application.

Remember to adjust the import path if your DataTables.jsx is in a different directory. After making these changes, your React app should now successfully display the DataTable component.

Step 5: Implementing PHP Server-side Processing


For optimal handling of extensive datasets, implement server-side processing using PHP. Create a dedicated PHP script at api/get.php to fetch and process your data efficiently:

api/get.php

<?php

//get.php

header("Access-Control-Allow-Origin:* ");
header("Access-Control-Allow-Headers: *");
header("Access-Control-Allow-Methods: *");

$connect = new PDO("mysql:host=127.0.0.1;dbname=testing", "root", "password");

$columns = array(
	'user_id',
    'user_name',
    'user_email'
);

$query = "SELECT user_id, user_name, user_email FROM users";

$totalRecordStatement = $connect->prepare($query);
$totalRecordStatement->execute();
$totalRecord = $totalRecordStatement->rowCount();

if(isset($_POST['search']['value']))
{
	$query .= ' WHERE user_id LIKE "%'.$_POST["search"]["value"].'%" ';
	$query .= 'OR user_name LIKE "%'.$_POST["search"]["value"].'%" ';
	$query .= 'OR user_email LIKE "%'.$_POST["search"]["value"].'%" ';
}

if(isset($_POST['order']))
{
	$query .= 'ORDER BY ' . $columns[$_POST['order']['0']['column']] . ' ' . $_POST['order']['0']['dir'] . ' ';
}
else
{
	$query .= 'ORDER BY user_id DESC ';
}

$filteredRecordStatement = $connect->prepare($query);
$filteredRecordStatement->execute();
$filteredRecord = $filteredRecordStatement->rowCount();

if($_POST['length'] != -1)
{
	$query .= 'LIMIT ' .  $_POST['start'] . ', ' . $_POST['length'];
}

$statement = $connect->prepare($query);
$statement->execute();
$data = $statement->fetchAll(PDO::FETCH_ASSOC);

$response = array(
	'draw'				=>	intval($_POST['draw']),
	'recordsTotal'		=>	$totalRecord,
	'recordsFiltered'	=>	$filteredRecord,
	'data'				=>	$data
);

echo json_encode($response);

?>


Conclusion:


You've successfully integrated jQuery DataTables with React.js using PHP for server-side processing. This comprehensive guide empowers you to create data-driven web applications with enhanced user interfaces and optimized performance. Experiment with DataTables options and React.js features to elevate your development projects.







Monday, 25 December 2023

How to Make Dynamic Cascading Dropdown Box in React JS with PHP


Introduction


In this tutorial, we'll explore how to create a dynamic cascading dropdown box using React JS for the front end and PHP for the back end. Cascading dropdowns provide a user-friendly way to filter and select data based on choices made in previous dropdowns.


How to Make Dynamic Cascading Dropdown Box in React JS with PHP


Prerequisites


Before we dive into the tutorial, make sure you have the following installed:

  • Node.js and npm for React development
  • A code editor (e.g., Visual Studio Code, Sublime Text)
  • PHP and a web server (e.g., Apache)

MySQL Database for Cascading Dropdown box


Below you can find country_state_city table sql query. So you have to run this query in your local mysql database which will be used under this Dyanmic Dependent Select box in React.js tutorial.


--
-- Table structure for table `country_state_city`
--
CREATE TABLE `country_state_city` (
  `id` int NOT NULL AUTO_INCREMENT,
  `country` varchar(250) NOT NULL,
  `state` varchar(250) NOT NULL,
  `city` varchar(250) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=23 DEFAULT CHARSET=latin1;

INSERT INTO `country_state_city` VALUES (1,'USA','New York','New York city'),(2,'USA','New York','Buffalo'),(3,'USA','New York','Albany'),(4,'USA','Alabama','Birmingham'),(5,'USA','Alabama','Montgomery'),(6,'USA','Alabama','Huntsville'),(7,'USA','California','Los Angeles'),(8,'USA','California','San Francisco'),(9,'USA','California','San Diego'),(10,'Canada','Ontario','Toronto'),(11,'Canada','Ontario','Ottawa'),(12,'Canada','British Columbia','Vancouver'),(13,'Canada','British Columbia','Victoria'),(14,'Australia','New South Wales','Sydney'),(15,'Australia','New South Wales','Newcastle'),(16,'Australia','Queensland','City of Brisbane'),(17,'Australia','Queensland','Gold Coast\r\n'),(18,'India','Delhi','New Delhi'),(19,'India','Gujarat','Ahmedabad'),(20,'India','Gujarat','Vadodara'),(21,'India','Maharashtra','Mumbai'),(22,'India','Maharashtra','Pune');





Create React App


Start by creating a new React application, so here in this tutorial, we have already describe step by step to install React JS Application under this React JS CRUD Application tutorial.

Create Dropdown Components


Build components for dynamic cascading dropdown. In this component we will build Country, State and City Select box and then convert into dynamic dependent cascading select box which you can seen below. Here we have make DynamicDropdown.jsx component under this src/Component directory.

src/Component/DynamicDropdown.jsx

import React, { useState, useEffect } from 'react'

function DynamicDropdown(){

	const [countries, setCountries] = useState([]);

	const [states, setStates] = useState([]);

	const [cities, setCities] = useState([]);

	const handleCountryChange = async (event) => {
		const selectedCountry = event.target.value;
		const response = await fetch(`http://localhost/tutorial/dynamic_dependent_dropdown_box/api/fetch.php?country=${selectedCountry}`);
		const data = await response.json();
		setStates(data);
		setCities([]);
	};

	const handleStateChange = async (event) => {
		const selectedState = event.target.value;
		const response = await fetch(`http://localhost/tutorial/dynamic_dependent_dropdown_box/api/fetch.php?state=${selectedState}`);
		const data = await response.json();
		setCities(data);
	};

	useEffect(() => {

		const fetchCountries = async () => {
			const response = await fetch('http://localhost/tutorial/dynamic_dependent_dropdown_box/api/fetch.php');

			const data = await response.json();

			setCountries(data);
		};

		fetchCountries();

	}, []);

	return (

		<div className="container">
            <h1 className="mt-5 mb-5 text-primary text-center"><b>Dynamic Dependent Dropdown Box in React.js</b></h1>

            <div className="card">
                <div className="card-header">Dynamic Dependent Dropdown Box in React.js</div>
                <div className="card-body">
                	<div className="mb-3">
                		<select className="form-select" onChange={handleCountryChange}>
                			<option value="">Select Country</option>
                			{
                				countries.map((country, index) => (
                					<option key={index} value={country.country}>{country.country}</option>
                				))
                			}
                		</select>
                	</div>
                	<div className="mb-3">
                		<select className="form-select" onChange={handleStateChange}>
                			<option value="">Select State</option>
                			{
                				states.map((state, index) => (
                					<option key={index} value={state.state}>{state.state}</option>
                				))
                			}
                		</select>
                	</div>
                	<div className="mb-3">
                		<select className="form-select">
                			<option value="">Select City</option>
                			{
                				cities.map((city, index) => (
                					<option key = {index} value={city.city}>{city.city}</option>
                				))
                			}
                		</select>
                	</div>
                </div>
            </div>
        </div>

	)

}

export default DynamicDropdown;





Below this you can find details description of above provided React JS Component code.


import React, { useState, useEffect } from 'react'


This line imports the necessary modules from the React library. It includes the useState and useEffect hooks, which are essential for managing state and performing side effects in functional components.


function DynamicDropdown() {


This declares a functional component named DynamicDropdown. Functional components are a type of React component that use JavaScript functions to define the behavior of the component.


const [countries, setCountries] = useState([]);
const [states, setStates] = useState([]);
const [cities, setCities] = useState([]);


These lines use the useState hook to create state variables (countries, states, and cities) and their corresponding setter functions. These states will store the data for countries, states, and cities selected by the user.


const handleCountryChange = async (event) => {
		const selectedCountry = event.target.value;
		const response = await fetch(`http://localhost/tutorial/dynamic_dependent_dropdown_box/api/fetch.php?country=${selectedCountry}`);
		const data = await response.json();
		setStates(data);
		setCities([]);
	};


This function (handleCountryChange) is an event handler that gets triggered when the value of the country dropdown changes. It fetches data from the server based on the selected country and updates the states state. It also resets the cities state to an empty array.


const handleStateChange = async (event) => {
		const selectedState = event.target.value;
		const response = await fetch(`http://localhost/tutorial/dynamic_dependent_dropdown_box/api/fetch.php?state=${selectedState}`);
		const data = await response.json();
		setCities(data);
	};


Similar to handleCountryChange, this function (handleStateChange) is an event handler triggered when the state dropdown value changes. It fetches data from the server based on the selected state and updates the cities state.


useEffect(() => {
		const fetchCountries = async () => {
			const response = await fetch('http://localhost/tutorial/dynamic_dependent_dropdown_box/api/fetch.php');
			const data = await response.json();
			setCountries(data);
		};

		fetchCountries();
	}, []);


The useEffect hook is used here to fetch the list of countries when the component mounts. It calls the fetchCountries function, which makes an asynchronous request to the server and updates the countries state.


return (
		<div className="container">
            <h1 className="mt-5 mb-5 text-primary text-center"><b>Dynamic Dependent Dropdown Box in React.js</b></h1>
            {/* ... */}
		</div>
	)


This is the JSX part of the component. It returns the structure of the component, including HTML elements and React components. The UI contains three dropdowns for selecting country, state, and city, and it includes the necessary event handlers (onChange) for each dropdown.


export default DynamicDropdown;


Finally, this exports the DynamicDropdown component as the default export from this module, making it available for use in other parts of the application.

In summary, this React component creates a dynamic dependent dropdown box where the options in the state and city dropdowns change based on the selected country and state, respectively. The data is fetched from a server using asynchronous requests, and the component uses the useState and useEffect hooks to manage and update its state.

Import Cascading Component in App.jsx

Now we want to import Cascading Component in main React JS Application file which you seen below.

src/App.jsx

import { useState } from 'react'
import 'bootstrap/dist/css/bootstrap.min.css'
/*import reactLogo from './assets/react.svg'
import viteLogo from '/vite.svg'
import './App.css'*/
import DynamicDropdown from './Component/DynamicDropdown'

function App() {
  

   return (
      
      <div>
         <DynamicDropdown />
      </div>

  )
}

export default App


Let's break down the provided App.jsx file code line by line:


import { useState } from 'react'


This line imports the useState hook from the React library. In this particular file, it seems unused, so you might consider removing it unless you plan to use state in this component.


import 'bootstrap/dist/css/bootstrap.min.css'


This line imports the Bootstrap CSS styles. Bootstrap is a popular front-end framework for building responsive and visually appealing web applications. The inclusion of this line suggests that the application may use Bootstrap styles for UI components.


import DynamicDropdown from './Component/DynamicDropdown'


This line imports the DynamicDropdown component from the specified file path. The DynamicDropdown component is likely the one you described in a previous section, responsible for rendering a dynamic dependent dropdown box.


return (
    <div>
      <DynamicDropdown />
    </div>
  )


This is the body of the App component. It returns JSX code, which represents the structure of the component. In this case, it renders a div that contains the DynamicDropdown component.

In summary, this App.jsx file appears to be a simple React application entry point. It imports the necessary dependencies, including the Bootstrap styles and the DynamicDropdown component, and renders the DynamicDropdown component within a div. This structure suggests that the main functionality or UI of the application is encapsulated within the DynamicDropdown component.

Setting Up PHP Backend


Create a new PHP file under api, fetch.php, to fetch data from the server.


<?php

//fetch.php

header("Access-Control-Allow-Origin:* ");
header("Access-Control-Allow-Headers: *");
header("Access-Control-Allow-Methods: *");

$connect = new PDO("mysql:host=127.0.0.1;dbname=testing", "root", "password");

if(isset($_GET['country']))
{
	$query = "SELECT DISTINCT state FROM country_state_city WHERE country = ?";
	$statement = $connect->prepare($query);
	$statement->execute([$_GET['country']]);
	$states = $statement->fetchAll(PDO::FETCH_ASSOC);
	echo json_encode($states);
}
else if(isset($_GET['state']))
{
	$query = "SELECT DISTINCT city FROM country_state_city WHERE state = ?";
	$statement = $connect->prepare($query);
	$statement->execute([$_GET['state']]);
	$cities = $statement->fetchAll(PDO::FETCH_ASSOC);
	echo json_encode($cities);
}
else
{
	$query = "SELECT DISTINCT country FROM country_state_city";
	$statement = $connect->query($query);
	$countries = $statement->fetchAll(PDO::FETCH_ASSOC);
	echo json_encode($countries);
}


?>


This PHP code serves as the backend script for handling requests related to dynamic dependent dropdowns. Let's break it down line by line:


header("Access-Control-Allow-Origin:* ");
header("Access-Control-Allow-Headers: *");
header("Access-Control-Allow-Methods: *");


These lines set the HTTP headers to enable Cross-Origin Resource Sharing (CORS). CORS headers are essential when your frontend and backend are hosted on different domains to allow requests from the frontend to the backend.


$connect = new PDO("mysql:host=127.0.0.1;dbname=testing", "root", "password");


This line establishes a connection to a MySQL database using the PDO (PHP Data Objects) extension. Adjust the connection parameters (host, dbname, root, password) according to your database configuration.


if(isset($_GET['country']))
{
	$query = "SELECT DISTINCT state FROM country_state_city WHERE country = ?";
	$statement = $connect->prepare($query);
	$statement->execute([$_GET['country']]);
	$states = $statement->fetchAll(PDO::FETCH_ASSOC);
	echo json_encode($states);
}


This block checks if the request includes a 'country' parameter. If true, it prepares and executes a SQL query to fetch distinct states based on the provided country. The fetched data is then encoded in JSON format and echoed back to the client.


else if(isset($_GET['state']))
{
	$query = "SELECT DISTINCT city FROM country_state_city WHERE state = ?";
	$statement = $connect->prepare($query);
	$statement->execute([$_GET['state']]);
	$cities = $statement->fetchAll(PDO::FETCH_ASSOC);
	echo json_encode($cities);
}


This block checks if the request includes a 'state' parameter. If true, it prepares and executes a SQL query to fetch distinct cities based on the provided state. The fetched data is then encoded in JSON format and echoed back to the client.


else
{
	$query = "SELECT DISTINCT country FROM country_state_city";
	$statement = $connect->query($query);
	$countries = $statement->fetchAll(PDO::FETCH_ASSOC);
	echo json_encode($countries);
}


If neither 'country' nor 'state' parameters are present in the request, this block executes a SQL query to fetch distinct countries. The fetched data is encoded in JSON format and echoed back to the client.

Run React JS Application


After follow all above step now we need to check output in the browser. So we have goes to terminal and goes into our working directory and run following command.


npm run dev





Once you have run this command then it will start server and provide base url of our React App. So you have to open that url in browser and you can able to view React.js Cascading Dropdown box on web page.

Conclusion


Congratulations! You've successfully created a dynamic cascading dropdown box in React JS with PHP. Feel free to adapt and expand upon this tutorial based on your specific needs.





Sunday, 17 December 2023

A Beginner's Guide to Implementing File Uploads in React.js with PHP Backend


If you're diving into the world of web development with React.js and need to incorporate file uploads into your project, you're in the right place. This guide will walk you through the process step by step, utilizing a PHP backend API. By the end, you'll have a solid understanding of how to implement file uploads seamlessly in your React.js application.

Prerequisites


Before we get started, make sure you have the following installed:

  • Node.js and npm (Node Package Manager)
  • React.js development environment set up
  • A PHP server for the backend (e.g., XAMPP, WampServer, or any other PHP server of your choice)

A Beginner's Guide to Implementing File Uploads in React.js with PHP Backend






Step 1: Set Up Your React.js App


First we have to create React App in our local computer. So if you want to know how to install React App then you you have to follow this React.js Crud Application Tutorial. In which you can find step by step guid for download and install dependencies in our React Application.

Step 2: Install Dependencies


Install the necessary packages for file handling in React:


npm install bootstrap


Step 3: Create a File Upload Component


In your src folder, there is one App.jsx in which we have create File Upload component. This component will handle the file upload functionality.

src/App.jsx

import React, { useState, useRef } from 'react';
import 'bootstrap/dist/css/bootstrap.min.css';

function App() {
	
	const [selectedFile, setSelectedFile] = useState(null);

	const [imageLink, setImageLink] = useState(null);

	const [validationError, setValidationError] = useState(null);

	const fileInputRef = useRef(null);

	const handleFileChange = (event) => {

		const file = event.target.files[0];
		if(file)
		{
			const allowedExtension = ['.jpg', '.png'];
			const selectedFileExtension = file.name.split('.').pop().toLowerCase();
			if(allowedExtension.includes('.' + selectedFileExtension))
			{
				setSelectedFile(file);
				setValidationError(null);
			}
			else
			{
				setSelectedFile(null);
				setValidationError('Invalid file extension. Please select a file with .jpg or .png extension.');
				fileInputRef.current.value = '';
			}
		}

	};

	const handleUpload = async() => {
		if(selectedFile)
		{
			const formData = new FormData();
			formData.append('file', selectedFile);
			const response = await fetch('http://localhost/tutorial/file-upload/api/upload.php', {
				method : 'POST',
				body : formData
			});

			const responseData = await response.json();
			setImageLink(responseData.image_link);
			fileInputRef.current.value = '';
		}
		else
		{
			setValidationError('Please select a file before uploading.');
		}
	};

	return (
		<div className="container">
            <h1 className="mt-5 mb-5 text-center"><b>Upload File in React.js</b></h1>

            <div className="card">
                <div className="card-header">Upload File in React.js</div>
                <div className="card-body">
                    <div className="row">
                        <div className="col col-2"><b>Select File</b></div>
                        <div className="col col-3">
                        	<input type="file" ref={fileInputRef} onChange={handleFileChange} />
                        </div>
                        <div className="col col-3">
                        	<button className="btn btn-primary" onClick={handleUpload}>Upload</button>
                        </div>
                    </div>
                    <div className="row">
                        <div className="col col-2">&nbsp;</div>
                        <div className="col col-3">
                            {validationError && (
                            	<p className="text-danger">{validationError}</p>
                            )}

                            {imageLink && (
                            	<div>
                                    <p><b>Uploaded Image : </b></p>
                                    <img src={imageLink} className="img-fluid img-thumbnail" />
                                </div>
                            )}
                        </div>
                    </div>
                </div>
            </div>
        </div>
	)
}

export default App


Import Statements:



import React, { useState, useRef } from 'react';
import 'bootstrap/dist/css/bootstrap.min.css';


  • The code imports React, which is necessary for creating React components.
  • It also imports the useState and useRef hooks from React. useState is used to manage component state, and useRef is used to create a reference to the file input element.
  • The bootstrap.min.css file is imported to apply Bootstrap styling to the component.

Functional Component Declaration:



function App() {
  // ... component logic
}


  • This code defines a functional component named App.

State Hooks:



const [selectedFile, setSelectedFile] = useState(null);
const [imageLink, setImageLink] = useState(null);
const [validationError, setValidationError] = useState(null);


  • Three state variables (selectedFile, imageLink, and validationError) are initialized using the useState hook.
  • selectedFile represents the currently selected file for upload.
  • imageLink holds the link to the uploaded image, if any.
  • validationError stores any validation error messages.

useRef Hook:



const fileInputRef = useRef(null);


  • The useRef hook is used to create a reference (fileInputRef) to the file input element. This reference will be used to manipulate the file input, such as clearing its value.

Event Handler - handleFileChange:



const handleFileChange = (event) => {
  // ... file change logic
};


handleFileChange: This function is triggered when a user selects a file using the file input. It performs validation to check the file extension and updates the state accordingly.


const file = event.target.files[0];


  • This line extracts the first file from the array of files selected by the user through the file input.

if (file) {
  // ...
}


  • This condition checks whether a file is actually selected. If not, the subsequent logic is not executed.

const allowedExtension = ['.jpg', '.png'];


  • An array (allowedExtension) is created, containing the allowed file extensions (in this case, '.jpg' and '.png').

const selectedFileExtension = file.name.split('.').pop().toLowerCase();


  • The selected file's name is split at the period ('.') to extract the file extension. It is then converted to lowercase for case-insensitive comparison.

if (allowedExtension.includes('.' + selectedFileExtension)) {
  // If allowed, set the selected file in the component state
  setSelectedFile(file);
  // Clear any previous validation error
  setValidationError(null);
} else {
  // If not allowed, set the selected file to null
  setSelectedFile(null);
  // Set a validation error message
  setValidationError('Invalid file extension. Please select a file with .jpg or .png extension.');
  // Clear the file input value to prevent submitting an invalid file
  fileInputRef.current.value = '';
}


  • This block of code checks if the selected file's extension is included in the allowedExtension array.
  • If the extension is allowed, it sets the selected file in the component state (setSelectedFile(file)) and clears any previous validation error.
  • If the extension is not allowed, it sets the selected file to null, sets a validation error message, and clears the file input value to prevent submitting an invalid file.

This handleFileChange function is designed to handle the logic when a user selects a file in the file input. It ensures that the selected file has a valid extension before updating the component state or displaying a validation error.





Event Handler - handleUpload:



const handleUpload = async () => {
  // ... file upload logic
};


  • handleUpload: This function is called when the user clicks the "Upload" button. It checks if a file is selected, and if so, it constructs a FormData object and sends a POST request to the PHP backend.

if (selectedFile) {
  // ...
} else {
  // ...
}


  • This condition checks whether a file is selected (selectedFile). If no file is selected, it executes the else block to set a validation error.

const formData = new FormData();


  • This line creates a new FormData object. FormData is used to construct a set of key/value pairs representing form fields and their values.

formData.append('file', selectedFile);


  • The selected file is appended to the FormData object with the key 'file'.

const response = await fetch('http://localhost/tutorial/file-upload/api/upload.php', {
  method: 'POST',
  body: formData
});


  • The fetch function is used to send a POST request to the specified URL (http://localhost/tutorial/file-upload/api/upload.php).
  • The request includes the method ('POST') and the body, which is set to the FormData object containing the selected file.

const responseData = await response.json();


  • The response from the server is expected to be in JSON format. This line parses the JSON data using await response.json().

setImageLink(responseData.image_link);


  • If the upload is successful, the image link returned from the server is set in the component state using setImageLink.

fileInputRef.current.value = '';


  • After a successful upload, the file input value is cleared to allow selecting a new file in the future.

setValidationError('Please select a file before uploading.');


  • If no file is selected, a validation error message is set to inform the user to select a file before attempting to upload.

This handleUpload function is responsible for sending a file to the PHP backend for upload, handling the server's response, and updating the component state accordingly. It also takes care of error handling and validation messages.

JSX Markup:



return (
		<div className="container">
            <h1 className="mt-5 mb-5 text-center"><b>Upload File in React.js</b></h1>

            <div className="card">
                <div className="card-header">Upload File in React.js</div>
                <div className="card-body">
                    <div className="row">
                        <div className="col col-2"><b>Select File</b></div>
                        <div className="col col-3">
                        	<input type="file" ref={fileInputRef} onChange={handleFileChange} />
                        </div>
                        <div className="col col-3">
                        	<button className="btn btn-primary" onClick={handleUpload}>Upload</button>
                        </div>
                    </div>
                    <div className="row">
                        <div className="col col-2">&nbsp;</div>
                        <div className="col col-3">
                            {validationError && (
                            	<p className="text-danger">{validationError}</p>
                            )}

                            {imageLink && (
                            	<div>
                                    <p><b>Uploaded Image : </b></p>
                                    <img src={imageLink} className="img-fluid img-thumbnail" />
                                </div>
                            )}
                        </div>
                    </div>
                </div>
            </div>
        </div>
	)


  • The return statement contains the JSX markup for the component.
  • The component is structured using Bootstrap classes for styling.
  • It includes a file input, an "Upload" button, and displays validation errors or the uploaded image based on the state.

Export Component



export default App;


  • The App component is exported to be used in other parts of the application.

Overall, this component provides a simple file upload form using React.js, where users can select an image file, validate its extension, and upload it to a PHP backend. The UI is styled using Bootstrap classes for a clean and responsive design.





Step 4: Set Up the PHP Backend


Create a PHP file (upload.php) in your React Application working api directory to handle file uploads. Here's a basic example:

api/upload.php

<?php

//upload.php

header("Access-Control-Allow-Origin:* ");
header("Access-Control-Allow-Headers: *");
header("Access-Control-Allow-Methods: *");

$upload_directory = '../upload/';
$file_name_array = explode(".", $_FILES['file']['name']);
$file_name = time() . '.' . end($file_name_array);
$upload_file = $upload_directory . $file_name;
$image_link = 'http://localhost/tutorial/file-upload/upload/' . $file_name;
if(!file_exists($upload_directory))
{
	mkdir($upload_directory, 0777, true);
}

if(move_uploaded_file($_FILES['file']['tmp_name'], $upload_file))
{
	echo json_encode([
		'message' => 'File uploaded successfully', 
		'image_link' => $image_link
	]);
}

?>

CORS Headers:



header("Access-Control-Allow-Origin:* ");
header("Access-Control-Allow-Headers: *");
header("Access-Control-Allow-Methods: *");


  • These lines set CORS headers to allow cross-origin requests. This is important when the frontend (React.js) and backend (PHP) are hosted on different domains.

Upload Directory and File Naming:



$upload_directory = '../upload/';
$file_name_array = explode(".", $_FILES['file']['name']);
$file_name = time() . '.' . end($file_name_array);


  • $upload_directory is set to the relative path where the uploaded files will be stored.
  • The uploaded file's name is modified to include the current timestamp, ensuring a unique filename.

Complete File Path and Image Link:



$upload_file = $upload_directory . $file_name;
$image_link = 'http://localhost/tutorial/file-upload/upload/' . $file_name;


  • The complete file path is formed using $upload_directory and $file_name.
  • An $image_link is created, representing the URL where the uploaded image can be accessed.

Create Upload Directory if Not Exists:



if (!file_exists($upload_directory)) {
    mkdir($upload_directory, 0777, true);
}


  • This block of code checks if the upload directory exists. If not, it creates the directory with full permissions.

Move Uploaded File:



if (move_uploaded_file($_FILES['file']['tmp_name'], $upload_file)) {
    // If successful, return a JSON response with a success message and the image link
    echo json_encode([
        'message' => 'File uploaded successfully',
        'image_link' => $image_link
    ]);
}


  • The move_uploaded_file function is used to move the uploaded file from its temporary location to the specified directory.
  • If the file is moved successfully, a JSON response is echoed with a success message and the image link.

This PHP script is designed to handle file uploads, create a unique filename, move the file to a specified directory, and return a JSON response with a success message and the URL of the uploaded image. It also includes CORS headers to allow cross-origin requests from the frontend.

Step 5: Run Your Applications


Start your React.js development server:


npm run dev


Start your PHP server and visit your React app in the browser. You should now be able to upload files successfully!

Congratulations! You've successfully implemented a file upload functionality in React.js using a PHP backend. Feel free to customize and expand upon this foundation to meet your specific project requirements. This guide should serve as a solid starting point for anyone looking to integrate file uploads into their React.js applications. Happy coding!





Saturday, 2 December 2023

Building a React.js CRUD Application with Vite, PHP API and MySQL

Building a React.js CRUD Application with Vite, PHP API, and MySQL


In this tutorial, we'll walk through the process of creating a full-stack CRUD (Create, Read, Update, Delete) application using React.js, Vite for the frontend, PHP for the backend, and MySQL as the database. This project will help you understand how to set up a modern development environment and integrate the different components seamlessly.

Prerequisites


Before getting started, make sure you have the following tools installed:

  • Node.js
  • npm (Node Package Manager)
  • PHP
  • Composer
  • MySQL

Steps for Create PHP React CRUD Application


  1. Installation
  2. Set Router for Fetch Data
  3. Create Fetch Data API
  4. Make Insert Data Component & Set Route
  5. Submit Form Data
  6. Set Router for Edit Data Component
  7. Make Update Data API
  8. Create Delete Data API




Step 1 - Installation


Here we have make CRUD Application by using React.js with PHP API. So first we want to download and install React.js on our local computer. So here we have use Vite tool and it is a front end tool which is used for building fast and optimized web application.

Now we want to download React Framework by using Vite. So first we have goes to command prompt and And here we have goes into directory from which we can run PHP application and for download and install React.js we have to run following command in terminal.


npm create vite@latest phpreactcrud


When you have run this command then it will create phpreactcrud directory and then after it will display JavaScript framework and from this list of framework we have to select React framework by pressing down key. And after selecting React and press enter then it has again ask for selecting JavaScript variant. So by pressing down key we have to select JavaScript and press enter.

After this, we have goes into phpreactcrud directory by run following command.


cd phpreactcrud


Inside your project directory, you'll need to install the project's dependencies using npm:


npm install


So after run this command it will start download React framework in phpreactcrud directory. Once download is complete, so we need to check React is properly install or not. So we have need to run following command.


npm run dev


When we have run this command then it will start React development server and provide us base url of our React Application. So from this url we can open React Application in the browser.

If React web page open in browser that means React is properly installed in our computer.

Directory Structure of React

Below you can find directory structure of React.js framework.


Directory Structure of React.js CRUD Application


Step 2 - Set Router for Fetch Data


This is second step for create PHP React.js CRUD application and under this step we have to set Router for Fetch Data. But before set Router for fetch data, first we have to install Bootstrap 5 library under this React CRUD Application.

So To use Bootstrap 5 in your React application, you need to install the Bootstrap package from npm. Bootstrap 5 comes with Sass, so you can take advantage of its customization features. Run the following command to install Bootstrap:


npm install bootstrap


So this command will download and install Bootstrap 5 library under this our React.js Application. Next we have to use Bootstrap library under this React CRUD Application.

So we have to open src/App.jsx file and for import the Bootstrap CSS at the top of the file:


import 'bootstrap/dist/css/bootstrap.min.css';


Next for display user data, we have to create Component/Userlist.jsx file and under this file, we want to import React, so we have to write following statement under this file.


import React from 'react';


So it will import React dependencies under this file. After this we have create React component for this Userlist by writing following code.

Component/Userlist.jsx

function Userlist(){
	return (
		<div className="card">
			<div className="card-header">
				<div className="row">
					<div className="col-md-6"><b>User Data</b></div>
					<div className="col-md-6">

					</div>
				</div>
			</div>
			<div className="card-body">
				<table className="table table-bordered">
					<thead>
						<tr>
							<th>First Name</th>
							<th>Last Name</th>
							<th>Email</th>
							<th>Action</th>
						</tr>
					</thead>
					<tbody>
					
					</tbody>
				</table>
			</div>
		</div>
	);
}


And for export this component, we have to write following code at the end of this file. So after write this code we can import this component in other file also.


export default Userlist;


Next we have open App.jsx file and under this file we have to first import React router dom library. So we have goes to command prompt and run following command. This command will download and install React router dom library under this App.jsx file.


npm install react-router-dom


After installing this library we can able to import React router dom library component like BrowserRouter, Routes, Route, Link by writing following statement under App.jsx file.


import { BrowserRouter, Routes, Route, Link } from 'react-router-dom';


BrowserRouter - Here BrowserRouter component is represents the router for your application, And it is the key component from react router dom, which provided routing functionality to react application.

Routes - Routes component is typically used to define collection of routes.

Route - Route component is used to define, individual route in your application.

Link - Link component is used for creating hyperlink, that navigate to different parts of your application.

Next we want to import Component/Userlist.jsx file under this App.jsx file. So we have to add following statement under App.jsx file.


import Userlist from './Component/Userlist';


After import React router dom library and Userlist component, in below code you can find how to define route for fetch data.

src/App.jsx

import { useState } from 'react';
import 'bootstrap/dist/css/bootstrap.min.css';
import { BrowserRouter, Routes, Route, Link } from 'react-router-dom';
import Userlist from './Component/Userlist';

function App() {
    return(
        <div className="container">
            <h1 className="mt-5 mb-5 text-center"><b>PHP React.js CRUD Application - <span className="text-primary">Create Delete Data API - 8</span></b></h1>
            <BrowserRouter>
                <Routes>
                    <Route path="/" element={<Userlist />} />
                </Routes>
            </BrowserRouter>
        </div>
    )
}

export default App



src/Component/Userlist.jsx

import React from 'react';

function Userlist(){

	return (
		<div className="card">
			<div className="card-header">
				<div className="row">
					<div className="col-md-6"><b>User Data</b></div>
					<div className="col-md-6">
						
					</div>
				</div>
			</div>
			<div className="card-body">
				<table className="table table-bordered">
					<thead>
						<tr>
							<th>First Name</th>
							<th>Last Name</th>
							<th>Email</th>
							<th>Action</th>
						</tr>
					</thead>
					<tbody>
					
					</tbody>
				</table>
			</div>
		</div>
	);
}

export default Userlist;




Step 3 - Create Fetch Data API


After set Router for Fetch Data, now we want to make PHP API for fetch data from MySQL table. But before this we have to write JavaScript under Component/Userlist.jsx file for send fetch data request to PHP API.

Source Code of Create Fetch Data API

src/Component/Userlist.jsx

import React, { useEffect, useState } from 'react';

function Userlist(){
	const [users, setUsers] = useState([]);

	useEffect(() => {
		const apiUrl = 'http://localhost/tutorial/phpreactcrud/api/action.php'; //This URL change according to path of your PHP Script

		fetch(apiUrl)
		.then((response) => response.json())
		.then((data) => {
			setUsers(data);
		});

	}, []);

	return (
		<div className="card">
			<div className="card-header">
				<div className="row">
					<div className="col-md-6"><b>User Data</b></div>
					<div className="col-md-6">
						
					</div>
				</div>
			</div>
			<div className="card-body">
				<table className="table table-bordered">
					<thead>
						<tr>
							<th>First Name</th>
							<th>Last Name</th>
							<th>Email</th>
							<th>Action</th>
						</tr>
					</thead>
					<tbody>
					{users.map((user, index) => (
						<tr key={index}>
							<td>{user.first_name}</td>
							<td>{user.last_name}</td>
							<td>{user.email}</td>
							<td>
								
							</td>
						</tr>
					))}
					</tbody>
				</table>
			</div>
		</div>
	);
}

export default Userlist;


1 - Import Statements:


import React, { useEffect, useState } from 'react';


  • The code imports the necessary functionalities from the react library.
  • useEffect is a hook used for side effects in functional components, and useState is a hook for managing state.

2 - Component Definition:


function Userlist(){


  • The functional component named Userlist is defined.

3 - State Initialization:


const [users, setUsers] = useState([]);


  • This line initializes a state variable users using the useState hook. The setUsers function is used to update the state.

4 - Data Fetching using useEffect:


useEffect(() => {
    const apiUrl = 'http://localhost/tutorial/phpreactcrud/api/action.php';

    fetch(apiUrl)
    .then((response) => response.json())
    .then((data) => {
        setUsers(data);
    });

}, []);


  • The useEffect hook is used to perform side effects in functional components. In this case, it fetches data from a specified API endpoint when the component mounts ([] as the dependency array means it runs once when the component mounts).
  • The data fetched is expected to be in JSON format, and it updates the users state with the received data.

5 - Rendering JSX:


return (
    <div className="card">
        {/* ... */}
    </div>
);


  • The return statement contains JSX code that represents the structure of the component.

6 - JSX Structure:

  • The component renders a Bootstrap-styled card with a header and body.
  • The body contains a table displaying user data with columns for "First Name," "Last Name," "Email," and an "Action" column.

7 - Mapping Through User Data:


{users.map((user, index) => (
    <tr key={index}>
        <td>{user.first_name}</td>
        <td>{user.last_name}</td>
        <td>{user.email}</td>
        <td>
            {/* Action content */}
        </td>
    </tr>
))}


  • The component maps through the users array and renders a table row (</tr>) for each user.
  • User details such as first name, last name, and email are displayed in the corresponding columns.

8 - Export Statement:


export default Userlist;


  • The Userlist component is exported as the default export of this module, making it available for use in other parts of the application.
api/action.php

<?php

header("Access-Control-Allow-Origin:* ");

header("Access-Control-Allow-Headers:* ");

header("Access-Control-Allow-Methods:* ");

$connect = new PDO("mysql:host=127.0.0.1;dbname=testing", "root", "password");

$method = $_SERVER['REQUEST_METHOD']; //return GET, POST, PUT, DELETE

if($method === 'GET')
{
	//fetch all user

		$query = "SELECT * FROM sample_users ORDER BY id DESC";

		$result = $connect->query($query, PDO::FETCH_ASSOC);

		$data = array();

		foreach($result as $row)
		{
			$data[] = $row;
		}

		echo json_encode($data);
	
}


?>


This PHP code is designed to handle HTTP requests, specifically for the GET method, and it interacts with a MySQL database to retrieve data. Let's break down the code:

1 - Cross-Origin Resource Sharing (CORS) Headers:


header("Access-Control-Allow-Origin:* ");
header("Access-Control-Allow-Headers:* ");
header("Access-Control-Allow-Methods:* ");


  • These lines set up CORS headers, allowing cross-origin requests from any origin (*). CORS headers are necessary for web applications hosted on one domain to make requests to a different domain.

2 - Database Connection:


$connect = new PDO("mysql:host=127.0.0.1;dbname=testing", "root", "password");


  • It establishes a connection to a MySQL database named "testing" on the local server (127.0.0.1). The username is "root," and the password is "password." This connection is created using the PDO (PHP Data Objects) extension.

3 - Request Method Check:


$method = $_SERVER['REQUEST_METHOD'];


  • It retrieves the HTTP request method (GET, POST, PUT, DELETE) from the $_SERVER superglobal.

4 - Handling GET Requests:


if ($method === 'GET') {
    //fetch all user
    $query = "SELECT * FROM sample_users ORDER BY id DESC";
    $result = $connect->query($query, PDO::FETCH_ASSOC);
    
    $data = array();
    foreach ($result as $row) {
        $data[] = $row;
    }
    echo json_encode($data);
}


  • If the request method is GET, the code executes a SELECT query to retrieve all records from the "sample_users" table, ordering them by the "id" column in descending order.
  • The result of the query is fetched using the query method, and the data is extracted using a foreach loop.
  • The retrieved data is then encoded as JSON using json_encode and echoed back to the client.

This PHP code handles GET requests, connects to a MySQL database, retrieves all records from a specific table, and returns the data in JSON format with appropriate CORS headers to allow cross-origin requests.




Step 4 - Make Insert Data Component & Set Route


Once we have fetch data from MySQL database and display on web page under this React.js CRUD Application. Next We will create insert data component in which we will create Add user data form, and then after we will set router of that insert data component under this React.js PHP CRUD Application.

src/Component/Add.jsx

import React, { useState } from 'react';
import { Link, useNavigate } from 'react-router-dom';

function Add(){

	let navigate = useNavigate();

	const [user, setUser] = useState({
		first_name : '',
		last_name : '',
		email : ''
	});

	const handleChange = (event) => {
		const { name, value } = event.target;

		setUser({
			...user,
			[name] : value
		});
	};

	return (
		<div className="card">
			<div className="card-header">
				<div className="row">
					<div className="col-md-6">Add User</div>
					<div className="col-md-6">
						<Link to="/" className="btn btn-success btn-sm float-end">View All</Link>
					</div>
				</div>
			</div>
			<div className="card-body">
				<div className="row">
					<div className="col-md-4">&nbsp;</div>
					<div className="col-md-4">
						<form method="POST">
							<div className="mb-3">
								<label>First Name</label>
								<input type="text" name="first_name" className="form-control" onChange={handleChange} />
							</div>
							<div className="mb-3">
								<label>Last Name</label>
								<input type="text" name="last_name" className="form-control" onChange={handleChange} />
							</div>
							<div className="mb-3">
								<label>Email</label>
								<input type="email" name="email" className="form-control" onChange={handleChange} />
							</div>
							<div className="mb-3">
								<input type="submit" className="btn btn-primary" value="Add" />
							</div>
						</form>
					</div>
				</div>
			</div>
		</div>
	);
}

export default Add;


This React.js code defines a functional component called Add that represents a form for adding a new user. It uses the useNavigate hook from react-router-dom to programmatically navigate between different views. Let's break down the code:

1 - Import Statements:


import React, { useState } from 'react';
import { Link, useNavigate } from 'react-router-dom';


  • The code imports the necessary functionalities from the react library, including the useState hook.
  • It also imports Link and useNavigate from react-router-dom. Link is used to create navigation links, and useNavigate is a hook used for programmatic navigation.

2 - Component Definition:


function Add(){


  • The functional component named Add is defined.

3 - Navigation Setup:


let navigate = useNavigate();


  • The useNavigate hook is used to get the navigate function, which can be used to navigate between different views in a React application.

4 - State Initialization:


const [user, setUser] = useState({
    first_name : '',
    last_name : '',
    email : ''
});


  • This line initializes a state variable user using the useState hook. The state represents the user data with properties first_name, last_name, and email.

5 - Event Handler Function:


const handleChange = (event) => {
    const { name, value } = event.target;

    setUser({
        ...user,
        [name] : value
    });
};


  • The handleChange function is an event handler for input changes. It uses object destructuring to extract the name and value from the changed input element.
  • The setUser function is then used to update the user state by spreading the existing state and updating the property corresponding to the changed input.

6 - Rendering JSX:


return (
    <div className="card">
        {/* ... */}
    </div>
);


  • The return statement contains JSX code that represents the structure of the component.

7 - JSX Structure:

  • The component renders a Bootstrap-styled card with a header and body.
  • The body contains a form with input fields for "First Name," "Last Name," and "Email," along with a submit button labeled "Add."

8 - Navigation Link:


<Link to="/" className="btn btn-success btn-sm float-end">View All</Link>


  • This is a Link component that creates a link to the root path ("/"). It's styled as a Bootstrap button and is labeled "View All."
  • Clicking on this link will navigate the user to the specified path.

9 - Form Input Fields:


<input type="text" name="first_name" className="form-control" onChange={handleChange} />
<input type="text" name="last_name" className="form-control" onChange={handleChange} />
<input type="email" name="email" className="form-control" onChange={handleChange} />


  • These input fields are controlled components, meaning their values are controlled by the state (user).
  • The onChange event is set to the handleChange function, ensuring that any changes to the input fields update the state.

10 - Submit Button:


<input type="submit" className="btn btn-primary" value="Add" />


  • This is a submit button for the form. It triggers the submission of the form data.

11 - Export Statement:


export default Add;


  • The Add component is exported as the default export of this module, making it available for use in other parts of the application.

This component provides a form for adding a new user. It captures input changes, updates the component state accordingly, and allows for the submission of the form data.

After creating this src/Component/Add.jsx file, now we want to import in src/App.jsx file.

src/App.jsx

import { useState } from 'react'
import 'bootstrap/dist/css/bootstrap.min.css';
import { BrowserRouter, Routes, Route, Link } from 'react-router-dom';
import Userlist from './Component/Userlist';
import Add from './Component/Add';

function App() {
    return(
        <div className="container">
            <h1 className="mt-5 mb-5 text-center"><b>PHP React.js CRUD Application - <span className="text-primary">Create Delete Data API - 8</span></b></h1>
            <BrowserRouter>
                <Routes>
                    <Route path="/" element={<Userlist />} />
                    <Route path="/add" element={<Add />} />
                </Routes>
            </BrowserRouter>
        </div>
    )
}

export default App



1 - Import Statements:


import Add from './Component/Add';


  • Component Add are imported from separate files.

2 - React Router Setup:


<BrowserRouter>
    <Routes>
        /* ... */
        <Route path="/add" element={<Add />} />
    </Routes>
</BrowserRouter>


  • The BrowserRouter component from react-router-dom is used to set up routing for the application.
  • Inside it, the Routes component defines different routes using the Route component. Two routes are defined:
    • The path /add renders the Add component.

So this way we can create Add user form component and import into App.jsx file.




Step 5 - Submit Form Data


Now you can move to How to submit form data by using React handle submit function and then after you will learn how to make PHP API for Insert Form data under this React CRUD Application.

src/Component/Add.jsx

import React, { useState } from 'react';
import { Link, useNavigate } from 'react-router-dom';

function Add(){

	let navigate = useNavigate();

	const [user, setUser] = useState({
		first_name : '',
		last_name : '',
		email : ''
	});

	const handleChange = (event) => {
		const { name, value } = event.target;

		setUser({
			...user,
			[name] : value
		});
	};

	const handleSubmit = (event) => {

		event.preventDefault();

		fetch('http://localhost/tutorial/phpreactcrud/api/action.php', {
			method : 'POST',
			headers : {
				'Content-Type' : 'application/json'
			},
			body : JSON.stringify(user)
		})
		.then((response) => response.json())
		.then((data) => {
			navigate("/");
		})

	};

	return (
		<div className="card">
			<div className="card-header">
				<div className="row">
					<div className="col-md-6">Add User</div>
					<div className="col-md-6">
						<Link to="/" className="btn btn-success btn-sm float-end">View All</Link>
					</div>
				</div>
			</div>
			<div className="card-body">
				<div className="row">
					<div className="col-md-4">&nbsp;</div>
					<div className="col-md-4">
						<form method="POST" onSubmit={handleSubmit}>
							<div className="mb-3">
								<label>First Name</label>
								<input type="text" name="first_name" className="form-control" onChange={handleChange} />
							</div>
							<div className="mb-3">
								<label>Last Name</label>
								<input type="text" name="last_name" className="form-control" onChange={handleChange} />
							</div>
							<div className="mb-3">
								<label>Email</label>
								<input type="email" name="email" className="form-control" onChange={handleChange} />
							</div>
							<div className="mb-3">
								<input type="submit" className="btn btn-primary" value="Add" />
							</div>
						</form>
					</div>
				</div>
			</div>
		</div>
	);
}

export default Add;


1 - Event Handler Function (handleSubmit):


const handleSubmit = (event) => {
    event.preventDefault();

    fetch('http://localhost/tutorial/phpreactcrud/api/action.php', {
        method : 'POST',
        headers : {
            'Content-Type' : 'application/json'
        },
        body : JSON.stringify(user)
    })
    .then((response) => response.json())
    .then((data) => {
        navigate("/");
    });
};


  • The handleSubmit function is an event handler for form submission. It prevents the default form submission behavior using event.preventDefault().
  • It then makes a POST request to the specified API endpoint ('http://localhost/tutorial/phpreactcrud/api/action.php') with the user data in JSON format.
  • Upon successful submission, it navigates the user back to the root path ("/") using the navigate function.

2 - Form onSubmit Event Handler:


<form method="POST" onSubmit={handleSubmit}>


  • The onSubmit attribute is set to the handleSubmit function.
  • This means that when the form is submitted (either by clicking a submit button or pressing Enter within a form field), the handleSubmit function will be called.
api/action.php

<?php

header("Access-Control-Allow-Origin:* ");

header("Access-Control-Allow-Headers:* ");

header("Access-Control-Allow-Methods:* ");

$connect = new PDO("mysql:host=127.0.0.1;dbname=testing", "root", "password");

$method = $_SERVER['REQUEST_METHOD']; //return GET, POST, PUT, DELETE

if($method === 'GET')
{	
	//fetch all user

	$query = "SELECT * FROM sample_users ORDER BY id DESC";

	$result = $connect->query($query, PDO::FETCH_ASSOC);

	$data = array();

	foreach($result as $row)
	{
		$data[] = $row;
	}

	echo json_encode($data);
}

if($method === 'POST')
{
	$form_data = json_decode(file_get_contents('php://input'));

	$data = array(
		':first_name'		=>	$form_data->first_name,
		':last_name'		=>	$form_data->last_name,
		':email'			=>	$form_data->email
	);

	$query = "
	INSERT INTO sample_users (first_name, last_name, email) VALUES (:first_name, :last_name, :email);
	";

	$statement = $connect->prepare($query);

	$statement->execute($data);

	echo json_encode(["success" => "done"]);
}

?>


This PHP code is a simple server-side script that handles HTTP requests, specifically for the POST method. It interacts with a MySQL database to insert data submitted through a JSON-encoded payload.


if($method === 'POST') {
    // Process POST data

    $form_data = json_decode(file_get_contents('php://input'));

    $data = array(
        ':first_name'		=>	$form_data->first_name,
        ':last_name'		=>	$form_data->last_name,
        ':email'			=>	$form_data->email
    );

    $query = "
    INSERT INTO sample_users (first_name, last_name, email) VALUES (:first_name, :last_name, :email);
    ";

    $statement = $connect->prepare($query);

    $statement->execute($data);

    echo json_encode(["success" => "done"]);
}


  • If the request method is POST, the code proceeds to handle the incoming data.
  • It uses json_decode to parse the JSON data received from the client via the php://input stream.
  • The parsed data is then used to construct an associative array $data with keys corresponding to database columns.
  • A SQL query is prepared to insert the data into the "sample_users" table.
  • The query is executed using the prepared statement, and a success message is echoed back as a JSON response.

In summary, this PHP script checks for incoming POST requests, parses the JSON data, inserts it into a MySQL database, and responds with a JSON success message.




Step 6 - Set Router for Edit Data Component


Under this step, you can find how to create Edit component under this React Crud application and then after, we will set route for that edit component, under this React Application.

src/Component/Userlist.jsx

import React, { useEffect, useState } from 'react';
import { Link } from 'react-router-dom';

function Userlist(){
	const [users, setUsers] = useState([]);

	useEffect(() => {
		const apiUrl = 'http://localhost/tutorial/phpreactcrud/api/action.php';

		fetch(apiUrl)
		.then((response) => response.json())
		.then((data) => {
			setUsers(data);
		});

	}, []);

	return (
		<div className="card">
			<div className="card-header">
				<div className="row">
					<div className="col-md-6"><b>User Data</b></div>
					<div className="col-md-6">
						<Link to="/add" className="btn btn-success btn-sm float-end">Add</Link>
					</div>
				</div>
			</div>
			<div className="card-body">
				<table className="table table-bordered">
					<thead>
						<tr>
							<th>First Name</th>
							<th>Last Name</th>
							<th>Email</th>
							<th>Action</th>
						</tr>
					</thead>
					<tbody>
					{users.map((user, index) => (
						<tr key={index}>
							<td>{user.first_name}</td>
							<td>{user.last_name}</td>
							<td>{user.email}</td>
							<td>
								<Link to={`/edit/${user.id}`} className="btn btn-warning btn-sm">Edit</Link>
							</td>
						</tr>
					))}
					</tbody>
				</table>
			</div>
		</div>
	);
}

export default Userlist;


Here We have uses the Link component from react-router-dom to create a navigation link styled as a Bootstrap button. Clicking the link navigates the user to an "edit" route with a dynamic parameter, specifically the id property of a user object. This pattern is often used to implement edit functionality in React applications.

src/Component/Edit.jsx

import React, {useState, useEffect} from 'react';

import { Link, useNavigate, useParams } from 'react-router-dom';

function Edit(){

	let navigate = useNavigate();
	
	const {user_id} = useParams();

	const [user, setUser] = useState({
		first_name : '',
		last_name : '',
		email : ''
	});

	const handleChange = (event) => {
		const {name, value} = event.target;

		setUser({
			...user,
			[name] : value
		});
	};

	const fetchUserData = () => {
		fetch(`http://localhost/tutorial/phpreactcrud/api/action.php?id=${user_id}`)
		.then((response) => response.json())
		.then((data) => {
			setUser(data);
		});
	};

	useEffect(() => {
		fetchUserData();
	}, []);

	return (
		<div className="card">
			<div className="card-header">
				<div className="row">
					<div className="col-md-6">Edit User</div>
					<div className="col-md-6">
						<Link to="/" className="btn btn-success btn-sm float-end">View All</Link>
					</div>
				</div>
			</div>
			<div className="card-body">
				<div className="row">
					<div className="col-md-4">&nbsp;</div>
					<div className="col-md-4">
						<form method="POST">
							<div className="mb-3">
								<label>First Name</label>
								<input type="text" name="first_name" className="form-control" value={user.first_name} onChange={handleChange} />
							</div>
							<div className="mb-3">
								<label>Last Name</label>
								<input type="text" name="last_name" className="form-control" value={user.last_name} onChange={handleChange} />
							</div>
							<div className="mb-3">
								<label>Email</label>
								<input type="email" name="email" className="form-control" value={user.email} onChange={handleChange} />
							</div>
							<div className="mb-3">
								<input type="submit" className="btn btn-primary" value="Edit" />
							</div>
						</form>
					</div>
				</div>
			</div>
		</div>
	)
}

export default Edit;


1 - Import Statements:


import React, {useState, useEffect} from 'react';
import { Link, useNavigate, useParams } from 'react-router-dom';


  • The code imports the necessary functionalities from the react and react-router-dom libraries.
  • useParams is used to extract parameters from the URL.

2 - Component Definition:


function Edit() {


  • The functional component named Edit is defined.

3 - Hooks and State Initialization:


let navigate = useNavigate();

const [user, setUser] = useState({
    first_name: '',
    last_name: '',
    email: ''
});


  • The useNavigate hook is used to get the navigate function for programmatic navigation.
  • The useState hook initializes the user state, representing user information with properties first_name, last_name, and email.

4 - Event Handler Function (handleChange):


const handleChange = (event) => {
    const { name, value } = event.target;

    setUser({
        ...user,
        [name]: value
    });
};

  • The handleChange function is an event handler for input changes. It updates the user state based on the changed input field.

5 - Fetch User Data Function (fetchUserData):


const fetchUserData = () => {
    fetch(`http://localhost/tutorial/phpreactcrud/api/action.php?id=${user_id}`)
        .then((response) => response.json())
        .then((data) => {
            setUser(data);
        });
};


  • The fetchUserData function uses the fetch API to retrieve user data based on the id parameter from the URL.
  • The fetched data is then used to update the user state.

6 - UseEffect Hook for Fetching Data:


useEffect(() => {
    fetchUserData();
}, []);


  • The useEffect hook is used to execute the fetchUserData function when the component mounts (empty dependency array []).
  • This ensures that user data is fetched once when the component is rendered.

Rendering JSX:


return (
    <div className="card">
        {/* ... */}
    </div>
);


  • The return statement contains JSX code that represents the structure of the component.

7 - JSX Structure:

  • The component renders a Bootstrap-styled card with a header and body.
  • The body contains a form with input fields for "First Name," "Last Name," and "Email," along with a submit button labeled "Edit."
  • The input values are controlled by the user state, ensuring that the form fields display the current user data.

9 - Navigation Link:


<Link to="/" className="btn btn-success btn-sm float-end">View All</Link>


  • This is a Link component that creates a link to the root path ("/"). It's styled as a Bootstrap button and is labeled "View All."
  • Clicking on this link will navigate the user back to the root path.

10 - Form Input Fields:


<input type="text" name="first_name" className="form-control" value={user.first_name} onChange={handleChange} />
<input type="text" name="last_name" className="form-control" value={user.last_name} onChange={handleChange} />
<input type="email" name="email" className="form-control" value={user.email} onChange={handleChange} />


  • These input fields are controlled components, meaning their values are controlled by the user state.
  • The value attribute is set to the corresponding property of the user state.
  • The onChange event is set to the handleChange function, ensuring that any changes to the input fields update the state.

11 - Submit Button:


<input type="submit" className="btn btn-primary" value="Edit" />


  • This is a submit button for the form. It triggers the submission of the form data.

12 - Export Statement:


export default Edit;


  • The Edit component is exported as the default export of this module, making it available for use in other parts of the application.

In summary, this Edit component is a form for editing user data. It uses the useEffect hook to fetch user data when the component mounts, and it provides a form with controlled input fields. The user can edit the information, and clicking the "Edit" button triggers an update operation, which is typically handled on the server side.

src/App.jsx

import { useState } from 'react';
import 'bootstrap/dist/css/bootstrap.min.css';
import { BrowserRouter, Routes, Route, Link } from 'react-router-dom';
import Userlist from './Component/Userlist';
import Add from './Component/Add';
import Edit from './Component/Edit';

function App() {
    return(
        <div className="container">
            <h1 className="mt-5 mb-5 text-center"><b>PHP React.js CRUD Application - <span className="text-primary">Create Delete Data API - 8</span></b></h1>
            <BrowserRouter>
                <Routes>
                    <Route path="/" element={<Userlist />} />
                    <Route path="/add" element={<Add />} />
                    <Route path="/edit/:user_id" element={<Edit />} />
                </Routes>
            </BrowserRouter>
        </div>
    )
}

export default App



  • Component Edit is imported from it's respective file.

<Route path="/edit/:user_id" element={<Edit />} />


  • The third one maps the "/edit/:user_id" path to the Edit component. The :user_id is a dynamic parameter that can be accessed in the Edit component.
api/action.php

<?php

header("Access-Control-Allow-Origin:* ");

header("Access-Control-Allow-Headers:* ");

header("Access-Control-Allow-Methods:* ");

$connect = new PDO("mysql:host=127.0.0.1;dbname=testing", "root", "password");

$method = $_SERVER['REQUEST_METHOD']; //return GET, POST, PUT, DELETE

if($method === 'GET')
{
	if(isset($_GET['id']))
	{
		//fetch single user
		$query = "SELECT * FROM sample_users WHERE id = '".$_GET["id"]."'";

		$result = $connect->query($query, PDO::FETCH_ASSOC);

		$data = array();

		foreach($result as $row)
		{
			$data['first_name'] = $row['first_name'];

			$data['last_name'] = $row['last_name'];

			$data['email'] = $row['email'];

			$data['id'] = $row['id'];
		}

		echo json_encode($data);
	}
	else 
	{
		//fetch all user

		$query = "SELECT * FROM sample_users ORDER BY id DESC";

		$result = $connect->query($query, PDO::FETCH_ASSOC);

		$data = array();

		foreach($result as $row)
		{
			$data[] = $row;
		}

		echo json_encode($data);
	}	
}

if($method === 'POST')
{
	$form_data = json_decode(file_get_contents('php://input'));

	$data = array(
		':first_name'		=>	$form_data->first_name,
		':last_name'		=>	$form_data->last_name,
		':email'			=>	$form_data->email
	);

	$query = "
	INSERT INTO sample_users (first_name, last_name, email) VALUES (:first_name, :last_name, :email);
	";

	$statement = $connect->prepare($query);

	$statement->execute($data);

	echo json_encode(["success" => "done"]);
}

?>


1 - Check for id Parameter:


if(isset($_GET['id']))


  • Checks if the id parameter is set in the query string of the URL. If id parameter value is set then single user data will be fetch otherwise all user data will be fetch.

2 - Fetch Single User Data


//fetch single user
		$query = "SELECT * FROM sample_users WHERE id = '".$_GET["id"]."'";

		$result = $connect->query($query, PDO::FETCH_ASSOC);

		$data = array();

		foreach($result as $row)
		{
			$data['first_name'] = $row['first_name'];

			$data['last_name'] = $row['last_name'];

			$data['email'] = $row['email'];

			$data['id'] = $row['id'];
		}

		echo json_encode($data);


  • If the id parameter is set, it constructs a SQL query to fetch a single user with the specified ID.
  • Executes the SQL query using PDO (PHP Data Objects) to fetch the data associated with the specified user ID.
  • Iterates over the result set and prepares the data for the single user. It assigns the user's first name, last name, email, and ID to the $data array.
  • Encodes the prepared data as JSON and echoes it back as the response.

In summary, this PHP script handles GET requests to fetch user data. If the request includes an id parameter, it fetches a single user; otherwise, it fetches all users. The script uses PDO for database interaction and outputs the result as JSON.




Step 7 - Make Update Data API


After creating Edit Component under this React CRUD Application and fetch single user data. Now you have to learn, how to submit edit user form data under this React application. And then after, We will make API for update user data under this React CRUD application.

src/Component/Edit.jsx

import React, {useState, useEffect} from 'react';

import { Link, useNavigate, useParams } from 'react-router-dom';

function Edit(){

	let navigate = useNavigate();

	const {user_id} = useParams();

	const [user, setUser] = useState({
		first_name : '',
		last_name : '',
		email : ''
	});

	const handleChange = (event) => {
		const {name, value} = event.target;

		setUser({
			...user,
			[name] : value
		});
	};

	const fetchUserData = () => {
		fetch(`http://localhost/tutorial/phpreactcrud/api/action.php?id=${user_id}`)
		.then((response) => response.json())
		.then((data) => {
			setUser(data);
		});
	};

	useEffect(() => {
		fetchUserData();
	}, []);

	const handleSubmit = (event) => {

		event.preventDefault();

		fetch(`http://localhost/tutorial/phpreactcrud/api/action.php?id=${user_id}`, {
			method : 'PUT',
			headers : {
				'Content-Type': 'application/json'
			},
			body : JSON.stringify(user)
		})
		.then((response) => response.json())
		.then((data) => {
			navigate("/");
		});

	};

	return (
		<div className="card">
			<div className="card-header">
				<div className="row">
					<div className="col-md-6">Edit User</div>
					<div className="col-md-6">
						<Link to="/" className="btn btn-success btn-sm float-end">View All</Link>
					</div>
				</div>
			</div>
			<div className="card-body">
				<div className="row">
					<div className="col-md-4">&nbsp;</div>
					<div className="col-md-4">
						<form method="POST" onSubmit={handleSubmit}>
							<div className="mb-3">
								<label>First Name</label>
								<input type="text" name="first_name" className="form-control" value={user.first_name} onChange={handleChange} />
							</div>
							<div className="mb-3">
								<label>Last Name</label>
								<input type="text" name="last_name" className="form-control" value={user.last_name} onChange={handleChange} />
							</div>
							<div className="mb-3">
								<label>Email</label>
								<input type="email" name="email" className="form-control" value={user.email} onChange={handleChange} />
							</div>
							<div className="mb-3">
								<input type="submit" className="btn btn-primary" value="Edit" />
							</div>
						</form>
					</div>
				</div>
			</div>
		</div>
	)
}

export default Edit;


1 - Form Submission Function (handleSubmit):


const handleSubmit = (event) => {
    event.preventDefault();

    fetch(`http://localhost/tutorial/phpreactcrud/api/action.php?id=${user_id}`, {
        method: 'PUT',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify(user)
    })
    .then((response) => response.json())
    .then((data) => {
        navigate("/");
    });
};


  • The handleSubmit function is called when the form is submitted.
  • It prevents the default form submission, sends a PUT request to update the user data, and then navigates to the root path (/) using the navigate function.

2 - Call JavaScript handleSubmit function


<form method="POST" onSubmit={handleSubmit}>
  {/* Form contents go here */}
</form>


  • The onSubmit attribute is set to a JavaScript function handleSubmit. This function will be called when the form is submitted.
  • The handleSubmit function is expected to handle the form submission logic. It usually includes tasks such as preventing the default form submission behavior, gathering form data, and sending it to the server.
api/action.php

<?php

header("Access-Control-Allow-Origin:* ");

header("Access-Control-Allow-Headers:* ");

header("Access-Control-Allow-Methods:* ");

$connect = new PDO("mysql:host=127.0.0.1;dbname=testing", "root", "password");

$method = $_SERVER['REQUEST_METHOD']; //return GET, POST, PUT, DELETE

if($method === 'GET')
{
	if(isset($_GET['id']))
	{
		//fetch single user
		$query = "SELECT * FROM sample_users WHERE id = '".$_GET["id"]."'";

		$result = $connect->query($query, PDO::FETCH_ASSOC);

		$data = array();

		foreach($result as $row)
		{
			$data['first_name'] = $row['first_name'];

			$data['last_name'] = $row['last_name'];

			$data['email'] = $row['email'];

			$data['id'] = $row['id'];
		}

		echo json_encode($data);
	}
	else 
	{
		//fetch all user

		$query = "SELECT * FROM sample_users ORDER BY id DESC";

		$result = $connect->query($query, PDO::FETCH_ASSOC);

		$data = array();

		foreach($result as $row)
		{
			$data[] = $row;
		}

		echo json_encode($data);
	}

	
}

if($method === 'POST')
{
	//Insert User Data

	$form_data = json_decode(file_get_contents('php://input'));

	$data = array(
		':first_name'		=>	$form_data->first_name,
		':last_name'		=>	$form_data->last_name,
		':email'			=>	$form_data->email
	);

	$query = "
	INSERT INTO sample_users (first_name, last_name, email) VALUES (:first_name, :last_name, :email);
	";

	$statement = $connect->prepare($query);

	$statement->execute($data);

	echo json_encode(["success" => "done"]);
}

if($method === 'PUT')
{
	//Update User Data

	$form_data = json_decode(file_get_contents('php://input'));

	$data = array(
		':first_name'		=>	$form_data->first_name,
		':last_name'		=>	$form_data->last_name,
		':email'			=>	$form_data->email,
		':id'				=>	$form_data->id
	);

	$query = "
	UPDATE sample_users 
	SET first_name = :first_name, 
	last_name = :last_name, 
	email = :email 
	WHERE id = :id
	";

	$statement = $connect->prepare($query);

	$statement->execute($data);

	echo json_encode(["success" => "done"]);
}
?>


This PHP code handles the logic for updating user data when the HTTP request method is PUT.

1 - Check Request Method:


if ($method === 'PUT') {
    // Update User Data
    // ...
}


  • This block checks if the HTTP request method is PUT. If true, it proceeds to handle the update operation.

2 - Decode JSON Data:


$form_data = json_decode(file_get_contents('php://input'));


  • Reads and decodes JSON data from the request body sent by the client. This data likely contains information about the user to be updated, including the new values for first_name, last_name, email, and id.

3 - Prepare Data for Update:


$data = array(
    ':first_name' => $form_data->first_name,
    ':last_name'  => $form_data->last_name,
    ':email'      => $form_data->email,
    ':id'         => $form_data->id
);


  • Creates an associative array ($data) with placeholders for the values to be updated in the SQL query.

4 - SQL Update Query:


$query = "
UPDATE sample_users 
SET first_name = :first_name, 
last_name = :last_name, 
email = :email 
WHERE id = :id
";


  • Defines an SQL query to update the user data in the sample_users table. The placeholders :first_name, :last_name, :email, and :id will be replaced with the corresponding values from the $data array.

5 - Prepare and Execute SQL Statement:


$statement = $connect->prepare($query);
$statement->execute($data);


  • Prepares the SQL statement using the PDO extension.
  • Executes the prepared statement with the data provided. This updates the user data in the database.

6 - JSON Response:


echo json_encode(["success" => "done"]);


  • Outputs a JSON response indicating the success of the update operation. This response is sent back to the client.

In summary, when a PUT request is received, this PHP code decodes the JSON data sent by the client, prepares the data for the update, executes an SQL query to update the user data in the database, and sends a JSON response indicating the success of the operation.




Step 8 - Create Delete Data API


Now we have come to last step of this React.js PHP CRUD Application and under this step you can find how to delete data from MySQL table by using PHP API and React.js function.

src/Component/Userlist.jsx

import React, { useEffect, useState } from 'react';
import { Link } from 'react-router-dom';

function Userlist(){
	const [users, setUsers] = useState([]);

	useEffect(() => {
		const apiUrl = 'http://localhost/tutorial/phpreactcrud/api/action.php';

		fetch(apiUrl)
		.then((response) => response.json())
		.then((data) => {
			setUsers(data);
		});

	}, []);

	const handleDelete = (user_id) => {
		if(confirm("Are your sure you want to remove it?"))
		{
			fetch(`http://localhost/tutorial/phpreactcrud/api/action.php?id=${user_id}`, {
				method : 'DELETE'
			})
			.then((response) => response.json())
			.then((data) => {
				setUsers((prevUser) => prevUser.filter((user) => user.id !== user_id));
			});
		}
	};

	return (
		<div className="card">
			<div className="card-header">
				<div className="row">
					<div className="col-md-6"><b>User Data</b></div>
					<div className="col-md-6">
						<Link to="/add" className="btn btn-success btn-sm float-end">Add</Link>
					</div>
				</div>
			</div>
			<div className="card-body">
				<table className="table table-bordered">
					<thead>
						<tr>
							<th>First Name</th>
							<th>Last Name</th>
							<th>Email</th>
							<th>Action</th>
						</tr>
					</thead>
					<tbody>
					{users.map((user, index) => (
						<tr key={index}>
							<td>{user.first_name}</td>
							<td>{user.last_name}</td>
							<td>{user.email}</td>
							<td>
								<Link to={`/edit/${user.id}`} className="btn btn-warning btn-sm">Edit</Link>&nbsp;
								<button type="button" onClick={() => handleDelete(user.id)} className="btn btn-danger btn-sm">Delete</button>
							</td>
						</tr>
					))}
					</tbody>
				</table>
			</div>
		</div>
	);
}

export default Userlist;


1 - Delete User Handler:


const handleDelete = (user_id) => {
		if(confirm("Are your sure you want to remove it?"))
		{
			fetch(`http://localhost/tutorial/phpreactcrud/api/action.php?id=${user_id}`, {
				method : 'DELETE'
			})
			.then((response) => response.json())
			.then((data) => {
				setUsers((prevUser) => prevUser.filter((user) => user.id !== user_id));
			});
		}
	};


  • Defines a function handleDelete to handle the deletion of a user.
  • Prompts the user with a confirmation dialog before proceeding with the deletion.
  • Sends a DELETE request to the server API with the user ID to be deleted.
  • Updates the users state by removing the deleted user from the array.

2 - Create Delete Button


<button type="button" onClick={() => handleDelete(user.id)} className="btn btn-danger btn-sm">Delete</button>


  • "Delete" button triggers the handleDelete function when clicked.
api/action.php

if($method === 'DELETE')
{
	//Delete User Data
	
	$data = array(
		':id' => $_GET['id']
	);

	$query = "DELETE FROM sample_users WHERE id = :id";

	$statement = $connect->prepare($query);

	$statement->execute($data);

	echo json_encode(["success" => "done"]);
}


This PHP code handles the logic for deleting a user when the HTTP request method is DELETE.

1 - Check Request Method:


if ($method === 'DELETE') {
    // Delete User Data
    // ...
}


  • This block checks if the HTTP request method is DELETE. If true, it proceeds to handle the delete operation.

2 - Prepare Data for Deletion:


$data = array(
    ':id' => $_GET['id']
);


  • Creates an associative array ($data) with a placeholder (:id) for the user ID to be deleted. The user ID is obtained from the query parameters ($_GET['id']).

3 - SQL Delete Query:


$query = "DELETE FROM sample_users WHERE id = :id";


  • Defines an SQL query to delete a user from the sample_users table based on the provided user ID.

4 - Prepare and Execute SQL Statement:


$statement = $connect->prepare($query);
$statement->execute($data);


  • Prepares the SQL statement using the PDO extension.
  • Executes the prepared statement with the data provided. This deletes the user from the database.

5 - JSON Response:


echo json_encode(["success" => "done"]);


  • Outputs a JSON response indicating the success of the delete operation. This response is sent back to the client.

In summary, when a DELETE request is received, this PHP code prepares the user ID for deletion, executes an SQL query to delete the user data from the database, and sends a JSON response indicating the success of the delete operation.




Conclusion


Congratulations! You've successfully built a full-stack CRUD application using React.js, Vite, PHP, and MySQL. This project provides a solid foundation for more complex applications, and you can further enhance it by adding features like authentication, error handling, and improved user interfaces.

Remember to follow best practices for security, such as validating and sanitizing user input on the server side, securing your database connections, and implementing proper authentication mechanisms. Happy coding!