Change Package Name

Author: RohitM-IN

Attributes/ExcludedPropertyAttribute.cs

@@ -0,0 +1,29 @@
+namespace DbSyncKit.DB.Attributes
+{
+    /// <summary>
+    /// Specifies whether a property should be excluded from certain operations, such as data fetching and query generation.
+    /// </summary>
+    /// <remarks>
+    /// This attribute can be applied to properties within a class to indicate that the marked property should
+    /// be excluded from specific operations. For example, it can be used to exclude a property from data fetching
+    /// and query generation.
+    /// </remarks>
+    [AttributeUsage(AttributeTargets.Property)]
+    public class ExcludedPropertyAttribute : Attribute
+    {
+        /// <summary>
+        /// Gets a value indicating whether the property should be excluded from operations.
+        /// </summary>
+        /// <value><c>true</c> if the property should be excluded; otherwise, <c>false</c>.</value>
+        public bool Excluded { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ExcludedPropertyAttribute"/> class.
+        /// </summary>
+        /// <param name="excluded">Indicates whether the property should be excluded. Default is <c>true</c>.</param>
+        public ExcludedPropertyAttribute(bool excluded = true)
+        {
+            Excluded = excluded;
+        }
+    }
+}

Attributes/GenerateInsertWithIDAttribute.cs

@@ -0,0 +1,32 @@
+namespace DbSyncKit.DB.Attributes
+{
+    /// <summary>
+    /// Specifies whether the insert query generation for a class should include the ID property or exclude it.
+    /// </summary>
+    /// <remarks>
+    /// This attribute can be applied to classes to indicate whether the ID property's value should be included
+    /// in the insert query generation. For example, it can be used to determine whether the ID property should be
+    /// part of the generated insert query or excluded.
+    /// </remarks>
+    [AttributeUsage(AttributeTargets.Class)]
+    public class GenerateInsertWithIDAttribute : Attribute
+    {
+        /// <summary>
+        /// Gets a value indicating whether the insert query generation should include the ID property.
+        /// </summary>
+        /// <value><c>true</c> if the insert query should include the ID property; otherwise, <c>false</c>.</value>
+        public bool GenerateWithID { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="GenerateInsertWithIDAttribute"/> class.
+        /// </summary>
+        /// <param name="generateWithID">Indicates whether the insert query generation should include the ID property.
+        /// Default is <c>true</c>.</param>
+        public GenerateInsertWithIDAttribute(bool generateWithID = true)
+        {
+            GenerateWithID = generateWithID;
+        }
+
+
+    }
+}

Attributes/KeyPropertyAttribute.cs

@@ -0,0 +1,39 @@
+namespace DbSyncKit.DB.Attributes
+{
+    /// <summary>
+    /// Specifies whether a property should be considered as a key property.
+    /// </summary>
+    /// <remarks>
+    /// This attribute can be applied to properties within a class to indicate that the marked property
+    /// should be treated as a key property. It is typically used to identify properties that uniquely
+    /// identify instances of the class in database operations such as insert, update, and delete.
+    /// </remarks>
+    [AttributeUsage(AttributeTargets.Property)]
+    public class KeyPropertyAttribute : Attribute
+    {
+        /// <summary>
+        /// Gets a value indicating whether the property should be considered as a key property.
+        /// </summary>
+        /// <value><c>true</c> if the property should be treated as a key property; otherwise, <c>false</c>.</value>
+        public bool KeyProperty { get; }
+
+        /// <summary>
+        /// Gets a value indicating whether the property is a primary key.
+        /// </summary>
+        /// <value><c>true</c> if the property is a primary key; otherwise, <c>false</c>.</value>
+        public bool IsPrimaryKey { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="KeyPropertyAttribute"/> class.
+        /// </summary>
+        /// <param name="keyProperty">Indicates whether the property should be considered as a key property.
+        /// Default is <c>true</c>.</param>
+        /// <param name="isPrimaryKey">Indicates whether the property is a primary key.
+        /// Default is <c>false</c>.</param>
+        public KeyPropertyAttribute(bool keyProperty = true, bool isPrimaryKey = false)
+        {
+            KeyProperty = keyProperty;
+            IsPrimaryKey = isPrimaryKey;
+        }
+    }
+}

Attributes/TableNameAttribute.cs

@@ -0,0 +1,27 @@
+namespace DbSyncKit.DB.Attributes
+{
+    /// <summary>
+    /// Specifies the name of the database table associated with a class.
+    /// </summary>
+    /// <remarks>
+    /// This attribute can be applied to classes to indicate the name of the corresponding
+    /// database table. It is used to associate a class with a specific table in database operations.
+    /// </remarks>
+    [AttributeUsage(AttributeTargets.Class)]
+    public class TableNameAttribute : Attribute
+    {
+        /// <summary>
+        /// Gets the name of the database table.
+        /// </summary>
+        public string TableName { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TableNameAttribute"/> class.
+        /// </summary>
+        /// <param name="tableName">The name of the database table associated with the class.</param>
+        public TableNameAttribute(string tableName)
+        {
+            TableName = tableName ?? throw new ArgumentNullException(nameof(tableName)); ;
+        }
+    }
+}

Attributes/TableSchemaAttribute.cs

@@ -0,0 +1,27 @@
+namespace DbSyncKit.DB.Attributes
+{
+    /// <summary>
+    /// Specifies the schema name of the database table associated with a class.
+    /// </summary>
+    /// <remarks>
+    /// This attribute can be applied to classes to indicate the schema name of the corresponding
+    /// database table. It is used to associate a class with a specific schema in database operations.
+    /// </remarks>
+    [AttributeUsage(AttributeTargets.Class)]
+    public class TableSchemaAttribute : Attribute
+    {
+        /// <summary>
+        /// Gets the schema name of the database table.
+        /// </summary>
+        public string SchemaName { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TableSchemaAttribute"/> class.
+        /// </summary>
+        /// <param name="schemaName">The schema name of the database table associated with the class.</param>
+        public TableSchemaAttribute(string schemaName)
+        {
+            SchemaName = schemaName ?? throw new ArgumentNullException(nameof(schemaName));
+        }
+    }
+}

DatabaseManager.cs

@@ -0,0 +1,56 @@
+using DbSyncKit.DB.Interface;
+using System.Data;
+
+
+namespace DbSyncKit.DB
+{
+    /// <summary>
+    /// Manages database operations for a specific database provider implementing the IDatabase interface.
+    /// </summary>
+    /// <typeparam name="T">Type of the database provider implementing IDatabase.</typeparam>
+    public class DatabaseManager<T> : IDisposable where T : IDatabase
+    {
+        private readonly T _databaseProvider;
+
+        /// <summary>
+        /// Initializes a new instance of the DatabaseManager class.
+        /// </summary>
+        /// <param name="databaseProvider">The instance of the database provider.</param>
+        public DatabaseManager(T databaseProvider)
+        {
+            _databaseProvider = databaseProvider ?? throw new ArgumentNullException(nameof(databaseProvider));
+        }
+
+        /// <summary>
+        /// Executes a query against the database and returns a list of results for a specific data type.
+        /// </summary>
+        /// <typeparam name="TItem">The type of data to retrieve, constrained to be an instance of DataContractUtility.</typeparam>
+        /// <param name="query">The SQL query to execute.</param>
+        /// <param name="tableName">The name of the table associated with the query.</param>
+        /// <returns>A list of results of type <typeparamref name="TItem"/>.</returns>
+        public List<TItem> ExecuteQuery<TItem>(string query, string tableName) where TItem : IDataContractComparer
+        {
+            List<TItem> result = new List<TItem>();
+
+            var dataset = _databaseProvider.ExecuteQuery(query, tableName);
+
+            if (dataset.Tables.Contains(tableName))
+            {
+                foreach (DataRow row in dataset.Tables[tableName]!.Rows)
+                {
+                    result.Add((TItem)Activator.CreateInstance(typeof(TItem), new object[] { row })!);
+                }
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Disposes of the DatabaseManager.
+        /// </summary>
+        public void Dispose()
+        {
+            // No additional cleanup required
+        }
+    }
+}

DbSyncKit.DB.csproj

@@ -0,0 +1,29 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+	<TargetFrameworks>net7.0;net8.0</TargetFrameworks>
+	<ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <GenerateDocumentationFile>True</GenerateDocumentationFile>
+	<AssemblyVersion>0.1.0.0</AssemblyVersion>
+	<FileVersion>0.1.0.0</FileVersion>
+	<Version>0.1.0.0</Version>
+	<PackageReadmeFile>README.md</PackageReadmeFile>
+	<RepositoryUrl>https://github.com/RohitM-IN/DbSyncKit</RepositoryUrl>
+	<PackageProjectUrl>https://github.com/RohitM-IN/DbSyncKit</PackageProjectUrl>
+	<PackageLicenseFile>LICENSE.txt</PackageLicenseFile>
+	<GeneratePackageOnBuild>True</GeneratePackageOnBuild>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Include="..\LICENSE.txt">
+      <Pack>True</Pack>
+      <PackagePath>\</PackagePath>
+    </None>
+    <None Include="..\README.md">
+      <Pack>True</Pack>
+      <PackagePath>\</PackagePath>
+    </None>
+  </ItemGroup>
+
+</Project>

Enum/DatabaseProvider.cs

@@ -0,0 +1,29 @@
+namespace DbSyncKit.DB.Enum
+{
+    /// <summary>
+    /// Enumerates the supported database providers.
+    /// </summary>
+    public enum DatabaseProvider
+    {
+        /// <summary>
+        /// Microsoft SQL Server.
+        /// </summary>
+        MSSQL,
+
+        /// <summary>
+        /// SQLite database engine.
+        /// </summary>
+        SQLite,
+
+        /// <summary>
+        /// MySQL database server.
+        /// </summary>
+        MySQL,
+
+        /// <summary>
+        /// PostgreSQL database server.
+        /// </summary>
+        PostgreSQL
+    }
+
+}

Extensions/DataRowExtensions.cs

@@ -0,0 +1,47 @@
+using DbSyncKit.DB.Utils;
+using System.Data;
+namespace DbSyncKit.DB.Extensions
+{
+    /// <summary>
+    /// Extension methods for DataRow to simplify retrieving values from columns.
+    /// </summary>
+    public static class DataRowExtensions
+    {
+        /// <summary>
+        /// Gets the value of a specified column in the DataRow, converted to the specified type.
+        /// </summary>
+        /// <typeparam name="T">The type to which the column value should be converted.</typeparam>
+        /// <param name="row">The DataRow from which to retrieve the value.</param>
+        /// <param name="columnName">The name of the column.</param>
+        /// <returns>The value of the specified column, converted to the specified type.</returns>
+        /// <remarks>
+        /// This extension method is intended for use with classes that inherit from <see cref="DataContractUtility{T}"/>.
+        /// </remarks>
+        public static T GetValue<T>(this DataRow row, string columnName)
+        {
+            // Check if the DataRow is null
+            if (row == null)
+            {
+                throw new ArgumentNullException(nameof(row));
+            }
+
+            // Check if the column exists in the DataRow's table
+            if (row.Table.Columns.Contains(columnName))
+            {
+                // Retrieve the value from the specified column
+                object value = row[columnName];
+
+                // Check if the value is not DBNull
+                if (value != DBNull.Value)
+                {
+                    // Convert the value to the specified type
+                    return (T)Convert.ChangeType(value, typeof(T));
+                }
+            }
+
+            // Handle the case when the column doesn't exist or the value is DBNull return a default value
+            return default(T)!;
+        }
+    }
+}
+