Skip to main content

APS Modular Structure

Modular organization of the APS platform: breakdown into functional modules, dependencies and responsibilities.

Overview​

The APS architecture is organized into distinct modules grouped by functional domain. This modular organization provides several advantages:

  • Separation of responsibilities: Each module has a clear functional scope
  • Reusability: Modules can be used in different contexts (Web, Studio, Agents)
  • Maintainability: Isolated modifications without global impact
  • Testability: Targeted unit tests per module

Main Modules​

Kernel​

Namespace: Avanteam.Kernel.*
Folder: /Kernel/

The Kernel constitutes the technical foundation of the application. It contains no business logic and provides cross-cutting services used by all other modules.

Sub-modules:

  • Kernel: Kernel core (configuration, logging, mail)
  • Kernel.DependencyInjection: Dependency injection infrastructure
  • Kernel.Configuration: Configuration reading and management
  • Kernel.Data: Data access abstraction
  • Kernel.Parameters: Application parameters management
  • Kernel.AspNetCore: Extensions for ASP.NET Core
  • Kernel.Web: Extensions for ASP.NET Framework
  • Kernel.Office: Office integration (Word, Excel)
  • Kernel.MicrosoftGraph: Microsoft Graph integration

Dependencies: None (base module)

Responsibilities:

  • Centralized configuration (.ini files, appsettings.json)
  • Logging (NLog)
  • Email sending
  • Database abstraction
  • Background services (background tasks)

Directory​

Namespace: Avanteam.Directory.*
Folder: /Directory/

The Directory module manages everything related to directory, users and authentication.

Sub-modules:

  • Directory: Directory module core
  • Directory.Api: Module public API
  • Directory.Identity: Identity model (users, roles, resources)
  • Directory.Authentication: Authentication mechanisms
    • Directory.Authentication.AspNetCore: ASP.NET Core authentication
    • Directory.Authentication.Cookies: Cookie authentication
    • Directory.Authentication.Saml2: SAML authentication
  • Directory.Authorization: Authorization management
  • Directory.Synchronization: Active Directory / LDAP synchronization
  • Directory.Repository: Directory data access
  • Directory.Web: Web extensions for directory
  • Directory.UI: UI components for directory

Dependencies: Kernel

Responsibilities:

  • User, group, resource management
  • Authentication (Forms, Windows, SAML, OAuth)
  • Authorization and security policies
  • Synchronization with external directories (AD, LDAP)
  • Delegation management

Application​

Namespace: Avanteam.Application.*
Folder: /Application/

The Application module contains the core business logic of the platform.

Sub-modules:

  • Application: Application module core
  • Application.Api: Module public API
  • Application.Agents: Agent system (scheduled tasks)
  • Application.Archives: Archive management
  • Application.Log: Business logging
  • Application.Modules: Specific business modules
  • Application.Repository: Business data access
    • Application.Repository.EFCore: Entity Framework Core implementation
    • Application.Repository.EFCore.SqlServer: SQL Server provider
    • Application.Repository.EFCore.Oracle: Oracle provider
  • Application.Web: Web extensions
  • Application.WebControls: Reusable web controls

Dependencies: Kernel, Directory

Responsibilities:

  • Document and metadata management
  • Form and schema management
  • View and query management
  • Agents and scheduled tasks
  • Document archiving
  • Business logs and audit

ApplicationPool​

Namespace: Avanteam.Application.Pool.*
Folder: /ApplicationPool/

The ApplicationPool module manages the application pool concept and multi-tenancy.

Sub-modules:

  • ApplicationPool: Pool core
  • ApplicationPool.Api: Pool API
  • ApplicationPool.Repository: Pool data access

Dependencies: Kernel, Directory, Application

Responsibilities:

  • Application profile management
  • Multi-tenant configuration
  • Data isolation per application

Workflow​

Namespace: Avanteam.Workflow.*
Folder: /Workflow/

The Workflow module provides the platform's workflow engine.

Sub-modules:

  • Workflow: Workflow engine core
  • Workflow.ComponentModel: Workflow component model
  • Workflow.Runtime: Workflow execution
  • Workflow.DataSource: Workflow data access

Dependencies: Kernel, Directory, Documents

Responsibilities:

  • Business process definition
  • Workflow instance execution
  • State and transition management
  • Automatic actions and notifications

Formulars​

Namespace: Avanteam.Formulars.*
Folder: /Formulars/

The Formulars module manages form design and rendering.

Sub-modules:

  • Formulars: Forms core
  • Formulars.Designer: Form editor
  • Formulars.Schema: Form schemas
  • Formulars.UI: Form UI rendering

Dependencies: Kernel, Application

Responsibilities:

  • Form schema definition
  • Dynamic form rendering
  • Data validation
  • Custom field types

Views​

Namespace: Avanteam.Views.*
Folder: /Views/

The Views module manages tabular data display and queries.

Dependencies: Kernel, Application

Responsibilities:

  • SQL/Entity query execution
  • Data filtering and sorting
  • Export to Excel/CSV
  • User-customized views

Documents​

Namespace: Avanteam.Documents.*
Folder: /Documents/

The Documents module manages documents and attachments.

Dependencies: Kernel

Responsibilities:

  • File storage
  • Version management
  • PDF conversion
  • Check-in/Check-out

Studio​

Namespace: Avanteam.Studio.*
Folder: /Studio/

The Studio module contains the desktop configuration tool (WinForms).

Sub-modules:

  • Studio.Main: Main application
  • Studio.Core: Studio core
  • Studio.Security: Studio security
  • Studio.Modules.*: Configuration modules
    • Studio.Modules.Formulars: Form configuration
    • Studio.Modules.Parameters: Parameter configuration
    • Studio.Modules.Views: View configuration
    • Studio.Modules.Workflow: Workflow configuration

Dependencies: Kernel, Directory, Application, all business modules

Responsibilities:

  • Form modeling
  • Workflow editing
  • View configuration
  • Application parameter management

Web​

Namespace: Avanteam.Web.*
Folder: /Web/

The Web module contains the web applications.

Sub-modules:

  • Web.Model: Main web application (ASP.NET Framework 4.8)
  • Web.Root: New application (ASP.NET Core - in development)

Dependencies: All modules

Responsibilities:

  • Web user interface
  • REST API
  • SignalR (real-time)
  • Session management

Additional Modules​

Localisation: Multilingual management
Remoting: Inter-process communication
Reporting: Report generation
Search: Full-text search
SharePoint: SharePoint integration
Exchange: Exchange integration
GraphBuilder: Visual graph construction
Navigators: Visual navigation

Project Organization​

Each module follows a standardized structure:

Module/
├── Abstractions/      # Interfaces and abstractions
├── Api/               # Module public API
├── DependencyInjection/  # DI configuration
├── Repository/        # Data access
├── Src/               # Main implementation
├── UnitTests/         # Unit tests
└── Web/               # Web extensions (if applicable)

Naming Pattern​

  • Project: {Module}.{SubModule}
  • Namespace: Avanteam.{Module}.{SubModule}
  • Assembly: Avanteam.{Module}.{SubModule}.dll

Example: Application.Repository.EFCore.SqlServer

Dependency Graph​

┌─────────────────────────────────────────────┐
│                   Studio                    │
│              (Configuration)                │
└──────────────────┬──────────────────────────┘
                   │
┌──────────────────▼──────────────────────────┐
│                Web.Model                    │
│            (Web Application)                │
└──────────────────┬──────────────────────────┘
                   │
        ┌──────────┼──────────┐
        │          │          │
┌───────▼────┐ ┌──▼────────┐ ┌▼──────────────┐
│ Workflow   │ │Application│ │ApplicationPool│
└──────┬─────┘ └──┬────────┘ └┬──────────────┘
       │          │            │
       └──────┬───┴────────────┘
              │
       ┌──────▼──────┐
       │  Directory  │
       └──────┬──────┘
              │
       ┌──────▼──────┐
       │   Kernel    │
       └─────────────┘

Versioning Strategy​

  • All projects share the same version number
  • Version defined in Directory.Build.props at the root
  • Format: {Year}.{Month}.{Build}.{Revision}
  • Example: 2023.1.0.0
<PropertyGroup>
  <Version Condition="'$(VERSION)' == ''">1.0.0.0</Version>
  <AssemblyVersion>1.0.0.0</AssemblyVersion>
</PropertyGroup>

Dependency Management​

Internal Dependencies​

Dependencies between APS modules are done via ProjectReference:

<ItemGroup>
  <ProjectReference Include="..\..\Kernel\Src\Kernel.csproj" />
  <ProjectReference Include="..\..\Directory\Src\Directory.csproj" />
</ItemGroup>

External Dependencies​

External NuGet packages are centralized and managed consistently:

  • Entity Framework Core
  • AutoMapper
  • NLog
  • DevExpress (UI components)
  • Microsoft.Extensions.*

Dependency Rules​

  1. Kernel depends on nothing: Autonomous base module
  2. No circular dependencies: Acyclic graph
  3. Separated abstractions: Interfaces in *.Abstractions modules
  4. Isolated public API: Contracts in *.Api modules

Extension and Customization​

Plugin System​

The architecture supports extension via the AddStartupExtensions system:

apsAppBuilder.AddStartupExtensions("MyModule");

This method automatically searches for and executes all classes implementing IStartupExtension in the module's assemblies.

Custom Modules​

To create a custom module:

  1. Create the standard folder structure
  2. Implement a Startup class with extension method
  3. Register services via IServiceCollection
  4. Reference dependent modules
  5. Call the extension method in the entry point

Compilation and Build​

Global Configuration​

The Directory.Build.props file at the root defines common parameters:

  • Target Framework (.NET Framework 4.8)
  • Output paths (Build/Debug or Build/Release)
  • Warnings and code analysis
  • Assembly metadata

Build Scripts​

  • npm scripts: Frontend compilation (webpack, gulp)
  • MSBuild: .NET compilation
  • Publish: Publishing to IIS server

Best Practices​

Code Organization​

  • One file per class
  • Namespaces consistent with folder structure
  • Interfaces in Abstractions projects
  • Implementation in Src projects

Service Registration​

Each module exposes a fluent extension method:

public static IApsAppBuilder AddMyModule(
    this IApsAppBuilder builder)
{
    AddServices(builder.Services);
    return builder.AddStartupExtensions("MyModule");
}

Unit Tests​

Each module has its corresponding UnitTests project with the same structure.

References​