CodedThought.Core 8.0.1.11

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, 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 easly done using the existing NuGet packages referenced.Installation is simply done by referencing the CodedThought.Core and Configuraion libraries and any of the 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.

Core Settings Parameters

CoreSettings/Settings

Connection Parameters

CoreSettings/Connections

The connections settings is an array of CoreSettings/Connections. However, only one can have the Primary key set to true or false. | Property | Data Type | Description | | ------ | ------| ------ | Name | string | Enter a unique name for the connection here. The CodedThought.Core framework supports multiple database connections on multiple platforms. | Primary | boolean | Specifies which connection the framework should use by default. | ProviderType | string |Specifies which client provider you are expecting to use with this connection. Accepted provider types: [ SqlServer | Oracle | MySql | OleDb | ApiServer ]. SqlServer is the default provider type. | DefaultSchema | string |Enter the default schema to use with this connection. Note: This feature allows the developer to create mulitple connections to the same database but pointing to different schemas within the database. This useful when setting the default schema for a database user is not possible.--The ApiServer provider does not require this | ConnectionString | string |Enter the full connection string here for the database. For Oracle connections you can enter the full TNS Names entry if necessary or just the TNSNAMES.ora entry name. For Api connection use the Url endpoint. | PoviderName | string | Enter the .NET System.Data allowed provider name for this connection. This is not a substitute for the ProviderType setting, and is only required for as long as your .NET connection requires it. The ApiServer provider does not require this. Microsoft.Data.SqlClient is the default provider name.

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 are 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 name dev then your settings file should be appsettings.dev.json.

// This is a simple extension to add the typical .NET appsettings.json file.
builder.AddAppSettingsConfiguration(Optional: IConfigurationBuilder.Environment)
// Alternatively you can use this extension to load both the typical appsettings.json as well as
// the CodedThought.Core settings file, ctsettings.json.
builder.AddCoreSettingsConfiguration(Optional: IHostEnvironment.Environment)

Add the provider specific libraries to your dependency injection

using CodedThought.Core.Extensions;

WebApplicationBuilder builder = WebApplication.CreateBuilder(args);

// Add the CodedThought.Core database type used in this project for DI.
builder.Services.AddCoreDataProvider<CodedThought.Core.Data.SqlServer.SqlServerDatabaseObject>();
builder.Services.AddCoreDataProvider<CodedThought.Core.Data.MySql.MySqlDatabaseObject>();
builder.Services.AddCoreDataProvider<CodedThought.Core.Data.OleDb.OleDbDatabaseObject>();