EmreAka/Kodlama.io.Devs

This system is a .NET-based web API that manages developer profiles, technical skills, and GitHub profiles within a layered architecture. It provides comprehensive authentication and authorization features, including JWT token generation, refresh tokens, and role-based access control. The platform supports full CRUD operations for managing programming languages, technologies, and user claims, while also exposing endpoints for user and profile management.

The application now supports creating, reading, updating, and deleting programming languages. This includes new commands for each operation, along with corresponding validators and DTOs. A caching mechanism is implemented for the list query, storing results for 5 minutes under the key 'programming languages'. Additionally, business rules enforce that duplicate programming languages cannot be inserted and that requested languages must exist.

src/Kodlama.io.Devs/Application/Features/ProgrammingLanguages · high confidence

A new query handler for retrieving a paginated list of technologies has been added. This introduces the ability to fetch technology records with associated programming language details, supporting standard pagination parameters.

src/Kodlama.io.Devs/Application/Features/Technologies/Queries · high confidence

A new TechnologyList model has been introduced in the Application layer to represent a paginated list of technologies. This model, which inherits from BasePageableModel, contains an array of TechnologyListDto objects, providing a structured way to handle technology listings with pagination support.

src/Kodlama.io.Devs/Application/Features/Technologies/Models · high confidence

A new command and its validator have been introduced to support deleting a technology by its ID. The command handler retrieves the technology, validates that it exists using business rules, performs the deletion, and returns a DTO of the deleted entity.

src/Kodlama.io.Devs/Application/Features/Technologies/Commands/DeleteTechnology · high confidence

Users can now create new technology entries via a dedicated command and its associated validator. The new CreateTechnologyCommand accepts a name and a programming language ID, handling the mapping, repository save, and DTO conversion in a single MediatR handler, while the validator enforces that the name is not empty and the language ID is provided.

src/Kodlama.io.Devs/Application/Features/Technologies/Commands/CreateTechnology · high confidence

Users can now update existing technology entries. This change introduces the UpdateTechnologyCommand and its associated validator, which enforce that the technology ID, name, and programming language ID are all provided and valid before the update is processed.

src/Kodlama.io.Devs/Application/Features/Technologies/Commands/UpdateTechnology · high confidence

Users can now create, update, and delete their GitHub profile information. The update and delete operations include validation to ensure the profile exists before modification or removal, and the create operation prevents duplicate profiles for a developer.

src/Kodlama.io.Devs/Application/Features/GitHubProfiles/Commands · high confidence

Users can now create, update, delete, and list operation claims through new application features. This includes the command and query handlers for CRUD operations, along with the necessary DTOs, business rules, and mapping profiles to support these actions.

src/Kodlama.io.Devs/Application/Features/OperationClaims · high confidence

A new MappingProfiles class was added to define AutoMapper configurations for GitHub profile entities and their corresponding DTOs and commands. The mappings cover Create, Update, and Delete operations, as well as list/query results, enabling automatic conversion between domain entities and application-layer models.

src/Kodlama.io.Devs/Application/Features/GitHubProfiles/Profiles · high confidence

Users can now create, update, and delete technologies through the application, with new AutoMapper mappings configured to convert between the Technology entity and its corresponding commands (CreateTechnology, UpdateTechnology, DeleteTechnology) and DTOs (CreatedTechnologyDto, UpdatedTechnologyDto, DeletedTechnologyDto).

src/Kodlama.io.Devs/Application/Features/Technologies/Profiles · high confidence

Users can now create, delete, and list user-operation claim associations. This change introduces commands to create and delete these associations, along with queries to retrieve a paginated list of all user-operation claims or those filtered by a specific user ID, supported by corresponding DTOs and business rule validations.

src/Kodlama.io.Devs/Application/Features/UserOperationClaims · high confidence

The repository was initialized with a new solution file (Kodlama.io.Devs.sln) that organizes the codebase into a layered architecture, including core packages (Application, CrossCuttingConcerns, ElasticSearch, Mailing, Persistence, Security, Domain) and application layers (Domain, Application, Infrastructure, Persistence, WebAPI). Additionally, the .gitignore file was updated to exclude IDE-specific directories (.vs, .vscode, .idea) from version control.

(repo-wide) · high confidence

A new model class, UserListModel, has been added to the application's developer features. This class serves as a container for a list of users, specifically holding an array of UserListDto objects in its Items property. This change supports the retrieval of user lists, aligning with the goal of getting a user list.

src/Kodlama.io.Devs/Application/Features/Developers/Models · high confidence

A new BaseDbContext class is added to the persistence layer, establishing the database schema for key domain entities including ProgrammingLanguage, Technology, User, Developer, and GitHubProfile. The context configures table names, primary keys, and relationships for these entities, and seeds initial data for programming languages and technologies. This change introduces the foundational data access structure for user authentication, developer profiles, and technology tracking.

src/Kodlama.io.Devs/Persistence/Contexts · high confidence

Adds a suite of MediatR pipeline behaviors and supporting types to the application layer: an AuthorizationBehavior that enforces role-based access by checking user claims against required roles, and a ValidationBehavior that runs FluentValidation validators before processing requests. It also introduces CachingBehavior and CacheRemovingBehavior to handle distributed caching and cache invalidation, a LoggingBehavior that records request details via a Serilog-based logger, and dynamic query support through Filter/Sort models and IQueryable extensions for sorting and filtering. Additionally, it adds an ExceptionMiddleware to standardize error responses, a base Entity class, and utility classes for paging and mail sending.

src/corePackages · high confidence

Adds new domain entity classes for user authentication and authorization, including EmailAuthenticator, OtpAuthenticator, RefreshToken, User, OperationClaim, and UserOperationClaim. These entities define the core data structures for managing user accounts, password verification, two-factor authentication, session management, and role-based access control within the Core.Domain layer.

corePackages · high confidence

The application now supports storing developer profiles with associated GitHub accounts, as well as organizing programming languages and specific technologies. This introduces new domain entities: a Developer entity that extends the existing User base class and includes a collection of GitHub profiles; a GitHubProfile entity linking developers to their GitHub URLs; and new entities for ProgrammingLanguage and Technology to structure technical skills. These changes lay the groundwork for managing developer profiles and their technical competencies within the system.

Kodlama.io.Devs · high confidence

The login flow for developers is now implemented with a new command handler that retrieves the user along with their operation claims, validates credentials against business rules, and generates a JWT token. A corresponding validator enforces email format and password length requirements.

src/Kodlama.io.Devs/Application/Features/Developers/Commands/LoginDeveloper · high confidence

The API now exposes new endpoints for managing authentication (register, login, and user listing), GitHub profiles (create, update, delete, list), operation claims (CRUD), programming languages (CRUD and by-id), technologies (CRUD), and user operation claims (create, delete, list, and list by user ID). These controllers implement the backend logic for user registration, login, and refresh token handling, as well as full CRUD operations for domain entities like technologies, programming languages, and claims.

src/Kodlama.io.Devs/WebAPI/Controllers · high confidence

The application layer now exposes repository interfaces for key domain entities, including Developer, GitHubProfile, OperationClaim, ProgrammingLanguage, RefreshToken, Technology, User, and UserOperationClaim. Corresponding persistence-layer implementations have been added to provide data access for these entities, supporting the separation of domain concerns and enabling new capabilities such as user registration and profile management.

src/Kodlama.io.Devs/Application/Services/Repositories, src/Kodlama.io.Devs/Persistence/Repositories · high confidence

A new service registration class for the Persistence layer has been introduced, configuring the SQL Server database context and registering all repository interfaces (ProgrammingLanguage, Technology, User, Developer, GitHubProfile, UserOperationClaim, OperationClaim, and RefreshToken) with scoped lifetimes.

src/Kodlama.io.Devs/Persistence · high confidence

A new query handler for listing GitHub profiles has been introduced, enabling the retrieval of paginated profile data. The implementation enforces an authorization check, restricting access to users with the "admin" role, ensuring that only authorized administrators can retrieve the list of GitHub profiles.

src/Kodlama.io.Devs/Application/Features/GitHubProfiles/Queries · high confidence

A new business rule class, TechnologyBusinessRules, has been added to the application layer. It introduces a validation method, TechnologyShouldExist, which checks if a Technology entity is null and throws a BusinessException if so. This ensures that operations on technologies verify the entity's existence before proceeding.

src/Kodlama.io.Devs/Application/Features/Technologies/Rules · high confidence

New DTOs have been introduced to support creating, updating, deleting, and listing technologies. Specifically, CreatedTechnologyDto, UpdatedTechnologyDto, DeletedTechnologyDto, and TechnologyListDto are now available in the application layer, each exposing properties such as Id, Name, and (for the list view) ProgrammingLanguageName.

src/Kodlama.io.Devs/Application/Features/Technologies/Dtos · high confidence

A new query handler has been added to retrieve a paginated list of users, including their associated operation claims. This endpoint is restricted to users with the 'admin' role, ensuring that only authorized administrators can access the user list.

src/Kodlama.io.Devs/Application/Features/Developers/Queries · medium confidence

The application layer now registers all business rules, the authentication service, and key infrastructure (Distributed Memory Cache, HTTP context accessor) in a single, centralized registration method. This includes wiring up MediatR, AutoMapper, and specific pipeline behaviors for validation, authorization, and caching, providing a unified entry point for the application's dependency injection setup.

src/Kodlama.io.Devs/Application · high confidence

The CreateDeveloper command handler was updated to generate JWT access tokens and refresh tokens upon successful registration. The handler now calls \_authService.CreateAccessToken and \_authService.CreateRefreshToken, returning both in the RegisteredDto, enabling clients to authenticate and refresh sessions without immediate re-login.

src/Kodlama.io.Devs/Application/Features/Developers/Commands/CreateDeveloper · medium confidence

The persistence layer now includes the initial database migration (20220908172044\_init) which establishes the foundational schema, including tables for users, operation claims, refresh tokens, and developer profiles. Additionally, a subsequent migration (mig-1) updates the Users table to set a default value of true for the Status column, ensuring new users are active by default.

src/Kodlama.io.Devs/Persistence/Migrations · high confidence

The AuthService now supports refresh tokens, allowing users to obtain new access tokens without re-authenticating. The service exposes methods to create and add refresh tokens, integrating with the existing token helper and repository infrastructure.

src/Kodlama.io.Devs/Application/Services/AuthService · medium confidence

The WebAPI project now includes a new Program.cs file that sets up JWT Bearer authentication using the System.IdentityModel.Tokens.Jwt library, configuring token validation parameters and authentication events. Additionally, Swagger is configured to document the Bearer token security scheme, allowing API consumers to understand how to authenticate requests. Configuration for token options (issuer, audience, expiration, security key) and connection strings are provided in appsettings.json.

src/Kodlama.io.Devs/WebAPI · medium confidence

A new \DeveloperBusinessRules\ class has been introduced to handle specific validation logic. This includes checking if a user exists, verifying user credentials against stored hashes, and ensuring that an email address is not duplicated when a new user is inserted.

src/Kodlama.io.Devs/Application/Features/Developers/Rules · high confidence

The application layer introduces new DTOs to support authentication and user management features. A \RefreshedTokenDto\ is added to handle JWT access and refresh tokens, while \TokenDto\ exposes token strings and expiration times. Additionally, \RegisteredDto\ extends the token DTO to include extra registration data, and \UserListDto\ provides a structured view of user profiles including name, email, and associated operation claims.

src/Kodlama.io.Devs/Application/Features/Developers/Dtos · high confidence

A new MappingProfiles class has been introduced to define object-to-object mappings using AutoMapper. It configures mappings for converting between Developer entities and CreateDeveloperCommand, User entities and UserForRegisterDto, TokenDto and AccessToken, as well as User to UserListDto (including operation claims) and IPaginate to UserListModel. This centralizes the transformation logic for these specific data transfer objects and domain entities.

src/Kodlama.io.Devs/Application/Features/Developers/Profiles · high confidence

A new data model, GithubProfileListModel, has been introduced to represent a paginated list of GitHub profiles. This model wraps an array of GithubProfileListDto items, providing a structured way to handle paginated results for GitHub profile queries.

src/Kodlama.io.Devs/Application/Features/GitHubProfiles/Models · high confidence

The application layer's data transfer objects for GitHub profiles have been refactored to support distinct create, read, update, and delete operations. New DTOs have been introduced: CreatedGitHubProfileDto, DeletedGitHubProfileDto, GithubProfileListDto, and UpdatedGitHubProfileDto. Each DTO contains an Id and a ProfileUrl property, providing a consistent structure for handling GitHub profile data across different states and operations.

src/Kodlama.io.Devs/Application/Features/GitHubProfiles/Dtos · medium confidence

The project has been upgraded to target .NET 6 across all components. To support secure user authentication, the System.IdentityModel.Tokens.Jwt package (version 6.23.1) has been added to the WebAPI layer, and the Microsoft.AspNetCore.Authentication.JwtBearer package (version 6.0.8) is now included, enabling JWT Bearer token validation for API endpoints.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 32 → 32 (-0.5)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 69 → 65 (-3.3)
• Architecture 91 → 91 (+0.0)
• Maturity 33 → 33 (+0.0)
• Readiness 21 → 20 (-0.9)
• Security 33 → 34 (+1.1)

• Bounded contexts not declared
• Duplicated block (8 lines × 2) (src/corePackages/Core.Persistence/Paging/Paginate.cs)
• Duplicated block (9 lines × 2) (src/corePackages/Core.Persistence/Paging/Paginate.cs)
• High CVE: System.Linq.Dynamic.Core 1.2.17
• Medium CVE: MimeKit 3.1.1
• No exposed public API
• XML-doc coverage: Infrastructure (src/Kodlama.io.Devs/Infrastructure/Infrastructure.csproj)
• redundant comment (src/Kodlama.io.Devs/Persistence/Contexts/BaseDbContext.cs)
• redundant comment (src/Kodlama.io.Devs/WebAPI/Program.cs)
• single-maintainer — knowledge-concentration (bus factor) risk

• CommentedOutCode (src/Kodlama.io.Devs/Persistence/Contexts/BaseDbContext.cs)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (11 lines × 2) (src/corePackages/Core.Persistence/Paging/Paginate.cs)
• Duplicated block (9–10 lines × 2) (src/corePackages/Core.Persistence/Paging/Paginate.cs)
• End-of-life runtime: .NET net6.0
• Migration class names are inconsistent and use placeholder/non-descriptive identifiers ('blabla', 'mig1') instead of following a standard naming convention (e.g., based on timestamp or feature name). This makes it impossible to identify the purpose or order of migrations from their names alone.
• WriteOnlyPrivateField (src/Kodlama.io.Devs/Application/Features/Technologies/Rules/TechnologyBusinessRules.cs)
• WriteOnlyPrivateField (src/corePackages/Core.CrossCuttingConcers/Logging/Serilog/Logger/FileLogger.cs)
• WriteOnlyPrivateField (src/corePackages/Core.Mailing/MailKitImplementations/MailKitMailService.cs)
• redundant comment (src/Kodlama.io.Devs/WebAPI/Program.cs)
• redundant comment (src/Kodlama.io.Devs/WebAPI/Program.cs)

• Unchanged — 16 HTTP endpoints

• Unchanged — 2 containers · 2 contexts · 1 edges

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

EmreAka/Kodlama.io.Devs was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.