th3chris — AI Solutions & Cloud Architecture for Business

Solution Explorer

📁 th3chris.API

📄 Program.cs

📄 UsersController.cs

📄 Startup.cs

📁 Controllers

📄 AuthController.cs

📄 ProjectsController.cs

📄 OrdersController.cs

📁 Models

📄 User.cs

📄 Project.cs

📄 Order.cs

📄 BaseEntity.cs

📁 Services

📄 UserService.cs

📄 IUserService.cs

📄 AuthService.cs

📄 EmailService.cs

📁 Data

📄 AppDbContext.cs

📄 DbInitializer.cs

📁 DTOs

📄 UserDto.cs

📄 CreateUserRequest.cs

📄 UpdateUserRequest.cs

📁 Middleware

📄 ErrorHandlingMiddleware.cs

📄 LoggingMiddleware.cs

📁 Extensions

📄 ServiceExtensions.cs

📄 ControllerExtensions.cs

UsersController.cs

// File: UsersController.cs
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using System.Threading.Tasks;
using th3chris.API.Models;
using th3chris.API.Services;
using Microsoft.Extensions.Logging;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using System.Security.Claims;
using AutoMapper;
using FluentValidation;
namespace th3chris.API.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    [Authorize]
    public class UsersController : ControllerBase
    {
        private readonly IUserService _userService;
        private readonly ILogger<UsersController> _logger;
        private readonly IMapper _mapper;
        private readonly IValidator<CreateUserRequest> _createValidator;
        private readonly IValidator<UpdateUserRequest> _updateValidator;
        public UsersController(
            IUserService userService,
            ILogger<UsersController> logger,
            IMapper mapper,
            IValidator<CreateUserRequest> createValidator,
            IValidator<UpdateUserRequest> updateValidator)
        {
            _userService = userService ?? throw new ArgumentNullException(nameof(userService));
            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
            _mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
            _createValidator = createValidator;
            _updateValidator = updateValidator;
        }
        /// <summary>
        /// Retrieves all users with pagination support
        /// </summary>
        /// <param name="pageNumber">Page number (default: 1)</param>
        /// <param name="pageSize">Page size (default: 10, max: 100)</param>
        /// <returns>Paginated list of users</returns>
        [HttpGet]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        public async Task<ActionResult<PagedResult<UserDto>>> GetUsers(
            [FromQuery] int pageNumber = 1,
            [FromQuery] int pageSize = 10,
            [FromQuery] string? search = null,
            [FromQuery] string? sortBy = null,
            [FromQuery] bool sortDescending = false)
        {
            try
            {
                if (pageNumber < 1)
                    return BadRequest("Page number must be greater than 0");
                if (pageSize < 1 || pageSize > 100)
                    return BadRequest("Page size must be between 1 and 100");
                _logger.LogInformation("Getting users - Page: {PageNumber}, Size: {PageSize}, Search: {Search}",  
                    pageNumber, pageSize, search);
                var currentUserId = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
                var filter = new UserFilter
                {
                    PageNumber = pageNumber,
                    PageSize = pageSize,
                    Search = search,
                    SortBy = sortBy,
                    SortDescending = sortDescending,
                    RequestingUserId = currentUserId
                };
                var users = await _userService.GetUsersAsync(filter);
                var userDtos = _mapper.Map<IEnumerable<UserDto>>(users.Items);
                var result = new PagedResult<UserDto>
                {
                    Items = userDtos,
                    TotalCount = users.TotalCount,
                    PageNumber = pageNumber,
                    PageSize = pageSize,
                    TotalPages = (int)Math.Ceiling((double)users.TotalCount / pageSize)
                };
                return Ok(result);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error occurred while getting users");
                return StatusCode(StatusCodes.Status500InternalServerError, 
                    "An error occurred while processing your request");
            }
        }
        /// <summary>
        /// Retrieves a specific user by ID
        /// </summary>
        /// <param name="id">User ID</param>
        /// <returns>User details</returns>
        [HttpGet("{id:int}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status403Forbidden)]
        public async Task<ActionResult<UserDetailDto>> GetUser(int id)
        {
            try
            {
                if (id <= 0)
                    return BadRequest("Invalid user ID");
                var currentUserId = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
                _logger.LogInformation("Getting user {UserId} requested by {CurrentUserId}", id, currentUserId);
                var user = await _userService.GetUserByIdAsync(id, currentUserId);
                if (user == null)
                {
                    _logger.LogWarning("User {UserId} not found or access denied for {CurrentUserId}", id, currentUserId);
                    return NotFound($"User with ID {id} not found");
                }
                var userDto = _mapper.Map<UserDetailDto>(user);
                return Ok(userDto);
            }
            catch (UnauthorizedAccessException ex)
            {
                _logger.LogWarning(ex, "Unauthorized access attempt for user {UserId}", id);
                return Forbid();
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error occurred while getting user {UserId}", id);
                return StatusCode(StatusCodes.Status500InternalServerError, 
                    "An error occurred while processing your request");
            }
        }
        /// <summary>
        /// Creates a new user
        /// </summary>
        /// <param name="request">User creation request</param>
        /// <returns>Created user</returns>
        [HttpPost]
        [ProducesResponseType(StatusCodes.Status201Created)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status409Conflict)]
        public async Task<ActionResult<UserDto>> CreateUser([FromBody] CreateUserRequest request)
        {
            try
            {
                if (request == null)
                    return BadRequest("Request body is required");
                var validationResult = await _createValidator.ValidateAsync(request);
                if (!validationResult.IsValid)
                {
                    var errors = validationResult.Errors.Select(e => e.ErrorMessage);
                    return BadRequest(new { Errors = errors });
                }
                var currentUserId = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
                _logger.LogInformation("Creating new user {Email} by {CurrentUserId}", request.Email, currentUserId);
                var user = _mapper.Map<User>(request);
                user.CreatedBy = currentUserId;
                user.CreatedAt = DateTime.UtcNow;
                var createdUser = await _userService.CreateUserAsync(user);
                var userDto = _mapper.Map<UserDto>(createdUser);
                return CreatedAtAction(nameof(GetUser), new { id = createdUser.Id }, userDto);
            }
            catch (DuplicateUserException ex)
            {
                _logger.LogWarning(ex, "Attempt to create duplicate user {Email}", request?.Email);
                return Conflict(new { Message = "User with this email already exists" });
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error occurred while creating user");
                return StatusCode(StatusCodes.Status500InternalServerError, 
                    "An error occurred while processing your request");
            }
        }
        /// <summary>
        /// Updates an existing user
        /// </summary>
        /// <param name="id">User ID</param>
        /// <param name="request">User update request</param>
        /// <returns>Updated user</returns>
        [HttpPut("{id:int}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status403Forbidden)]
        public async Task<ActionResult<UserDto>> UpdateUser(int id, [FromBody] UpdateUserRequest request)
        {
            try
            {
                if (id <= 0)
                    return BadRequest("Invalid user ID");
                if (request == null)
                    return BadRequest("Request body is required");
                var validationResult = await _updateValidator.ValidateAsync(request);
                if (!validationResult.IsValid)
                {
                    var errors = validationResult.Errors.Select(e => e.ErrorMessage);
                    return BadRequest(new { Errors = errors });
                }
                var currentUserId = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
                _logger.LogInformation("Updating user {UserId} by {CurrentUserId}", id, currentUserId);
                var existingUser = await _userService.GetUserByIdAsync(id, currentUserId);
                if (existingUser == null)
                {
                    _logger.LogWarning("User {UserId} not found for update by {CurrentUserId}", id, currentUserId);
                    return NotFound($"User with ID {id} not found");
                }
                _mapper.Map(request, existingUser);
                existingUser.UpdatedBy = currentUserId;
                existingUser.UpdatedAt = DateTime.UtcNow;
                var updatedUser = await _userService.UpdateUserAsync(existingUser);
                var userDto = _mapper.Map<UserDto>(updatedUser);
                return Ok(userDto);
            }
            catch (UnauthorizedAccessException ex)
            {
                _logger.LogWarning(ex, "Unauthorized update attempt for user {UserId}", id);
                return Forbid();
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error occurred while updating user {UserId}", id);
                return StatusCode(StatusCodes.Status500InternalServerError, 
                    "An error occurred while processing your request");
            }
        }
        /// <summary>
        /// Deletes a user by ID
        /// </summary>
        /// <param name="id">User ID</param>
        /// <returns>No content on success</returns>
        [HttpDelete("{id:int}")]
        [ProducesResponseType(StatusCodes.Status204NoContent)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status403Forbidden)]
        public async Task<IActionResult> DeleteUser(int id)
        {
            try
            {
                if (id <= 0)
                    return BadRequest("Invalid user ID");
                var currentUserId = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
                _logger.LogInformation("Deleting user {UserId} by {CurrentUserId}", id, currentUserId);
                var success = await _userService.DeleteUserAsync(id, currentUserId);
                if (!success)
                {
                    _logger.LogWarning("User {UserId} not found for deletion by {CurrentUserId}", id, currentUserId);
                    return NotFound($"User with ID {id} not found");
                }
                _logger.LogInformation("User {UserId} successfully deleted by {CurrentUserId}", id, currentUserId);
                return NoContent();
            }
            catch (UnauthorizedAccessException ex)
            {
                _logger.LogWarning(ex, "Unauthorized deletion attempt for user {UserId}", id);
                return Forbid();
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error occurred while deleting user {UserId}", id);
                return StatusCode(StatusCodes.Status500InternalServerError, 
                    "An error occurred while processing your request");
            }
        }
    }
}
// File: UserService.cs
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using th3chris.API.Models;
using th3chris.API.Data;
using th3chris.API.Exceptions;
namespace th3chris.API.Services
{
    public class UserService : IUserService
    {
        private readonly AppDbContext _context;
        private readonly ILogger<UserService> _logger;
        public UserService(AppDbContext context, ILogger<UserService> logger)
        {
            _context = context ?? throw new ArgumentNullException(nameof(context));
            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
        }
        public async Task<PagedResult<User>> GetUsersAsync(UserFilter filter)
        {
            var query = _context.Users.AsQueryable();
            if (!string.IsNullOrWhiteSpace(filter.Search))
            {
                var searchTerm = filter.Search.ToLower();
                query = query.Where(u => u.Email.ToLower().Contains(searchTerm) ||
                                         u.FirstName.ToLower().Contains(searchTerm) ||
                                         u.LastName.ToLower().Contains(searchTerm));
            }
            var totalCount = await query.CountAsync();
            if (!string.IsNullOrWhiteSpace(filter.SortBy))
            {
                query = ApplySorting(query, filter.SortBy, filter.SortDescending);
            }
            else
            {
                query = query.OrderBy(u => u.LastName).ThenBy(u => u.FirstName);
            }
            var users = await query
                .Skip((filter.PageNumber - 1) * filter.PageSize)
                .Take(filter.PageSize)
                .ToListAsync();
            return new PagedResult<User>
            {
                Items = users,
                TotalCount = totalCount
            };
        }
    }
}

Test Explorer

GetUsers_ReturnsOk

GetUsers_WithPagination

GetUsers_WithSearch

GetUser_ValidId_ReturnsUser

GetUser_InvalidId_NotFound

CreateUser_ValidData

CreateUser_DuplicateEmail

CreateUser_InvalidData

UpdateUser_ValidData

UpdateUser_NotFound

UpdateUser_Unauthorized

DeleteUser_Success

DeleteUser_NotFound

DeleteUser_Unauthorized

Auth_Login_ValidCredentials

Auth_Login_InvalidPassword

Auth_Register_NewUser

Email_SendWelcome_Success

Validation_User_RequiredFields

Validation_Email_Format

Christian Daniel

Your customers are waiting.Your processes are manual.I change that.

Process automation, cloud solutions and artificial intelligence — for SMBs and enterprise.

Does this sound familiar?

Leads lost after hours

Nobody answers at 8pm — and the customer is with your competitor by morning.

Your team loses hour after hour on manual tasks

Data entry, email sorting, report generation — all tasks that can be automated. In seconds instead of hours.

Technology alone doesn't solve problems

What actually delivers value for your business — and what's just hype? That's exactly what we figure out.

Vibe coding delivers code. Not understanding.

Quickly generated, never questioned. Eventually the bill comes — security vulnerabilities, outages, and a developer who doesn't understand their own code.

Solutions that actually work

AI chatbots that work 24/7

Answer customer questions, qualify leads, and book appointments — even at midnight.

For customer-facing businesses

Process automation with AI

Extract documents, classify emails, generate reports — automatically instead of manually.

For teams with repetitive tasks

Cloud systems that scale

Kubernetes, microservices, CI/CD — architecture that grows with your business.

For companies with growth ambitions

Team augmentation when it counts

Senior architecture experience for your existing team — from weeks to years.

For teams that need expertise

Project Highlights

Selected projects with measurable impact

Trusted by leading companies

Work model — flexible to your needs

Solo Development

Complete solutions from one source

From architecture through implementation to deployment — one point of contact for everything. No overhead, short decision paths, maximum speed.

Quickmail/Quickpac: 4 years of complete mobile app development as a solo developer for Swiss Post. 6 independent solutions. Offline-first for mountain regions.

Team Integration

Seamlessly in your existing team

Code reviews, mentoring, joint architecture decisions. I integrate into your team as if I've been there from day one — bringing experience that moves teams forward.

Hoffmann Group: 5+ years in a 5-person Digital Services team. Together built 3 central DataHubs and maintained 8 shared libraries.

Enterprise Architecture

Mastering complex system landscapes

When multiple divisions, legacy systems, and international teams need to work together — that's where I thrive. SAP integration, multi-system orchestration, regulatory compliance.

Schneider Electric: Integration of diverse divisions into a seamless IDE — after Microsoft professionals deemed it "impossible".

AI is my tool — not my autopilot

My approach to responsible use of AI in software development

Every line is understood

AI generates code faster than ever before. But code that isn't understood is technical debt from day one. I use AI for speed — and review, understand, and optimize every result.

Security is not an afterthought

AI-generated code has blind spots: injection vulnerabilities, missing input validation, unchecked edge cases. With 25+ years of experience, I catch these weaknesses — before they reach production.

Code must be maintainable without AI

What happens when the LLM model changes or the AI service goes down? My code follows Clean Architecture principles and is human-readable — today and in 5 years.

AI Engineering in Action

Live Demo: These features run on my own RAG system

RAG Pipeline

This is how the chat on this site works: Your question is converted into a vector, relevant documents are searched, and an LLM processes them into a well-founded answer.

Documents

70k+

Tokens

Chunks/Query

Want more details? Ask me!

Ask me about my projects, technologies, or experience.

What others say

Oscar Angress

Cyber Security Consultant

Bosch Engineering GmbH

LinkedIn - Referenz

“... outstanding mind with excellent skills in development; great software architect. Highly recommended if you need to find a professional fast and scalable solution. We've been working together on a project that was rated by Microsoft professionals as "not possible". Together with Christian our team managed to deliver a great working solution/product!”

Enterprise Projects & References

13 Engagements25+ Years100% Remote since 2010

Click on a project to chat about it directly with the AI assistant.

Recent engagements:

... and many more exciting projects from over 25 years of professional experience.

View full resumePDF export available

Tech Stack & Expertise

AI & RAG Systems

RAG-Pipelines, Embeddings, Vector Search mit pgvector und Weaviate, Semantic Kernel, Dify – von der Wissensbasis bis zur intelligenten Antwort. Produktionsreife KI-Systeme, nicht nur Prototypen.

AI Agent Development

LLM-orchestrierte Agenten mit Tool-Use, MCP (Model Context Protocol), autonome Workflows – AI Agents die eigenständig Aufgaben lösen und sich in bestehende Systeme integrieren.

C# & .NET

Mein Heimathafen seit über 15 Jahren. Von ASP.NET Core über Entity Framework bis zu modernen Minimal APIs – hier fühle ich mich zuhause und baue Backend-Systeme, die rocken.

Azure Cloud

Cloud-native Architecture at its best: AKS für Container-Orchestrierung, Service Bus für Messaging, Cosmos DB für globale Daten – der perfekte Playground für moderne Enterprise-Lösungen.

Kubernetes

Container-Orchestrierung ist Kunst und Wissenschaft zugleich. Mit K8s bringe ich Microservices ins Rollen, manage Deployments ohne Downtime und halte Systeme skalierbar und resilient.

RabbitMQ

Message-driven Architecture für die Win. Asynchrone Communication, Event-driven Workflows, und Entkopplung von Services – RabbitMQ ist der unsichtbare Held in verteilten Systemen.

Elasticsearch

Wenn Suche mehr sein muss als SQL LIKE. Full-Text Search, Log-Aggregation mit dem Elastic Stack, Real-time Analytics – hier wird aus Daten echte Insight gewonnen.

TypeScript & Next.js

Frontend, das Spaß macht: Type-safe React mit Server Components, moderne Routing-Patterns, und Performance out of the box. Full-Stack heißt auch, dass der Browser genauso wichtig ist wie der Server.

GitOps & DevOps

ArgoCD, Flux, GitLab CI, Terraform – Infrastructure as Code und GitOps-Workflows für reproduzierbare, auditierbare Deployments. Die gesamte Infrastruktur lebt im Git-Repository.

CI/CD & Automation

Deploy sollte keine Wissenschaft sein. Mit GitHub Actions, Azure DevOps und automatisierten Pipelines mache ich aus Manual Work schnelle, sichere und reproduzierbare Release-Prozesse.

Before vs. After

How AI transforms your workflows

Before: Manual

Customer sends email at 8pm

Nobody responds until next morning

Employee reads, forwards, asks follow-up questions

Response takes 24-48 hours

Customer has already gone to competitor

After: AI-powered

Customer chats on website at 8pm

AI chatbot responds instantly and qualifies

Relevant info captured automatically

Appointment booked directly

Employee starts the morning with a warm lead

Ready to automate your processes?

Describe your project in the chat — or write to me directly.

Send email