DEV Community: Saahen Sriyan Mishra

# End-To-End Full-stack Event Management application (using ASP.NET, React, Node.js, and Spring Boot with SQLite Backend)

Saahen Sriyan Mishra — Sat, 31 May 2025 15:17:04 +0000

This full-stack Event Management application is developed using ASP.NET, React, Node.js, and Spring Boot, codded in C#, JavaScript, and Java.

GitHub: Event Management Sytem

Table Of Content

Table Of Content
Key Features
Tech Stack Used
Modules (Backend Endpoints, URLs and Application UI)
- 1. Login and SignUp Module
- 2. User Module Features
- 3. Admin Module Features
SQLite Integration with Spring Boot
ER Diagram
- Database Schema
- Relationship, Logic and Usage
Flow Documentation
- 1. User Interaction Flow
- 2. Admin Interaction Flow
Dockerization
Application Deployment & Usage Guide
- Usage Option 1: Dockerized Deployment
- Usage Option 2: Manual Deployment
- Usage Option 3: Hybrid Deployment

Key Features

Streamlined Event Scheduling: The application automates scheduling, integrating vendor bookings, venue management, and notifications into a cohesive workflow
Optimized Attendee Management: It includes features to handle registrations, guest lists, and automated communication for reminders and updates, ensuring efficient attendee handling.
Advanced Budget Tracking: The system allows for real-time budget monitoring, expense management, and easy generation of comprehensive financial reports
Enhanced Customer Engagement: Through its intuitive interface, customers can effortlessly browse event details, make bookings, and stay updated with personalized notifications

Tech Stack Used

This application consists of three modules, including the module for user login and authentication, the User Module and the Admin Module.

Component	Technology
Frontend	React, ASP.NET (Razor Pages)
Backend	Node.js, ASP.NET, Spring Boot with Maven
Database	SQLite
Authentication	JWT with BCrypt hashing

Login and SignUp Module (Backend Endpoints, URLs and Application UI)

Module	Features	Backend Endpoints
User Signup	- Users provide an email and password during signup. - Password is hashed using BCrypt before storage for secure handling. - Duplicate email entries are checked to ensure uniqueness. - Users are redirected to the login page upon successful signup.	POST /api/auth/signup - Validates request data, ensuring the email and password are provided. - Checks for existing email in the Users table. - Hashes the password using BCrypt. - Inserts new user record into Users table. - Handles validation and database errors.
User Login	- Users log in with registered email and password. - Password is verified using BCrypt. - A JWT token is generated and returned. - Users are redirected to their profile page after login.	POST /api/auth/login - Queries Users table for the provided email. - Verifies password using BCrypt. - Generates JWT token with user's email. - Returns token upon success. - Returns error on invalid credentials.
Admin Login	- Admins log in with their credentials. - Password is verified using BCrypt. - A JWT token is generated with "Admin" role. - Redirects to admin functionality page after login.	POST /api/auth/admin-login - Queries Admin table using provided email. - Verifies password using BCrypt. - Generates JWT token with role "Admin". - Redirects to admin page. - Handles login failures and errors.
JWT Authentication	- JWT token is generated during login (User/Admin). - Includes claims: email and role. - Signed with HMAC-SHA256. - Token expires after 2 hours.	Token Generation Function (GenerateJwtToken): - Embeds claims (email and role). - Uses SymmetricSecurityKey for signing. - Adds issuer, audience, and expiration metadata. - Uses JwtSecurityTokenHandler. - Supports both User and Admin roles.

Technical Highlights

Category	Details
Security Implementation	- Passwords are securely hashed using BCrypt, ensuring stored credentials cannot be reversed. - JWT tokens are signed using HMAC-SHA256 and include embedded claims, ensuring secure and verifiable session handling.
Database Interaction	- Efficient queries (SELECT, INSERT) are utilized for user and admin authentication processes. - Ensures email uniqueness via HasIndex constraints on the Users and Admin tables.
Role-Based Access	- Role-specific claims (User/Admin) are embedded in JWT tokens, enabling differentiation in session functionalities.
Frontend Integration	- Upon successful login/signup, users are redirected to their respective pages (User Profile or Admin Functionality) seamlessly.

Application URLs

Pages	URL
Initial page on opening the application	http://localhost:5274/Home
User Signup	http://localhost:5274/UserSignup
User Login	http://localhost:5274/UserLogin
Admin login	http://localhost:5274/Admin

Application UI

Image	Description
	Initial page on opening the application
	User Signup
	User Login
	Admin login

User Module Features (Backend Endpoints, URLs and Application UI)

Module	Features	Backend Endpoints
User Welcome & Profile Management	- Users are greeted with a personalized message using their stored name. - "Edit Profile" allows users to dynamically update their name.	GET /api/username/:email - Fetches the username from the Users table based on the provided email. - Returns personalized data for greeting and profile. PUT /api/username/:email - Updates the Username field for the specified email. - Validates non-empty input. - Returns success or error based on affected rows.
Event Browsing & Venue Viewing	- Users can browse a full list of events with key details: name, theme, description, date, time, capacity, price, and venue. - "View Location" uses Google Maps integration to show the venue.	GET /api/events - SELECT query joins Events and Location tables using event ID. - Returns event metadata along with latitude and longitude for Google Maps embedding. - Handles DB errors and returns fallback messages if needed.
Event Booking & Confirmation	- Users can book events via a confirmation window. - Event is added to the user's profile in real time. - Multiple ticket booking is supported, with data reflected instantly after booking or refreshing.	POST /api/book-event - Validates event capacity (max vs current) from Events table. - Retrieves user ID from Users table using email. - Checks existing bookings in Booked table: - If exists: Updates tickets_booked count. - Else: Inserts new booking record. - Updates event's current capacity. - Includes checks for errors and prevents overbooking.
Event Availability & Restrictions	- Events with full capacity or undefined venue details are displayed as unavailable. - Such events remain visible for awareness but are restricted from booking.	POST /api/book-event (shared logic) - Validates that event has available capacity and defined venue location (latitude/longitude). - Returns an error if event is fully booked or venue is unassigned. - Prevents proceeding to booking step for restricted events.
Tracking Booked Events	- Users can view a complete list of their booked events. - Includes event name, date, time, venue, theme, and number of tickets. - Booking data persists and is retrieved after login.	GET /api/booked-events/:email - Complex JOIN query on Booked, Events, Location, and Users tables. - Filters on user email. - Returns a detailed JSON of all booked events for rendering in user profile. - Ensures that data integrity is maintained across login sessions.

Technical Highlight

Category	Details
Input Validation	- Each endpoint includes input validation for user-provided data. - Example: Checking if username is empty in `PUT /api/username/:email` or ensuring valid `eventId` in `POST /api/book-event`.
Error Handling	- Robust error handling ensures that database errors, invalid inputs, or unforeseen issues are gracefully managed. - Meaningful HTTP response codes are used (e.g., `404 Not Found`, `400 Bad Request`, `500 Internal Server Error`).
Dynamic Updates	- Real-time updates for event capacities. - User bookings enhancing the seamlessness of the application workflow.

Technical Framework Summary

Category	Details
Frontend	- React ensures an interactive and responsive user interface. - Features include personalized greetings, event browsing, filtering, and booking.
Backend	- Express facilitates robust API endpoints. - Connects the frontend with the SQLite database for real-time data fetching and updates.
Database Operations	- SQLite handles efficient storage and retrieval of user, event, and booking data. - Operations include `SELECT` (retrieving data), `INSERT` (new records), and `UPDATE` (modifying existing records) for synchronized functionality.

Application URLs

Pages	URL
* User Profile (Different for different users)	http://localhost:5173/email?user=saahen1@gmail.com

User profile is separate for each user like

http://localhost:5173/email?user=Email

Email is the user email given during the time of signup.

Application UI

Image	Description
	Page a new user sees.
	Page after editing profile, changing names, and booking events.
	Images showing edit user profile functionality.
	Images showing a list of all available events.
	Images showing a dialogue box for payment confirmation for event booking.
	Images showing search by event feature.
	Images showing filter by theme feature.

Admin Module Features (Backend Endpoints, URLs and Application UI)

Module	Features	Backend Endpoint(s)
Create New Event	- Admin creates events by entering name, description, theme, date, time, capacity, and ticket price via a form. - Created events are shown in both admin and user dashboards.	POST /api/events • Validates required fields (e.g., name, max_capacity, ticket_price, event_datetime). • Inserts data into `Events` table. • Returns new event ID with error handling.
Edit Event Details	- Admin can modify existing event info via "Edit" button. - Changes reflect dynamically across all dashboards.	PUT /api/events/:id • Updates fields in `Events` table (e.g., name, theme, datetime, etc.). • Simultaneously updates related venue info in `Location` table. • Includes relational checks and error handling.
Venue Management	- Admin assigns venues to events. - Venue details include name and coordinates for map integration. - Edits are reflected system-wide.	PUT /api/venues/:id • Updates venue_name, latitude, and longitude in `Location` table. • Validates input and ensures event-venue linkage. • Handles input errors and relational integrity.
Dashboard Metrics	- Admin sees metrics: total/average income, capacity % per event. - Events filterable by theme or search bar. - Admin views attendee details and sends reminders.	GET /getevents • Fetches event data for metric calculations. GET /getbooked • Retrieves attendee details by `event_id`. • Reminder emails triggered through confirmation modal.

Frontend Functionalities

Feature	Details
Create Event	- Admins use a form to enter event details such as name, theme, description, date, and capacity. - React handles form submission and sends data via `POST` requests to the backend.
Edit Event and Venue	- Event and venue details are editable using "Edit" buttons, dynamically updating fields based on admin input. - Frontend sends `PUT` requests to backend endpoints to persist changes.
Revenue and Metrics Dashboard	- The admin dashboard calculates metrics like total revenue, average income, and availability percentage using React state variables and backend API responses. - Filtering is implemented with search bars and checkboxes.
Attendee Tracking and Reminder	- Admins input event IDs to view attendee lists and booking details. - Clicking "Send Reminder" triggers a modal confirmation window, where reminders are sent to attendees via email using backend logic.

Application URLs

Pages	URL
Admin’s Event and Venue management page	http://localhost:5174/admindashboard
Admin’s vendor and Attendee Management page	http://localhost:5174/vendor-att

Application UI

Image	Description
	Create Event Form.
	Event list table.
	Event form loaded with event data to be edited.
	Venue list table.
	Venue list table with edit venue form.
	Vendor Dashboard.
	Vendor Dashboard’s search event by name functionality.
	Vendor Dashboard’s filter by theme functionality.
	Attendee management Tracker list.
	Attendee management Tracker list’s email reminder dialogue box.

SQLite Integration with Spring Boot

SQLite integration with Spring Boot necessitated the implementation of custom dialects and entity mappings due to SQLite's limited compatibility with Spring's JPA. To handle this, the following steps were taken:

Feature	Details
Custom Dialects	- A custom SQLite dialect was created to enable seamless communication between the Spring Boot application and the SQLite database. - Overcomes limitations in handling constraints and field types.
Service Layers	- Services such as `EventService` and `BookedService` fetch, process, and transform entity data into DTOs (Data Transfer Objects). - Facilitates efficient frontend communication via APIs.
Entity and Repository Management	- Entities were explicitly mapped to database tables using `@EntityScan` annotations. - Repositories (`EventRepository`, `BookedRepository`) encapsulate database operations like `findAll`, `save`, and `update`.
Frontend-Backend Communication	- React fetches parsed values from the Spring Boot backend running on `<http://localhost:8080>`. - API responses dynamically render metrics, attendee data, and venue details on the admin page.

ER Diagram

An Entity Relationship Diagram for visual representation of the data structure and relationships within the database.

Database Schema

Table Name	Attribute	Properties
Admin	Id	Integer, primary key, auto-incremented. Unique identifier for each admin.
	Email	Text, unique, not null. Stores the admin's email address.
	Password	Text, not null. Stores the admin's password.
Users	Id	Integer, primary key, auto-incremented. Unique identifier for each user.
	Email	Text, not null. Stores the user's email address.
	Password	Text, not null. Stores the user's password.
	Username	Text, default value `___`. Stores the user's display name.
Events	eventid	Integer, primary key, auto-incremented. Unique identifier for each event.
	name	Text, not null. Stores the name of the event.
	theme	Text. Stores the theme of the event.
	description	Text. Stores details about the event.
	max_capacity	Integer, not null. Maximum attendees the event can accommodate.
	current_capacity	Integer, default value 0. Tracks the current number of attendees.
	ticket_price	Integer, not null. Stores the ticket price for the event.
	event_datetime	Datetime, not null. Records the scheduled date and time for the event.
Booked	id	Integer, primary key, auto-incremented. Unique identifier for each booking.
	useremail_id	Integer, foreign key referencing `Users.Id`, on delete cascade. Links the booking to the user who made it.
	event_booked	Integer, foreign key referencing `Events.eventid`, on delete cascade. Links the booking to a specific event.
	tickets_booked	Integer, not null, default value 1. Records the number of tickets booked.
	Email	Text. Stores the email address associated with the booking.
Location	venueid	Integer, primary key, auto-incremented. Unique identifier for each venue.
	event_name	Varchar(255). Stores the name of the event hosted at the venue.
	event_theme	Varchar(255). Stores the theme of the event hosted at the venue.
	venue_name	Varchar(255), default value `'unassigned'`. Stores the venue name.
	event_datetime	Datetime. Records the date and time of the event at the venue.
	longitude	Real, default value `0.000000`. Geographical longitude of the venue.
	latitude	Real, default value `0.000000`. Geographical latitude of the venue.
	eventid	Integer, foreign key referencing `Events.eventid`. Links the venue to the event.

Relationship, Logic and Usage

Relationship	Logic	Usage
Users → Booked (One-to-Many)	- A user can book multiple events. - Relationship established via `useremail_id` foreign key in `Booked`, referencing `Users.Id`.	- When a user books an event, a new entry is created in `Booked`, linking `useremail_id` and `event_booked`. - Stores the number of tickets (`tickets_booked`) and associated email.
Events → Booked (One-to-Many)	- An event can have multiple bookings. - Relationship established via `event_booked` foreign key in `Booked`, referencing `Events.eventid`.	- When an event is booked, `current_capacity` in `Events` is updated. - A new row is created in `Booked` linking the event's ID.
Events → Location (One-to-One)	- Each event is assigned a specific venue. - Relationship established via `eventid` foreign key in `Location`, referencing `Events.eventid`.	- The app associates each event with a venue. - Venue details (name, coordinates, datetime) are stored in the `Location` table.

Flow Documentation

Flow Documentation for User and Admin.

1. User Interaction Flow

Feature	Action	Outcome	Endpoint
User Signup	User visits the signup page and enters email and password. Confirms password for accuracy.	Backend validates input and checks for duplicate emails. Password is hashed using `BCrypt`. User is redirected to the login page.	`POST /api/auth/signup`
User Login	User enters email and password and submits login form.	Backend verifies credentials. On success, a JWT token is generated and stored. User is redirected to dashboard.	`POST /api/auth/login`
Browsing Events	User browses events on main dashboard. Can filter events by name or theme.	Events displayed with details: name, theme, description, datetime, venue, price, and availability.	`GET /api/events`
Booking an Event	User clicks "Book Event" and confirms booking.	Event added to user's "Confirmed Events". Multiple tickets can be booked.	`POST /api/book-event`
Viewing Booked Events	User navigates to profile page.	List of booked events with name, theme, date, venue, and number of tickets.	`GET /api/booked-events/:email`

2. Admin Interaction Flow

Feature	Action	Outcome	Endpoint
Admin Login	Admin enters credentials on login page.	JWT token generated upon successful login. Redirected to dashboard.	`POST /api/auth/admin-login`
Creating New Events	Admin fills form with event details.	Event saved and visible to users and admins.	`POST /api/events`
Editing Events	Admin clicks "Edit" and modifies details.	Database updated and UI reflects changes.	`PUT /api/events/:id`
Venue Management	Admin assigns or edits venue details.	Venue updates reflected in linked `Location` table.	`PUT /api/venues/:id`
Vendor & Attendee Dashboard	Admin views revenue, ticket stats, and attendee details. Can send email reminders.	Metrics and attendee info dynamically shown. Email reminder logic triggered.	Fetch metrics: `GET /getevents` Fetch attendee list: `GET /getbooked`

Dockerization

Service	Purpose	Features
ASP.NET Core (`asp`)	Hosts ASP.NET backend.	- Uses `mcr.microsoft.com/dotnet/sdk` for build. - Publishes to a lightweight runtime image. - Exposes port `5274`.
React User Interface (`react`)	Hosts the frontend user interface.	- Installs Node.js dependencies, copies source, sets environment. - Exposes ports `5173` (frontend) and `3001` (backend).
React Admin Interface (`react-admin`)	Admin-facing frontend.	- Exposes ports `5174` (frontend) and `3002` (backend).
Spring Boot Backend (`spring`)	Hosts admin functionality.	- Uses Maven with SQLite integration. - Exposes port `8080`.

Visual Overview

Image	Description
	Docker Compose build process.
	Docker images after build (Docker UI).
	Docker images after build (Terminal).
	Running containers with port mappings.

Application Deployment & Usage Guide

Usage Option 1: Dockerized Deployment

Navigate to the project root:

docker-compose up --build

Builds and starts:
- ASP.NET backend
- Node.js backend
- Spring Boot backend
- React UIs

Usage Option 2: Manual Deployment

Terminal 1: ASP.NET

cd asp
dotnet run

Ensure you update appsettings.json connection string to:

"DefaultConnection": "Data Source=../Backend/EventManagement.db"

Terminal 2: React Frontend

cd react
npm run dev

Terminal 3: React Backend

cd react
node server.js

Terminal 4: React Admin Frontend

cd reactadmin
npm run dev

Terminal 5: React Admin Backend

cd reactadmin
node server.js

Terminal 6: Spring Boot Backend

cd spring
mvn spring-boot:run

Usage Option 3: Hybrid Deployment

Build selected images (React, Admin, ASP):

docker-compose up react-app react-admin asp-app --build

Run Spring Boot manually:

cd spring
mvn spring-boot:run

Hover Bug: A Prankware Simulator. Based on the "Butterfly on Desktop" (text only) that will probably never touch the corner.

Saahen Sriyan Mishra — Mon, 05 May 2025 03:59:46 +0000

Hey folks!

I recently finished a fun little C++ project that simulates a butterfly flying around your desktop — but with a twist: it does so in a controlled environment for custom text input! Remember the DVD logo that people love when it touches the corner based on a fixed path, this one is unpredictable as its movement is random.

Give it a try by downloading the Github Release: Hover_Bug

🧠 What It Does:

Spawns a entered text that "hovers" on top of all windows.
Almost like a DVD logo that people love when it touches the corner.
Runs seamlessly on Windows — think of it like a lightweight desktop companion.

🔧 Tech Stack:

Language: C++
Framework: Win32 API for desktop-level rendering and layering
Executable Output: Hover_Bug.exe and main.exe
Release Build: Available under the release branch on GitHub — only 2.exe files.

📦 Use Case: (For fun only)

A desktop pet that displays motivational quotes or reminders.
A customizable visual toy to demonstrate Win32 overlay capabilities.

🛠️ Features

Dynamic Floating Text

Smooth movement patterns (3-7 sec per direction)
Starts centered on any screen

Eye-Catching Effects

🌈 Smooth color fading (rainbow mode)
🎯 Always-on-top display

Easy Control

Simple launcher for text updates
System tray friendly (low resource usage)

Additional:

The overlay doesn’t interfere with mouse events or system focus.
Controlling CPU usage by limiting it to only 1 instance.
Clean and minimal without background threads going wild.

👨‍💻 Code

main.cpp — Hover-Bug Launcher

This file creates a simple Windows GUI app using the Win32 API. It allows the user to input text and launch/stop a floating text overlay (Hover_Bug.exe).

✅ `FindHoverBugProcess` — Finds if Hover_Bug.exe is already running

DWORD FindHoverBugProcess() {
    HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnap == INVALID_HANDLE_VALUE) return 0;

    PROCESSENTRY32 pe;
    pe.dwSize = sizeof(PROCESSENTRY32);

    if (Process32First(hSnap, &pe)) {
        do {
            if (_wcsicmp(pe.szExeFile, L"Hover_Bug.exe") == 0) {
                CloseHandle(hSnap);
                return pe.th32ProcessID;
            }
        } while (Process32Next(hSnap, &pe));
    }

    CloseHandle(hSnap);
    return 0;
}

Explanation:

Takes a snapshot of all running processes.
Loops through each using Process32First/Next.
Compares the process name (case-insensitive) with Hover_Bug.exe.
If found, returns its Process ID (PID).

✅ TerminateHoverBug — Kills Hover_Bug.exe if running

Copy code
void TerminateHoverBug() {
    DWORD pid = FindHoverBugProcess();
    if (pid) {
        HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, pid);
        if (hProcess) {
            TerminateProcess(hProcess, 0);
            CloseHandle(hProcess);
        }
    }
}

Explanation:

Calls FindHoverBugProcess() to check if it's running.
Opens the process with permission to terminate it.
Calls TerminateProcess().

✅ LaunchHoverBug — Starts Hover_Bug.exe with user text

Copy code
void LaunchHoverBug(const std::string& text) {
    TerminateHoverBug(); // Ensure only one instance

    std::string command = "Hover_Bug.exe \"" + text + "\"";
    STARTUPINFOA si = { sizeof(si) };
    PROCESS_INFORMATION pi;
    CreateProcessA(NULL, const_cast<LPSTR>(command.c_str()), NULL, NULL, FALSE,
                   CREATE_NO_WINDOW, NULL, NULL, &si, &pi);
    CloseHandle(pi.hProcess);
    CloseHandle(pi.hThread);
}

Explanation:

Terminates any existing instance.
Creates the command: Hover_Bug.exe "user text".
Uses CreateProcessA() to launch it silently (CREATE_NO_WINDOW).

✅ WindowProc — Main GUI Event Handler

Copy code
LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
    static HWND hEdit, hStartButton, hStopButton;

    switch (uMsg) {
    case WM_CREATE:
        CreateWindow("STATIC", "Enter text:", WS_VISIBLE | WS_CHILD,
                     20, 20, 80, 20, hwnd, (HMENU)ID_LABEL, NULL, NULL);

        hEdit = CreateWindow("EDIT", "", WS_VISIBLE | WS_CHILD | WS_BORDER,
                             110, 20, 250, 20, hwnd, (HMENU)ID_EDIT, NULL, NULL);

        hStartButton = CreateWindow("BUTTON", "Start", WS_VISIBLE | WS_CHILD,
                                    110, 60, 100, 30, hwnd, (HMENU)ID_START_BUTTON, NULL, NULL);

        hStopButton = CreateWindow("BUTTON", "Stop", WS_VISIBLE | WS_CHILD,
                                   220, 60, 100, 30, hwnd, (HMENU)ID_STOP_BUTTON, NULL, NULL);
        break;

    case WM_COMMAND:
        if (LOWORD(wParam) == ID_START_BUTTON) {
            char buffer[256];
            GetWindowTextA(hEdit, buffer, 256);
            std::string text(buffer);
            if (!text.empty()) {
                LaunchHoverBug(text);
            } else {
                MessageBox(hwnd, "Please enter text.", "Error", MB_OK | MB_ICONERROR);
            }
        }
        else if (LOWORD(wParam) == ID_STOP_BUTTON) {
            TerminateHoverBug();
        }
        break;

    case WM_DESTROY:
        TerminateHoverBug(); // Clean up
        PostQuitMessage(0);
        break;

    default:
        return DefWindowProc(hwnd, uMsg, wParam, lParam);
    }

    return 0;
}

Explanation:

On WM_CREATE: Creates input field and Start/Stop buttons.
On WM_COMMAND: If Start is clicked, gets input and calls LaunchHoverBug. If Stop is clicked, terminates.

- On WM_DESTROY: Kills Hover_Bug before quitting.

✅ WinMain — Entry Point

Copy code
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR, int nCmdShow) {
    const char CLASS_NAME[] = "HoverBugLauncher";

    WNDCLASS wc = {};
    wc.lpfnWndProc = WindowProc;
    wc.hInstance = hInstance;
    wc.lpszClassName = CLASS_NAME;

    RegisterClass(&wc);

    HWND hwnd = CreateWindowEx(
        0, CLASS_NAME, "Hover-Bug Launcher",
        WS_OVERLAPPEDWINDOW ^ WS_THICKFRAME ^ WS_MAXIMIZEBOX,
        CW_USEDEFAULT, CW_USEDEFAULT, 400, 150,
        NULL, NULL, hInstance, NULL
    );

    if (!hwnd) return 0;

    ShowWindow(hwnd, nCmdShow);
    UpdateWindow(hwnd);

    MSG msg = {};
    while (GetMessage(&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    return 0;
}

Explanation:

Defines and registers a window class.
Creates the main window.
Shows it and enters the message loop to handle UI events.

hover_bug.cpp — Floating Overlay Window (Full Explanation)

This file creates a transparent, always-on-top, click-through window that displays floating text passed via command-line arguments. It uses the GDI+ library to draw smooth text with a blur/glow effect.

✅ Globals and Setup

#pragma comment(lib, "gdiplus.lib")

#include <windows.h>
#include <gdiplus.h>
#include <string>

using namespace Gdiplus;

ULONG_PTR gdiplusToken;
std::wstring g_text;

Explanation:

Links gdiplus.lib to use GDI+ for graphics.
Declares g_text to hold the overlay text.
gdiplusToken manages the GDI+ session.

✅ DrawTextWithBlur — Draws Text with Shadow/Glow

Copy code
void DrawTextWithBlur(HDC hdc, const std::wstring& text, RECT rect) {
    Graphics graphics(hdc);
    graphics.SetSmoothingMode(SmoothingModeAntiAlias);
    graphics.SetTextRenderingHint(TextRenderingHintClearTypeGridFit);

    FontFamily fontFamily(L"Segoe UI");
    Font font(&fontFamily, 36, FontStyleBold, UnitPixel);
    PointF origin(rect.left, rect.top);

    SolidBrush shadowBrush(Color(128, 0, 0, 0)); // semi-transparent black
    for (int dx = -2; dx <= 2; ++dx) {
        for (int dy = -2; dy <= 2; ++dy) {
            PointF shadowOrigin(origin.X + dx, origin.Y + dy);
            graphics.DrawString(text.c_str(), -1, &font, shadowOrigin, &shadowBrush);
        }
    }

    SolidBrush textBrush(Color(255, 255, 255, 255)); // white text
    graphics.DrawString(text.c_str(), -1, &font, &origin, &textBrush);
}

Explanation:

Uses GDI+ to draw high-quality text.
First, it draws shadows by looping through offsets.
Then, it draws solid white text on top.

- Creates a blur/glow effect using offset rendering.

✅ WindowProc — Message Handler for Overlay Window

Copy code
LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
    switch (uMsg) {
    case WM_PAINT: {
        PAINTSTRUCT ps;
        HDC hdc = BeginPaint(hwnd, &ps);
        RECT rect;
        GetClientRect(hwnd, &rect);
        DrawTextWithBlur(hdc, g_text, rect);
        EndPaint(hwnd, &ps);
        return 0;
    }
    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    default:
        return DefWindowProc(hwnd, uMsg, wParam, lParam);
    }
}

Explanation:

On WM_PAINT, it draws the blurred text inside the window.
On WM_DESTROY, posts quit message.
Default handling for other messages.

✅ wWinMain — Entry Point for the Hover Bug Overlay

Copy code
int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE, PWSTR pCmdLine, int) {
    GdiplusStartupInput gdiplusStartupInput;
    GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);

    g_text = pCmdLine;

Explanation:

Starts GDI+ graphics session.
Retrieves the overlay text passed via command line (from main.cpp).

✅ Register Window Class

Copy code
    const wchar_t CLASS_NAME[] = L"HoverBugWindowClass";
    WNDCLASS wc = {};
    wc.lpfnWndProc = WindowProc;
    wc.hInstance = hInstance;
    wc.lpszClassName = CLASS_NAME;
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);

    RegisterClass(&wc);

Explanation:

Defines the look and behavior of the overlay window.
Sets background to black (for blending).
Uses the earlier WindowProc.

✅ Create Transparent, Click-through Window

Copy code
    HWND hwnd = CreateWindowEx(
        WS_EX_LAYERED | WS_EX_TRANSPARENT | WS_EX_TOPMOST | WS_EX_TOOLWINDOW,
        CLASS_NAME, L"Hover Bug",
        WS_POPUP,
        100, 100, 800, 200,
        NULL, NULL, hInstance, NULL
    );

Explanation:

WS_EX_LAYERED: Allows transparency.
WS_EX_TRANSPARENT: Mouse click passes through it.
WS_EX_TOPMOST: Always on top.
WS_EX_TOOLWINDOW: Hides from taskbar.
WS_POPUP: No border/titlebar.

✅ Set Layered Transparency & Show Window

Copy code
    SetLayeredWindowAttributes(hwnd, 0, 255, LWA_ALPHA);
    ShowWindow(hwnd, SW_SHOW);

Explanation:

Makes the window fully visible (alpha = 255), still layered for potential opacity.
Shows the window after creation.

✅ Message Loop

Copy code
    MSG msg = {};
    while (GetMessage(&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    GdiplusShutdown(gdiplusToken);
    return 0;
}

Explanation:

Runs standard Win32 message loop.
Cleans up GDI+ before exit.

📥 Installation

Download the latest release from Releases
Extract Hover-Bug_v2.3.zip
Run main.exe

No admin rights required!

🖥️ Usage

Basic Controls

Type your text in the launcher

Click "Start" to launch floating text

Use "Stop" to remove it

Advanced Options

Command Line:

  Hover_Bug.exe "Your Text Here"

🛠️ Building from Source

Requires:

MinGW/GCC (Windows)
Win32 API development headers

g++ -std=c++11 -O2 -mwindows hover_bug.cpp -o Hover_Bug.exe -static -lgdi32 -lwinmm
g++ main.cpp -o main.exe -mwindows

📎 GitHub:

🔗 Repo
⬇️ Release v2.3.2

If you're into desktop UI tweaks, C++ visual projects, or just need some zen in your workspace, check it out!

Feedback and suggestions are all welcome. BTW i will be adding a Input for desired image over the text to make it more cool.

ClassiSage: Terraform IaC Automated AWS SageMaker based HDFS Log classification Model

Saahen Sriyan Mishra — Fri, 25 Oct 2024 01:11:52 +0000

ClassiSage

A Machine Learning model made with AWS SageMaker and its Python SDK for Classification of HDFS Logs using Terraform for automation of infrastructure setup. Done with process automation using python script over based concepts of DevOps over machine learning. (ML Ops)

Link: GitHub
Language: HCL (terraform), Python

Content

Overview: Project Overview.
System Architecture: System Architecture Diagram
ML Model: Model Overview.
Getting Started: How to run the project.
Console Observations: Changes in instances and infrastructure that can be observed while running the project.
Ending and Cleanup: Ensuring no additional charges.
Auto Created Objects: Files and Folders created during execution process.

Firstly follow the Directory Structure for better project setup.
Take major reference from the ClassiSage's Project Repository uploaded in GitHub for better understanding.

Overview

The model is made with AWS SageMaker for Classification of HDFS Logs along with S3 for storing dataset, Notebook file (containing code for SageMaker instance) and Model Output.
The Infrastructure setup is automated using Terraform a tool to provide infrastructure-as-code created by HashiCorp
The data set used is HDFS_v1.
The project implements SageMaker Python SDK with the model XGBoost version 1.2

System Architecture

ML Model

Image URI

  # Looks for the XGBoost image URI and builds an XGBoost container. Specify the repo_version depending on preference.
  container = get_image_uri(boto3.Session().region_name,
                            'xgboost', 
                            repo_version='1.0-1')

Initializing Hyper Parameter and Estimator call to the container

  hyperparameters = {
        "max_depth":"5",                ## Maximum depth of a tree. Higher means more complex models but risk of overfitting.
        "eta":"0.2",                    ## Learning rate. Lower values make the learning process slower but more precise.
        "gamma":"4",                    ## Minimum loss reduction required to make a further partition on a leaf node. Controls the model’s complexity.
        "min_child_weight":"6",         ## Minimum sum of instance weight (hessian) needed in a child. Higher values prevent overfitting.
        "subsample":"0.7",              ## Fraction of training data used. Reduces overfitting by sampling part of the data. 
        "objective":"binary:logistic",  ## Specifies the learning task and corresponding objective. binary:logistic is for binary classification.
        "num_round":50                  ## Number of boosting rounds, essentially how many times the model is trained.
        }
  # A SageMaker estimator that calls the xgboost-container
  estimator = sagemaker.estimator.Estimator(image_uri=container,                  # Points to the XGBoost container we previously set up. This tells SageMaker which algorithm container to use.
                                          hyperparameters=hyperparameters,      # Passes the defined hyperparameters to the estimator. These are the settings that guide the training process.
                                          role=sagemaker.get_execution_role(),  # Specifies the IAM role that SageMaker assumes during the training job. This role allows access to AWS resources like S3.
                                          train_instance_count=1,               # Sets the number of training instances. Here, it’s using a single instance.
                                          train_instance_type='ml.m5.large',    # Specifies the type of instance to use for training. ml.m5.2xlarge is a general-purpose instance with a balance of compute, memory, and network resources.
                                          train_volume_size=5, # 5GB            # Sets the size of the storage volume attached to the training instance, in GB. Here, it’s 5 GB.
                                          output_path=output_path,              # Defines where the model artifacts and output of the training job will be saved in S3.
                                          train_use_spot_instances=True,        # Utilizes spot instances for training, which can be significantly cheaper than on-demand instances. Spot instances are spare EC2 capacity offered at a lower price.
                                          train_max_run=300,                    # Specifies the maximum runtime for the training job in seconds. Here, it's 300 seconds (5 minutes).
                                          train_max_wait=600)                   # Sets the maximum time to wait for the job to complete, including the time waiting for spot instances, in seconds. Here, it's 600 seconds (10 minutes).

Training Job

  estimator.fit({'train': s3_input_train,'validation': s3_input_test})

Deployment

  xgb_predictor = estimator.deploy(initial_instance_count=1,instance_type='ml.m5.large')

Validation

  from sagemaker.serializers import CSVSerializer
  import numpy as np
  from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix

  # Drop the label column from the test data
  test_data_features = test_data_final.drop(columns=['Label']).values

  # Set the content type and serializer
  xgb_predictor.serializer = CSVSerializer()
  xgb_predictor.content_type = 'text/csv'

  # Perform prediction
  predictions = xgb_predictor.predict(test_data_features).decode('utf-8')

  y_test = test_data_final['Label'].values

  # Convert the predictions into a array
  predictions_array = np.fromstring(predictions, sep=',')
  print(predictions_array.shape)

  # Converting predictions them to binary (0 or 1)
  threshold = 0.5
  binary_predictions = (predictions_array >= threshold).astype(int)

  # Accuracy
  accuracy = accuracy_score(y_test, binary_predictions)

  # Precision
  precision = precision_score(y_test, binary_predictions)

  # Recall
  recall = recall_score(y_test, binary_predictions)

  # F1 Score
  f1 = f1_score(y_test, binary_predictions)

  # Confusion Matrix
  cm = confusion_matrix(y_test, binary_predictions)

  # False Positive Rate (FPR) using the confusion matrix
  tn, fp, fn, tp = cm.ravel()
  false_positive_rate = fp / (fp + tn)

  # Print the metrics
  print(f"Accuracy: {accuracy:.8f}")
  print(f"Precision: {precision:.8f}")
  print(f"Recall: {recall:.8f}")
  print(f"F1 Score: {f1:.8f}")
  print(f"False Positive Rate: {false_positive_rate:.8f}")

Getting Started

Clone the repository using Git Bash / download a .zip file / fork the repository.
Go to your AWS Management Console, click on your account profile on the Top-Right corner and select My Security Credentials from the dropdown.
Create Access Key: In the Access keys section, click on Create New Access Key, a dialog will appear with your Access Key ID and Secret Access Key.
Download or Copy Keys: (IMPORTANT) Download the .csv file or copy the keys to a secure location. This is the only time you can view the secret access key.
Open the cloned Repo. in your VS Code
Create a file under ClassiSage as terraform.tfvars with its content as

  # terraform.tfvars
  access_key = "<YOUR_ACCESS_KEY>"
  secret_key = "<YOUR_SECRET_KEY>"
  aws_account_id = "<YOUR_AWS_ACCOUNT_ID>"

Download and install all the dependancies for using Terraform and Python.
In the terminal type/paste terraform init to initialize the backend.
Then type/paste terraform Plan to view the plan or simply terraform validate to ensure that there is no error.
Finally in the terminal type/paste terraform apply --auto-approve
This will show two outputs one as bucket_name other as pretrained_ml_instance_name (The 3rd resource is the variable name given to the bucket since they are global resources ).

After Completion of the command is shown in the terminal, navigate to ClassiSage/ml_ops/function.py and on the 11th line of the file with code

  output = subprocess.check_output('terraform output -json', shell=True, cwd = r'<PATH_TO_THE_CLONED_FILE>' #C:\Users\Saahen\Desktop\ClassiSage

and change it to the path where the project directory is present and save it.

Then on the ClassiSage\ml_ops\data_upload.ipynb run all code cell till cell number 25 with the code

  # Try to upload the local CSV file to the S3 bucket
  try:
    print(f"try block executing")
    s3.upload_file(
        Filename=local_file_path, 
        Bucket=bucket_name,       
        Key=file_key               # S3 file key (filename in the bucket)
    )
    print(f"Successfully uploaded {file_key} to {bucket_name}")

    # Delete the local file after uploading to S3
    os.remove(local_file_path)
    print(f"Local file {local_file_path} deleted after upload.")

  except Exception as e:
    print(f"Failed to upload file: {e}")
    os.remove(local_file_path)

to upload dataset to S3 Bucket.

Output of the code cell execution

After the execution of the notebook re-open your AWS Management Console.
You can search for S3 and Sagemaker services and will see an instance of each service initiated (A S3 bucket and a SageMaker Notebook)

S3 Bucket with named 'data-bucket-' with 2 objects uploaded, a dataset and the pretrained_sm.ipynb file containing model code.

Go to the notebook instance in the AWS SageMaker, click on the created instance and click on open Jupyter.
After that click on new on the top right side of the window and select on terminal.
This will create a new terminal.

On the terminal paste the following (Replacing with the bucket_name output that is shown in the VS Code's terminal output):

  aws s3 cp s3://<Bucket-Name>/pretrained_sm.ipynb /home/ec2-user/SageMaker/

Terminal command to upload the pretrained_sm.ipynb from S3 to Notebook's Jupyter environment

Go Back to the opened Jupyter instance and click on the pretrained_sm.ipynb file to open it and assign it a conda_python3 Kernel.
Scroll Down to the 4th cell and replace the variable bucket_name's value by the VS Code's terminal output for bucket_name = "<bucket-name>"

  # S3 bucket, region, session
bucket_name = 'data-bucket-axhq3rp8'
my_region = boto3.session.Session().region_name
sess = boto3.session.Session()
print("Region is " + my_region + " and bucket is " + bucket_name)

Output of the code cell execution

On the top of the file do a Restart by going to the Kernel tab.
Execute the Notebook till code cell number 27, with the code

# Print the metrics
print(f"Accuracy: {accuracy:.8f}")
print(f"Precision: {precision:.8f}")
print(f"Recall: {recall:.8f}")
print(f"F1 Score: {f1:.8f}")
print(f"False Positive Rate: {false_positive_rate:.8f}")

You will get the intended result. The data will be fetched, split into train and test sets after being adjusted for Labels and Features with a defined output path, then a model using SageMaker's Python SDK will be Trained, Deployed as a EndPoint, Validated to give different metrics.

Console Observation Notes

Execution of 8th cell

# Set an output path where the trained model will be saved
prefix = 'pretrained-algo'
output_path ='s3://{}/{}/output'.format(bucket_name, prefix)
print(output_path)

An output path will be setup in the S3 to store model data.

Execution of 23rd cell

estimator.fit({'train': s3_input_train,'validation': s3_input_test})

A training job will start, you can check it under the training tab.

After some time (3 mins est.) It shall be completed and will show the same.

Execution of 24th code cell

xgb_predictor = estimator.deploy(initial_instance_count=1,instance_type='ml.m5.large')

An endpoint will be deployed under Inference tab.

Additional Console Observation:

Creation of an Endpoint Configuration under Inference tab.

Creation of an model also under under Inference tab.

Ending and Cleanup

In the VS Code comeback to data_upload.ipynb to execute last 2 code cells to download the S3 bucket's data into the local system.
The folder will be named downloaded_bucket_content. Directory Structure of folder Downloaded.

You will get a log of downloaded files in the output cell. It will contain a raw pretrained_sm.ipynb, final_dataset.csv and a model output folder named 'pretrained-algo' with the execution data of the sagemaker code file.
Finally go into pretrained_sm.ipynb present inside the SageMaker instance and execute the final 2 code cells. The end-point and the resources within the S3 bucket will be deleted to ensure no additional charges.
Deleting The EndPoint

  sagemaker.Session().delete_endpoint(xgb_predictor.endpoint)

Clearing S3: (Needed to destroy the instance)

  bucket_to_delete = boto3.resource('s3').Bucket(bucket_name)
  bucket_to_delete.objects.all().delete()

Come back to the VS Code terminal for the project file and then type/paste terraform destroy --auto-approve
All the created resource instances will be deleted.

Auto Created Objects

ClassiSage/downloaded_bucket_content
ClassiSage/.terraform
ClassiSage/ml_ops/pycache
ClassiSage/.terraform.lock.hcl
ClassiSage/terraform.tfstate
ClassiSage/terraform.tfstate.backup

NOTE:
If you liked the idea and the implementation of this Machine Learning Project using AWS Cloud's S3 and SageMaker for HDFS log classification, using Terraform for IaC (Infrastructure setup automation), Kindly consider liking this post and starring after checking-out the project repository at GitHub.

Camouflage-Shield: An Image Encryption Application.

Saahen Sriyan Mishra — Fri, 18 Oct 2024 22:17:52 +0000

Camouflage Shield

Camouflage Shield is a Windows Form application designed for sensitive image storage in an encrypted format. The project employs various encryption and hashing algorithms to ensure secure user authentication and image protection.

Project Overview

Here we have a cryptography based image encryption application made With C# on .NET framework using Visual Studio.
It is a Windows Form Application.
Link: GitHub Repository

Usage: With core Functionality code snippet

Here the user will create an account with required details and the user data will be stored in database by using Hash Functions MD5, SHA-1, SHA-256, SHA-384 and SHA-512. These are used for encrypting and storing the login credentials. (MD5 and SHA1 are low level algorithm for data storing so not used in real world application, but used here for diversity in algorithms)

User data conversion to different hashes, code snippet

// Hashing values before inserting into the database
string hashedDate = GetHash(TextBoxBirthDate.Text, MD5.Create());
string hashedEmail = GetHash(TextBoxEmail.Text, SHA1.Create());
string hashedPhoneNumber = GetHash(TextBoxPhoneNumber.Text, SHA256.Create());
string hashedUsername = GetHash(LabelDisplayUserName.Text, SHA384.Create());
string hashedPassword = GetHash(TextBoxConfirmPassword.Text, SHA512.Create());

The user can then login into the profile (hash functions are not decrypted, instead when credentials are entered into the login page the text entered is hashed and then mapped to the values stored in database)
After logging into the profile user can select to encrypt image or view it (given they have an encrypted image string and know the encryption process and key used).
The image encryption is done my 5 symmetric key cryptography algorithms (AES, DES, 3DES, RC2, Rijndael).

-The user will select an image and a process (each process is a different algorithm) and a key to be used.

The image will be converted into its Base64 format (a string representation of the image) and on that generated string the algorithm using the provided key is applied after locking the selection.

Image conversion to Base64, code snippet

if (PictureBox.Image != null)
{
    // Convert the image to a byte array
    using (MemoryStream ms = new MemoryStream())
    {
        PictureBox.Image.Save(ms, PictureBox.Image.RawFormat);
        byte[] imageBytes = ms.ToArray();

        // Get the selected algorithm
        string algorithm = GetSelectedAlgorithm();

        // Get the key
        string key = TextBoxKey.Text;

        // Encrypt the byte array based on the selected algorithm
        byte[] encryptedBytes = EncryptData(imageBytes, key, algorithm);

        // Convert the encrypted byte array to a Base64 string
        string base64String = Convert.ToBase64String(encryptedBytes);

        // Display the Base64 string in TextboxImageCODE
        TextboxImageCODE.Text = base64String;
    }
}
else
{
    MessageBox.Show("Please select an image before generating the Base64 code.");
}

This will generate an encrypted string, user can choose to save it, and when done the encryption string mapped against the user name profile is saved in another database.
In the profile the encrypted string will be present, user need to copy that string and paste it in View Image tab, after that user need to select the process number signifying the algorithm and have to enter the key used. If any of the 3 variables do not match, an error message will be shown.

On the correct provision of the values, there will be an image generated that will be the original image encrypted.

Cryptographic algorithm for string Encryption, code snippet

private byte[] EncryptData(byte[] data, string key, string algorithm)
{
    byte[] keyBytes = Encoding.UTF8.GetBytes(key);
    byte[] result;

    switch (algorithm.ToLower())
    {
        case "aes":
            using (Aes aesAlg = Aes.Create())
            {
                aesAlg.Key = GetKey(keyBytes, aesAlg.KeySize / 8);
                aesAlg.Mode = CipherMode.ECB;
                aesAlg.Padding = PaddingMode.PKCS7;

                using (ICryptoTransform encryptor = aesAlg.CreateEncryptor())
                {
                    result = encryptor.TransformFinalBlock(data, 0, data.Length);
                }
            }
            break;

        case "des":
            using (DESCryptoServiceProvider desAlg = new DESCryptoServiceProvider())
            {
                desAlg.Key = GetKey(keyBytes, desAlg.KeySize / 8);
                desAlg.Mode = CipherMode.ECB;
                desAlg.Padding = PaddingMode.PKCS7;

                using (ICryptoTransform encryptor = desAlg.CreateEncryptor())
                {
                    result = encryptor.TransformFinalBlock(data, 0, data.Length);
                }
            }
            break;

        case "3des":
            using (TripleDESCryptoServiceProvider tripleDesAlg = new TripleDESCryptoServiceProvider())
            {
                tripleDesAlg.Key = GetKey(keyBytes, tripleDesAlg.KeySize / 8);
                tripleDesAlg.Mode = CipherMode.ECB;
                tripleDesAlg.Padding = PaddingMode.PKCS7;

                using (ICryptoTransform encryptor = tripleDesAlg.CreateEncryptor())
                {
                    result = encryptor.TransformFinalBlock(data, 0, data.Length);
                }
            }
            break;

        case "rc2":
            using (RC2CryptoServiceProvider rc2Alg = new RC2CryptoServiceProvider())
            {
                rc2Alg.Key = GetKey(keyBytes, rc2Alg.KeySize / 8);
                rc2Alg.Mode = CipherMode.ECB;
                rc2Alg.Padding = PaddingMode.PKCS7;

                using (ICryptoTransform encryptor = rc2Alg.CreateEncryptor())
                {
                    result = encryptor.TransformFinalBlock(data, 0, data.Length);
                }
            }
            break;

        case "Rijndael":
            using (RijndaelManaged rijndaelAlg = new RijndaelManaged())
            {
                rijndaelAlg.Key = GetKey(keyBytes, rijndaelAlg.KeySize / 8);
                rijndaelAlg.Mode = CipherMode.ECB;
                rijndaelAlg.Padding = PaddingMode.PKCS7;

                using (ICryptoTransform encryptor = rijndaelAlg.CreateEncryptor())
                {
                    result = encryptor.TransformFinalBlock(data, 0, data.Length);
                }
            }
            break;


        default:
            throw new NotSupportedException("Unsupported algorithm");
    }

    return result;
}

Apart from this there is a functionality for a Hash Text Encrypter. This gives a idea of how the login credential data is stored in the DB.

UseCase

The real world application of this project is for storing sensitive/confidential/evidential/private images.

Limitations

Even Though Practical and useful it have some limitations.

Dynamic updation limitation (need to re-start application to login, encrypted image string is visible only after re-start)
User profile may not show any text for encryption but can be copy pasted for decrypting and viewing the image.
Takes a long time to process image to text (base64 encrypted).
UI is practical but not attractive.
The database created is for Development phase, a practical application shall have a DB server hosted instead of the local machine.

Summary of Security Considerations

Passwords are hashed using MD5, SHA-1, SHA-256, SHA-384, and SHA-512
Multi-algorithm image encryption using AES, DES, 3DES, RC2, Rijndael.

README for reference and the encrypted image text file, process and key to have a quick demo to the functionalities along-with instruction for using the application.

If you liked the article, kindly consider liking it and possibly staring the GitHub Repository

NOTE:

If anyone who liked the idea and the implementation, and would like to contribute to fixing the limitation, feel free to do so by initiating an issue so we can be in contact. Then we can discuss the features and implementation.

DEV Community: Saahen Sriyan Mishra

# End-To-End Full-stack Event Management application (using ASP.NET, React, Node.js, and Spring Boot with SQLite Backend)

Table Of Content

Key Features

Tech Stack Used

Login and SignUp Module (Backend Endpoints, URLs and Application UI)

Technical Highlights

Application URLs

Application UI

User Module Features (Backend Endpoints, URLs and Application UI)

Technical Highlight

Technical Framework Summary

Application URLs

Application UI

Admin Module Features (Backend Endpoints, URLs and Application UI)

Frontend Functionalities

Application URLs

Application UI

SQLite Integration with Spring Boot

ER Diagram

Database Schema

Relationship, Logic and Usage

Flow Documentation

1. User Interaction Flow

2. Admin Interaction Flow

Dockerization

Application Deployment & Usage Guide

Usage Option 1: Dockerized Deployment

Usage Option 2: Manual Deployment

Usage Option 3: Hybrid Deployment

Hover Bug: A Prankware Simulator. Based on the "Butterfly on Desktop" (text only) that will probably never touch the corner.

🧠 What It Does:

🔧 Tech Stack:

📦 Use Case: (For fun only)

🛠️ Features

👨‍💻 Code

main.cpp — Hover-Bug Launcher

✅ FindHoverBugProcess — Finds if Hover_Bug.exe is already running

✅ TerminateHoverBug — Kills Hover_Bug.exe if running

✅ LaunchHoverBug — Starts Hover_Bug.exe with user text

✅ WindowProc — Main GUI Event Handler

- On WM_DESTROY: Kills Hover_Bug before quitting.

✅ WinMain — Entry Point

hover_bug.cpp — Floating Overlay Window (Full Explanation)

✅ Globals and Setup

✅ DrawTextWithBlur — Draws Text with Shadow/Glow

- Creates a blur/glow effect using offset rendering.

✅ wWinMain — Entry Point for the Hover Bug Overlay

✅ Register Window Class

✅ Create Transparent, Click-through Window

✅ Set Layered Transparency & Show Window

✅ Message Loop

📥 Installation

🖥️ Usage

Basic Controls

Advanced Options

🛠️ Building from Source

📎 GitHub:

ClassiSage: Terraform IaC Automated AWS SageMaker based HDFS Log classification Model

ClassiSage

Content

Overview

System Architecture

ML Model

Getting Started

Console Observation Notes

Ending and Cleanup

Auto Created Objects

Camouflage-Shield: An Image Encryption Application.

Camouflage Shield

Project Overview

Usage: With core Functionality code snippet

UseCase

Limitations

Summary of Security Considerations

NOTE:

✅ `FindHoverBugProcess` — Finds if Hover_Bug.exe is already running