E2IP Inventory Management
Mobile & Web Application with Spring Boot & DigiKey Integration
Project Overview
The E2IP Inventory Management Application is a comprehensive Spring Boot-based application designed to manage inventory, components, and their associated data. It integrates with external APIs (e.g., DigiKey) and provides endpoints for managing components, suppliers, and inventory stock.
The system features a Flutter mobile application with a layered architecture, providing both mobile (Android/iOS) and desktop/web interfaces. It uses Riverpod for state management and follows clean architecture principles with clear separation of concerns.
Backend Architecture
Core Components:
- Controllers: Handle HTTP requests and responses (ComponentController, DigikeyAuthController, AuthController)
- Services: Contain business logic (ComponentServiceImp, AuthService, JsonParsingService)
- Repositories: Provide database access using Spring Data JPA
Key Features:
- Component Management: Add, update, and manage components and their stock
- DigiKey API Integration: Fetch categories and search for components
- JWT Authentication: Secure endpoints with token-based authentication
- Database Management: Spring Data JPA for entity persistence
Mobile App Architecture
Layered Structure:
- Presentation Layer: Flutter UI, screens and widgets using Riverpod for state management
- Domain Layer: Business models, repository interfaces, and data-source contracts
- Data Layer: Concrete implementations of repositories and networking
Navigation Structure:
- Dashboard: Overview cards, quick actions, recent activity
- Local Components: Lists locally stored components with search and filters
- DigiKey Components: Search and manage external component data
- Scanner: Barcode/QR scanning for components
- Settings: App-level preferences
Networking Architecture
The networking layer uses DioService for HTTP client management with:
- Automatic authentication token management
- Token refresh mechanism
- DigiKey API token management
- Standardized error handling
- Request/response interceptors
Motorola 6809 Emulator
Complete CPU Simulator with Assembly Editor and Real-time Visualization
Project Overview
A complete simulator/emulator for the Motorola 6809 microprocessor built with Java Swing. The application provides a comprehensive development environment with an integrated code editor, execution controls, and real-time visualization of CPU registers, flags, ROM, and RAM memory.
Features include full program execution, step-by-step debugging, live memory inspection, and a modern UI with syntax highlighting. The emulator supports assembly-like source code with ORG directives and implements core 6809 instruction set operations.
Architecture & Components
UI Layer (Swing):
- MainFRAME: Primary window with split-pane layout, code editor, and control panel
- RegisterDisplay: Real-time visualization of CPU registers and condition flags
- MemoryROMDisplay: Compact window showing ROM contents with address mapping
- MemoryRAMDisplay: Live RAM viewer with address range 0000-03FF
CPU/Logic Layer:
- UAL (Arithmetic Logic Unit): Core execution engine for parsing and processing instructions
- Instruction: Implements 6809 instruction semantics (load, store, arithmetic, logic operations)
- Rom: Program storage with configurable start address (default AC00)
- Registre: CPU register data model (A, B, D, X, Y, U, S, PC)
- Flag: Condition code flags management (N, Z, V, C, etc.)
Key Features
- Integrated Development Environment: Code editor with file operations (load, save, new)
- Execution Modes: Full program execution and step-by-step debugging
- Real-time Monitoring: Live updates of registers, flags, and memory contents
- Memory Management: Separate ROM and RAM visualization with address mapping
- Error Handling: Comprehensive error detection with SWI termination support
- Modern UI: Clean interface with Consolas font and consistent styling
DevSecOps Pipeline
Complete CI/CD Automation with Security Integration and Kubernetes Orchestration
Project Overview
A comprehensive DevSecOps chain hosted on Ubuntu VMs in VMware, automating the full software lifecycle from code analysis to deployment and monitoring. The solution integrates security scans, quality checks, and orchestrates containerized applications on a local Kubernetes cluster.
Built for Steet, a real-time chat platform for students, featuring Flutter mobile frontend and Spring Boot microservices backend with Node.js communication via WebRTC/WebSocket. The pipeline ensures cloud independence for learning and simulation environments.
Key Objectives
- Automated CI/CD Pipelines: Complete automation for Java projects from code to deployment
- Security Integration: Integrated vulnerability scanning and quality gates
- Container Orchestration: Kubernetes cluster management for scalability and resilience
- Performance Monitoring: Real-time metrics collection and visualization
- Cloud Independence: Local infrastructure for learning and development
Architecture & Implementation
Environment Setup:
- VMware Infrastructure: Local VMs with optimized resource allocation (Jenkins: 4GB RAM/4 CPU, K8s master: 8GB/8 CPU)
- Network Configuration: Static IP setup with host-only/bridged networking
- SSH Management: Secure access via Termius with proper authentication
Pipeline Workflow:
- Source Control: GitHub integration with webhook triggers
- Code Analysis: SonarQube static analysis with quality gates
- Security Scanning: Trivy vulnerability assessment for Docker images
- Artifact Management: Nexus Repository for Maven JARs and Docker images
- Deployment: Automated Kubernetes deployment with verification
- Monitoring: Prometheus metrics with Grafana visualization
- Notifications: HTML email reports for pipeline status
Audi Service Platform
Complete Service Management System with Flutter Frontend & Spring Boot Backend
Project Overview
A comprehensive full-stack service management platform for Audi vehicles, featuring a Flutter mobile frontend and Spring Boot backend API. The system enables users to authenticate, request service quotes, manage maintenance operations, and generate PDF documentation for Audi vehicle services.
The platform includes JWT-based authentication, role management, vehicle data tracking, service operations management, and analytics endpoints for business metrics. Features a modern UI with custom design system and responsive multi-step quote request workflows.
Backend Architecture (Spring Boot)
Core Features:
- Authentication & Security: JWT-based authentication with Spring Security integration
- User Management: Complete user and role management system
- Vehicle Data: Comprehensive vehicle and engine data management
- Service Operations: Maintenance and service tracking with analytics
- Quote Generation: PDF quote generation using Flying Saucer and iText7
- REST API: RESTful endpoints with Spring Data REST integration
Frontend Architecture (Flutter / Angular)
Key Components:
- Authentication Flow: Complete login/register system with session management
- Design System: Custom UI component library with standardized colors and typography
- Quote Request: Multi-step form process with step indicators and validation
- Responsive Design: Screen-adaptive UI using flutter_screenutil
- State Management: Controller-based architecture for business logic
- Asset Management: Organized structure for fonts, images, and SVG icons
Research Project Management
Collaborative Research Platform for Electronic Document Production
Project Overview
A comprehensive collaborative platform designed to facilitate teamwork for research projects and electronic document production. The system enables collaborative work among multiple participants, providing project management, user administration, and resource sharing capabilities.
Built with Vue.js frontend and Spring Boot backend, the platform supports public registration, role-based access control, and automated resource provisioning. Features include document repositories, mailing lists, calendars, and automated website generation from project documents.
Core Features
Account Management:
- Public Registration: Open registration system with automatic Default group assignment
- Role-Based Access: Admin, Default, and Guest user groups with privileged operations
- User Profiles: Complete user information management with unique identifiers
Project Management:
- Project Creation: Comprehensive project setup with metadata and licensing
- Member Management: Dynamic team composition with administrators and members
- Access Control: Public/private project visibility with resource-level permissions
- Project Lifecycle: Complete workflow from proposal to closure with validation
Resource Management:
- Document Repositories: Separate 'src' and 'web' spaces for project documents
- Automated Website: Public web generation from document repositories
- Communication Tools: Integrated mailing lists and project calendars
- Personal Resources: Individual user calendars and workspace
AI Models Deployment (Docker)
Flask Backend + Static Frontend containerized with Docker
Project Overview
A small, container-friendly stack that exposes three AI capabilities behind a Flask backend and a static frontend: audio transcription, text chat, and image generation. Each component is Dockerized for easy deployment.
The repository is organized into a Flask backend (REST API for /model1, /chat, /image) and a static
frontend (HTML/CSS/JS pages for each model). Generated images are persisted under static/uploads
with volume mounting support in Docker for production resilience.
Architecture
- Frontend: Static pages for Model 1 (audio), Model 2 (chat), Model 3 (image); fetches backend on 127.0.0.1:5000
- Backend (Flask): CORS-enabled API
- /model1: multipart audio upload, transcribed via Whisper-like API
- /chat: JSON chatInput, relays to NVIDIA-hosted LLM (OpenAI client with custom base_url)
- /image: JSON prompt, calls a Hugging Face model and saves to static/uploads
- Persistence: static/uploads volume for generated and uploaded images
