A modern, responsive web application built with Blazor Server that allows users to explore GitHub profiles and repositories with detailed insights, statistics, and visualizations.

🌐 Live Demo - Try it now!

• User Search: Search for GitHub users with real-time suggestions
• Comprehensive Profile View: Display user information, statistics, and bio
• Repository Analysis: Browse and analyze user repositories with detailed metrics
• Gist Support: View and explore user's gists

• Interactive Charts: Visual representation of repository statistics
• Language Distribution: See programming language usage across repositories
• Activity Insights: Track user activity and contributions

• GitHub Token Integration: Optional personal access token for enhanced API limits
• Rate Limit Monitoring: Real-time display of API quota usage
• Secure Storage: Tokens stored securely in browser's local storage

• Responsive Design: Built with Bulma CSS framework for mobile-first experience
• Fast Performance: Server-side rendering with interactive components
• Caching System: Intelligent caching to reduce API calls and improve performance

• Modern Architecture: Clean separation of concerns with services and interfaces
• Error Handling: Comprehensive error handling and user feedback
• Docker Support: Ready for containerized deployment
• Memory Caching: Efficient caching system to optimize API usage

• .NET 9.0 SDK
• Git
• (Optional) Docker for containerized deployment

1. Clone the repository

   git clone https://github.com/sametcn99/GPVBlazor.git
   cd GPVBlazor

2. Navigate to the project directory

   cd GPVBlazor/GPVBlazor

3. Restore dependencies

   dotnet restore

4. Run the application

   dotnet run

# Build the Docker image
docker build -t gpvblazor .

# Run the container
docker run -d -p 8080:8080 --name gpvblazor-app gpvblazor

The application can be configured through appsettings.json:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*"
}

1. Generate a Personal Access Token:

   • Go to GitHub Settings → Developer settings → Personal access tokens
   • Generate a new token with appropriate permissions
   • Copy the token

2. Add Token in Application:

   • Enter the token in the authentication section on the home page
   • The token will be stored securely in your browser's local storage

GPVBlazor/
├── Components/                  # Blazor components
│   ├── Displays/               # Display components
│   │   ├── AuthQuotaDisplay.razor
│   │   ├── UserProfileDisplay.razor
│   │   └── ...
│   ├── Layout/                 # Layout components
│   └── Pages/                  # Page components
├── Services/                   # Business logic services
│   ├── Interfaces/            # Service interfaces
│   ├── UserService.cs         # GitHub API interactions
│   └── ...
├── Models/                     # Data models
├── Endpoints/                  # API endpoints
└── wwwroot/                   # Static assets

• ASP.NET Core 9.0: Web framework
• Blazor Server: Interactive web UI framework
• C#: Primary programming language

• Blazor Components: Interactive UI components
• Bulma CSS: Modern CSS framework
• JavaScript: Client-side interactions
• Chart.js: Data visualization

• Markdig: Markdown processing for README files
• Memory Caching: Performance optimization
• HttpClient: API communication
• Docker: Containerization

Contributions are welcome! Please follow these steps:

1. Fork the repository

2. Create a feature branch

   git checkout -b feature/AmazingFeature

3. Commit your changes

   git commit -m 'Add some AmazingFeature'

4. Push to the branch

   git push origin feature/AmazingFeature

5. Open a Pull Request

The application interacts with the GitHub API v3. Key endpoints used:

• GET /users/{username} - User profile information
• GET /users/{username}/repos - User repositories
• GET /repos/{owner}/{repo}/readme - Repository README files
• GET /search/users - User search functionality

• Without Authentication: 60 requests per hour
• With Personal Access Token: 5,000 requests per hour
• The application includes built-in rate limit monitoring and displays current usage

• Memory Caching: Reduces API calls by caching responses
• Lazy Loading: Components load data as needed
• Batch Processing: Multiple API calls processed concurrently
• Responsive Design: Optimized for all device sizes

• No Server-Side Token Storage: Tokens are stored only in browser local storage
• HTTPS Enforced: All communications encrypted in production
• Input Validation: All user inputs are validated and sanitized
• Error Handling: Secure error messages that don't leak sensitive information

See the LICENSE.txt file for details.