Third Party Services

A compilation of third-part services, libraries, frameworks, and software that FEDS is dependant on.

Hosting Infrastructure

FEDS Platform – Private service (paid tier). Scalable. Zero downtime deploys.

MySQL – Private service (pair tier). Scalable. Zero downtime deploys.

Disk Drive – Dedicated virtual drive. Persistent storage. Current 10 GB limit.

All hosting is done on Render.

Software Stack

Layer
Target(s)
Description
Rationale

MVC (Model View Controller)

Blazor 8

Blazor is a Microsoft web framework that enables developers to build interactive web applications using C# and .NET instead of JavaScript. It runs either directly in the browser via WebAssembly or on the server with UI updates streamed to clients.

  • Blazor provides out-of-the-box solutions for server-side rendering.

  • WebAssembly provides enhanced security over JavaScript.

  • Enhanced security when interacting with internal systems.

  • Faster TTD

  • Secure direct access between front and backend.

Database

MySQL 8

MySQL is an open-source relational database management system that uses Structured Query Language (SQL) for managing and manipulating data. It's widely used for web applications, offering reliability, performance, and cross-platform compatibility.

  • High performance and reliability for handling large volumes of data

  • Extensive community support with abundant documentation and resources

  • Excellent compatibility with most web development frameworks and languages

  • Free to use with affordable scaling options as needs grow

Database Driver

Entity Framework Core 8

Entity Framework Core (EF Core) is Microsoft's lightweight, extensible, open-source object-relational mapping framework for .NET. It enables developers to work with databases using .NET objects, eliminating the need to write most data-access code by automatically translating between database tables and C# classes.

  • Simplifies data access by automating SQL queries through LINQ expressions

  • Provides type safety and compile-time error checking for database operations

  • Enables database-agnostic development with multiple database providers

  • Supports code-first, database-first, and model-first development approaches

  • Offers powerful change tracking and relationship management features

Platform Libraries

Feds.csproj
<Project Sdk="Microsoft.NET.Sdk.Web">
    <!-- Other item groups -->
    
    <ItemGroup>
        <PackageReference Include="ClosedXML" Version="0.104.2" />
        <PackageReference Include="CsvHelper" Version="33.0.1" />
        <PackageReference Include="DotNetEnv" Version="3.1.1" />
        <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="8.0.7">
          <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
          <PrivateAssets>all</PrivateAssets>
        </PackageReference>
        <PackageReference Include="Microsoft.Extensions.Logging" Version="8.0.1" />
        <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="8.0.1" />
    </ItemGroup>
    
    <!-- Other item groups -->
</Project>
ClosedXML v0.104.2

ClosedXML is a .NET library that provides a simplified approach to creating, reading, and manipulating Excel files without requiring the Microsoft Office applications to be installed. It's essentially a wrapper around the OpenXML SDK that makes working with Excel files much more intuitive.

Key features of ClosedXML include:

  1. Creating Excel workbooks and worksheets from scratch

  2. Reading and writing data to existing Excel files

  3. Creating and customizing cell formatting, styles, and conditional formatting

  4. Adding formulas, charts, and tables

  5. Handling worksheet operations such as hiding, grouping, and filtering

  6. Validating data and creating dropdown lists

ClosedXML is popular among .NET developers because it offers a more developer-friendly API compared to the lower-level OpenXML SDK. It lets you work with Excel files through an object model that closely mirrors Excel's own structure, making the code more readable and maintainable.

The library is open-source and can be installed via NuGet in your .NET projects. It supports both .NET Framework and .NET Core/.NET 5+.

FEDS uses ClosedXML to export certain data using the Microsoft Excel 2010+ format.

CsvHelper v33.0.1

CsvHelper is a popular .NET library for reading and writing CSV (Comma-Separated Values) files. It provides a clean, intuitive API that makes working with CSV data much easier than using built-in .NET functionality.

Key features of CsvHelper include:

  1. Reading and writing CSV files with a fluent, easy-to-use interface

  2. Strong typing support to automatically map CSV records to C# classes

  3. Custom mapping configurations to handle complex data transformations

  4. Support for different delimiters, not just commas (tabs, pipes, etc.)

  5. Handling of quoted fields, escaped characters, and other CSV complexities

  6. Data validation and error handling during reading/writing

  7. Support for different encoding types

  8. Reading data in a streaming fashion for working with large files efficiently

CsvHelper is particularly valuable because it abstracts away many of the common challenges when dealing with CSV files, such as handling quoted fields, newlines within fields, and different cultural formats for dates and numbers.

The library is open-source, well-maintained, and can be easily installed via NuGet in your .NET projects. It works with both .NET Framework and modern .NET Core/.NET 5+ applications.

This library is no longer used within the platform, as the "Export to CSV" feature is deprecated.

DotNetEnv v3.1.1

DotNetEnv is a .NET library inspired by the Node.js dotenv package that allows developers to load environment variables from .env files into their .NET applications. It provides a simple way to manage configuration settings across different environments without hardcoding sensitive information in your source code.

Key features of DotNetEnv include:

  1. Loading environment variables from .env files into the application's environment

  2. Support for different .env file formats and variable substitution

  3. Ability to override existing environment variables or preserve them

  4. Optional encryption support for sensitive configuration values

  5. Flexible parsing options to handle different line formats and comments

  6. Support for both .NET Framework and .NET Core/.NET 5+ applications

Using DotNetEnv is straightforward - you typically call DotNetEnv.Env.Load() at the start of your application, which reads a .env file in the project root and makes those variables available through the standard .NET environment variable mechanisms.

This approach aligns with the 12-factor app methodology, which recommends storing configuration in the environment rather than in code, making it easier to deploy the same codebase to different environments without code changes.

The library is open-source and available through NuGet, making it easy to integrate into any .NET project.

Microsoft.EntityFrameworkCore.Design v8.0.7

Microsoft.EntityFrameworkCore.Design is a NuGet package that provides design-time support for Entity Framework Core operations. It's a critical component when you need to use EF Core tools like migrations, scaffolding, and other commands that run during development rather than at runtime.

Key features and purposes include:

  1. Migration Support: Enables creating, applying, and managing database migrations through commands like Add-Migration, Update-Database, and Remove-Migration

  2. Reverse Engineering: Supports scaffolding entity models from existing databases using the Scaffold-DbContext command

  3. Design-Time Services: Provides infrastructure needed for design-time tools to interact with your EF Core model

  4. Command-Line Interface: Required when using the EF Core CLI tools via the dotnet ef command

  5. Design Factory Pattern: Implements interfaces that help the tooling discover and create instances of your DbContext at design time

This package is typically added as a development dependency rather than a runtime dependency, meaning it should be included in your project file with PrivateAssets="All" to prevent it from being deployed to production environments.

When setting up a project that uses EF Core migrations or scaffolding, you'll need both this package and either the Microsoft.EntityFrameworkCore.Tools package (for Package Manager Console commands) or the dotnet-ef global tool (for CLI commands).

This may no longer be required in the platform project since the DataClienthandles all database context and design-time instructions. However, removing/updating any EF Core design-time dependency is high risk and provides no reward.

Microsoft.Extensions.Logging v8.0.1

Microsoft.Extensions.Logging is a flexible logging API that's part of the broader Microsoft.Extensions libraries in .NET. It provides a standard logging framework that applications can use to log information, warnings, errors, and other messages.

Key features include:

  1. A consistent logging abstraction that works across different logging providers

  2. Built-in support for categorization of logs through a category name (typically the class name)

  3. Log filtering based on log level and category

  4. Structured logging with support for semantic/structured data in log messages

  5. Extensibility through logging providers for different output destinations

The framework defines six standard log levels: Trace, Debug, Information, Warning, Error, and Critical, allowing developers to control the verbosity of logs.

Microsoft.Extensions.Logging follows a provider pattern, where the core package defines the interfaces and basic functionality, while separate provider packages implement logging to specific destinations. Common providers include:

  • Console logging

  • Debug output logging

  • EventSource logging

  • EventLog (Windows)

  • File logging (via third-party providers)

  • Application Insights

  • Serilog, NLog, log4net (via integration packages)

This logging system is deeply integrated with ASP.NET Core and is the default logging mechanism for .NET applications built with the modern .NET platform. It can be configured through dependency injection and the configuration system, making it highly customizable.

Microsoft.Extensions.Logging.Console v8.0.1

Microsoft.Extensions.Logging.Console is a logging provider package that's part of the Microsoft.Extensions.Logging ecosystem. It specifically enables applications to write log messages to the console or terminal window.

Key features include:

  1. Output of formatted log messages to the standard output (console)

  2. Support for colored console output based on log levels (e.g., errors in red, warnings in yellow)

  3. Configurable formatting options for log messages

  4. Integration with the structured logging capabilities of Microsoft.Extensions.Logging

  5. Support for different console formatter options (Simple, JSON, and SystemdConsole)

  6. Ability to control verbosity through log filtering

This package is commonly used during development for immediate visual feedback or in containerized environments where console output is captured by container logging systems.

To use it, you typically register it with the logging builder in your application's startup code:

You can also configure it through appsettings.json or programmatically to customize formats, colors, and other behaviors. The console logger works seamlessly with the broader Microsoft.Extensions.Logging infrastructure, allowing it to be used alongside other logging providers.

DataClient Libraries

This section is incomplete. If you require an explanation for each of the included dependencies, please reach out to the development team ([email protected]).

Schemas Libraries

This section is incomplete. If you require an explanation for each of the included dependencies, please reach out to the development team ([email protected]).

EmailClient Libraries

The EmailClientproject does not have any third-party dependencies.

PreviousTitleActionBar

Last updated

Was this helpful?