CodedThought.Core 8.0.1.25

CodedThough.Core

A Custom ORM and .NET Utility Codebase

The CodedThought.Core library is a custom entity framework used to primarily abstract the database away from consuming components or clients. It has many other useful aspects:

• SQL Server, Oracle, MySQL, OleDb, PostGreSQL, and REST API Data Providers
• Email and Address Parsing
• Excel Import and Generation
• Extensions
• LDAP API Integrations
• SFTP and cURL Integration
• ASP.NET WebControls
• US Holiday Calculator
• Validation Engine with highly customizable expression-based language

Installation

CodedThought.Core requires several package dependencies, but these are easily done using the existing NuGet packages referenced. Installation is simply done by referencing the CodedThought.Core and Configuration libraries and any source-specific Core Provider libraries like CodedThought.Core.Data.SqlServer.

A recommended approach to installation is by using the Nuget package manager. The path to all the packages is https://nuget.pkg.github.com/erikbartlow/index.json.

Usage

Application Settings are accessed via .NET Core appsettings.json while database and/or API connection details are stored in a custom JSON settings file named ctSettings.json. CodedThought.Core supports environment-based settings.json implementations.

CoreSettings/Settings

CoreSettings/Connections

The connection settings are an array of CoreSettings/Connections. However, only one can have the Primary key set to true or false.

Data Entity Management

Custom Attributes

There are two custom attributes used by CodedThought.Core.Data.

• DataTable
• DataColumn
• ApiDataController
• ApiDataParameter

DataTable Attribute Properties

Sample Usage

[DataTable( tblRegions )]
[DataTable( tblRegions, vRegions )]

DataColumn Attribute Properties

Sample Usage

// Constructor Samples
[DataColumn( name: Id, type: System.Data.Int32, isKey: true )]
[DataColumn( name: Name, type: System.Data.String, size: 20 )]
[DataColumn( name: Name, type: System.Data.String, extendedPropertyType: typeof(Country), CountryName )]

IMPORTANT: Setting the ViewName property will override any TableName value previously set for all GET routines. However, Save and Delete routines will always use the TableName value since updateable views are not always supported across database platforms.

ApiDataController Attribute Properties

Create Data Aware classes

A key component to the CodedThought.Core.Data framework is the custom tags designed to enable the framework to learn how to communicate with your database. You can design them like any C# class, but it is key to understand that the framework is dynamically creating parameterized queries based on the custom attributes you set.

Create a Controller Class that inherits from the GenericDataStoreController with at least one constructor.

Important: The GenericDataStoreController class provides your controller with all the necessary methods for CRUD through the DataStore object. The DataStore is the derived instance of the DatabaseObject.

    public DbController(IMemoryCache memoryCache, CoreConnectionString connectionString) {
      // Connection to database.
      DatabaseConnection cn = new DatabaseConnection( *Connection Name* );
      try {
        DataStore = new GenericDataStore( memoryCache, new(connectionString) );
      } catch ( Exception ex ) {
        throw;
      }
    }

Create a class with data aware properties.

using System.Data;
using CodedThought.Core.Data;

[DataTable( tblRegion )]
public class Region{

	[DataColumn( name: regionId, type: System.Data.Int32, isKey: true )]
    public int Id{ get; set; }
    [DataColumn( name: regionName, type: System.Data.String, size: 20 )]
    public string Name { get; set; }
    
}

Add CRUD Methods to the Controller class

public Region GetRegion( int id ){
	try{
    	return DataStore.Get<Region>( id );
    } catch {
    	throw;
	}
}
public List<Region> GetRegions(){
	try{
    	// The GetMultiple method requires a ParameterCollection.  So to simply
        // return all records we just have to pass a null ParameterCollection.
    	return DataStore.GetMultiple<Region>(null);
    } catch {
    
    }
}

ParameterCollection

The ParameterCollection inherits from CollectionBase and implements the IList, ICollection, IEnumerable interface.

Load and Access appSettings.json and ctSettings.json

Using the configuration-specific extension routines you can auto-load the appSettings and any environment-based JSON configurations.

Note: The name of the environment is used to locate any environment-specific versions of the file. For example, if your environment is named "development" then your settings file should be appsettings.development.json.

builder.AddAppSettingsConfiguration(Optional: IConfigurationBuilder.Environment)
builder.AddCoreSettingsConfiguration(Optional: IHostEnvironment.Environment)