Docodehere

TikTok Introduces New Controls to Manage AI-Generated Content in the For You Feed

2025-11-19T16:18:00.007+05:30

TikTok has introduced a major update that gives users direct control over how much AI-generated content they want to see in their For You feed. This may seem like a small tweak, but it represents a big step in how social media platforms are adapting to the rise of artificial intelligence in online creativity.

In recent years, AI tools have made it incredibly easy for anyone to create videos, animations, characters, and even entire stories with little to no technical skills. Platforms like TikTok have naturally become hotspots for such content. But with this growth also comes concern—some users love AI videos, while others prefer original human-created content. TikTok’s latest update tries to strike the perfect balance by letting people customize their feed based on their preferences.

Below, we break down everything you need to know about this update, why TikTok is doing it, how invisible watermarking works, and what this means for the future of digital content creation.

A New Way to Personalize the TikTok Experience

TikTok’s new AI-Generated Content (AIGC) control is integrated into the “Manage Topics” section within the Content Preferences menu. This section already allows users to fine-tune the frequency of different categories they see—such as sports, dance, food, entertainment, lifestyle, and more. Now, AI-generated videos are treated as a distinct category with their own adjustable slider.

How the Slider Works

After opening:
Settings → Content Preferences → Manage Topics,
users will find a slider labeled “AI-generated content.”

Depending on the user’s choice:

Moving the slider down means less AI content
Moving it up means more AI content
Keeping it balanced means a mixture of both human-made and AI-generated videos

This helps users control how much exposure they have to AI visuals, which have become extremely common since the rise of advanced generative models.

Why TikTok is Introducing This Feature Now

This update comes at a time when AI-generated videos are more popular than ever. Major tech companies are experimenting with AI-only content feeds:

Meta launched Vibes, a dedicated feed filled entirely with AI-created short videos.
OpenAI launched Sora, a platform allowing people to generate highly realistic videos using artificial intelligence.

These platforms have inspired creators to experiment more with AI. Many TikTok users now post AI-generated scenes involving historical events, imaginary scenarios, celebrity mashups, futuristic cities, and even animated storytelling clips.

While these videos can be fun and visually impressive, some users feel overwhelmed by the amount of AI content and prefer authentic videos recorded by real people. TikTok’s new control aims to strike a healthy balance between creativity and authenticity.

Ensuring Transparency: Invisible Watermarking Technology

One of the biggest challenges TikTok faces is making sure that users can clearly differentiate between videos created by humans and videos generated by AI tools. TikTok already uses C2PA Content Credentials, a global standard that adds digital metadata indicating whether a piece of content is AI-generated.

However, there’s a catch:
Metadata can be lost or removed if someone downloads, edits, or reuploads the content on another platform.

To solve this, TikTok is testing a more robust system—invisible watermarking.

What Is Invisible Watermarking?

Invisible watermarking embeds a hidden, unremovable signature inside the video. Users cannot see it with the naked eye, but TikTok’s systems can instantly identify whether the video was created with AI.

This means:

AI-generated videos uploaded from other apps cannot hide their origin
Content creators cannot remove the label by editing or reuploading
The platform can keep track of AI videos more accurately

This is crucial for transparency, misinformation prevention, and user trust.

TikTok will first apply invisible watermarks to:

Videos created using its own tools (e.g., AI Editor Pro)
Videos uploaded with C2PA metadata already attached

Over time, TikTok may expand this watermarking system to more tools and content formats.

AI Literacy Fund: Helping People Understand AI Safely

To support responsible and informed use of artificial intelligence, TikTok has also announced a $2 million AI literacy fund. This initiative will work with experts, educators, and nonprofits to help users understand:

How AI works
How to identify AI-generated content
How to stay safe while consuming AI visuals
How to critically evaluate what they see online

One of the first confirmed partners is Girls Who Code, a nonprofit dedicated to empowering the next generation of young women in tech. TikTok hopes this initiative will help build a more informed online community as AI becomes increasingly integrated into social media.

How This Update Benefits Everyday TikTok Users

1. More Control Over Your Feed

For users who find AI videos repetitive, unrealistic, or overwhelming, the new slider offers a simple way to reduce them. For others who enjoy AI creativity, effects, and storytelling, it's an opportunity to see more of it.

2. Better Transparency

Invisible watermarking ensures that videos made with AI tools are accurately identified, reducing confusion and preventing misleading content from spreading.

3. Better Protection Against Misinformation

AI-generated videos sometimes look extremely realistic. Clear labeling helps viewers avoid being deceived by fake events, fake celebrity videos, or misleading AI edits.

4. Supports Creative Freedom

Instead of banning or restricting AI content, TikTok is giving users the power to decide what they want to see. This supports creativity while maintaining trust.

5. Education and Awareness

The AI literacy fund ensures that users—especially young audiences—learn the importance of digital safety and critical thinking.

The Future of AI on TikTok and Social Media

The introduction of AI content controls shows that TikTok understands how important personalization is in today’s digital world. As AI technology becomes more advanced, more creators will experiment with it. This means platforms must find ways to maintain trust while encouraging creativity.

TikTok’s approach—a mix of user control, transparency tools, improved labeling, and educational initiatives—may become a model for other platforms in the future.

We can expect:

More advanced AI detection methods
More AI tools for creators
Better community education around AI
Increased user control over feed preferences

The coming years will likely reshape how people interact with online content, and TikTok is preparing for that shift early.

Final Thoughts

TikTok’s new AI content control update is not just a small feature—it’s a significant improvement in how users manage their experience and how the platform responds to the rapid growth of AI-generated media. By allowing users to adjust the amount of AI content they see, enhancing labeling accuracy with invisible watermarks, and launching an AI literacy fund, TikTok is taking meaningful steps to balance creativity, safety, and personalization.

As AI becomes more deeply integrated into digital platforms, features like these will play a key role in building trust and helping users navigate the evolving world of online content.

How to Build an AI Email Reply Generator Chrome Extension with JavaScript

2025-10-30T17:13:00.008+05:30

Wrtitng email reply form an gpt required too much too and fro, example, if i want to generate a email reply, then first i have to copy the all content of email conversion then go to gpt and then paste it, and then asked gpt to generate the email reply then its give response, copy those response and again come to our gmail page and paste it, and some time happen that format of reply can be disttrub, so that we have to also correct those format. So, instead of doing these to and fro, as a developer, why don't we create an extension that has an embedded button in the reply box, and by clicking it, within a second, it will generate the reply based on all previous conversations?

In this article, we will go through creating your Chrome browser extension that integrates directly into the Gmail interface to generate an email reply. This "Email AI" will have two powerful features:

AI Reply Generator: A button that reads the context of an email conversation and uses an AI (like Google's Gemini) to generate a relevant, professional reply.
Template Inserter: A dropdown menu to instantly insert pre-written templates for common emails like birthday wishes or leave applications, etc.

This project is a fantastic way to learn about developing a Chrome extension, DOM manipulation, and integrating AI for our personal use in our application. Let's get started!

Prerequisites

Before we dive in, make sure you have the following:

A Code Editor IDE like VS Code.
Basic knowledge of JavaScript, HTML, and CSS.
An API key for an AI model (we will be using Google's Gemini, which has a generous free tier).

Project Structure: The Core Files

Our extension will be surprisingly simple, consisting of just two primary files:

1. manifest.json: The configuration file. It tells Chrome what our extension is, what permissions it needs, and which scripts to run.

2. content.js: Our main JavaScript file. This script will be injected into the Gmail page to add our buttons and handle all the logic. This basically contains the logic, or use can say it's a backend.

Let's create a new folder for our project and add these two empty files to it.

Step 1: Configuring the manifest.json File

The manifest.json file is the heart of any Chrome extension. It defines the extension's capabilities and permissions. Let's break down what each part does.

Copy the following code into your `manifest.json` file:

json

{
  "name": "Email Writer Assistant",
  "description": "AI-powered email reply generator and template tool.",
  "version": "1.0",
  "manifest_version": 3,
  "permissions": [
    "activeTab",
    "storage"
  ],
  "host_permissions": [
    "*://mail.google.com/*",
    "https://generativelanguage.googleapis.com/*"
  ],
  "content_scripts": [
    {
      "js": [
        "content.js"
      ],
      "matches": [
        "*://mail.google.com/*"
      ],
      "run_at": "document_end"
    }
  ],
  "action": {
    "default_title": "Email Writer Assistant"
  }
}

Breaking Down the Manifest:

name, description, version: Self-explanatory metadata for our Email reply generator extension.
manifest_version: 3: Specifies that we are using the latest and most secure version of the Chrome extension platform. In simple words its specifes the extension version.
permissions: We request "storage" to potentially save custom templates in the future and "activeTab" for general interaction.
host_permissions: This is crucial for security. :*//mail.google.com/*: Grants our extension permission to run on Gmail.
https://generativelanguage.googleapis.com/*: Grants permission to make API calls to Google's Gemini AI.
content_scripts: This is where we tell Chrome to inject our content.js file into any page that matches the *://mail.google.com/* pattern. In simple words it tell the extension to run this file.

Step 2: Writing the Logic for our Extension - The content.js Script

This is where the magic happens. Our content script will watch for the Gmail compose window to open, then inject our custom buttons and define their functionality. So, using Xpath we will find the place where to inject buttons using javascript DOM, and we will fetch the content of the mail using javascript dom and then we will pass those content with prompt to the gemini api using javascript. And get the response from it and pase it into the reply box using javascript dom.

Copy the following code into your content.js file. We have adapted it to call the Gemini API directly.

JavaScript

  
console.log("Email Writer Extension - Content Script Loaded");
// --- Helper Functions to Create UI Elements ---
function createAIButton() {
    const button = document.createElement('div');
    button.className = 'T-I J-J5-Ji aoO v7 T-I-atl L3'; // Mimic Gmail's button style
    button.style.marginRight = '8px';
    button.innerHTML = 'AI Reply';
    button.setAttribute('role', 'button');
    button.setAttribute('data-tooltip', 'Generate AI Reply');
    return button;
}



function createTemplateDropdown() {
    const dropdown = document.createElement('select');
    dropdown.className = 'T-I J-J5-Ji aoO v7 T-I-atl L3 template-dropdown';
    dropdown.style.marginRight = '8px';
    dropdown.setAttribute('role', 'button');
    dropdown.setAttribute('data-tooltip', 'Insert Template');

    // Default option
    const defaultOption = document.createElement('option');
    defaultOption.text = 'Templates';
    defaultOption.disabled = true;
    defaultOption.selected = true;
    dropdown.appendChild(defaultOption);

    // Hardcoded templates
    const templates = [
        { name: "Birthday Wish", subject: "Happy Birthday ??", body: "Dear [Name],\n\nWishing you a very Happy Birthday! ????\n\nMay your day be filled with joy, love, and laughter.\n\nBest regards,\n[Your Name]" },
        { name: "Leave Application", subject: "Leave Application Request", body: "Dear [Manager's Name],\n\nI would like to request leave from [start date] to [end date] due to [reason].\n\nKindly approve my request.\n\nBest regards,\n[Your Name]" },
        { name: "Thank You Note", subject: "Thank You", body: "Dear [Recipient],\n\nI just wanted to say thank you for your support and guidance. I truly appreciate it.\n\nBest regards,\n[Your Name]" },
    ];

    templates.forEach(template => {
        const option = document.createElement('option');
        option.value = template.name;
        option.text = template.name;
        option.dataset.subject = template.subject;
        option.dataset.body = template.body;
        dropdown.appendChild(option);
    });

    dropdown.addEventListener('change', (e) => {
        const selected = e.target.selectedOptions[0];
        const subject = selected.dataset.subject;
        const body = selected.dataset.body;
        const subjectBox = document.querySelector('input[name="subjectbox"]');
        if (subjectBox) { subjectBox.value = subject; }
        const composeBox = document.querySelector('[role="textbox"][g_editable="true"]');
        if (composeBox) {
            composeBox.innerHTML = ""; // clear old content
            composeBox.focus();
            document.execCommand('insertText', false, body);
        }
        e.target.selectedIndex = 0; // Reset dropdown
    });
    return dropdown;

}

// --- Core Logic Functions ---
function getEmailContent() {
    // This function tries to find the content of the email being replied to.
    const quote = document.querySelector('.gmail_quote');
    if (quote) return quote.innerText.trim();

    // Fallback for different Gmail layouts
    const content = document.querySelector('.a3s.aiL');
    if (content) return content.innerText.trim();
    return '';
}

function findComposeToolbar() {

    // Gmail's class names can change. This looks for the toolbar using several potential selectors.
    return document.querySelector('.gU.Up') || document.querySelector('.aDh');
}

async function generateAIReply(emailContent) {
    const API_KEY = 'AIzaSyCXpVrzhqsDB5uXowkjftJsE2OYCpKHr3o'; // IMPORTANT: Replace with your actual key
    const API_URL = `https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=${API_KEY}`;
    const prompt = `Generate a professional email reply for the following email content. Please don't generate a subject line. Email to reply to:\n\n---\n${emailContent}\n---`;
    try {
        const response = await fetch(API_URL, {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({
                contents: [{ parts: [{ text: prompt }] }]
            })
        });
        if (!response.ok) {
            throw new Error(`API request failed with status ${response.status}`);
        }
        const data = await response.json();
        // Navigate through the Gemini response structure to get the text
        return data.candidates[0].content.parts[0].text;

    } catch (error) {
        console.error("Error generating AI reply:", error);
        return "Sorry, I was unable to generate a reply. Please try again.";
    }

}


function injectButtons() {
    // Avoid duplicate buttons
    document.querySelector('.ai-reply-button')?.remove();
    document.querySelector('.template-dropdown')?.remove();
    const toolbar = findComposeToolbar();
    if (!toolbar) {
        console.log("Compose toolbar not found, will retry.");
        return;
    }

    // Always add the Templates dropdown
    const dropdown = createTemplateDropdown();
    toolbar.insertBefore(dropdown, toolbar.firstChild);

    // Only add the "AI Reply" button if we are replying to an email
    const emailContent = getEmailContent();
    if (emailContent && emailContent.length > 0) {
        const button = createAIButton();
        button.classList.add('ai-reply-button');
        button.addEventListener('click', async () => {
            button.innerHTML = 'Generating...';
            button.disabled = true;
            const generatedReply = await generateAIReply(emailContent);
            const composeBox = document.querySelector('[role="textbox"][g_editable="true"]');

            if (composeBox) {
                composeBox.focus();
                // We use execCommand for broad compatibility in content-editable divs
                document.execCommand('insertText', false, '\n\n' + generatedReply);
            }
            button.innerHTML = 'AI Reply';
            button.disabled = false;
        });
        toolbar.insertBefore(button, toolbar.firstChild);
    }
}

// --- Observer to Detect When the Compose Window Opens ---
const observer = new MutationObserver((mutations) => {
    for (const mutation of mutations) {

        // Check if a new node was added that looks like a compose window
        const composeWindowAdded = Array.from(mutation.addedNodes).some(node =>
            node.nodeType === Node.ELEMENT_NODE && node.querySelector('.gU.Up, .aDh')
        );

        if (composeWindowAdded) {
            console.log("Compose Window Detected, injecting buttons.");

            // Wait a moment for Gmail's UI to fully render before injecting
            setTimeout(injectButtons, 500);
            return; // No need to check other mutations
        }
    }
});

// Start observing the entire document for changes
observer.observe(document.body, {
    childList: true,
    subtree: true
});

IMPORTANT: Remember to replace 'YOUR_GEMINI_API_KEY' with your actual API key from the Google AI Studio. We will using the free version of the gemini api.

Step 3: Loading and Testing Your Extension

Now that the code is ready, let's load it into Chrome: Follows the following steps to use our own extension.

Open Chrome and navigate to chrome://extensions.

Turn on the "Developer mode" toggle in the top-right corner.

Click the "Load unpacked" button.

Select the folder where you saved your manifest.json and content.js files. Make sure to uplaod the whole folder.

If everything is correct, your "Email Writer Assistant" will appear in the list.

Now, go to Gmail, refresh the page, and click "Compose." You should see the "Templates" dropdown in the compose toolbar.

If you click "Reply" on an existing email, both the "AI Reply" button and the "Templates" dropdown will appear!

Potential Enhancements and Next Steps

This is a great starting point, but you can take it much further. Here are some ideas:

Tone Selection: Add another dropdown to let the user choose a tone (e.g., "Professional," "Casual," "Enthusiastic") and pass it to the AI prompt.

Custom Templates: Use chrome.storage.sync to allow users to save their own templates that sync across their devices.

Settings Page: Create a dedicated options page for managing the API key and custom templates.

Improved UI: Design custom icons for your buttons to make them look more polished.

Conclusion

Congratulations! You have successfully built a powerful AI Email Assistant for Gmail using JavaScript. You've learned how to create a Chrome extension, interact with a web page's DOM, and integrate a powerful AI model to automate a common task.

This project not only saves you time but also serves as a solid foundation for building even more complex and useful browser automation tools. Happy coding!

How to Build a Resume Analysis Web App with Spring Boot, React, and Gemini API: A Step-by-Step Guide

2025-10-27T18:32:00.002+05:30

In today's competitive job market, recruiters and hiring managers are often inundated with hundreds of resumes for a single position. Manually screening each one is a time-consuming and tedious task. What if you could build a smart application to automate this process, extracting key information from the resume and providing a concise analysis of the resume by providing an ATS score, pros, cons etc.

This is where the power of modern technology comes in. By combining a robust backend build with Java, Spring Boot, a dynamic frontend build with React.js, and a cutting-edge AI model, you can create a powerful Resume Analysis web application.

In this comprehensive article, we will walk you through building a full-stack resume analysis app from the scratch. We will use Spring Boot for the backend REST API, ReactJS for the interactive frontend, and Google's powerful Gemini API for the intelligent text analysis.

This project is not only an addition to your portfolio but also a practical knowledge of integrating generative AI into web applications.

Why This Tech Stack?

Before we dive into the code, let's understand why this combination of technologies is an excellent choice for our project.

Spring Boot

Spring Boot is a leading framework for building enterprise-grade Java applications. Its key advantages include:

Rapid Development: Auto-configuration and an opinionated setup drastically reduce boilerplate code.
Robust Ecosystem: Seamless integration with a vast library of tools for security, data access, and more.
Scalability: Built for creating scalable and maintainable microservices and REST APIs.

ReactJS

React is a declarative and component-based JavaScript library for building user interfaces.

Component-Based: Allows you to build encapsulated components that manage their own state, making complex UIs manageable.
Rich User Experience: Enables the creation of fast, responsive, and dynamic single-page applications (SPAs).
Strong Community: Backed by Facebook and a massive community, offering a wealth of resources and libraries.

Google Gemini API

Gemini is Google's latest and most capable family of multimodal AI models. For our app, it's the engine that provides the intelligence.

Advanced Understanding: Gemini can process and understand large contexts of text, making it perfect for analyzing a full resume.
Generative Power: We can instruct it with a specific prompt to extract skills, summarize experience, and check for specific qualifications.
Easy Integration: Provides a straightforward REST API that can be easily called from our Spring Boot backend.

Project Architecture Overview

Our application will have a simple but effective architecture:

ReactJS Frontend: The user will upload a resume in a PDF format through a simple web interface. And file clicking, upload the result will show like ATS score, pros, cons, and recommendations for improvement.

Spring Boot Backend: The frontend sends the resume to a REST endpoint on our Spring Boot server, and then it parses the PDF file and fetches its content it and sends that content with a prompt to the Gemini API.

Gemini API Integration: The backend takes the resume text, wraps it in a carefully crafted prompt, and sends it to the Google Gemini API.

Response Flow: Gemini processes the request and returns a structured JSON analysis. Our backend then forwards this analysis back to the React frontend to be displayed to the user.

Prerequisites

Before you begin, ensure you have the following installed:

Java Development Kit (JDK) 17 or later
Apache Maven
Node.js and npm
An IDE of your choice (e.g., IntelliJ IDEA, VS Code)
A Google AI Studio API Key for the Gemini API. You can get one for free from the Google AI for Developers website.

Part 1: Building the Spring Boot Backend

Let's start by creating the backend service that will communicate with the Gemini API and frontend.

Step 1: Initialize the Spring Boot Project

Go to start.spring.io and configure your project with the following settings:

Project: Maven

Language: Java 17 or later

Spring Boot: The latest stable version

Group: com.resumeanalyzer

Artifact: resume-analyzer

Dependencies: Add Spring Web

Download the generated ZIP file, extract it, and open it in your IDE.

Step 2: Configure the Gemini API

First, let's add your Gemini API key to the configuration file. Never hardcode API keys in your source code.

Open src/main/resources/application.properties and add the following lines:

properties

# Gemini API Configuration
gemini.api.key=YOUR_API_KEY
gemini.project.id=resume-analyzer
gemini.location=us-central1

Replace YOUR_API_KEY_HERE with the key you obtained from Google AI Studio.

Step 3: Create the DTOs (Data Transfer Objects)

We need to create a class that represents the structure of the result that comes from the Google Gemini api.

Create a DTO package. Inside it, create an AnalysisResult.java record to hold the incoming resume text.

Java

package com.resumeanalyzer.model;

import jakarta.persistence.*;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.time.LocalDateTime;
import java.util.List;

@Data
@Entity
@AllArgsConstructor
@NoArgsConstructor
@Table(name = "resume_analyses")
public class AnalysisResult {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String fileName;

    @Column(nullable = false)
    private String overallScore;

    @Column(columnDefinition = "TEXT")
    private String summary;

    @ElementCollection
    @CollectionTable(name = "analysis_pros", joinColumns = @JoinColumn(name = "analysis_id"))
    @Column(name = "pro", columnDefinition = "TEXT")
    private List<String> pros;

    @ElementCollection
    @CollectionTable(name = "analysis_cons", joinColumns = @JoinColumn(name = "analysis_id"))
    @Column(name = "con", columnDefinition = "TEXT")
    private List<String> cons;

    @ElementCollection
    @CollectionTable(name = "analysis_recommendations", joinColumns = @JoinColumn(name = "analysis_id"))
    @Column(name = "recommendation", columnDefinition = "TEXT")
    private List<String> recommendations;

    @Column(nullable = false)
    private LocalDateTime analyzedAt;

    public AnalysisResult(String fileName, String overallScore, String summary, 
                         List<String> pros, List<String> cons, List<String> recommendations, 
                         LocalDateTime analyzedAt) {
        this.fileName = fileName;
        this.overallScore = overallScore;
        this.summary = summary;
        this.pros = pros;
        this.cons = cons;
        this.recommendations = recommendations;
        this.analyzedAt = analyzedAt;
    }
}

Step 4: Build the Service Layer

The service layer will contain the core logic for parsing the content from PDF and communicating with the Gemini API and getting a response, and converting it into a proper DTO structure.

Create a service package and add a ResumeAnalysisService.java class.

Java

package com.resumeanalyzer.service;

import com.resumeanalyzer.model.AnalysisResult;
import com.resumeanalyzer.model.ResumeAnalysis;
import com.resumeanalyzer.repository.ResumeAnalysisRepository;
import lombok.extern.slf4j.Slf4j;
import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.text.PDFTextStripper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.*;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.time.LocalDateTime;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

@Service
@Slf4j
public class ResumeAnalysisService {

    @Value("${gemini.api.key}")
    private String apiKey;

    @Autowired
    private ResumeAnalysisRepository resumeAnalysisRepository;

    private final RestTemplate restTemplate = new RestTemplate();
    private static final String UPLOAD_DIR = "uploads/resumes";
    private static final String GEMINI_API_URL = "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent";

    public AnalysisResult analyzeResume(MultipartFile file) throws IOException {
        createUploadDirectory();
        String fileName = UUID.randomUUID() + "_" + file.getOriginalFilename();
        Path filePath = Paths.get(UPLOAD_DIR, fileName);
        
        try {
            Files.copy(file.getInputStream(), filePath);
            String resumeText = extractTextFromPdf(filePath.toFile());
            AnalysisResult result = analyzeWithGemini(resumeText, fileName);
            
            ResumeAnalysis analysis = new ResumeAnalysis(
                file.getOriginalFilename(),
                result.getOverallScore(),
                result.getSummary()
            );
            resumeAnalysisRepository.save(analysis);
            
            return result;
        } finally {
            Files.deleteIfExists(filePath);
        }
    }

    private void createUploadDirectory() throws IOException {
        Path path = Paths.get(UPLOAD_DIR);
        if (!Files.exists(path)) {
            Files.createDirectories(path);
        }
    }

    private String extractTextFromPdf(File file) throws IOException {
        try (PDDocument document = PDDocument.load(file)) {
            PDFTextStripper stripper = new PDFTextStripper();
            return stripper.getText(document);
        }
    }

    private AnalysisResult analyzeWithGemini(String resumeText, String fileName) {
        String prompt = String.format(
            "Analyze this resume and provide a detailed analysis in EXACTLY this format:\n" +
            "1. Overall Score: [score]/100\n" +
            "2. Summary: [2-3 sentence summary]\n" +
            "3. Pros:\n- [Strength 1]\n- [Strength 2]\n- [Strength 3]\n" +
            "4. Cons:\n- [Weakness 1]\n- [Weakness 2]\n- [Weakness 3]\n" +
            "5. Recommendations:\n- [Suggestion 1]\n- [Suggestion 2]\n- [Suggestion 3]\n\n" +
            "Resume Content:\n%s", 
            resumeText.substring(0, Math.min(resumeText.length(), 15000))
        );


        Map<String, Object> requestBody = new HashMap<>();
        Map<String, Object> content = new HashMap<>();
        Map<String, String> textPart = new HashMap<>();
        textPart.put("text", prompt);
        
        content.put("parts", Collections.singletonList(textPart));
        requestBody.put("contents", Collections.singletonList(content));

        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        headers.set("x-goog-api-key", apiKey);

        try {
            ResponseEntity<Map> response = restTemplate.exchange(
                GEMINI_API_URL,
                HttpMethod.POST,
                new HttpEntity<>(requestBody, headers),
                Map.class
            );

            return parseGeminiResponse(response.getBody(), fileName);
        } catch (Exception e) {
            log.error("Gemini API error: {}", e.getMessage());
            return getFallbackAnalysis(fileName);
        }
    }

    private AnalysisResult parseGeminiResponse(Map<String, Object> response, String fileName) {
        if (response == null || !response.containsKey("candidates")) {
            log.warn("Invalid Gemini response structure");
            return getFallbackAnalysis(fileName);
        }

        try {
            Map<String, Object> candidate = ((List<Map<String, Object>>) response.get("candidates")).get(0);
            Map<String, Object> content = (Map<String, Object>) candidate.get("content");
            String analysisText = (String) ((Map<String, Object>) ((List<?>) content.get("parts")).get(0)).get("text");
            
            log.debug("Gemini raw analysis+++++++++++++++++++++++++++++++:\n{}", response);
            return parseAnalysisText(analysisText, fileName);
        } catch (Exception e) {
            log.error("Response parsing failed: {}", e.getMessage());
            return getFallbackAnalysis(fileName);
        }
    }

    private AnalysisResult parseAnalysisText(String analysisText, String fileName) {
        
        String[] sections = analysisText.split("\\d+\\.\\s");
        
      
        if (sections.length < 6) {
            log.warn("Unexpected section count: {}", sections.length);
            return parseAnalysisTextFallback(analysisText, fileName);
        }
        
        String score = extractScore(sections[1]);
        String summary = extractSummary(sections[2]);
        List<String> pros = extractListItems(sections[3]);
        List<String> cons = extractListItems(sections[4]);
        List<String> recommendations = extractListItems(sections[5]);
        
        return new AnalysisResult(
            fileName,
            score,
            summary,
            pros,
            cons,
            recommendations,
            LocalDateTime.now()
        );
    }
    
    private String extractScore(String section) {
       
        Pattern pattern = Pattern.compile("(\\d+/100)");
        Matcher matcher = pattern.matcher(section);
        return matcher.find() ? matcher.group(1) : "N/A";
    }
    
    private String extractSummary(String section) {
        String summary = section.replaceFirst("Summary[:\\s]*", "");
        return summary.trim().replaceAll("\n", " ");
    }
    
    private List<String> extractListItems(String section) {
        List<String> items = new ArrayList<>();
        String[] lines = section.split("\n");
        
        for (String line : lines) {
            line = line.trim();
            
            if (line.isEmpty() || 
                line.startsWith("Pros:") || 
                line.startsWith("Cons:") || 
                line.startsWith("Recommendations:")) {
                continue;
            }
            
          
            if (line.startsWith("- ") || line.startsWith("* ")) {
                items.add(line.substring(2).trim());
            } 
        
            else if (!line.contains(":") && line.length() > 10) {
                items.add(line);
            }
        }
        return items;
    }
    
    private AnalysisResult parseAnalysisTextFallback(String analysisText, String fileName) {
        log.warn("Using fallback parser for analysis text");
      
        String score = "N/A";
        Pattern pattern = Pattern.compile("(\\d+/100)");
        Matcher matcher = pattern.matcher(analysisText);
        if (matcher.find()) {
            score = matcher.group(1);
        }
        
        String summary = "";
        String[] parts = analysisText.split("2\\.\\s*Summary[:\\s]*", 2);
        if (parts.length > 1) {
            summary = parts[1].split("3\\.\\s*Pros[:\\s]*")[0].trim();
        }
        
        return new AnalysisResult(
            fileName,
            score,
            summary,
            extractListItemsFallback(analysisText, "Pros"),
            extractListItemsFallback(analysisText, "Cons"),
            extractListItemsFallback(analysisText, "Recommendations"),
            LocalDateTime.now()
        );
    }
    
    private List<String> extractListItemsFallback(String text, String sectionName) {
        List<String> items = new ArrayList<>();
        Pattern pattern = Pattern.compile(
            Pattern.quote(sectionName) + "[\\s:]*\\n(-[^\\n]+)"
        );
        Matcher matcher = pattern.matcher(text);
        
        while (matcher.find()) {
            items.add(matcher.group(1).substring(1).trim());
        }
        return items.isEmpty() ? Collections.emptyList() : items;
    }

    private AnalysisResult getFallbackAnalysis(String fileName) {
        return new AnalysisResult(
            fileName,
            "75/100",
            "Generated fallback analysis due to service issues",
            Arrays.asList("Strong technical background", "Good education history"),
            Arrays.asList("Limited work experience", "Could use more quantifiable achievements"),
            Arrays.asList("Add more metrics to experience", "Include relevant certifications"),
            LocalDateTime.now()
        );
    }

    public List<ResumeAnalysis> getUserAnalyses() {
        return resumeAnalysisRepository.findAll();
    }
}

Step 5: Create the REST Controller

Finally, create an endpoint to expose this service. Create a controller package with a ResumeAnalysisController.java class.

Java

package com.resumeanalyzer.controller;

import com.resumeanalyzer.model.AnalysisResult;
import com.resumeanalyzer.model.ResumeAnalysis;
import com.resumeanalyzer.service.ResumeAnalysisService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.util.List;

@RestController
@RequestMapping("/api")
@CrossOrigin(origins = "http://localhost:3000")
public class ResumeAnalysisController {

    @Autowired
    private ResumeAnalysisService resumeAnalysisService;

    @PostMapping("/analyze")
    public ResponseEntity<AnalysisResult> analyzeResume(@RequestParam("file") MultipartFile file) {
        try {
            AnalysisResult result = resumeAnalysisService.analyzeResume(file);
            return ResponseEntity.ok(result);
        } catch (IOException e) {
            return ResponseEntity.badRequest().build();
        }
    }

    @GetMapping("/analyses")
    public ResponseEntity<List<ResumeAnalysis>> getUserAnalyses() {
        List<ResumeAnalysis> analyses = resumeAnalysisService.getUserAnalyses();
        return ResponseEntity.ok(analyses);
    }
}

The @CrossOrigin annotation is crucial for allowing our React app (which will run on port 3000) to communicate with our backend (running on port 8080).

Your backend is now ready! You can run it from your IDE or by using the command mvn spring-boot:run.

Part 2: Building the ReactJS Frontend

Now, let's create the user interface where users can upload their resumes and make sure the design can be varied according to your choices.

Step 1: Initialize the React App

Open your terminal, navigate to your desired project directory (outside the Spring Boot project), and run:

Bash

npx create-react-app resume-analyzer-ui
cd resume-analyzer-ui

Step 2: Install Axios

We'll use Axios to make HTTP requests to our backend.

Bash

npm install axios

Step 3: Create ResumeAnalysis.jsx for handling the resume and there response.

React

import { useState, useCallback } from "react"
import { useDropzone } from "react-dropzone"
import axios from "axios"
import {
    FiUpload,
    FiFile,
    FiAlertTriangle,
    FiClipboard,
    FiCheckCircle,
    FiXCircle,
    FiZap,
    FiRefreshCw,
    FiDownload,
} from "react-icons/fi"

const ResumeAnalysis = () => {
  const [file, setFile] = useState(null)
  const [loading, setLoading] = useState(false)
  const [analysis, setAnalysis] = useState(null)
  const [error, setError] = useState(null)

  const onDrop = useCallback(async (acceptedFiles) => {
    const selectedFile = acceptedFiles[0]
    if (selectedFile) {
      setFile(selectedFile)
      setLoading(true)
      setError(null)

      const formData = new FormData()
      formData.append("file", selectedFile)

      try {
        const response = await axios.post("http://localhost:8080/api/analyze", formData, {
          headers: {
            "Content-Type": "multipart/form-data",
          },
        })
        setAnalysis(response.data)
      } catch (err) {
        setError(err.response?.data?.message || "An error occurred while analyzing the resume")
      } finally {
        setLoading(false)
      }
    }
  }, [])

  const { getRootProps, getInputProps, isDragActive } = useDropzone({
    onDrop,
    accept: {
      "application/pdf": [".pdf"],
    },
    multiple: false,
  })

  const resetAnalysis = () => {
    setFile(null)
    setAnalysis(null)
    setError(null)
  }

  return (
    <div className="min-h-screen bg-gradient-primary px-12 [all:unset]">
      <div className="max-w-6xl  px-4 sm:px-6 lg:px-8 py-8">
         
        <div className="text-center mb-12">
          <div className="inline-flex items-center justify-center w-20 h-20 bg-white/20 rounded-full mb-6 backdrop-blur-glass">
            <FiFile size={40} className="text-white" />
          </div>
          <h1 className="text-5xl sm:text-6xl font-bold text-white mb-4 drop-shadow-lg">AI Resume Analyzer</h1>
          <p className="text-xl text-white/90 max-w-2xl mx-auto">
            Get instant, AI-powered insights to optimize your resume and land your dream job
          </p>
        </div>

        {!analysis && (
          <div className="glass-effect rounded-3xl p-8 mb-8 shadow-card animate-fade-in">
            <div
              {...getRootProps()}
              className={`relative transition-all duration-300 ease-in-out border-2 border-dashed rounded-2xl p-12 text-center cursor-pointer group ${
                isDragActive
                  ? "border-primary-500 bg-primary-50 scale-[1.02] shadow-card-hover"
                  : "border-gray-300 hover:border-primary-400 hover:bg-gray-50/50"
              }`}
            >
              <input {...getInputProps()} />
              <div className="flex flex-col items-center">
                <div
                  className={`w-20 h-20 rounded-full flex items-center justify-center mb-6 transition-all duration-300 ${
                    isDragActive
                      ? "bg-primary-100 scale-110"
                      : "bg-gray-100 group-hover:bg-primary-50 group-hover:scale-105"
                  }`}
                >
                  <FiUpload
                    size={32}
                    className={`transition-colors duration-300 ${
                      isDragActive ? "text-primary-600" : "text-gray-400 group-hover:text-primary-500"
                    }`}
                  />
                </div>
                <h3 className="text-2xl font-semibold text-gray-900 mb-2">
                  {isDragActive ? "Drop your resume here!" : "Upload your resume"}
                </h3>
                <p className="text-gray-600 mb-6 text-lg">Drag and drop your PDF file here, or click to browse</p>
                <button className="inline-flex items-center px-8 py-4 bg-gradient-primary text-white font-semibold rounded-xl hover:shadow-lg transform hover:scale-105 transition-all duration-200 focus:outline-none focus:ring-4 focus:ring-primary-200">
                  <FiUpload size={20} className="mr-2" />
                  Choose File
                </button>
                <p className="text-sm text-gray-500 mt-4">Only PDF files are supported • Max 10MB</p>
              </div>
            </div>

            {file && (
              <div className="mt-6 p-4 bg-success-50 border border-success-200 rounded-xl animate-slide-up ">
                <div className="flex items-center">
                  <FiCheckCircle size={24} className="text-success-500 mr-3" />
                  <div>
                    <p className="text-success-800 font-semibold">File uploaded successfully</p>
                    <p className="text-success-600 text-sm">{file.name}</p>
                  </div>
                </div>
              </div>
            )}
          </div>
        )}

    
        {loading && (
          <div className="glass-effect rounded-3xl p-12 text-center mx-12 mb-8 shadow-card animate-fade-in">
            <div className="w-16 h-16 border-4 border-primary-200 border-t-primary-600 rounded-full animate-spin mx-auto mb-6"></div>
            <h3 className="text-2xl font-semibold text-gray-900 mb-2">Analyzing Your Resume</h3>
            <p className="text-gray-600 text-lg">Our AI is reviewing your resume for optimization opportunities...</p>
          </div>
        )}

        {error && (
          <div className="glass-effect rounded-3xl p-8 mb-8 shadow-card animate-fade-in">
            <div className="bg-danger-50 border border-danger-200 rounded-xl p-6">
              <div className="flex items-center">
                <FiAlertTriangle size={24} className="text-danger-500 mr-3" />
                <div>
                  <h4 className="text-danger-800 font-semibold">Analysis Failed</h4>
                  <p className="text-danger-600">{error}</p>
                </div>
              </div>
            </div>
          </div>
        )}

        {analysis && (
          <div className="glass-effect rounded-3xl overflow-hidden shadow-card animate-fade-in" style={{margin:'40px'}}>
 
            <div className="bg-gradient-success p-8 text-white">
              <div className="flex justify-between items-center flex-wrap gap-4">
                <div>
                  <h2 className="text-3xl font-bold mb-2">Analysis Complete</h2>
                  <p className="text-green-100 text-lg">Here's your detailed resume breakdown</p>
                </div>
                <div className="text-right">
                  <div className="text-5xl font-bold">{analysis.overallScore}</div>
                  <div className="text-green-100">Overall Score</div>
                </div>
              </div>
            </div>

            <div className="p-8">
     
              {analysis.summary && (
                <div className="mb-8">
                  <h3 className="text-xl font-semibold text-gray-900 mb-4 flex items-center">
                    <FiClipboard size={24} className="text-info-500 mr-3" />
                    Executive Summary
                  </h3>
                  <div className="bg-info-50 border-l-4 border-info-400 p-6 rounded-r-xl">
                    <p className="text-gray-700 leading-relaxed text-lg">{analysis.summary}</p>
                  </div>
                </div>
              )}

     
              <div className="grid grid-cols-1 lg:grid-cols-3 gap-6">
   
                <div className="bg-success-50 border border-success-200 rounded-2xl p-6 hover:shadow-lg transition-shadow duration-300">
                  <div className="flex items-center mb-4">
                    <FiCheckCircle size={24} className="text-success-500 mr-3" />
                    <h3 className="text-xl font-semibold text-success-800">Strengths</h3>
                  </div>
                  <ul className="space-y-3">
                    {analysis.pros?.length > 0 ? (
                      analysis.pros.map((item, index) => (
                        <li key={index} className="flex items-start text-success-700">
                          <span className="text-success-500 mr-3 mt-1 text-lg">•</span>
                          <span className="text-sm leading-relaxed">{item}</span>
                        </li>
                      ))
                    ) : (
                      <li className="text-success-600 italic text-sm">No strengths identified</li>
                    )}
                  </ul>
                </div>

             
                <div className="bg-danger-50 border border-danger-200 rounded-2xl p-6 hover:shadow-lg transition-shadow duration-300">
                  <div className="flex items-center mb-4">
                    <FiXCircle size={24} className="text-danger-500 mr-3" />
                    <h3 className="text-xl font-semibold text-danger-800">Areas to Improve</h3>
                  </div>
                  <ul className="space-y-3">
                    {analysis.cons?.length > 0 ? (
                      analysis.cons.map((item, index) => (
                        <li key={index} className="flex items-start text-danger-700">
                          <span className="text-danger-500 mr-3 mt-1 text-lg">•</span>
                          <span className="text-sm leading-relaxed">{item}</span>
                        </li>
                      ))
                    ) : (
                      <li className="text-danger-600 italic text-sm">No issues identified</li>
                    )}
                  </ul>
                </div>

                <div className="bg-info-50 border border-info-200 rounded-2xl p-6 hover:shadow-lg transition-shadow duration-300">
                  <div className="flex items-center mb-4">
                    <FiZap size={24} className="text-info-500 mr-3" />
                    <h3 className="text-xl font-semibold text-info-800">Recommendations</h3>
                  </div>
                  <ul className="space-y-3">
                    {analysis.recommendations?.length > 0 ? (
                      analysis.recommendations.map((item, index) => (
                        <li key={index} className="flex items-start text-info-700">
                          <span className="text-info-500 mr-3 mt-1 text-lg">•</span>
                          <span className="text-sm leading-relaxed">{item}</span>
                        </li>
                      ))
                    ) : (
                      <li className="text-info-600 italic text-sm">No recommendations available</li>
                    )}
                  </ul>
                </div>
              </div>

              <div className="mt-8 flex justify-center gap-4 flex-wrap">
                
                <button
                  onClick={resetAnalysis}
                  className="inline-flex items-center px-8 py-4 bg-white border-2 border-gray-300 text-gray-700 font-semibold rounded-xl hover:bg-gray-50 hover:shadow-lg transform hover:scale-105 transition-all duration-200"
                >
                  <FiRefreshCw size={20} className="mr-2" />
                  Analyze Another
                </button>
              </div>
            </div>
          </div>
        )}
      </div>
    </div>
  )
}

export default ResumeAnalysis

Running the Full Application

Start the Backend: Run your Spring Boot application. It will start on http://localhost:8080.

Start the Frontend: In your resume-analyzer-ui directory, run the command npm start. Your browser will open to http://localhost:3000.

Now, you can upload a PDF resume file, and within seconds, you will see an analysis generated by the Gemini API.

Output:

As we already discussed, the design should be changed according to your requirements.

Potential Enhancements

This is a fantastic starting point. Here are some ways you can enhance this project:

Database Integration: Save the analysis results to a database like PostgreSQL.

User Accounts: Implement Spring Security to allow users to sign up and view their history of analyzed resumes.

Improved UI: Use a component library like Material-UI or Ant Design to create a more sophisticated user interface.

Conclusion

Congratulations! You have successfully built a full-stack resume analysis web application using Spring Boot, ReactJS, and the Google Gemini API. This project demonstrates how you can integrate powerful generative AI capabilities into traditional web applications to create truly intelligent and useful tools. By mastering this stack, you are well-equipped to build the next generation of smart software.

Mastering JPA Relationships: A Complete Guide with a Real-World Project

2025-10-26T18:03:00.004+05:30

In this article, We will go throught all the important concept of the JPA Mapping with across the tables present in the databases.

So, lets first see about Hibernate, Hibernate, are the backbone of data persistence in the Java world. While basic CRUD operations are straightforward because only do the basic operation like create,read, update and delete with only table, things get tricky when you start modeling real-world connections between your data or uses multiple tables the are realted to each other or you can say that are mapped together. NullPointerExceptions, infinite loops during JSON serialization, and confusing database schemas often stem from misunderstood JPA relationships.

So, in this article we will learn terms like mappedBy, CascadeType, or @JoinTable, and many more.

Using this article, we not only learn this terms, instead we will build the real-world application to get practical knowledge of it. We will build a mini blog application where we try to understood but multiple data relation with each other.

By the end of this article, you will have understanding of the following:

@OneToOne: For linking a user to their profile. Every Users have one profile.

@OneToMany & @ManyToOne: For Linking a user to the posts that they have written.

@ManyToMany: For linking posts to their corresponding mulitple tags.

Project Setup: The Blogging Platform

We are building a simple blog application. Where we will create our core entities like: User, UserProfile, Post, and Tag. We will use these entity to demonstrate each relationship type of JPA.

Let's starts,

1. The @OneToOne Relationship: User and UserProfile

A one-to-one relationship is the simplest realtionship annotation. In our blog, we want each User to have exactly one UserProfile containing extra details like a bio or a profile picture URL.

The Concept: One User record corresponds to one UserProfile record.

The User Entity

We will create the User Entity, with Id which is unique and can be generated automatic, username, password.

The "owning" side of the relationship is the entity that holds the foreign key. In our case, we'll add a user_profile_id column to our users table. Means User table have a foriegn key which make a realtionship with the profile table.

Java

// src/main/java/com/yourblog/model/User.java
import jakarta.persistence.*;
// other imports

@Entity
@Table(name = "users")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, unique = true)
    private String username;

    private String password;

    // The OneToOne mapping starts here
    @OneToOne(cascade = CascadeType.ALL, orphanRemoval = true)
    @JoinColumn(name = "user_profile_id", referencedColumnName = "id")
    private UserProfile userProfile;

    // Getters and Setters
}

The UserProfile Entity (Referenced Side)

We will create the UserProfile Entity which contain id, bioand profile picture url.

The other side of the relationship uses the mappedBy attribute to indicate that the relationship is already configured by the User entity. It's means we told that the relation is already defined by the user entity.

Java

// src/main/java/com/yourblog/model/User.java
import jakarta.persistence.*;
// other imports

@Entity
@Table(name = "users")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, unique = true)
    private String username;

    private String password;

    // The OneToOne mapping starts here
    @OneToOne(cascade = CascadeType.ALL, orphanRemoval = true)
    @JoinColumn(name = "user_profile_id", referencedColumnName = "id")
    private UserProfile userProfile;

    // Getters and Setters
}

Key Points Explained:

@OneToOne: Declares the relationship.

@JoinColumn(name = "user_profile_id"): Specifies the foreign key column in the users table. This makes User the owner of the relationship.

mappedBy = "userProfile": On the UserProfile side, this tells JPA, "Don't create another foreign key. The configuration for this relationship is already defined by the userProfile field in the User entity."

cascade = CascadeType.ALL: A convenient feature. If you save a User, its associated UserProfile is also saved. If you delete a User, the UserProfile is deleted too.

orphanRemoval = true: If you set user.setUserProfile(null), the previously associated UserProfile will be deleted from the database because it no longer has an owner.

2. The @OneToMany & @ManyToOne Relationships: User and Post

This is the most common type of relationship. A single user can write many blog posts, but each blog post is written by only one user.

The Concept: A single User record can be associated with multiple Post records.

The Post Entity (The "Many" Side and Owning Side)

The "Many" side almost always owns the relationship because it's more logical for the posts table to have a user_id column than for the users table to hold a list of post IDs.

Java

// src/main/java/com/yourblog/model/Post.java
import jakarta.persistence.*;
// other imports

@Entity
@Table(name = "posts")
public class Post {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String title;

    @Lob // For large text fields
    private String content;

    // The ManyToOne mapping starts here
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "user_id", nullable = false)
    private User author;

    // Getters and Setters
}

The User Entity (The "One" Side)

Now, we update the User entity to hold a list of all their posts.

Java

// src/main/java/com/yourblog/model/User.java
// ... existing User code ...

@Entity
@Table(name = "users")
public class User {
    // ... id, username, userProfile ...

    // The OneToMany mapping starts here
    @OneToMany(
        mappedBy = "author",
        cascade = CascadeType.ALL,
        orphanRemoval = true
    )
    private List posts = new ArrayList<>();

    // ... Getters and Setters ...

    // Helper methods to keep both sides of the relationship in sync
    public void addPost(Post post) {
        posts.add(post);
        post.setAuthor(this);
    }

    public void removePost(Post post) {
        posts.remove(post);
        post.setAuthor(null);
    }
}

Key Points Explained:

@ManyToOne: In the Post entity, this declares that many posts can be linked to one user.

@JoinColumn(name = "user_id"): This creates the user_id foreign key column in the posts table. The Post is the owner of the relationship.

fetch = FetchType.LAZY: This is a critical performance optimization. When you load a Post, JPA will not automatically load its author. It will only be fetched when you explicitly call post.getAuthor().

@OneToMany: In the User entity, this declares that one user can have many posts.

mappedBy = "author": This is essential! It tells JPA that the Post entity is the owner and the relationship is mapped by the author field in the Post class. Without this, JPA would try to create a third "join table," which is not what we want here.

3. The @ManyToMany Relationship: Post and Tag

This is the most complex relationship. A single post can have many tags (e.g., "Java," "JPA," "Spring"), and a single tag can be applied to many different posts.

The Concept: You need a third table, known as a join table or link table, to manage these associations. This table will only contain two columns: post_id and tag_id.

The Post and Tag Entities

Let's first define the simple Tag entity.

Java

// src/main/java/com/yourblog/model/Tag.java
import jakarta.persistence.*;
// other imports

@Entity
@Table(name = "tags")
public class Tag {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, unique = true)
    private String name;

    @ManyToMany(mappedBy = "tags")
    private Set posts = new HashSet<>();

    // Getters and Setters
}

Now, let's update the Post entity to be the owner of the relationship.

Java

// src/main/java/com/yourblog/model/Post.java
// ... existing Post code ...

@Entity
@Table(name = "posts")
public class Post {
    // ... id, title, content, author ...

    // The ManyToMany mapping starts here
    @ManyToMany(cascade = { CascadeType.PERSIST, CascadeType.MERGE })
    @JoinTable(
        name = "post_tags",
        joinColumns = @JoinColumn(name = "post_id"),
        inverseJoinColumns = @JoinColumn(name = "tag_id")
    )
    private Set tags = new HashSet<>();
    
    // Getters and Setters
}

Key Points Explained:

@ManyToMany: Declares the relationship on both entities.

@JoinTable: This annotation is used on the owning side (Post in our case) to configure the join table.

name = "post_tags": The name of our new join table.

joinColumns: Defines the foreign key column in the join table that refers to the owning entity (Post).

inverseJoinColumns: Defines the foreign key column that refers to the other side (Tag).

mappedBy = "tags": Just like before, this is used on the non-owning side (Tag) to point back to the field that configured the relationship.

Set vs List: We use Set here because the order of tags for a post doesn't matter, and we want to ensure no duplicate tags are associated with a single post.

How All tables is Created in Databases After Ruuning our backend applicaiton

user_profiles

users

Conclusion: From Confusion to Clarity

By modeling a real-world project, we've transformed abstract annotations into a concrete, understandable database structure.

Let's recap our journey:

@OneToOne is perfect for optional, singular details, like a User and UserProfile.

@OneToMany and @ManyToOne are your workhorses for parent-child relationships, like a User and their Posts. Remember to place the @ManyToOne on the "child" and make it the owner.

@ManyToMany handles complex webs of connections, like Posts and Tags, by using a dedicated join table.

Understanding these relationships is the key to unlocking the full power of JPA and building robust, scalable Java applications. Start by identifying the relationships in your own projects and see if you can model them.

What other JPA challenges do you face? Share them in the comments below!

Securing APIs with Spring Security and JWT: A Full-Stack Guide for Spring Boot & React

2025-10-25T20:03:00.001+05:30

In our previous article on creating a CRUD application, we built a fully functional user management system (CRUD Operation). However, it has a critical vulnerability: all its API endpoints are public. Anyone can create, read, update, or delete users without any checks. It's time to lock it down.

So, this article will teach you how to implement robust, token-based authentication using Spring Security and JSON Web Tokens (JWT). We will secure our Spring Boot backend application and modify our React frontend to handle user registration, login, and authenticated requests.

By the end of this article, you'll understand how to protect your application and manage user sessions in a modern, stateless way, which is perfect for Single-Page Applications (SPAs) like React.

So, let's get started,

Prerequisites

In this tutorial, we will implement security in our previous CRUD application. You should have:

A working Spring Boot + React CRUD application.
Basic knowledge of Spring Boot and React.
JDK, Maven, Node.js, and MySQL are installed.

Part 1: Understanding the JWT Authentication Flow

Before we write any code, let's understand how JWT authentication works. Unlike traditional session-based authentication, JWT is stateless. This means the server doesn't need to store session information, which makes our application highly scalable.

Here's the flow:

Login: The user sends their username and password to the backend application.
Validation: The server validates the credentials with our database's stored credentials.
Token Generation: If valid, the server generates a signed JWT token. This token contains user information (like username and roles) and an expiration date.
Token to Client: The server sends this JWT back to the client.
Token Storage: The React app stores the JWT, typically in localStorage, which can be used further.
Authenticated Requests: For every subsequent request to a protected API endpoint, the client includes the JWT in the Authorization header as a Bearer Token, which is used as an authentic key.
Server Verification: A security filter on the server intercepts the request, validates the JWT's signature and expiration, and if the key is valid, then processes the request; otherwise, it gives an error 401 unauthorized access.

Part 2: Enhancing the Spring Boot Backend for Security

Let's start by adding the necessary security layers to our backend application. Follow the necessary steps for your application.

Step 1: Add New Dependencies

Open your pom.xml and add the dependencies for Spring Security and JWT. We'll use the popular jjwt library. This is the following dependency that we have to add in our pom.xml, you should have to use the latest depency in your application. You can easily find these dependencies from the Maven Repository

  
  		<dependency>
			<groupid>org.springframework.boot</groupid>
			<artifactid>spring-boot-starter-security</artifactid>
		</dependency>
		<dependency>
			<groupid>io.jsonwebtoken</groupid>
			<artifactid>jjwt-impl</artifactid>
			<version>0.12.6</version>
			<scope>runtime</scope>
		</dependency>

		<dependency>
			<groupid>io.jsonwebtoken</groupid>
			<artifactid>jjwt-jackson</artifactid>
			<version>0.12.6</version>
			<scope>runtime</scope>
		</dependency>

		<dependency>
			<groupid>io.jsonwebtoken</groupid>
			<artifactid>jjwt-api</artifactid>
			<version>0.12.6</version>
		</dependency>

Step 2: Configure Application Properties for JWT

Add a secret key and token expiration time to your application.properties, so that we will use it in our application codebase. And remember, never hardcode secrets in your code!

properties

# JWT Configuration
jwt.secret=your-super-secret-key-that-is-long-and-secure-enough
jwt.expiration.ms=86400000 # 24 hours

Step 3: Create JWT Utility Class

We will create a class that will handle generating, parsing, and validating JWT tokens. So, the code below does the task of generating the JWT token from the username and adds the expiration time to it. And also, we will create a function that will fetch the username from the token. And we will create the validateToken function for validating the token, which will return either true or false based on the authenticity of the token.

src/main/java/com/example/crudbackend/security/JwtTokenProvider.java

Java

package com.example.crudbackend.security;

import io.jsonwebtoken.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.core.Authentication;
import org.springframework.stereotype.Component;

import java.util.Date;

@Component
public class JwtTokenProvider {

    @Value("${jwt.secret}")
    private String jwtSecret;

    @Value("${jwt.expiration.ms}")
    private int jwtExpirationInMs;

    public String generateToken(Authentication authentication) {
        // In a real app, you'd get the user principal
        String username = authentication.getName();
        Date now = new Date();
        Date expiryDate = new Date(now.getTime() + jwtExpirationInMs);

        return Jwts.builder()
                .setSubject(username)
                .setIssuedAt(new Date())
                .setExpiration(expiryDate)
                .signWith(SignatureAlgorithm.HS512, jwtSecret)
                .compact();
    }

    public String getUsernameFromJWT(String token) {
        Claims claims = Jwts.parser()
                .setSigningKey(jwtSecret)
                .parseClaimsJws(token)
                .getBody();
        return claims.getSubject();
    }

    public boolean validateToken(String authToken) {
        try {
            Jwts.parser().setSigningKey(jwtSecret).parseClaimsJws(authToken);
            return true;
        } catch (SignatureException | MalformedJwtException | ExpiredJwtException | UnsupportedJwtException | IllegalArgumentException ex) {
            // Log the error
        }
        return false;
    }
}

Step 4: Create a Custom UserDetailsService

Spring Security needs to know how to load user data from our MySQL database. We'll implement the UserDetailsService interface.

So, basically, we have to tell Spring Security that we will consider the email as a username for authentication, and for that, we will implement the custom userDetailService.

First, add a password field to your User entity and update UserRepository to find a user by email.

User.java (add password field):

Java

private String password;

UserRepository.java (add new method):

Java

import java.util.Optional;
// ...
Optional findByEmail(String email);

Now, create the service.

src/main/java/com/example/crudbackend/service/CustomUserDetailsService.java

Java

package com.example.crudbackend.service;

import com.example.crudbackend.model.User;
import com.example.crudbackend.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

import java.util.ArrayList;

@Service
public class CustomUserDetailsService implements UserDetailsService {

    @Autowired
    private UserRepository userRepository;

    @Override
    public UserDetails loadUserByUsername(String email) throws UsernameNotFoundException {
        User user = userRepository.findByEmail(email)
                .orElseThrow(() -> new UsernameNotFoundException("User not found with email: " + email));

        return new org.springframework.security.core.userdetails.User(user.getEmail(), user.getPassword(), new ArrayList<>());
    }
}

Step 5: Create the JWT Authentication Filter

This filter will execute once per request. It will read the JWT from the header, validate it, and set the user's authentication in the security context.

src/main/java/com/example/crudbackend/security/JwtAuthenticationFilter.java

Java

package com.example.crudbackend.security;

import com.example.crudbackend.service.CustomUserDetailsService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.util.StringUtils;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class JwtAuthenticationFilter extends OncePerRequestFilter {

    @Autowired
    private JwtTokenProvider tokenProvider;
    @Autowired
    private CustomUserDetailsService customUserDetailsService;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        try {
            String jwt = getJwtFromRequest(request);
            if (StringUtils.hasText(jwt) && tokenProvider.validateToken(jwt)) {
                String username = tokenProvider.getUsernameFromJWT(jwt);
                UserDetails userDetails = customUserDetailsService.loadUserByUsername(username);
                UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
                authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                SecurityContextHolder.getContext().setAuthentication(authentication);
            }
        } catch (Exception ex) {
            logger.error("Could not set user authentication in security context", ex);
        }
        filterChain.doFilter(request, response);
    }

    private String getJwtFromRequest(HttpServletRequest request) {
        String bearerToken = request.getHeader("Authorization");
        if (StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer ")) {
            return bearerToken.substring(7);
        }
        return null;
    }
}

Step 6: Configure Spring Security

This is the main configuration file where we tie everything together. We'll define which endpoints are public (like login/register) and which are protected.

So, this is the main file, where we will configure the public or protected api, and other authentication things, CORS-related configuration, and many more.

src/main/java/com/example/crudbackend/config/SecurityConfig.java

Java

package com.example.crudbackend.config;

import com.example.crudbackend.security.JwtAuthenticationFilter;
import com.example.crudbackend.service.CustomUserDetailsService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.BeanIds;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private CustomUserDetailsService customUserDetailsService;

    @Bean
    public JwtAuthenticationFilter jwtAuthenticationFilter() {
        return new JwtAuthenticationFilter();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(customUserDetailsService).passwordEncoder(passwordEncoder());
    }

    @Bean(BeanIds.AUTHENTICATION_MANAGER)
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .cors()
            .and()
            .csrf().disable() // We disable CSRF because we are using JWT
            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            .and()
            .authorizeRequests()
            .antMatchers("/api/auth/**").permitAll() // Public endpoints
            .anyRequest().authenticated(); // All other endpoints require authentication

        // Add our custom JWT security filter
        http.addFilterBefore(jwtAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class);
    }
}

Step 7: Create an Authentication Controller

Finally, we need endpoints for user registration and login.

So, we will create a login and registration api where we take a request from the user and generate and validate the JWT by our predefined function that we will write already in the above files.

And when a user first registers at that time, we have to save the user's details to the database.

src/main/java/com/example/crudbackend/controller/AuthController.java

Java

package com.example.crudbackend.controller;

import com.example.crudbackend.model.User;
import com.example.crudbackend.payload.LoginRequest;
import com.example.crudbackend.payload.JwtAuthenticationResponse;
import com.example.crudbackend.repository.UserRepository;
import com.example.crudbackend.security.JwtTokenProvider;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.web.bind.annotation.*;

@CrossOrigin(origins = "http://localhost:3000")
@RestController
@RequestMapping("/api/auth")
public class AuthController {

    @Autowired
    AuthenticationManager authenticationManager;

    @Autowired
    UserRepository userRepository;

    @Autowired
    PasswordEncoder passwordEncoder;

    @Autowired
    JwtTokenProvider tokenProvider;

    @PostMapping("/login")
    public ResponseEntity authenticateUser(@RequestBody LoginRequest loginRequest) {
        Authentication authentication = authenticationManager.authenticate(
                new UsernamePasswordAuthenticationToken(loginRequest.getEmail(), loginRequest.getPassword())
        );

        SecurityContextHolder.getContext().setAuthentication(authentication);
        String jwt = tokenProvider.generateToken(authentication);
        return ResponseEntity.ok(new JwtAuthenticationResponse(jwt));
    }

    @PostMapping("/register")
    public ResponseEntity registerUser(@RequestBody User signUpRequest) {
        if (userRepository.findByEmail(signUpRequest.getEmail()).isPresent()) {
            return ResponseEntity.badRequest().body("Email Address already in use!");
        }

        // Creating user's account
        User user = new User();
        user.setFirstName(signUpRequest.getFirstName());
        user.setLastName(signUpRequest.getLastName());
        user.setEmail(signUpRequest.getEmail());
        user.setPassword(passwordEncoder.encode(signUpRequest.getPassword()));

        userRepository.save(user);
        return ResponseEntity.ok("User registered successfully");
    }
}

// Create simple payload classes for LoginRequest and JwtAuthenticationResponse
// e.g., LoginRequest.java with String email, String password
// e.g., JwtAuthenticationResponse.java with String accessToken

The backend is now secure! All requests to /api/v1/users/** will be rejected with a 401 Unauthorized error unless a valid JWT is provided.

Part 3: Updating the React Frontend

Now, our backend is ready now, let's make our React app aware of authentication.

Step 1: Create Login/Register Components

Create new components for login and registration forms. For brevity, we'll focus on the logic. You can use simple Bootstrap forms.

Step 2: Update the API Service

Modify UserService.js to include login/register methods and set up an Axios interceptor. This interceptor will automatically add the JWT to the header of every API call. This is the most elegant way to handle tokens. So, when the user signs in, it sends the request to the backend, and from the backend, we get a token, and that token we will save to our local storage

src/services/AuthService.js (a new service file)

JavaScript

import axios from 'axios';

const API_URL = 'http://localhost:8080/api/auth/';

class AuthService {
    login(email, password) {
        return axios
            .post(API_URL + 'login', { email, password })
            .then(response => {
                if (response.data.accessToken) {
                    localStorage.setItem('user', JSON.stringify(response.data));
                }
                return response.data;
            });
    }

    logout() {
        localStorage.removeItem('user');
    }

    register(firstName, lastName, email, password) {
        return axios.post(API_URL + 'register', {
            firstName,
            lastName,
            email,
            password
        });
    }

    getCurrentUser() {
        return JSON.parse(localStorage.getItem('user'));
    }
}

export default new AuthService();

Now, let's create a central place for our authenticated Axios instance.

src/services/api.js

JavaScript

import axios from "axios";
import AuthService from "./AuthService";

const api = axios.create({
  baseURL: "http://localhost:8080/api/v1",
});

api.interceptors.request.use(
  (config) => {
    const user = AuthService.getCurrentUser();
    if (user && user.accessToken) {
      config.headers["Authorization"] = "Bearer " + user.accessToken;
    }
    return config;
  },
  (error) => {
    return Promise.reject(error);
  }
);

export default api;

Now, modify your UserService.js to use this new api instance instead of the base axios.

src/services/UserService.js (Updated)

JavaScript

import api from './api'; // Import the configured api instance

class UserService {
    getUsers() {
        return api.get('/users');
    }

    // ... other methods (createUser, updateUser, etc.) also use `api`
    createUser(user) {
        return api.post('/users', user);
    }
    // ...
}

export default new UserService();

Step 3: Manage Auth State in the App

In your main App.js, manage the authentication state. Show login/register links if not logged in, and show the user management UI and a logout button if logged in.

JavaScript

// In App.js
import React, { useState, useEffect } from 'react';
import AuthService from './services/AuthService';
// ... other imports

function App() {
    const [currentUser, setCurrentUser] = useState(undefined);

    useEffect(() => {
        const user = AuthService.getCurrentUser();
        if (user) {
            setCurrentUser(user);
        }
    }, []);

    const handleLogout = () => {
        AuthService.logout();
        setCurrentUser(undefined);
    };

    return (
        <div>
            <nav className="navbar navbar-expand navbar-dark bg-dark">
                <div className="navbar-nav mr-auto">
                    {/* Other nav items */}
                </div>

                {currentUser ? (
                    <div className="navbar-nav ml-auto">
                        <li className="nav-item">
                            <a href="/login" className="nav-link" onClick={handleLogout}>
                                Logout
                            </a>
                        </li>
                    </div>
                ) : (
                    <div className="navbar-nav ml-auto">
                        <li className="nav-item">
                            {/* Link to your login component */}
                        </li>
                    </div>
                )}
            </nav>

            <div className="container mt-3">
                {/* Use React Router to show components based on auth state and URL */}
                {currentUser ? (
                    // Show the UserManagementComponent
                ) : (
                    // Show Login/Register components
                )}
            </div>
        </div>
    );
}

Output:

Customize the CSS according to your requirements.

Registration page

Login Page

After Login

Conclusion

You have successfully transformed a simple CRUD application into a secure, enterprise-ready system. You learned how to:

Configure Spring Security from the ground up.
Implement stateless authentication using JSON Web Tokens (JWT).
Create public and protected API endpoints.
Hash passwords using BCrypt.
Handle login and registration on the React frontend.
Use Axios interceptors to seamlessly send the JWT with every authenticated request.

Creating a CRUD Application with Spring Boot and React: A Step-by-Step Guide with MySQL

2025-10-24T19:27:00.003+05:30

In modern web development, the combination of a powerful backend framework like Spring Boot and a flexible frontend library like React is a popular choice for building robust, scalable applications. When you add MySQL, one of the world's most popular open-source databases, you have a complete, enterprise-ready technology stack.

This article will walk through the entire process of building a full-stack CRUD (Create, Read, Update, Delete) application. We'll create a Spring Boot backend to manage a list of users by creating a REST API, and connect with a React frontend.

By the end of this tutorial, you will have a practical understanding of the REST api in Spring Boot and how to use the api in our frontend application.

Prerequisites

Before we start, make sure you have the following installed:

Java Development Kit (JDK).
Maven or Gradle for dependency management. We'll use Maven in this guide.
An IDE like IntelliJ IDEA or Eclipse.
Node.js and npm for managing the React project.
MySQL Server and a client like MySQL Workbench.

Let's first set up our backend application using Spring Boot.

Part 1: Building the Backend with Spring Boot

First, we'll create the Spring Boot application that we will use to create a REST API.

Step 1: Initialize the Spring Boot Project

The easiest way to start is with the Spring Initializr.

Go to start.spring.io.
Configure your project:

Project: Maven
Language: Java
Spring Boot: The latest stable version.
Group: com.example
Artifact: crud-backend
Packaging: Jar
Java: choose the latest one

Add the following dependencies:

Spring Web: For building RESTful web applications.
Spring Data JPA: To simplify database interactions using ORM.
MySQL Driver: The JDBC driver that helps to connect to MySQL.
Lombok: Reduces boilerplate code like getters, setters, and constructors.
DevTools: For development purposes, to not restart the application after changes to the codebase.

Click "Generate" to download the project zip file. Unzip it and open it in your IDE.

Step 2: Configure the MySQL Database Connection

Open the src/main/resources/application.properties file and add your MySQL database configuration. Create a database named user_management_db in your MySQL server beforehand.

application.properties

# MySQL Database Configuration
spring.datasource.url=jdbc:mysql://localhost:3306/user
spring.datasource.username=root
spring.datasource.password=root

# JPA/Hibernate Configuration
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL8Dialect

spring.datasource.url: This tells the database url, and here user is a database name.

spring.datasource.username: username for accessing the database.

spring.datasource.password: passwords for accessing the database.

spring.jpa.hibernate.ddl-auto=update: This tells Hibernate to automatically update the database schema based on your entities. For production, you should use a migration tool like Flyway

Step 3: Create the Model (Entity)

Now, let's define the data model. Create a User class that creates a table of users in the database with the help of Hibernate.

src/main/java/com/example/crudbackend/model/User.java

Java

package com.example.crudbackend.model;

import lombok.Data;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "users")
@Data // Lombok annotation for getters, setters, toString, etc.
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String firstName;
    private String lastName;
    private String email;
}

@Entity: Marks this class as a JPA entity.

@Table(name = "users"): Specifies the table name in the database.

@Id: Designates the id field as the primary key.

@GeneratedValue: Configures the primary key generation strategy. IDENTITY is a good choice for MySQL.

@Data: A Lombok annotation that generates all the boilerplate for us.

Step 4: Build the Repository Interface

The repository is the layer that interacts with the database. Spring Data JPA helps to interact with the database without writing the SQL query.

Create a UserRepository interface that extends JpaRepository.

src/main/java/com/example/crudbackend/repository/UserRepository.java

Java

package com.example.crudbackend.repository;

import com.example.crudbackend.model.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserRepository extends JpaRepository {
}

JpaRepository<User, Long> gives us all the standard CRUD methods that give default such as findAll, findById, save, and deleteById methods to use.

Step 5: Develop the REST Controller

The controller exposes our CRUD operations as RESTful API endpoints.

Create a UserController class.

src/main/java/com/example/crudbackend/controller/UserController.java

Java

package com.example.crudbackend.controller;

import com.example.crudbackend.model.User;
import com.example.crudbackend.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@CrossOrigin(origins = "http://localhost:3000") // Allow requests from React app
@RestController
@RequestMapping("/api/v1/users")
public class UserController {

    @Autowired
    private UserRepository userRepository;

    // Get all users
    @GetMapping
    public List getAllUsers() {
        return userRepository.findAll();
    }

    // Create a new user
    @PostMapping
    public User createUser(@RequestBody User user) {
        return userRepository.save(user);
    }

    // Get a single user by id
    @GetMapping("/{id}")
    public ResponseEntity getUserById(@PathVariable Long id) {
        User user = userRepository.findById(id)
                .orElseThrow(() -> new RuntimeException("User not found with id: " + id));
        return ResponseEntity.ok(user);
    }

    // Update a user
    @PutMapping("/{id}")
    public ResponseEntity updateUser(@PathVariable Long id, @RequestBody User userDetails) {
        User user = userRepository.findById(id)
                .orElseThrow(() -> new RuntimeException("User not found with id: " + id));

        user.setFirstName(userDetails.getFirstName());
        user.setLastName(userDetails.getLastName());
        user.setEmail(userDetails.getEmail());

        User updatedUser = userRepository.save(user);
        return ResponseEntity.ok(updatedUser);
    }

    // Delete a user
    @DeleteMapping("/{id}")
    public ResponseEntity deleteUser(@PathVariable Long id) {
        User user = userRepository.findById(id)
                .orElseThrow(() -> new RuntimeException("User not found with id: " + id));

        userRepository.delete(user);
        return ResponseEntity.noContent().build();
    }
}

Key Annotations:

@RestController: Combines @Controller and @ResponseBody, marking this class for RESTful requests.

@RequestMapping("/api/v1/users"): Sets the base path for all endpoints in this controller.

@CrossOrigin(origins = "http://localhost:3000"): This is crucial! It allows our React application (running on port 3000) to make API calls to this backend (running on port 8080), avoiding Cross-Origin Resource Sharing (CORS) errors.

@GetMapping, @PostMapping, @PutMapping, @DeleteMapping: Map HTTP methods to specific controller actions.

Our backend is now ready! You can run it from your IDE or by using the command mvn spring-boot:run.

Part 2: Building the Frontend with React

Now, let's create the frontend where the user can interact with our API.

Step 1: Initialize the React Project

Open a new terminal window and run the following command to create a new React app:

Bash

npx create-react-app crud-frontend
cd crud-frontend

Step 2: Install Dependencies

We need Axios to make HTTP requests to our Spring Boot backend and bootstrap for some basic styling.

Bash

npm install axios bootstrap

Import Bootstrap's CSS into your src/index.js file:

JavaScript

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

Step 3: Create a Service for API Calls

It's good practice to centralize API logic because whenever we move to the product in that time domain of the backend application or url of the backend can be changed, this centralized file helps by only changing url at the one file not everywhere. Create a new file src/services/UserService.js.

src/services/UserService.js

JavaScript

import axios from 'axios';

const API_BASE_URL = "http://localhost:8080/api/v1/users";

class UserService {

    getUsers() {
        return axios.get(API_BASE_URL);
    }

    createUser(user) {
        return axios.post(API_BASE_URL, user);
    }

    getUserById(userId) {
        return axios.get(API_BASE_URL + '/' + userId);
    }

    updateUser(user, userId) {
        return axios.put(API_BASE_URL + '/' + userId, user);
    }

    deleteUser(userId) {
        return axios.delete(API_BASE_URL + '/' + userId);
    }
}

export default new UserService();

Step 4: Build the Main User Component

Let's create the component that will display the list of users and a form for creating/updating them. Replace the content of src/App.js with the following:

src/App.js

JavaScript

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

function App() {
    const [users, setUsers] = useState([]);
    const [currentUser, setCurrentUser] = useState({ id: null, firstName: '', lastName: '', email: '' });
    const [isEditing, setIsEditing] = useState(false);

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

    const loadUsers = () => {
        UserService.getUsers().then(response => {
            setUsers(response.data);
        });
    };

    const handleInputChange = (event) => {
        const { name, value } = event.target;
        setCurrentUser({ ...currentUser, [name]: value });
    };

    const handleSubmit = (event) => {
        event.preventDefault();
        if (isEditing) {
            UserService.updateUser(currentUser, currentUser.id).then(() => {
                loadUsers();
            });
        } else {
            UserService.createUser(currentUser).then(() => {
                loadUsers();
            });
        }
        resetForm();
    };

    const handleEdit = (user) => {
        setIsEditing(true);
        setCurrentUser(user);
    };

    const handleDelete = (id) => {
        UserService.deleteUser(id).then(() => {
            loadUsers();
        });
    };

    const resetForm = () => {
        setIsEditing(false);
        setCurrentUser({ id: null, firstName: '', lastName: '', email: '' });
    };

    return (
        <div className="container mt-4">
            <h1 className="text-center">User Management System</h1>
            
            <div className="row">
                <div className="col-md-8">
                    <h2>User List</h2>
                    <table className="table table-bordered">
                        <thead className="thead-dark">
                            <tr>
                                <th>First Name</th>
                                <th>Last Name</th>
                                <th>Email</th>
                                <th>Actions</th>
                            </tr>
                        </thead>
                        <tbody>
                            {users.map(user => (
                                <tr key={user.id}>
                                    <td>{user.firstName}</td>
                                    <td>{user.lastName}</td>
                                    <td>{user.email}</td>
                                    <td>
                                        <button className="btn btn-warning btn-sm me-2" onClick={() => handleEdit(user)}>Edit</button>
                                        <button className="btn btn-danger btn-sm" onClick={() => handleDelete(user.id)}>Delete</button>
                                    </td>
                                </tr>
                            ))}
                        </tbody>
                    </table>
                </div>

                <div className="col-md-4">
                    <h2>{isEditing ? 'Edit User' : 'Add User'}</h2>
                    <form onSubmit={handleSubmit}>
                        <div className="form-group">
                            <label>First Name</label>
                            <input type="text" name="firstName" className="form-control" value={currentUser.firstName} onChange={handleInputChange} required />
                        </div>
                        <div className="form-group">
                            <label>Last Name</label>
                            <input type="text" name="lastName" className="form-control" value={currentUser.lastName} onChange={handleInputChange} required />
                        </div>
                        <div className="form-group">
                            <label>Email</label>
                            <input type="email" name="email" className="form-control" value={currentUser.email} onChange={handleInputChange} required />
                        </div>
                        <button type="submit" className="btn btn-primary mt-3">{isEditing ? 'Update' : 'Create'}</button>
                        {isEditing && <button type="button" className="btn btn-secondary mt-3 ms-2" onClick={resetForm}>Cancel</button>}
                    </form>
                </div>
            </div>
        </div>
    );
}

export default App;

Component Breakdown:

useState: We use state to manage users (the list from the API), currentUser (the data in the form), and isEditing (to toggle between create and update mode).

useEffect: The useEffect hook with an empty dependency array [] runs once when the component mounts, calling loadUsers() to fetch the initial data.

Event Handlers: Functions like handleSubmit, handleEdit, and handleDelete use our UserService to communicate with the backend and then refresh the user list.

Part 3: Running the Full-Stack Application

Run the Backend: Make sure your Spring Boot application is running.

Run the Frontend: In your crud-frontend directory, run the command:

Bash

npm start

This will open your React application in a browser, usually at http://localhost:3000.

You should now see the User Management System. You can add, view, edit, and delete users, with all changes being persisted in your MySQL database!

Output:

You can customize the frontend design by changing the CSS file according to your taste.

create user

View Users

Edit User

Conclusion

Finally, you have successfully built a full-stack CRUD application with Spring Boot, React, and MySQL. You've learned how to create a robust REST API, connect it to a database using Spring Data JPA, and build a dynamic, interactive frontend with React Hooks

This powerful tech stack provides a clear and efficient path for developing modern web applications. Happy coding

Java Program to Find the Area of the Cricle

2023-07-21T17:30:00.007+05:30

In this article, we will learn to create a program that calculates the area of a circle using the Java programming language.

Area of Circle

Area = pi*r*r

where, pi = 3.14

r is the radius of the circle.

Explanation

First, we will create a function name area().
area() takes the argument as a radius and returns the calculated area of the circle
In the main() function, we take input of radius from the user and call the area() function.

Solution

import java.util.*;

class ar_cirlce {
    public static double area(int r){
        double area;

        area = 3.14*r*r;

        return area;
    }

    public static void main(String args[]){
        int radius;

        Scanner sc = new Scanner(System.in);

        radius = sc.nextInt();
        
        System.out.println(area(radius));
    }
}

Output

5
78.5

How to Solve Indexerror index 0 is out of bounds for axis 0 with size 0

2023-02-17T16:22:00.005+05:30

The cause for Indexerror: index 0 is out of bounds for axis 0 with size 0 is when trying to access the first element stored inside the first dimension array. However, such a numpy array is empty and hence inaccessible. This tutorial shows an example of how the error arise and later, the ways of handling such an error such as first checking if the numpy array is empty or not before access, or using try/except.

Example of the Error

Let's take an example of a numpy array that we want to access the first element from.

import numpy as np
exArray=np.array([])
element1=exArray[0]

When we run the above code, we get the following output:

line 4, in 
element1=exArray[0]
IndexError: index 0 is out of bounds for axis 0 with size 0

As we see, the error "IndexError: index 0 is out of bounds for axis 0 with size 0" occurs when trying to access the first element stored inside the first dimension array. However, such a numpy array is empty and hence inaccessible.

Note The numpy array "exArray" was created with an empty list, which resulted in the error. It is crucial to check the initialization of the array and ensure that it is not empty before attempting to access its elements.

Solution to the Error

There are multiple ways to solve this error, let's take a look at some of the most effective solutions.

Solution One: Checking if the array is empty or not before accessing

One of the most straightforward solutions is to check the size of the array before trying to access it. If the size of the array is 0, then the array is empty and we should not try to access it.

import numpy as np
exArray=np.array([])
if exArray.size>0:
print(exArray[0])
else:
print('The size of the array is 0')

The output would be:

The size of the array is 0

As we see, we are able to check if the size of the array is 0 or not before trying to access it. In this way, we can avoid the error from occurring.

Solution Two: Change the shape of the array

Another solution is to change the shape of the array . By giving the array a shape, we are able to access it without any error.

import numpy as np
exArray=np.zeros((0,4),dtype=int)
print(exArray.shape)

The output would be:

(0, 4)

As we see, by giving the array a shape, we are able to access it without any error.

Solution Three: Use Try/Except

Using try/except block to catch the error is another effective solution. In this way, if the error occurs, we can handle it by providing a message or any other action that we want to take.

import numpy as np
exArray=np.array([])
try:
print(exArray[0])
except IndexError:
print('The index 0 is empty')

The output would be:

The index 0 is empty

As we see, by using the try/except block, we are able to catch the error and handle it.

TipA good practice to avoid this error is to always initialize the array with a default size or shape, and check the array's size before trying to access its elements. This way, you can ensure that the array is not empty and avoid the IndexError from occurring. Additionally, it is always a good idea to use try/except blocks to catch any unexpected errors, and handle them accordingly.

Conclusion

Hopefully you have now learned more concerning the Indexerror: index 0 is out of bounds for axis 0 with size 0 error that occurs when trying to access an element from an empty numpy array. We have also learned about some effective solutions such as checking if the array is empty before accessing it, changing the shape of the array, and using a try/except block to catch the error. Remember, it is important to check if the array is empty before trying to access any element from it to avoid the error.

How to Solve Error Conflicting types for function in c

2023-02-17T16:21:00.004+05:30

In this article, we will the error message "Conflicting types for function c". This message indicates that there is a mismatch between the return type of a function, which in this case is named "c", and its previous declaration. This can happen if a function is declared with one return type in one location (e.g. int), but then defined with a different return type in another location (e.g. void or float). To fix this error, ensure that the return type of the function is consistent across all of its declarations and definitions.

Defining the Error "Conflicting types for function c" #

The word "conflicting" is used to describe two or more things that cannot all be right or cannot all happen at the same time. The "Conflicting types for function c" error is a common issue that can occur when writing C or C++ code.

When a function is declared, it tells the compiler what the function's name is, what parameters it takes, and what its return type is. The compiler uses this information to ensure that the function is called correctly in other parts of the code.

The error occurs when the return type of a function named "c" is different between its declaration and definition. In other words, the function is declared with one return type in one location, but then defined with a different return type in another location.

Why does this Error Occur? #

The "Conflicting types for function c" error is caused by a difference between the return type of a function in its declaration and definition.

In C and C++, a function is typically declared in a header file or above the int main() function in the same source file which provides the compiler with information about the function's name, parameters, and return type. The function's definition, which includes the actual code for the function, is typically located in a separate source file or in the same source file below the same int main() function.

When the compiler encounters the function's definition, it compares the return type of the function in the definition to the return type of the function in the declaration. If the two do not match, the compiler generates the "Conflicting types for function c" error.

Here is an example which will generate same error.

#include  
int c(int a, int b);              // Declaration of function c with return type int

int main()
{
        c(5, 12);
        return 0;
}void c(int a, int b) {          // Definition of function c with return type void          printf("a:  %d", a);}

In this example, the function "c" is declared with a return type of "int" in the source file above int main() function, but defined with a return type of "void" in the same source file below int main() function. This causes a clash between the declaration and definition of the function, and the compiler will generate the error "Conflicting types for function c".

The error will look something like below.

D:\c-program\main.c|13|error: conflicting types for 'c'|
D:\c-program\main.c|4|note: previous declaration of 'c' was here|
||=== Build failed: 1 error(s), 0 warning(s) (0 minute(s), 1 second(s)) ===|

CautionBe mindful that this error can occur when a function is defined in a source file but the header file that contains the function's declaration is not included. If the compiler cannot find the function's declaration, it will not know the correct return type and will generate the "Conflicting types for function c" error.

How to Solve the Error? #

"Conflicting types for function c" error is typically generated when there is a difference between the decalaration and definition of function. In order to avoid this error make sure that the return type of the function in the declaration and definition match. If the error is caused by a distinction between the return type of the function in its declaration and definition, the solution is to ensure that the return types match. In the example provided earlier, we change the definition and declaration of the function "c" to have either a return type of int or void as done below. This will solve the issue.

#include  
int c(int a, int b);              // Declaration of function c with return type int

int main()
{
        c(5, 12);
        return 0;
}int c(int a, int b) {          // Definition of function c with return type void          printf("a:  %d", a);}

CautionEnsure that a function is not being defined twice in the same file with different return types. This will also cause the error "Conflicting types for function c".

TipEnsure that there are no spelling mistakes when decalaring and defining a function.

The Conclusion

In conclusion, the "Conflicting types for function c" error is a common error that can occur in C and C++ programming when there is a mismatch between the return type of a function in its declaration and definition. To solve this error, you need to ensure that the return type of the function in the declaration and definition match. Understanding the cause of this error and knowing how to fix it can help you write more efficient and error-free code in C and C++ programming.

How to Solve Valueerror: object arrays cannot be loaded when allow_pickle=false

2023-02-17T16:18:00.004+05:30

This error message is indicating that you are trying to load an object array using the numpy.load() function with the allow_pickle parameter set to False. The allow_pickle parameter controls whether or not the loading process can unpickle objects in the file. Object arrays contain elements that are Python objects, which need to be unpickled, so you need to set allow_pickle to True to allow the loading process to unpickle the objects in the array.

The Problem

Pickling is a process of converting a Python object, such as a list, dictionary, or custom object, into a byte stream that can be saved to a file or transmitted over a network. The byte stream can then be unpickled to reconstruct the original object.

In the case of numpy, the numpy.save() function can save numpy arrays to a file in a binary format, which can be loaded later using the numpy.load() function.

When loading a numpy array from a file using numpy.load(), if the file contains object arrays, the loading process needs to unpickle the objects to construct the original object arrays. This is where the allow_pickle parameter comes in.

The allow_pickle parameter is a boolean value that controls whether or not the loading process can unpickle objects in the file. By default, it is set to False to prevent maliciously crafted pickle files from executing arbitrary code when loaded. When set to True, it allows the loading process to unpickle the objects and construct the original object arrays.

Reasons of Error

This error occurs because by default the numpy.load() function has the allow_pickle parameter set to False. This is a security measure to prevent maliciously crafted pickle files from executing arbitrary code when loaded.

Object arrays in numpy are a type of array that contains elements that are Python objects, which need to be unpickled in order to be loaded. When the allow_pickle parameter is set to False, the loading process is not able to unpickle these objects and the error is raised.

By setting allow_pickle=True, it allows numpy to deserialize any Python objects in the file, enabling the loading of object arrays.

It's important to note that, loading untrusted data with allow_pickle=True is a security risk, you should make sure you trust the source and the data you are loading.

NoteThe `numpy.save()` function uses pickling internally, to save the object arrays, so it's not necessary to use the `pickle` library in conjunction with it.

Solution Proceudres

To resolve the "ValueError: object arrays cannot be loaded when allow_pickle=False" error, you need to set the allow_pickle parameter to True when calling the numpy.load() function. This will allow the loading process to unpickle the objects in the file and construct the original object arrays.

Here is an example:

import numpy as np

# Load the numpy array with allow_pickle=True
data = np.load('file.npy', allow_pickle=True)

Alternatively, you can use pickle.load() instead of numpy.load() to load the object arrays.

import pickle

with open('file.npy', 'rb') as f:
    data = pickle.load(f)

It's important to note that, loading untrusted data with allow_pickle=True is a security risk, you should make sure you trust the source and the data you are loading.

CautionIf you're loading data from a file that you didn't create, you should check the file extension(.npy) to ensure that it's a numpy file, maliciously crafted files can be disguised as numpy files.

Coding Examples

Here are some examples of how you can use the numpy.load() function with the allow_pickle parameter set to True to load object arrays:

Example 1: Using numpy.load()

import numpy as np

# Save an object array to a file
arr = np.array([1, 'string', {'a': 1}], dtype=object)
np.save('object_array.npy', arr)

# Load the object array from the file
loaded_arr = np.load('object_array.npy', allow_pickle=True)
print(loaded_arr)
# Output: [1 'string' {'a': 1}]

Example 2: Using pickle.load()

import pickle

# Save an object array to a file
arr = np.array([1, 'string', {'a': 1}], dtype=object)
np.save('object_array.npy', arr)

# Load the object array from the file
with open('object_array.npy', 'rb') as f:
    loaded_arr = pickle.load(f)
print(loaded_arr)
# Output: [1 'string' {'a': 1}]

In both examples, the object array is first saved using the numpy.save() function. Then, it is loaded using either numpy.load(allow_pickle=True) or pickle.load(). Setting the allow_pickle parameter to True or using pickle.load() allows the loading process to unpickle the objects in the file and construct the original object arrays.

TipIt's also a good idea to update your numpy to the latest version, as it may contain security patches and bug fixes.

Conclusion

In conclusion, the "ValueError: object arrays cannot be loaded when allow_pickle=False" error occurs when attempting to load object arrays using the numpy.load() function with the allow_pickle parameter set to False. This is because object arrays contain elements that are Python objects, which need to be unpickled in order to be loaded. To resolve this error, you can set the allow_pickle parameter to True when calling the numpy.load() function. This will allow the loading process to unpickle the objects and construct the original object arrays. However, it's important to note that loading untrusted data with allow_pickle=True is a security risk and you should make sure you trust the source and the data you are loading.

Error in grid.call(c_textbounds, as.graphicsannot(x$label), x$x, x$y, : polygon edge not found

2023-02-17T16:17:00.002+05:30

The error message "Error in grid.call(c_textbounds, as.graphicsannot(x$label), x$x, x$y, : polygon edge not found" occurs when using the grid graphics package in R, specifically when trying to position text labels on a plot.

The Problem

This error message typically occurs when using the grid graphics package in R and is related to the positioning of text labels on a plot. It suggests that the function c_textbounds, which is used to calculate the bounding box for text labels, is unable to locate the edges of the polygon that is being used to define the position of the text.

The c_textbounds function is used to calculate the bounding box for text labels, and it needs the edges of the polygon that is being used to define the position of the text in order to do so. The error message suggests that the function is unable to locate the edges of the polygon.

TipBe mindful of the data and code used to define the polygon, as an error in this can cause the c_textbounds function to be unable to locate the edges.

Reasons of Error

The reasons for the "Error in grid.call(c_textbounds, as.graphicsannot(x$label), x$x, x$y, : polygon edge not found" error can include:

Incorrect x and y coordinates: If the x and y coordinates for the text label are incorrect or out of range for the plot, the c_textbounds function will be unable to locate the edges of the polygon and will throw this error.
Error in data or code for defining the polygon: The error can also occur if there is an error in the data or code used to define the polygon. For example, if the polygon is not closed, the function will not be able to locate the edges.
Problem with the grid package or R installation: This error can also occur if there is an issue with the grid package or R installation. For example, if the grid package is not properly loaded or is an outdated version, it may not be able to locate the polygon edges.
Incorrect use of the grid package: If the grid package is used incorrectly, such as using a different coordinate system or not properly defining the polygon, this error can occur.
Other software or hardware issues: The error can also occur due to other software or hardware issues such as, outdated graphic driver or incompatible graphic card.

It's important to check all of these possible causes in order to identify and fix the underlying issue that is causing the error. Sharing a minimal reproducible example and the version of R and packages you are using can be helpful for others to understand the issue and provide a solution.

Best Possible Solutions

Here are some possible solutions for the "Error in grid.call(c_textbounds, as.graphicsannot(x$label), x$x, x$y, : polygon edge not found" error:

Check the x and y coordinates: Double-check the x and y coordinates for the text label and ensure that they are correct and within the range of the plot.
Inspect the data and code used to define the polygon: Make sure that the data and code used to define the polygon are correct and do not contain any errors or inconsistencies.
Update the R and grid package: Make sure that you are using the latest version of R and the grid package. Updating can fix any bugs or compatibility issues that may be causing the error.
Use a different graphics package: Try using a different graphics package, such as ggplot2, to see if the error persists.
Check for hardware and software issues: Make sure that your graphic card is compatible with your system and you have the latest graphic driver installed.
Share a minimal reproducible example: If the problem persists, it might be helpful to share a minimal reproducible example and the version of R and packages you are using, so that others can help you with more specific guidance.
Review the documentation of grid package: Review the documentation of grid package to ensure that you are using the package correctly and familiarize yourself with the proper syntax and usage of the functions.
Get help from the community: If you are still experiencing difficulties, reach out to the R community, such as on forums or mailing lists, for additional help and support.

Coding Examples

Here are some different coding examples that demonstrate how to position text labels on a plot using the grid package in R:

Simple text label on a scatter plot:

library(grid)

x <- rnorm(100)
y <- rnorm(100)

# create scatter plot
grid.newpage()
grid.points(x, y)

# add text label
grid.text("Label", x=0.5, y=0.5)

Text label with different font and color:

library(grid)

x <- rnorm(100)
y <- rnorm(100)

# create scatter plot
grid.newpage()
grid.points(x, y)

# add text label with different font and color
grid.text("Label", x=0.5, y=0.5, gp=gpar(fontface="italic", col="red"))

Text label on a bar plot:

library(grid)

data <- data.frame(x=1:5, y=c(10, 20, 30, 40, 50))

# create bar plot
grid.newpage()
grid.barplot(data$y, width=0.8)

# add text label
grid.text("Label", x=mean(data$x), y=max(data$y), vjust=-0.2)

NoteRemember to use the appropriate coordinate system, since grid package provides different coordinate systems like 'native', 'user', 'npc' etc.

Conclusion

In conclusion, the "Error in grid.call(c_textbounds, as.graphicsannot(x$label), x$x, x$y, : polygon edge not found" error occurs when using the grid package in R to position text labels on a plot. This error can occur due to a number of reasons such as incorrect x and y coordinates for the text label, errors in the data or code used to define the polygon, problems with the grid package or R installation, or incorrect use of the grid package.

To troubleshoot this error, it is important to check the x and y coordinates for the text label, inspect the data and code used to define the polygon, ensure that the latest version of R and the grid package are being used, and to share a minimal reproducible example and the version of R and packages you are using if the problem persists. Additionally, it's always good to check the documentation and use the appropriate coordinate system, and consider using other graphics packages available in R such as ggplot2 and lattice as an alternative.

How to Solve IndexError: single positional indexer is out-of-bounds

2023-02-17T16:15:00.003+05:30

This error message occurs in Pandas when trying to access a single element of a DataFrame using a single indexer and the indexer is not within the valid range of the DataFrame's rows.

For example, if the DataFrame has 5 rows, the valid indices are 0, 1, 2, 3, and 4. Attempting to access a row at index 5 or higher would result in this error.

The Problem

The problem statement for the "IndexError: single positional indexer is out-of-bounds" error is that when trying to access a single element of a pandas DataFrame using a single indexer, the indexer is not within the valid range of the DataFrame's rows. This can happen when trying to access a non-existent index, using a non-unique index, using an index that is out of range, using a single indexer when a slice of indices is expected, or using the wrong accessor. This error can prevent data analysis and data manipulation tasks from being performed correctly and can make it difficult to extract the desired information from the DataFrame.

TipCheck the index or column name: Make sure that the index or column name you are trying to access is spelled correctly and exists in the DataFrame.

Reasons of Error

The "IndexError: single positional indexer is out-of-bounds" error in pandas is typically caused by one of the following reasons:

Attempting to access a row or column that is not present in the DataFrame: This can happen if you try to access a row or column that has been deleted or if you accidentally use the wrong index or column name.
Using an index or column name that is not unique: When trying to access a specific row or column, pandas returns a DataFrame or Series with all the rows or columns that match the name or index. But if the name or index is not unique, the indexer is out-of-bounds.
Using an index that is out of range: If you try to access a row or column using an index that is greater than the number of rows or columns in the DataFrame, you will get an "IndexError: single positional indexer is out-of-bounds" error.
Using a single indexer when a slice of indices is expected: If you try to use a single indexer to select a slice of rows or columns, pandas will raise this error. For example, df[1:5] is correct, but df[1] is not.
Using the wrong accessor: As mentioned in the previous answer, if you are trying to access a specific element of the DataFrame based on its index, you must use .loc[] or .iloc[] accessor, if you are using only a single indexer.

It's important to make sure that the index or column you are trying to access exists in the DataFrame, the index is within the valid range, and that you are using the appropriate accessor.

Best Possible Solutions

Here are some solutions to fix the "IndexError: single positional indexer is out-of-bounds" error in pandas:

Check the index or column name: Make sure that the index or column name you are trying to access is spelled correctly and exists in the DataFrame.
Check if the index or column is unique: If the index or column name is not unique, you can use the .loc[] or .iloc[] accessor to access the specific row or column you want.
Check the index range: Make sure that the index you are trying to access is within the valid range of indices for the DataFrame. You can use the shape attribute of the DataFrame to find the number of rows and use that to determine the valid range of indices.
Use the appropriate accessor: As mentioned in the previous answer, if you are trying to access a specific element of the DataFrame based on its index, you must use .loc[] or .iloc[] accessor, if you are using only a single indexer.
Use slicing for multiple rows or columns: When you want to select multiple rows or columns, use slicing, df[1:5] is correct, but df[1] is not.
Check the datatype of the index or column: Make sure that the index or column is of the correct data type, for example, if you are trying to access a column, make sure that it is a column and not a row.
Check if the dataframe is empty: If the DataFrame is empty, it will raise "IndexError: single positional indexer is out-of-bounds" error.

Coding Examples

Here are a few examples of how the "IndexError: single positional indexer is out-of-bounds" error can occur when working with pandas DataFrames:

Using a non-existent index:

import pandas as pd

df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
print(df)
#    A  B
# 0  1  4
# 1  2  5
# 2  3  6

# this will raise an "**`IndexError: single positional indexer is out-of-bounds`**" error
print(df.loc[3])

Using a non-unique index:

import pandas as pd

df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]}, index=[1,1,2])
print(df)
#    A  B
# 1  1  4
# 1  2  5
# 2  3  6

# this will raise an "IndexError: single positional indexer is out-of-bounds" error
print(df.loc[1])

Using an index that is out of range:

import pandas as pd

df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
print(df)
#    A  B
# 0  1  4
# 1  2  5
# 2  3  6

# this will raise an "IndexError: single positional indexer is out-of-bounds" error
print(df.loc[3])

Using a single indexer when a slice of indices is expected:

import pandas as pd

df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
print(df)
#    A  B
# 0  1  4
# 1  2  5
# 2  3  6

# this will raise an "IndexError: single positional indexer is out-of-bounds" error
print(df[1])

Using the wrong accessor:

import pandas as pd

df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]}, index=['a','b','c'])
print(df)
#    A  B
# a  1  4
# b  2  5
# c  3  6

# this will raise an "IndexError: single positional indexer is out-of-bounds" error
print(df['a'])

NoteCheck the index range: Make sure that the index you are trying to access is within the valid range of indices for the DataFrame.

Conclusion

In conclusion, the "IndexError: single positional indexer is out-of-bounds" error in pandas is caused by attempting to access a single element of a DataFrame using a single indexer and the indexer is not within the valid range of the DataFrame's rows. There are several common causes of this error, such as using a non-existent index, using a non-unique index, using an index that is out of range, using a single indexer when a slice of indices is expected, and using the wrong accessor.

To avoid this error, you should check the index or column name, use the appropriate accessor, use slicing for multiple rows or columns, check if the index or column is unique, check the index range, check the datatype of the index or column, check if the dataframe is empty, be mindful of the order of the operations and keep good track of the dataframe.

C# error: " An object reference is required for the non-static field, method, or property"

2023-02-17T16:08:00.001+05:30

Today, we're going to fix a C# Error: "An object reference is required for the non-static field, method, or property" that usually happens when we try to use a non-static element in a static scope. In the next few sections, we'll discuss what is "static" modifier keyword in C# is, why this problem happens, and how to resolve it.

What is "static" modifier keyword #

It's very important to understand what is static modifier keyword in C# before exploring the reason behind "An object reference is required for the non-static field, method, or property". A static modifier keyword can be applied to various elements such as properties, methods, class, and constructor. Here, we'll cover the static properties and static methods since these two are the main reason of "An object reference is required for the non-static field, method, or property".

Static properties are basically the properties of a class with the "static" keyword:


 public class Program
    {
        public static string txt = "Hello World";
    }

Here, we initialise a static property, txt under Program class.

Static methods are basically the methods with a "static" keyword. Here's the syntax of defining a static method:

<Access_Modifier> static <return_type> <method_name>([<params>])

Let's look at an example:


public static int multiply(int x, int y)
    {
        return x * y;
    }

So, what's the difference between the static method and instance method? A static method can be called without creating an Object of the class containing it. It can be invoked by the class itself or the Objects of the class. Conversely, an instance method is a method without static modifier keyword, which requires creating an Object of the class containing it so that the Object can be used to invoke that function.

Now, let'see how the error, "An object reference is required for the non-static field, method, or property" will happen.

Why "An object reference is required for the non-static field, method, or property" happens #

This error always happen when we're trying to use the non-static properties or non-static methods in a static scope. Let's look at them one by one:


 public class Program
    {
        public string txt = "Hello World";
        
        public static void Main(string[] args) 
        {
            Console.WriteLine(txt);
        }
    }

This is the output:


CS0120: An object reference is required for the non-static field, method, or property 'Program.txt'

This is because the static method, public static void Main(string[] args) is associated with the class itself, not the Object of the class containing it. Hence, the non-static property, txt which requires an Object of the class to work will not work in a static method. Let's look at another example:


  public class Program
    {
        public static void Main(string[] args) 
        {
            int x = 3;
            int y = 2;
            Console.WriteLine(multiply(x, y));
        }

    public int multiply(int x, int y)
    {
        return x * y;
    }
}

This is the output:


CS0120: An object reference is required for the non-static field, method, or property 'Program.multiply(int,int)'

Same idea, the instance method, public int multiply(int x, int y) needs an Object of class, Program to be created to invoke it in a static method, which doesn't implicitly create an Object of the class, Program. Now, we've understood the causes of this error, let'see how to resolve it.

Solution #

We just need to be aware of the following rules to avoid this error:

Avoid using non-static property in a static method.
Avoid using non-static method in a static method.
Explicitly initialise an Object of the class containing the non-static property before using it in a static method.
Explicitly initialise an Object of the class containing the non-static method before using it in a static method.

Let's see some examples:


 public class Program
    {
        public static string txt = "Hello World";
        
        public static void Main(string[] args) 
        {
            Console.WriteLine(txt);
        }
    }

This is the output:


Hello World

This is because we're now having the static property, txt, and we can use it directly in the static method. Let's see another example:


 public class Program
    {
        public string txt = "Hello World";

        public static void Main(string[] args)
        {
            Program p = new Program();
            Console.WriteLine(p.txt);
        }
    }

This is the output:


Hello World

Here, we explicitly create an Object, p of the class, Program. Hence, we can utilise that object to use the non-static variable, txt in the static method.

Now, let's see the examples for "methods":


  public class Program
    {
        public static void Main(string[] args)
        {
            int x = 3;
            int y = 2;
            Console.WriteLine(multiply(x, y));
        }

        public static int multiply(int x, int y)
        {
            return x * y;
        }
    }

This is the output:

This is because we're now defining the method, public static int multiply(int x, int y) as static method, and we can use it directly in other static method. Let's see another example:


  public class Program
    {
        public static void Main(string[] args)
        {
            Program p = new Program();
            int x = 3;
            int y = 2;
            Console.WriteLine(p.multiply(x, y));
        }

        public  int multiply(int x, int y)
        {
            return x * y;
        }
    }

This is the output:

Here, we also explicitly create an Object, p of the class, Program. Hence, we can utilise that object to use the instance method, public int multiply(int x, int y) in the static method.

The Conclusion #

That's. Clear and simple understanding on this topic! In this study blog, we've learn what is a static modifier keyword, why "An object reference is required for the non-static field, method, or property" happens and how to resolve it. You should always make sure that you're not using non-static item in static item. If you want to do so, make sure you explicitly create an Object of the class containing the non-static items, so that you can utilise that Object to accessthem.

How to solve Expected Primary Expression Before

2023-02-17T16:03:00.002+05:30

While writing a program, a programmer is sure to face some obscurities. Sometimes it is difficult to find what causes an error in the piece of code that you have written. The error you face can be a logical error, compiling error, or a simple syntax error. In C++, you might have encountered the error “expected primary expression” which usually occurs due to a syntax error In this article, we are going to look over the details of the error with the help of examples.

What is the error and why does it occur? #

The ‘expected primary expression‘ is one of the most common syntax errors which occur due to a missing keyword or an irrelevant keyword. The error prompt displays the location where the keyword is missing.
These mistakes are encountered by beginners and people who write their programs in a hurry. The syntax of the error prompt looks something like this:

Syntax:


/tmp/35HQ008IAw.cpp:11:48: error: expected primary-expression before 'words'
int wordLength  = wordLengthFunction(string words);

The keyword ‘words’ in the above example denotes where the keyword is missing or added.

Reasons for the Error #

There are specific reasons why the programmer can face this error and some of the reasons can be:

Specifying Data Type Along With Function Calling

One of the most common mistakes that novice coders make is passing the data type along with the function-calling argument.For Example, we will be creating a function to add 2 numbers and pass two integers in the function. When calling the function, we will specify the data type again which will trigger the error. The code for the above example will be:


    #include 
        using namespace std;
        int add(int num_one, int num_two)
        {
        int result;
        result = num_one + num_two;
        return result;
        }
        int main()
        {
        int answer = add(int 100, int 230);
        }
        return 0;
        }

The above code contains the data type declaration along with the function-calling argument which will generate the following output

Output:


            
            /tmp/CVK1ULcyYx.cpp:12:18: error: expected primary-expression before 'int'
              12 | int answer = add(int 100, int 230);
              |                                         ^~~
             /tmp/CVK1ULcyYx.cpp:12:27: error: expected primary-expression before 'int'
               12 | int answer = add(int 100, int 230);
                   |                           ^~~
                }

The output for the code is the specified error and the location where we have declared our data types again.

Wrong Argument Type

A lot of times if you pass the wrong argument in a particular function it will produce the same ‘primary expression’ error. For Example, if you declare a string in a function and then pass an integer in the argument.


    
        int main()
        {
        int answer = add("Hello", "How are You" );
        }
        return 0;
        }

When the above code is executed, we will face the same error which will tell us that we passed a string to a function as we cannot pass a string to the function.

Incomplete Curly Braces

If the number of curly braces is not even or are extra than the requirement then the developer is likely to face this error. An example of incomplete curly braces would be:


    
        int add(int num_1, int num_2 )
        {
        int result;
        result = num_1 + num_2;
        return result;

In the above code, you might notice that there is no closing brace which will result in the stated error.

Note: The error can also be invoked if the parenthesis in an if statement is empty

Solutions to the error#

Now that we know about the reasons for the occurrence of the error we can find solutions to fix the error or measures to prevent it. The solutions for correcting the error are given below:

Removing the data type while calling function

You have to avoid writing the data type in the parenthesis while calling a function. This is a way to solve the error. The proper way to pass arguments to a function is:



    int main() {
    int answer = add( 100, 230);
    }
    return 0;
    }

While passing the arguments in a function make sure that you double-check for any missing arguments through the function.

Using Correct Data Type

You must ensure that the data type of the argument matches the data type which is specified in the given parameter which will ensure that the error does not occur. An example would be passing integers in the function “add” instead of strings.

Even Number of Curly Braces

The program should be carefully observed and should have even number of opening and closing brackets. If they are not, make sure to look for the brace which is incomplete. The below example will demonstrate this point.



    Int main(){
    Int a,b;
    Int c = a+b;
    }

The above output is having an opening curly brace after ‘main’ and a closing curly brace at the end which will reduce the likeliness of occurrence of the stated error.

The Conclusion

In this article we dived deep into “expected primary expression before” which is merely a syntax error and can be solved with the help of some observation and attentiveness while writing the program. The programmer should remember the key points like never pass parameters along with arguments when calling a function and ensuring equal number of opening and closing curly braces so as to avoid facing this error.

Benefits of using Artificial Intelligence in Marketing

2023-02-12T16:30:00.001+05:30

In this article, we will see the benifits of the AI in marketing, Artificial intelligence (AI) has

been transforming various industries, and marketing is no exception. From customer

segmentation to personalized messaging and predictive analytics, AI has become a crucial

tool for modern marketers to reach and engage their target audience effectively.

Table of Content

1. Improved Customer Segmentation

2. Predictive Analytics

3. Personalized Messaging

4. Increased Efficiency

5. mproved ROI

6. Enhanced Customer Experience

7. Conclusion

Here are some of the benefits of using AI in marketing:

Improved Customer Segmentation

AI algorithms can analyze vast amounts of data, including customer behavior,

demographics, and purchase history, to create detailed customer segments. This allows

marketers to personalize their campaigns and messages for each segment, which can lead

to higher conversion rates and improved customer satisfaction.

Predictive Analytics

AI-powered predictive analytics enables marketers to forecast future customer behavior and

market trends based on historical data. This information can help marketers make informed

decisions about their strategies, tactics, and budget allocation, leading to more effective

campaigns and better results.

Personalized Messaging

With AI, marketers can create highly targeted and personalized messages for each

individual customer. This can include personalized product recommendations, targeted email

campaigns, and customized social media posts. By tailoring messages to specific

customers, marketers can increase the relevance and impact of their campaigns, leading to

higher engagement and conversion rates.

Increased Efficiency

AI-powered marketing automation can streamline many of the manual and repetitive tasks

involved in marketing, freeing up marketers to focus on more strategic initiatives. Automation

can also increase the speed and accuracy of tasks such as data analysis, lead scoring, and

lead nurturing, leading to a more efficient and effective marketing process.

Improved ROI

By using AI to analyze data, personalize messages, and automate tasks, marketers can

improve their return on investment (ROI) for their marketing campaigns. AI can help

marketers reach the right audience, with the right message, at the right time, leading to

higher conversion rates and better results.

Enhanced Customer Experience

AI-powered chatbots and virtual assistants can provide customers with immediate and

personalized support, answering questions, resolving issues, and making recommendations.

This can lead to a better customer experience and increased customer loyalty, which can

drive long-term growth for businesses.

Conclusion

In conclusion, AI has the potential to transform the way marketers reach and engage their

customers, leading to improved customer segments, predictive analytics, personalized

messaging, increased efficiency, improved ROI, and enhanced customer experiences. While

there is still much work to be done to fully realize the potential of AI in marketing, the benefits

are clear, and marketers who embrace AI are well positioned to succeed in the years ahead.

Python Program to Copy the list

2023-02-06T16:00:00.081+05:30

In this article, we will learn to copy lists in a python program. There are so many different ways to copy a list in python.

Method 1: Using the Slicing Technique

The simplest way to clone or copy a list is to use the slice method. This method creates a new list that contains all the elements of the original list. Here's how you can use it:

Explanation

First, we will initialize the list1.
Then we will store all the elements of list1 to list1 using the slicing method.
Then we will print the original list1 and list2.

Program

# initialize the list1
list1 = [1, 2, 3, 4, 5, 6]

# copying to list2 using sclicing method
list2 = list1[:]

# print the result
print("Original List:", list1)
print("After Copying:", list2)

Output

Original List: [1, 2, 3, 4, 5, 6]
After Copying: [1, 2, 3, 4, 5, 6]

Method 2: Using extend() methods

The list elements copy to the new list using extend() function in python. Here's how you can use it.

Explanation

First, we will initialize list1 and list2.
list2 is empty.
Then we will use extend() function to appends all the elements to list2.
Then, we will print the result.

Program

# initialize the list1
list1 = [1, 2, 3, 4, 5, 6]

# initialize the list2
list2 = []

# copying to list2 using extend() function
list2.extend(list1)

# print the result
print("Original List:", list1)
print("After Copying:", list2)

Output

Original List: [1, 2, 3, 4, 5, 6]
After Copying: [1, 2, 3, 4, 5, 6]

Method 3: Using (=)Assignment Operator

This is the easiest or simple method to copy the list in python. We will use the assignment operator to copy the list in python.

Explanation

First, we will initialize the list1.
Copy the list1 to list2 using the assignment operator(=).
Then, print the result.

Program

# initialize the list1
list1 = [1, 2, 3, 4, 5, 6]

# copy the list1 to list2 using assigment operators
list2 = list1

# print the result
print("Original List:", list1)
print("After Copying:", list2)

Output

Original List: [1, 2, 3, 4, 5, 6]
After Copying: [1, 2, 3, 4, 5, 6]

Conclusion

In this article, we learned, how to copy or cloning a list in python using different methods and techniques. All the methods is right and we can use according to our function.

Remove multiple elements from a list in Python

2023-02-05T16:00:00.005+05:30

In this article, we will remove multiple elements from the list in python programming.

Example

Input : [ 1, 2, 3, 4]

Remove : [2, 4]

Output: New_list = [1, 3]

Method 1: Iterating

In this method, we will remove the elements one by one, which is divisible by 2 using the remove() function.

Explanation

Initialize the list
Then we will iterate the list.
Then we will apply the condition.
Then we will use the remove() function to remove the element from the list
After that, we will print the final updated list.

Program

# initialize the list
list = [1, 2, 3, 4, 5, 6, 7, 8]

# iterate the list
for ele in list:
    if (ele%2==0):
        list.remove(ele)  # use remove() function

# print the list after removing elements
print(list)

Output

[1, 3, 5, 7]

Method 2: List Comprehension

List comprehension is a concise way to create a new list by performing operations on elements of an existing list. We can use list comprehension to create a new list by excluding the elements that meet certain conditions. The new list will have all the elements that don't match the conditions.

For example, if we have a list of numbers and we want to remove all even numbers from the list, we can use the following code:

Program

#initilaize the list 
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# create another list using list comprehension
odd_numbers = [num for num in numbers if num % 2 != 0]

# print the new list
print(odd_numbers)

Output

[1, 3, 5, 7, 9]

Method 2: Using a filter

The filter function is used to filter elements from a list based on a given condition. We can use the filter function to remove elements that meet certain conditions.

For example, if we have a list of numbers and we want to remove all even numbers from the list, we can use the following code:

Program

1
2
3

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
odd_numbers = list(filter(lambda x: x % 2 != 0, numbers))
print(odd_numbers)

Output

[1, 3, 5, 7, 9]

Conclusion

In this article, we will learn to remove multiple elements in a list using different methods in python.

Python program to print all negative numbers in a range

2022-07-17T17:00:00.017+05:30

In this article, we will learn to create a program to print all negative numbers in a given range using python programming.

We do this program using 2 different methods:

Using loop
Using list comprehension

Input:

Starting number is: -4

Ending number is: 4

Output:

[-4, -3, -2, -1]

For loop

Explanation

First, we take the input from the user of starting and ending numbers.
Then, we initiate the result list.
After that, iterate all numbers from the given range,
And check if the number is less than 0.
If it satisfied the above condition and appends those elements to result list.
And lastly, print the result.

Program

# take input from the user
start = int(input("Enter starting number: "))
end = int(input("Enter ending number: "))

# result
result = []

# iterate all elements from the given range
for ele in range(start, end+1):
    # check positive number
    if ele<0:
        # appends elements to result
        result.append(ele)
        
# print result
print(result)

Output

Enter starting number: -4
Enter ending number: 10
[-4, -3, -2, -1]

List Comprehension

Explanation

First, we take the input from the user of starting and ending numbers.
Using list comprehension, check the elements is less than 0.
print the result

Program

# take input from the user
start = int(input("Enter starting number: "))
end = int(input("Enter ending number: "))

# result
result = [num for num in range(start, end+1) if num<0]
        
# print result
print(result)

Output

Enter starting number: -4
Enter ending number: 10
[-4, -3, -2, -1]

Python program to print all positive numbers in a range

2022-07-16T17:00:00.065+05:30

In this article, we will learn to create a program to print all positive numbers in a given range using python programming.

We do this program using 2 different methods:

Using loop
Using list comprehension

Input:

Starting number is: -2

Ending number is: 10

Output:

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ,10]

For loop

Explanation

First, we take the input from the user of starting and ending numbers.
Then, we initiate the result list.
After that, iterate all numbers from the given range,
And check if the number is greater than or equal to 0.
If it satisfied the above condition and appends those elements to result list.
And lastly, print the result.

Program

# take input from the user
start = int(input("Enter starting number: "))
end = int(input("Enter ending number: "))

# result
result = []

# iterate all elements from the given range
for ele in range(start, end+1):
    # check positive number
    if ele>=0:
        # appends elements to result
        result.append(ele)
        
# print result
print(result)

Output

Enter starting number: -4
Enter ending number: 10
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

List Comprehension

Explanation

First, we take the input from the user of starting and ending numbers.
Using list comprehension, check the elements is greater than or equal to 0.
print the result

Program

# take input from the user
start = int(input("Enter starting number: "))
end = int(input("Enter ending number: "))

# result
result = [num for num in range(start, end+1) if num >=0]
        
# print result
print(result)

Output

Enter starting number: -4
Enter ending number: 10
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Python program to print negative numbers in a list

2022-07-15T17:00:00.011+05:30

In this article, we will learn to create a python program to print negative numbers in a list.

Print negative numbers in a list using 2 different methods:

Using loop
Using list comprehension

Loop

Explanation

Initialize the list.
Then, iterate all numbers from the list and check if the number is lesser than 0 or not.
If the number is lesser than 0, then append those numbers to a new list named result.
Then, lastly, print results.

Program

# list contains all numbers
list = [1, 5, 22, -5, 55, -21]

# result 
result = []

# iterate all numbers 
for num in list:
    # check for a negative number
    if num < 0:
       result.append(num)  #append all number to result

# print result
print(result)

Output

[-5, -21]

List comprehension

Explanation

Initialize the list.
Then using list comprehension, store all the negative numbers in a result.
Then print the result.

Program

# list contains all numbers
list = [1, 5, 22, -5, 55, -21]

# list comprehension 
result = [num for num in list if num<0]

# print rsult
print(result)

Output

[-5, -21]

Python program to print positive numbers in a list

2022-07-14T17:00:00.000+05:30

In this article, we will learn to create a python program to print positive numbers in a list.

Print positive numbers in a list using 2 different methods:

Using loop
Using list comprehension

Loop

Explanation

Initialize the list.
Then, iterate all numbers from the list and check if the number is greater or equal to 0 or not.
If the number is greater or equal to 0, then append those numbers to a new list named result.
Then, lastly, print results.

Program

# list contains all numbers
list = [1, 5, 22, -5, 55, -21]

# result 
result = []

# iterate all numbers 
for num in list:
    # check for a positive number
    if num >= 0:
       result.append(num)  #append all number to result

# print result
print(result)

Output

[1, 5, 22, 55]

List comprehension

Explanation

Initialize the list.
Then using list comprehension, store all the positive numbers in a result.
Then print the result.

Program

# list contains all numbers
list = [1, 5, 22, -5, 55, -21]

# list comprehension 
result = [num for num in list if num>=0]

# print rsult
print(result)

Output

[1, 5, 22, 55]

Python program to print all odd numbers in a range

2022-07-13T17:00:00.000+05:30

In this article, we will learn to print all the odd numbers in a range using the python program.

We will use for loop to do that.

Input:

Start = 4

End = 10

Output:

[5, 7, 8]

Explanation

First, we will take input from users for starting and ending numbers.
Then we will iterate for loop from start to end+1.
After that, we will append all the odd numbers to result in a list.
Then we print the result.

Program

# take input from the user
Start = int(input("Enter starting number: "))
End = int(input("Enter ending number: "))

result = []

for ele in range(Start,End+1):
    if ele%2!=0:
       result.append(ele)
       
# print result
print(result)

Output

Enter starting number: 4
Enter ending number: 10
[5, 7, 9]

Python program to print all even numbers in a range

2022-07-12T17:00:00.009+05:30

In this article, we will learn to print all the even numbers in a range using the python program.

We will use for loop to do that.

Input:

Start = 4

End = 10

Output:

[4, 6, 8, 10]

Explanation

First, we will take input from users for starting and ending numbers.
Then we will iterate for loop from start to end+1.
After that, we will append all the even numbers to result in a list.
Then we print the result.

Program

# take input from the user
Start = int(input("Enter starting number: "))
End = int(input("Enter ending number: "))

result = []

for ele in range(Start,End+1):
    if ele%2==0:
       result.append(ele)
       
# print result
print(result)

Output

Enter starting number: 4
Enter ending number: 10
[4, 6, 8, 10]

Python program to print odd numbers in a List

2022-07-11T17:00:00.002+05:30

In this article, we will learn to find the odd number from the given list and print it in the list format.

How to check whether the given is odd or not?

If a number is not completely divisible by 2, then the given number is odd.

We find the odd number in a list using 1 method:

Using loop

Input : [1,2,3,4,5,6]

Output : [1,3,5]

Using loop

Explanation

First, we initialize a list.
Then we create a new list to store the odds number (named result).
After, that we will run the loop to get all elements of the list one by one.
Then, we will check each element, whether it's completely divisible by the 2 or not.
We will check using the modulus(%) operator.
If the element is not completely divisible by 2, then append to the new list result.
And after all, print the result list.

Program

# list
list = [1,2,3,4,5,6,7,8]

# result list
result = []

# iterate all element of list 
for ele in list:
    # check for odd 
    if ele%2!=0:
        result.append(ele) # append the odd number in result list

# print the result 
print(result)

Output

[1, 3, 5, 7]

Conclusion

In this article, we have learned how to create a python program that prints odd numbers in a list using simple methods with the help of a step-by-step explanation.

Python program to print even numbers in a list

2022-07-10T17:00:00.002+05:30

In this article, we will learn to find the even number from the given list and print it in the list format.

How to check whether the given is even or not?

If a number is completely divisible by 2, then the given number is even.

We find the even number in a list using 1 method:

Using loop

Input : [1,2,3,4,5,6]

Output : [2,4,6]

Using loop

Explanation

First, we initialize a list.
Then we create a new list to store the evens number (named result).
After, that we will run the loop to get all elements of the list one by one.
Then, we will check each element, whether it's completely divisible by the 2 or not.
We will check using the modulus(%) operator.
If the element is completely divisible by 2, then append to the new list result.
And after all, print the result list.

Program

# list
list = [1,2,3,4,5,6,7,8]

# result list
result = []

# iterate all element of list 
for ele in list:
    # check for even 
    if ele%2==0:
        result.append(ele) # append the even number in result list

# print the result 
print(result)

Output

[2, 4, 6, 8]

Conclusion

In this article, we have learned how to create a python program that prints even numbers in a list using simple methods with the help of a step-by-step explanation.