DEV Community: Muhammed Shamal PV

Full Stack Development (Mern && Flutter)

Muhammed Shamal PV — Wed, 08 Jan 2025 15:38:48 +0000

Relief from Fever and Cough

Muhammed Shamal PV — Fri, 16 Aug 2024 19:59:20 +0000

Follow me on LinkedIn
Follow me on Github.com

Click & Read

Hi friends, today I'm dealing with a severe fever and a bad cough.

So, I asked ChatGPT for some natural remedies to help me feel better.

Here's what it suggested:

For a cough and fever, here are some natural remedies that might help:

1. Ginger Tea

Benefits: Ginger has anti-inflammatory properties that can help soothe a sore throat and reduce coughing.
How to Use: Boil a few slices of fresh ginger in water for 10 minutes. Add honey and lemon for additional soothing effects.

2. Honey and Warm Water

Benefits: Honey has antibacterial properties and can help coat the throat, reducing irritation.
How to Use: Mix a tablespoon of honey in warm water or herbal tea. Drink it slowly.

3. Turmeric Milk

Benefits: Turmeric is known for its anti-inflammatory and antioxidant properties, which can help boost your immune system.
How to Use: Mix half a teaspoon of turmeric powder in warm milk. Drink it before bed for better sleep and relief from cough.

4. Steam Inhalation

Benefits: Steam can help loosen mucus and soothe irritated airways.
How to Use: Boil water and pour it into a bowl. Lean over the bowl, cover your head with a towel, and inhale the steam for 5-10 minutes. Adding eucalyptus oil can enhance the effect.

5. Hydration

Benefits: Staying hydrated is crucial when you have a fever as it helps in maintaining body temperature and flushing out toxins.
How to Use: Drink plenty of water, herbal teas, and clear broths.

6. Rest

Benefits: Your body needs energy to fight off illness, so rest is essential.
How to Use: Make sure to get plenty of sleep and avoid overexerting yourself.

If your symptoms persist or worsen, it might be best to consult a healthcare professional.

npm : File C:\Program Files\nodejs\npm.ps1 cannot be loaded because running scripts is disabled on this system.

Muhammed Shamal PV — Tue, 06 Aug 2024 15:16:22 +0000

Follow me on LinkedIn
Follow me on Github.com

Click & Read

Just run this:

Set-ExecutionPolicy -ExecutionPolicy Unrestricted -Scope CurrentUser

Happy Coding

React Native for Beginners

Muhammed Shamal PV — Tue, 06 Aug 2024 00:47:23 +0000

Follow me on LinkedIn
Follow me on Github.com

Click & Read

React Native is a popular framework developed by Facebook for building mobile applications using JavaScript and React. It allows developers to create cross-platform apps with a single codebase, which can run on both iOS and Android. In this blog post, we'll cover the basics of React Native, provide a simple example, and offer tips for beginners.

Introduction to React Native
Setting Up Your Development Environment
Creating Your First React Native App
Understanding React Native Components
Adding Styles
Handling State and Events
Tips for Beginners
Conclusion

1. Introduction to React Native

React Native allows you to build mobile apps using JavaScript and React. It leverages native components, which means the app will look and feel like a native app. One of the biggest advantages is the ability to share code between iOS and Android, reducing development time and effort.

2. Setting Up Your Development Environment

Starts without boring

Before you start coding, you'll need to set up your development environment.

Prerequisites

Node.js and npm: Download and install Node.js
Expo CLI: npm install -g expo-cli
A code editor, such as Visual Studio Code
iOS Simulator (requires Xcode) or Android Emulator (requires Android Studio) for testing

Initial Setup

Install Expo CLI:

   npm install -g expo-cli

Create a New Project:

   expo init AwesomeProject
   cd AwesomeProject

Start the Development Server:

   expo start

This command will start the development server and open a new tab in your browser where you can see your project.

3. Creating Your First React Native App

Let's create a simple "Hello World" app.

Open App.js: This file is the main entry point for your application.
Replace the existing code with the following:

import React from 'react';
import { StyleSheet, Text, View } from 'react-native';

export default function App() {
  return (
    <View style={styles.container}>
      <Text style={styles.text}>Hello, React Native!</Text>
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
    justifyContent: 'center',
    alignItems: 'center',
    backgroundColor: '#f0f0f0',
  },
  text: {
    fontSize: 24,
    color: '#333',
  },
});

4. Understanding React Native Components

React Native provides a set of built-in components that correspond to native UI components. Here are a few key components:

View: The fundamental component for layout and styling.
Text: Used for displaying text.
Image: Used for displaying images.
Button: A simple button component.

5. Adding Styles

Styling in React Native is done using JavaScript objects. You can use the StyleSheet API to create styles.

const styles = StyleSheet.create({
  container: {
    flex: 1,
    justifyContent: 'center',
    alignItems: 'center',
    backgroundColor: '#f0f0f0',
  },
  text: {
    fontSize: 24,
    color: '#333',
  },
});

6. Handling State and Events

You can use React's useState hook to manage state and handle events like button clicks.

import React, { useState } from 'react';
import { StyleSheet, Text, View, Button } from 'react-native';

export default function App() {
  const [count, setCount] = useState(0);

  return (
    <View style={styles.container}>
      <Text style={styles.text}>You clicked {count} times</Text>
      <Button title="Click me" onPress={() => setCount(count + 1)} />
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
    justifyContent: 'center',
    alignItems: 'center',
    backgroundColor: '#f0f0f0',
  },
  text: {
    fontSize: 24,
    color: '#333',
  },
});

7. Tips for Beginners

Understand the Basics of React: React Native is built on top of React. Having a solid understanding of React will make learning React Native easier.
Use Expo for Development: Expo simplifies many aspects of React Native development, such as setting up the environment and testing on physical devices.
Follow Best Practices: Organize your code properly, use meaningful variable names, and write reusable components.
Learn Native Development Basics: Knowing some basics of iOS and Android development can be helpful, especially when you need to write native modules.

Happy coding!

Product listing page in flutter

Muhammed Shamal PV — Mon, 05 Aug 2024 18:26:52 +0000

Follow me on LinkedIn
Follow me on Github.com

Click & Read

let's create a simple product listing page in Flutter. This example will include a basic UI to display a list of products with their names and images. We'll also include a dummy data list to simulate fetching product data.

This example is easy to understand and serves as a good starting point for beginners to learn how to build a product listing page in Flutter.

Step 1: Setting Up the Project

First, ensure you have Flutter installed and set up on your machine. Create a new Flutter project:

flutter create product_listing
cd product_listing

Step 2: Creating the Product Model

Create a simple model class for the product. This will help us to organize the product data.

// lib/models/product.dart
class Product {
  final String name;
  final String imageUrl;

  Product({required this.name, required this.imageUrl});
}

Step 3: Creating Dummy Data

Let's create some dummy data for our products.

// lib/data/dummy_products.dart
import '../models/product.dart';

List<Product> dummyProducts = [
  Product(name: 'Product 1', imageUrl: 'https://via.placeholder.com/150'),
  Product(name: 'Product 2', imageUrl: 'https://via.placeholder.com/150'),
  Product(name: 'Product 3', imageUrl: 'https://via.placeholder.com/150'),
  Product(name: 'Product 4', imageUrl: 'https://via.placeholder.com/150'),
];

Step 4: Creating the Product Listing Page

Now, we'll create the product listing page that will display our list of products.

// lib/screens/product_listing_page.dart
import 'package:flutter/material.dart';
import '../models/product.dart';
import '../data/dummy_products.dart';

class ProductListingPage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('Product Listing'),
      ),
      body: GridView.builder(
        padding: const EdgeInsets.all(10.0),
        itemCount: dummyProducts.length,
        itemBuilder: (ctx, i) => ProductItem(dummyProducts[i]),
        gridDelegate: SliverGridDelegateWithFixedCrossAxisCount(
          crossAxisCount: 2,
          childAspectRatio: 3 / 2,
          crossAxisSpacing: 10,
          mainAxisSpacing: 10,
        ),
      ),
    );
  }
}

class ProductItem extends StatelessWidget {
  final Product product;

  ProductItem(this.product);

  @override
  Widget build(BuildContext context) {
    return ClipRRect(
      borderRadius: BorderRadius.circular(10),
      child: GridTile(
        child: Image.network(
          product.imageUrl,
          fit: BoxFit.cover,
        ),
        footer: GridTileBar(
          backgroundColor: Colors.black87,
          title: Text(
            product.name,
            textAlign: TextAlign.center,
          ),
        ),
      ),
    );
  }
}

Step 5: Updating the Main Application File

Finally, update the main application file to use the ProductListingPage.

// lib/main.dart
import 'package:flutter/material.dart';
import 'screens/product_listing_page.dart';

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Product Listing',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: ProductListingPage(),
    );
  }
}

Step 6: Running the Application

Run the application using the following command:

flutter run

Summary

This simple Flutter application displays a list of products using a GridView. Each product is represented by a name and an image. We used dummy data to simulate product information and created a basic UI to present the data.

happy coding !

crud in python

Muhammed Shamal PV — Fri, 02 Aug 2024 08:46:37 +0000

Follow me on LinkedIn
Follow me on Github.com

Click & Read

Building a Simple CRUD API with Django Rest Framework Using Class-Based Views

In this tutorial, we'll build a simple CRUD (Create, Read, Update, Delete) API for a TODO application using Django Rest Framework (DRF) with normal class-based views. This is ideal for beginners who want to understand how to manually handle HTTP methods in Django without relying on DRF's generic views.

1. Models

First, let's define our Todo model. This model will have fields for the title, description, completed status, and timestamps for when the TODO item was created and last updated.

# models.py
from django.db import models

class Todo(models.Model):
    title = models.CharField(max_length=255)
    description = models.TextField(blank=True, null=True)
    completed = models.BooleanField(default=False)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    def __str__(self):
        return self.title

2. Serializers

Next, we'll create a serializer for our Todo model. Serializers in DRF work similarly to Django forms, converting complex data types such as querysets and model instances into native Python data types.

# serializers.py
from rest_framework import serializers
from .models import Todo

class TodoSerializer(serializers.ModelSerializer):
    class Meta:
        model = Todo
        fields = '__all__'

3. Views

We'll now create views for each CRUD operation using APIView. This approach gives us full control over how each HTTP method is handled.

# views.py
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from django.shortcuts import get_object_or_404
from .models import Todo
from .serializers import TodoSerializer

class TodoListCreateAPIView(APIView):
    def get(self, request):
        todos = Todo.objects.all()
        serializer = TodoSerializer(todos, many=True)
        return Response(serializer.data)

    def post(self, request):
        serializer = TodoSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

class TodoDetailAPIView(APIView):
    def get_object(self, pk):
        return get_object_or_404(Todo, pk=pk)

    def get(self, request, pk):
        todo = self.get_object(pk)
        serializer = TodoSerializer(todo)
        return Response(serializer.data)

    def put(self, request, pk):
        todo = self.get_object(pk)
        serializer = TodoSerializer(todo, data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

    def patch(self, request, pk):
        todo = self.get_object(pk)
        serializer = TodoSerializer(todo, data=request.data, partial=True)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

    def delete(self, request, pk):
        todo = self.get_object(pk)
        todo.delete()
        return Response(status=status.HTTP_204_NO_CONTENT)

4. URLs

We need to set up our URLs to route to these views. This involves mapping URL patterns to the appropriate view classes.

# urls.py
from django.urls import path
from .views import TodoListCreateAPIView, TodoDetailAPIView

urlpatterns = [
    path('todos/', TodoListCreateAPIView.as_view(), name='todo-list-create'),
    path('todos/<int:pk>/', TodoDetailAPIView.as_view(), name='todo-detail'),
]

5. Settings

Ensure you have Django Rest Framework installed and added to your INSTALLED_APPS:

# settings.py
INSTALLED_APPS = [
    # Other installed apps
    'rest_framework',
    'your_app_name',
]

Summary

With this setup, you can perform CRUD operations on the Todo model using the following endpoints:

Create: POST /todos/ - handled by TodoListCreateAPIView
Read: GET /todos/ (list) - handled by TodoListCreateAPIView
Read: GET /todos/{id}/ (retrieve) - handled by TodoDetailAPIView
Update: PUT /todos/{id}/ (update) - handled by TodoDetailAPIView
Partial Update: PATCH /todos/{id}/ (partial update) - handled by TodoDetailAPIView
Delete: DELETE /todos/{id}/ - handled by TodoDetailAPIView

Example of Creating a TODO Item

Using Postman or any HTTP client, you can create a TODO item by sending a POST request to http://localhost:8000/todos/ with a JSON body:

{
    "title": "Buy groceries",
    "description": "Milk, Bread, Cheese, Eggs",
    "completed": false
}

Example of Reading TODO Items

Send a GET request to http://localhost:8000/todos/ to retrieve a list of TODO items.

Conclusion

This approach uses normal class-based views to handle CRUD operations, providing a straightforward way to manage TODO items with Django Rest Framework. Adjust the model, serializer, and views as needed for your specific application requirements.

Happy Coding

file and folder architecture in react js

Muhammed Shamal PV — Fri, 02 Aug 2024 04:03:04 +0000

Follow me on LinkedIn
Follow me on Github.com

Click & Read

Creating a well-structured file and folder architecture is crucial for maintaining, scaling, and collaborating on React projects. Here is a comprehensive guide to setting up a professional file and folder structure for your React applications, suitable for sharing with the dev community in a blog post.

Introduction

When working on React projects, having a consistent and logical file structure can make a significant difference in code readability and maintainability. This guide will cover a modular approach to organizing your files and folders, promoting best practices that can be scaled for larger projects.

Top-Level Folder Structure

A typical React project setup includes the following top-level directories and files:

my-react-app/
├── public/
├── src/
│   ├── assets/
│   ├── components/
│   ├── hooks/
│   ├── pages/
│   ├── services/
│   ├── store/
│   ├── styles/
│   ├── utils/
│   ├── App.js
│   ├── index.js
│   └── routes.js
├── .env
├── .gitignore
├── package.json
├── README.md
└── node_modules/

Folder Descriptions

1. `public/`

This folder contains static assets that you want to be served directly by the server.

index.html: The main HTML file.
favicon.ico: The favicon for your app.

2. `src/`

This is where all the source code for your application lives.

a. `assets/`

This folder is for images, fonts, and other static assets.

src/
└── assets/
    ├── images/
    ├── fonts/
    └── icons/

b. `components/`

Reusable UI components should be placed here. Each component gets its own folder.

src/
└── components/
    ├── Button/
    │   ├── Button.js
    │   ├── Button.test.js
    │   └── Button.css
    ├── Header/
    │   ├── Header.js
    │   ├── Header.test.js
    │   └── Header.css
    └── ...

c. `hooks/`

Custom hooks are placed here.

src/
└── hooks/
    ├── useAuth.js
    ├── useFetch.js
    └── ...

d. `pages/`

Each page or route in your application has its own folder. Pages can also contain sub-components that are specific to that page.

src/
└── pages/
    ├── Home/
    │   ├── Home.js
    │   ├── Home.css
    │   └── components/
    │       └── HomeFeature.js
    ├── About/
    │   ├── About.js
    │   ├── About.css
    │   └── components/
    │       └── Team.js
    └── ...

e. `services/`

This folder is for API calls and other external services.

src/
└── services/
    ├── api.js
    └── auth.js

f. `store/`

If you are using Redux or any state management library, put your store configuration and slices/reducers here.

src/
└── store/
    ├── index.js
    ├── userSlice.js
    └── productSlice.js

g. `styles/`

Global CSS, SASS, or styled-components can be placed here.

src/
└── styles/
    ├── variables.scss
    ├── mixins.scss
    └── global.css

h. `utils/`

Utility functions and helpers.

src/
└── utils/
    ├── formatDate.js
    ├── calculateDiscount.js
    └── ...

3. Core Files

`App.js`

The root component that wraps all other components.

import React from 'react';
import { BrowserRouter as Router } from 'react-router-dom';
import Routes from './routes';

function App() {
  return (
    <Router>
      <Routes />
    </Router>
  );
}

export default App;

`index.js`

The entry point of the application.

import React from 'react';
import ReactDOM from 'react-dom';
import App from './App';
import './styles/global.css';

ReactDOM.render(
  <React.StrictMode>
    <App />
  </React.StrictMode>,
  document.getElementById('root')
);

`routes.js`

Defines the routes for the application.

import React from 'react';
import { Route, Switch } from 'react-router-dom';
import Home from './pages/Home/Home';
import About from './pages/About/About';

function Routes() {
  return (
    <Switch>
      <Route path="/" exact component={Home} />
      <Route path="/about" component={About} />
    </Switch>
  );
}

export default Routes;

Conclusion

Organizing your React project with a clear, modular file structure can make your codebase more maintainable and scalable. This structure helps in keeping related files together, promoting reusability and separation of concerns.

Alway do this like file & folder structuring in any tech

Happy Coding!

flutter tutorial for beginners

Muhammed Shamal PV — Wed, 31 Jul 2024 15:19:02 +0000

Follow me on LinkedIn
Follow me on Github.com

Click & Read

Friends
This simple app is a great starting point for beginners to get familiar with Flutter's basics, including widgets, state management, and building a user interface.

Flutter Counter App

Step 1: Set Up Your Flutter Environment

Before you start, make sure you have Flutter installed on your machine. Follow the instructions on the Flutter official website to set up your environment.

Step 2: Create a New Flutter Project

Open your terminal or command prompt and run the following command to create a new Flutter project:

flutter create counter_app

Navigate to the project directory:

cd counter_app

Step 3: Modify `lib/main.dart`

Replace the contents of lib/main.dart with the following code:

import 'package:flutter/material.dart';

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Counter App',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: MyHomePage(title: 'Flutter Counter App'),
    );
  }
}

class MyHomePage extends StatefulWidget {
  MyHomePage({Key? key, required this.title}) : super(key: key);

  final String title;

  @override
  _MyHomePageState createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
  int _counter = 0;

  void _incrementCounter() {
    setState(() {
      _counter++;
    });
  }

  void _decrementCounter() {
    setState(() {
      if (_counter > 0) {
        _counter--;
      }
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text(widget.title),
      ),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: <Widget>[
            Text(
              'You have pushed the button this many times:',
            ),
            Text(
              '$_counter',
              style: Theme.of(context).textTheme.headline4,
            ),
            Row(
              mainAxisAlignment: MainAxisAlignment.center,
              children: [
                ElevatedButton(
                  onPressed: _incrementCounter,
                  child: Text('Increment'),
                ),
                SizedBox(width: 20),
                ElevatedButton(
                  onPressed: _decrementCounter,
                  child: Text('Decrement'),
                ),
              ],
            ),
          ],
        ),
      ),
    );
  }
}

Step 4: Run the App

Make sure you have an emulator running or a physical device connected. Then run the app with the following command:

flutter run

Explanation

Main Entry Point: The main function is the entry point of the app, calling runApp(MyApp()) to launch the application.
MyApp Widget: This is the root widget of the application, which sets up the MaterialApp with a home page.
MyHomePage Widget: This is the main stateful widget that maintains the state of the counter and defines the UI.
_MyHomePageState: This is the state class for MyHomePage which manages the counter state and updates the UI accordingly.

Features

Increment and Decrement Buttons: Two buttons allow the user to increase and decrease the counter.
State Management: Uses setState to manage and update the state of the counter.

usestate and useeffect hooks in react

Muhammed Shamal PV — Wed, 31 Jul 2024 15:12:05 +0000

Follow me on LinkedIn
Follow me on Github.com

Click & Read

Friends
Understanding these hooks is crucial for managing state and side effects in your React applications. They provide a powerful way to build dynamic and responsive UIs with functional components.

useState

The useState hook allows you to add state to functional components. Here's a simple example demonstrating how to use useState:

Counter Example

import React, { useState } from 'react';

function Counter() {
  // Declare a state variable named "count" and a function "setCount" to update it
  const [count, setCount] = useState(0);

  return (
    <div>
      <p>You clicked {count} times</p>
      <button onClick={() => setCount(count + 1)}>
        Click me
      </button>
    </div>
  );
}

export default Counter;

In this example:

useState(0) initializes the count state variable with 0.
setCount is a function that updates the state.
Clicking the button increments the count state by 1, which causes the component to re-render and display the new count.

useEffect

The useEffect hook allows you to perform side effects in function components. Side effects can include data fetching, subscriptions, or manually changing the DOM.

Example: Data Fetching

Here's an example that uses useEffect to fetch data from an API when the component mounts:

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

function DataFetcher() {
  const [data, setData] = useState([]);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    // Fetch data from an API
    fetch('https://jsonplaceholder.typicode.com/posts')
      .then(response => response.json())
      .then(data => {
        setData(data);
        setLoading(false);
      });
  }, []); // Empty dependency array means this effect runs once after initial render

  if (loading) {
    return <div>Loading...</div>;
  }

  return (
    <div>
      <h1>Fetched Data</h1>
      <ul>
        {data.map(item => (
          <li key={item.id}>{item.title}</li>
        ))}
      </ul>
    </div>
  );
}

export default DataFetcher;

In this example:

useEffect is used to fetch data when the component mounts.
The empty dependency array ([]) ensures that the effect runs only once after the initial render.
The fetched data is stored in the data state variable, and the loading state variable is used to show a loading message until the data is fetched.

useEffect Dependencies

The useEffect hook can also accept a dependency array that allows you to control when the effect runs.

Example: Effect with Dependencies

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

function CounterWithEffect() {
  const [count, setCount] = useState(0);

  useEffect(() => {
    // Update the document title using the browser API
    document.title = `You clicked ${count} times`;

    // Clean up by resetting the title when component unmounts
    return () => {
      document.title = 'React App';
    };
  }, [count]); // Only re-run the effect if count changes

  return (
    <div>
      <p>You clicked {count} times</p>
      <button onClick={() => setCount(count + 1)}>
        Click me
      </button>
    </div>
  );
}

export default CounterWithEffect;

In this example:

The effect updates the document title whenever the count state changes.
The dependency array [count] ensures that the effect only runs when count changes.
The cleanup function resets the document title when the component unmounts or before the effect runs again.

Conclusion

useState is used for adding state to function components. It returns an array containing the current state value and a function to update it.
useEffect is used for handling side effects in function components. It runs after the component renders and can optionally clean up before the component unmounts or before the effect runs again.

Happy Coding !

todo list in react js

Muhammed Shamal PV — Wed, 31 Jul 2024 15:06:16 +0000

Follow me on LinkedIn
Follow me on Github.com

Click & Read

This simple Todo List app is a great starting point for beginners to get familiar with React's fundamentals, including state management, event handling, and rendering lists.

Step-by-Step Guide to Creating a Todo List App in React

Step 1: Set Up Your React Environment

Before you start, make sure you have Node.js and npm (or yarn) installed on your machine. You can create a new React project using Create React App.

Open your terminal or command prompt and run the following command to create a new React project:

npx create-react-app todo-list

Navigate to the project directory:

cd todo-list

Step 2: Modify `src/App.js`

Replace the contents of src/App.js with the following code:

import React, { useState } from 'react';
import './App.css';

function App() {
  const [todos, setTodos] = useState([]);
  const [input, setInput] = useState('');

  const handleInputChange = (e) => {
    setInput(e.target.value);
  };

  const handleAddTodo = () => {
    if (input.trim()) {
      setTodos([...todos, { text: input, completed: false }]);
      setInput('');
    }
  };

  const handleToggleComplete = (index) => {
    const newTodos = todos.map((todo, i) => {
      if (i === index) {
        return { ...todo, completed: !todo.completed };
      }
      return todo;
    });
    setTodos(newTodos);
  };

  const handleDeleteTodo = (index) => {
    const newTodos = todos.filter((_, i) => i !== index);
    setTodos(newTodos);
  };

  return (
    <div className="App">
      <header className="App-header">
        <h1>Todo List</h1>
        <div>
          <input
            type="text"
            value={input}
            onChange={handleInputChange}
            placeholder="Add a new todo"
          />
          <button onClick={handleAddTodo}>Add</button>
        </div>
        <ul>
          {todos.map((todo, index) => (
            <li key={index}>
              <span
                style={{
                  textDecoration: todo.completed ? 'line-through' : 'none',
                }}
                onClick={() => handleToggleComplete(index)}
              >
                {todo.text}
              </span>
              <button onClick={() => handleDeleteTodo(index)}>Delete</button>
            </li>
          ))}
        </ul>
      </header>
    </div>
  );
}

export default App;

Step 3: Add Some Basic Styling

Modify the src/App.css file to add some basic styling:

.App {
  text-align: center;
}

.App-header {
  background-color: #282c34;
  min-height: 100vh;
  display: flex;
  flex-direction: column;
  align-items: center;
  justify-content: center;
  font-size: calc(10px + 2vmin);
  color: white;
}

input {
  padding: 10px;
  margin-right: 10px;
  font-size: 16px;
}

button {
  padding: 10px;
  font-size: 16px;
  cursor: pointer;
}

ul {
  list-style-type: none;
  padding: 0;
}

li {
  display: flex;
  justify-content: space-between;
  align-items: center;
  padding: 10px;
  margin: 10px 0;
  background-color: #444;
  border-radius: 5px;
}

li span {
  cursor: pointer;
}

Step 4: Run the App

Now, you can run your Todo List app with the following command:

npm start

This command starts the development server and opens your new React application in your default web browser.

Happy Coding !

form validation using react js

Muhammed Shamal PV — Fri, 26 Jul 2024 14:37:12 +0000

Follow me on LinkedIn
Follow me on Github.com

Click & Read

0.Form Validation Without Third-Party Libraries

import React, { useState } from 'react';

function BasicFormValidation() {
  const [formData, setFormData] = useState({ name: '', email: '' });
  const [errors, setErrors] = useState({});

  const handleChange = (e) => {
    const { name, value } = e.target;
    setFormData({ ...formData, [name]: value });
  };

  const validate = () => {
    let tempErrors = {};
    tempErrors.name = formData.name ? "" : "Name is required";
    tempErrors.email = /^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$/.test(formData.email) ? "" : "Email is not valid";
    setErrors(tempErrors);
    return Object.keys(tempErrors).every(x => tempErrors[x] === "");
  };

  const handleSubmit = (e) => {
    e.preventDefault();
    if (validate()) {
      alert("Form submitted successfully");
    }
  };

  return (
    <form onSubmit={handleSubmit}>
      <div>
        <label>Name</label>
        <input type="text" name="name" value={formData.name} onChange={handleChange} />
        {errors.name && <div style={{ color: 'red' }}>{errors.name}</div>}
      </div>
      <div>
        <label>Email</label>
        <input type="email" name="email" value={formData.email} onChange={handleChange} />
        {errors.email && <div style={{ color: 'red' }}>{errors.email}</div>}
      </div>
      <button type="submit">Submit</button>
    </form>
  );
}

export default BasicFormValidation;

1.Using React Hooks

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

function HookFormValidation() {
  const [formData, setFormData] = useState({ username: '', password: '' });
  const [errors, setErrors] = useState({});
  const [isSubmitting, setIsSubmitting] = useState(false);

  const handleChange = (e) => {
    const { name, value } = e.target;
    setFormData({ ...formData, [name]: value });
  };

  const validate = () => {
    let tempErrors = {};
    tempErrors.username = formData.username ? "" : "Username is required";
    tempErrors.password = formData.password.length > 6 ? "" : "Password must be at least 6 characters long";
    setErrors(tempErrors);
    return Object.keys(tempErrors).every(x => tempErrors[x] === "");
  };

  const handleSubmit = (e) => {
    e.preventDefault();
    if (validate()) {
      setIsSubmitting(true);
    }
  };

  useEffect(() => {
    if (isSubmitting) {
      alert("Form submitted successfully");
      setIsSubmitting(false);
    }
  }, [isSubmitting]);

  return (
    <form onSubmit={handleSubmit}>
      <div>
        <label>Username</label>
        <input type="text" name="username" value={formData.username} onChange={handleChange} />
        {errors.username && <div style={{ color: 'red' }}>{errors.username}</div>}
      </div>
      <div>
        <label>Password</label>
        <input type="password" name="password" value={formData.password} onChange={handleChange} />
        {errors.password && <div style={{ color: 'red' }}>{errors.password}</div>}
      </div>
      <button type="submit">Submit</button>
    </form>
  );
}

export default HookFormValidation;

2.Form Validation With Third-Party Libraries

import React from 'react';
import { useFormik } from 'formik';
import * as Yup from 'yup';

const FormikFormValidation = () => {
  const formik = useFormik({
    initialValues: {
      firstName: '',
      lastName: '',
      email: '',
    },
    validationSchema: Yup.object({
      firstName: Yup.string()
        .max(15, 'Must be 15 characters or less')
        .required('Required'),
      lastName: Yup.string()
        .max(20, 'Must be 20 characters or less')
        .required('Required'),
      email: Yup.string().email('Invalid email address').required('Required'),
    }),
    onSubmit: (values) => {
      alert(JSON.stringify(values, null, 2));
    },
  });

  return (
    <form onSubmit={formik.handleSubmit}>
      <div>
        <label>First Name</label>
        <input
          type="text"
          name="firstName"
          onChange={formik.handleChange}
          onBlur={formik.handleBlur}
          value={formik.values.firstName}
        />
        {formik.touched.firstName && formik.errors.firstName ? (
          <div style={{ color: 'red' }}>{formik.errors.firstName}</div>
        ) : null}
      </div>
      <div>
        <label>Last Name</label>
        <input
          type="text"
          name="lastName"
          onChange={formik.handleChange}
          onBlur={formik.handleBlur}
          value={formik.values.lastName}
        />
        {formik.touched.lastName && formik.errors.lastName ? (
          <div style={{ color: 'red' }}>{formik.errors.lastName}</div>
        ) : null}
      </div>
      <div>
        <label>Email</label>
        <input
          type="email"
          name="email"
          onChange={formik.handleChange}
          onBlur={formik.handleBlur}
          value={formik.values.email}
        />
        {formik.touched.email && formik.errors.email ? (
          <div style={{ color: 'red' }}>{formik.errors.email}</div>
        ) : null}
      </div>
      <button type="submit">Submit</button>
    </form>
  );
};

export default FormikFormValidation;

3.Using React Hook Form

import React from 'react';
import { useForm } from 'react-hook-form';

function ReactHookFormValidation() {
  const { register, handleSubmit, watch, formState: { errors } } = useForm();
  const onSubmit = (data) => alert(JSON.stringify(data));

  return (
    <form onSubmit={handleSubmit(onSubmit)}>
      <div>
        <label>Username</label>
        <input {...register("username", { required: "Username is required" })} />
        {errors.username && <div style={{ color: 'red' }}>{errors.username.message}</div>}
      </div>
      <div>
        <label>Password</label>
        <input {...register("password", { required: "Password is required", minLength: { value: 6, message: "Password must be at least 6 characters long" } })} />
        {errors.password && <div style={{ color: 'red' }}>{errors.password.message}</div>}
      </div>
      <button type="submit">Submit</button>
    </form>
  );
}

export default ReactHookFormValidation;

4.Using Yup with Formik

import React from 'react';
import { useFormik } from 'formik';
import * as Yup from 'yup';

const FormikYupValidation = () => {
  const formik = useFormik({
    initialValues: {
      username: '',
      email: '',
    },
    validationSchema: Yup.object({
      username: Yup.string()
        .max(15, 'Must be 15 characters or less')
        .required('Required'),
      email: Yup.string().email('Invalid email address').required('Required'),
    }),
    onSubmit: (values) => {
      alert(JSON.stringify(values, null, 2));
    },
  });

  return (
    <form onSubmit={formik.handleSubmit}>
      <div>
        <label>Username</label>
        <input
          type="text"
          name="username"
          onChange={formik.handleChange}
          onBlur={formik.handleBlur}
          value={formik.values.username}
        />
        {formik.touched.username && formik.errors.username ? (
          <div style={{ color: 'red' }}>{formik.errors.username}</div>
        ) : null}
      </div>
      <div>
        <label>Email</label>
        <input
          type="email"
          name="email"
          onChange={formik.handleChange}
          onBlur={formik.handleBlur}
          value={formik.values.email}
        />
        {formik.touched.email && formik.errors.email ? (
          <div style={{ color: 'red' }}>{formik.errors.email}</div>
        ) : null}
      </div>
      <button type="submit">Submit</button>
    </form>
  );
};

export default FormikYupValidation;

Byyyy
Happy Coding !

center a div in html and css

Muhammed Shamal PV — Fri, 26 Jul 2024 14:21:46 +0000

Follow me on LinkedIn
Follow me on Github.com

Click & Read

Without Boaring Setion we can redirec to coding!

1. Using Flexbox

Flexbox is a powerful layout tool that makes it easy to center elements both horizontally and vertically.

Example:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Center Div with Flexbox</title>
    <style>
        .container {
            display: flex;
            justify-content: center; /* Horizontal center */
            align-items: center;    /* Vertical center */
            height: 100vh;          /* Full viewport height */
        }

        .centered-div {
            width: 200px;
            height: 200px;
            background-color: lightblue;
        }
    </style>
</head>
<body>
    <div class="container">
        <div class="centered-div">Centered with Flexbox</div>
    </div>
</body>
</html>

2. Using Grid

CSS Grid is another powerful layout system that can easily center elements.

Example:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Center Div with Grid</title>
    <style>
        .container {
            display: grid;
            place-items: center; /* Center both horizontally and vertically */
            height: 100vh;       /* Full viewport height */
        }

        .centered-div {
            width: 200px;
            height: 200px;
            background-color: lightcoral;
        }
    </style>
</head>
<body>
    <div class="container">
        <div class="centered-div">Centered with Grid</div>
    </div>
</body>
</html>

3. Using Absolute Positioning and Transform

This method involves positioning the div absolutely and using transform to center it.

Example:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Center Div with Absolute Positioning</title>
    <style>
        .container {
            position: relative;
            height: 100vh; /* Full viewport height */
        }

        .centered-div {
            position: absolute;
            top: 50%;
            left: 50%;
            transform: translate(-50%, -50%);
            width: 200px;
            height: 200px;
            background-color: lightgreen;
        }
    </style>
</head>
<body>
    <div class="container">
        <div class="centered-div">Centered with Absolute Positioning</div>
    </div>
</body>
</html>

4. Using Margin Auto

Setting margin: auto on an element with a specified width can center it horizontally.

Example:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Center Div with Margin Auto</title>
    <style>
        .container {
            width: 100%;
            height: 100vh; /* Full viewport height */
            display: flex;
            align-items: center; /* Vertical center */
        }

        .centered-div {
            margin: 0 auto; /* Horizontal center */
            width: 200px;
            height: 200px;
            background-color: lightcoral;
        }
    </style>
</head>
<body>
    <div class="container">
        <div class="centered-div">Centered with Margin Auto</div>
    </div>
</body>
</html>

5. Using Table Display

This method uses display: table and display: table-cell to center an element.

Example:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Center Div with Table Display</title>
    <style>
        .container {
            display: table;
            width: 100%;
            height: 100vh; /* Full viewport height */
        }

        .centered-div {
            display: table-cell;
            vertical-align: middle; /* Vertical center */
            text-align: center;     /* Horizontal center */
        }

        .inner-div {
            display: inline-block;
            width: 200px;
            height: 200px;
            background-color: lightpink;
        }
    </style>
</head>
<body>
    <div class="container">
        <div class="centered-div">
            <div class="inner-div">Centered with Table Display</div>
        </div>
    </div>
</body>
</html>

Byyy
Happy Coding!

DEV Community: Muhammed Shamal PV

Full Stack Development (Mern && Flutter)

Relief from Fever and Cough

For a cough and fever, here are some natural remedies that might help:

1. Ginger Tea

2. Honey and Warm Water

3. Turmeric Milk

4. Steam Inhalation

5. Hydration

6. Rest

npm : File C:\Program Files\nodejs\npm.ps1 cannot be loaded because running scripts is disabled on this system.

React Native for Beginners

Table of Contents

1. Introduction to React Native

2. Setting Up Your Development Environment

Prerequisites

Initial Setup

3. Creating Your First React Native App

4. Understanding React Native Components

5. Adding Styles

6. Handling State and Events

7. Tips for Beginners

Product listing page in flutter

Step 1: Setting Up the Project

Step 2: Creating the Product Model

Step 3: Creating Dummy Data

Step 4: Creating the Product Listing Page

Step 5: Updating the Main Application File

Step 6: Running the Application

Summary

crud in python

Building a Simple CRUD API with Django Rest Framework Using Class-Based Views

1. Models

2. Serializers

3. Views

4. URLs

5. Settings

Summary

Example of Creating a TODO Item

Example of Reading TODO Items

Conclusion

file and folder architecture in react js

Introduction

Top-Level Folder Structure

Folder Descriptions

1. public/

2. src/

a. assets/

b. components/

c. hooks/

d. pages/

e. services/

f. store/

g. styles/

h. utils/

3. Core Files

App.js

index.js

routes.js

Conclusion

flutter tutorial for beginners

Flutter Counter App

Step 1: Set Up Your Flutter Environment

Step 2: Create a New Flutter Project

Step 3: Modify lib/main.dart

Step 4: Run the App

Explanation

Features

usestate and useeffect hooks in react

useState

Counter Example

useEffect

Example: Data Fetching

useEffect Dependencies

Example: Effect with Dependencies

Conclusion

todo list in react js

Step-by-Step Guide to Creating a Todo List App in React

Step 1: Set Up Your React Environment

Step 2: Modify src/App.js

1. `public/`

2. `src/`

a. `assets/`

b. `components/`

c. `hooks/`

d. `pages/`

e. `services/`

f. `store/`

g. `styles/`

h. `utils/`

`App.js`

`index.js`

`routes.js`

Step 3: Modify `lib/main.dart`

Step 2: Modify `src/App.js`