Preparing xPushService ...

Base/XBaseDtoProvider.cs

@@ -17,25 +17,26 @@ using xPushService.Interfaces;
 
 namespace xPushService.Base
 {
-    public abstract class XBaseDtoProvider<TEntity, TDto, TKey> : IXBaseDtoProvider<TEntity, TDto, TKey>
+    public abstract class XBaseDtoProvider<TEntity, TDto, TKey, THub> : IXBaseDtoProvider<TEntity, TDto, TKey, THub>
     where TEntity : XBaseEntity<TKey>
     where TDto : XBaseEntityDto<TKey>
+    where THub : XBaseDtoHub<TEntity, TDto, TKey>
     {
         //
         #region Properties ...
+        public IHubContext<THub> Hub { get; }
         public IXIdentityProvider IdentityProvider { get; }
         public XDataServiceConfiguration DataConfiguration { get; }
-        public IHubContext<XBaseDtoHub<TEntity, TDto, TKey>> Hub { get; }
         public IXBaseRepositoryService<TEntity, TDto, TKey> Service { get; }
         #endregion
 
         //
         #region Constructor ...
         protected XBaseDtoProvider(
-            IXIdentityProvider identityProvider,
+            IHubContext<THub> hub,
             XDataServiceConfiguration dataConfiguration,
-            IHubContext<XBaseDtoHub<TEntity, TDto, TKey>> hub,
+            IXBaseRepositoryService<TEntity, TDto, TKey> service,
-            IXBaseRepositoryService<TEntity, TDto, TKey> service
+            IXIdentityProvider identityProvider = null
         )
         {
             //

Base/XBaseEntityProvider.cs

@@ -17,24 +17,25 @@ using xPushService.Interfaces;
 
 namespace xPushService.Base
 {
-    public abstract class XBaseEntityProvider<TEntity, TKey> : IXBaseEntityProviderr<TEntity, TKey>
+    public abstract class XBaseEntityProvider<TEntity, TKey, THub> : IXBaseEntityProviderr<TEntity, TKey, THub>
     where TEntity : XBaseEntity<TKey>
+    where THub : XBaseEntityHub<TEntity, TKey>
     {
         //
         #region Properties ...
+        public IHubContext<THub> Hub { get; }
         public IXIdentityProvider IdentityProvider { get; }
         public IXBaseRepository<TEntity, TKey> Repository { get; }
         public XDataServiceConfiguration DataConfiguration { get; }
-        public IHubContext<XBaseEntityHub<TEntity, TKey>> Hub { get; }
         #endregion
 
         //
         #region Constructor ...
         protected XBaseEntityProvider(
-            IXIdentityProvider identityProvider,
+            IHubContext<THub> hub,
             IXBaseRepository<TEntity, TKey> repository,
             XDataServiceConfiguration dataConfiguration,
-            IHubContext<XBaseEntityHub<TEntity, TKey>> hub
+            IXIdentityProvider identityProvider = null
         )
         {
             //

Controllers/XBaseRepositoryProviderController.cs

@@ -0,0 +1,568 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore.Query;
+using Microsoft.Extensions.Logging;
+using xCommons.Configurations;
+using xCommons.Extensions;
+using xCommons.Providers;
+using xDataService.Extensions;
+using xExceptions.Constants;
+using xIdentityService.Controllers;
+using xIdentityService.Interfaces;
+using xModels.Base;
+using xModels.Dtos;
+using xPushService.Base;
+using xPushService.Interfaces;
+
+namespace xPushService.Controllers
+{
+    public abstract class XBaseRepositoryProviderController<TEntity, TKey, THub> : XBaseIdentityApiV1Controller, IXBaseRepositoryProviderController<TEntity, TKey, THub>
+    where TEntity : XBaseEntity<TKey>
+    where THub : XBaseEntityHub<TEntity, TKey>
+    {
+        //
+        #region Properties ...
+        public IXBaseEntityProviderr<TEntity, TKey, THub> Provider { get; }
+        public Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> DefaultOrderBuilder { get; }
+        public Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> DefaultIncludeBuilder { get; }
+        #endregion
+
+        protected XBaseRepositoryProviderController(
+            ILogger logger,
+            XAppConfiguration appConfiguration,
+            IXIdentityProvider identityProvider,
+            XValidationProvider validationProvider,
+            IXBaseEntityProviderr<TEntity, TKey, THub> provider,
+            Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> defaultOrderBuilder,
+            Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> defaultIncludeBuilder
+        ) : base(
+            logger: logger,
+            appConfiguration: appConfiguration,
+            identityProvider: identityProvider,
+            validationProvider: validationProvider
+        )
+        {
+            //
+            Provider = provider;
+            DefaultOrderBuilder = defaultOrderBuilder;
+            DefaultIncludeBuilder = defaultIncludeBuilder;
+        }
+
+        //
+        #region Actions ...
+        /// <summary>
+        /// add a new Item ...
+        /// </summary>
+        /// <param name="item"></param>
+        /// <param name="saveChanges"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [HttpPost]
+        public virtual async Task<ActionResult<TEntity>> Add(
+            [FromBody] TEntity item,
+            [FromQuery] bool saveChanges = true,
+            CancellationToken cancellationToken = default
+        )
+        {
+            //
+            try
+            {
+                //
+                // Validate ...
+                if (!ModelState.IsValid)
+                {
+                    XException.InvalidArgs.Throw();
+                }
+                ValidationProvider.NotNull(item);
+
+                //
+                var connectionId = GetConnectionId();
+
+                //
+                var result = await Provider.AddAsync(
+                    item: item,
+                    saveChanges: saveChanges,
+                    connectionId: connectionId,
+                    cancellationToken: cancellationToken
+                );
+
+                //
+                return Ok(result.ToDynamicObject());
+            }
+            catch (Exception ex)
+            {
+                //
+                var result = GetExceptionActionResult(ex);
+                return result;
+            }
+        }
+
+        /// <summary>
+        /// Update an Item values ...
+        /// </summary>
+        /// <param name="id"></param>
+        /// <param name="item"></param>
+        /// <param name="saveChanges"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [HttpPut("{id}")]
+        public virtual async Task<ActionResult<TEntity>> Update(
+            [FromRoute] TKey id,
+            [FromBody] TEntity item,
+            [FromQuery] bool saveChanges = true,
+            CancellationToken cancellationToken = default
+        )
+        {
+            //
+            try
+            {
+                //
+                // Validate ...
+                if (!ModelState.IsValid)
+                {
+                    XException.InvalidArgs.Throw();
+                }
+                ValidationProvider.NotNull(item);
+
+                //
+                var connectionId = GetConnectionId();
+
+                //
+                var result = await Provider.UpdateAsync(
+                    id: id,
+                    item: item,
+                    saveChanges: saveChanges,
+                    connectionId: connectionId,
+                    cancellationToken: cancellationToken
+                );
+
+                //
+                return Ok(result.ToDynamicObject());
+            }
+            catch (Exception ex)
+            {
+                //
+                var result = GetExceptionActionResult(ex);
+                return result;
+            }
+        }
+
+        /// <summary>
+        /// remove an Item by it's Id ...
+        /// </summary>
+        /// <param name="id"></param>
+        /// <param name="softDelete"></param>
+        /// <param name="saveChanges"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [HttpDelete("{id}")]
+        public virtual async Task<ActionResult<TEntity>> Remove(
+            [FromRoute] TKey id,
+            [FromQuery] bool softDelete = true,
+            [FromQuery] bool saveChanges = true,
+            CancellationToken cancellationToken = default
+        )
+        {
+            //
+            try
+            {
+                //
+                // Validate ...
+                if (!ModelState.IsValid)
+                {
+                    XException.InvalidArgs.Throw();
+                }
+
+                //
+                var connectionId = GetConnectionId();
+
+                //
+                var result = await Provider.RemoveAsync(
+                    id: id,
+                    softDelete: softDelete,
+                    saveChanges: saveChanges,
+                    connectionId: connectionId,
+                    cancellationToken: cancellationToken
+                );
+
+                //
+                return Ok(result.ToDynamicObject());
+            }
+            catch (Exception ex)
+            {
+                //
+                var result = GetExceptionActionResult(ex);
+                return result;
+            }
+        }
+
+        /// <summary>
+        /// Check an Item exists or not ...
+        /// </summary>
+        /// <param name="id"></param>
+        /// <param name="ignoreSoftDeleteds"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [HttpGet("{id}/[action]")]
+        public virtual async Task<ActionResult<bool>> IsExists(
+            [FromRoute] TKey id,
+            [FromQuery] bool ignoreSoftDeleteds = true,
+            CancellationToken cancellationToken = default
+        )
+        {
+            //
+            try
+            {
+                //
+                // Validate ...
+                if (!ModelState.IsValid)
+                {
+                    XException.InvalidArgs.Throw();
+                }
+
+                //
+                var result = await Provider.IsExistsAsync(
+                    id: id,
+                    cancellationToken: cancellationToken,
+                    ignoreSoftDeleteds: ignoreSoftDeleteds
+                );
+
+                //
+                return Ok(result);
+            }
+            catch (Exception ex)
+            {
+                //
+                var result = GetExceptionActionResult(ex);
+                return result;
+            }
+        }
+
+        /// <summary>
+        /// count all exists Items ...
+        /// </summary>
+        /// <param name="ignoreSoftDeleteds"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [HttpGet("Count")]
+        public virtual async Task<ActionResult<long>> Count(
+            [FromQuery] bool ignoreSoftDeleteds = true,
+            CancellationToken cancellationToken = default
+        )
+        {
+            //
+            try
+            {
+                //
+                // Validate ...
+                if (!ModelState.IsValid)
+                {
+                    XException.InvalidArgs.Throw();
+                }
+
+                //
+                var result = await Provider.CountAsync(
+                    cancellationToken: cancellationToken,
+                    ignoreSoftDeleteds: ignoreSoftDeleteds
+                );
+
+                //
+                return Ok(result);
+            }
+            catch (Exception ex)
+            {
+                //
+                var result = GetExceptionActionResult(ex);
+                return result;
+            }
+        }
+
+        /// <summary>
+        /// retrieve an Item by it's Id ...
+        /// </summary>
+        /// <param name="id"></param>
+        /// <param name="ignoreSoftDeleteds"></param>
+        /// <param name="useDefaultIncludes"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [HttpGet("{id}")]
+        public virtual async Task<ActionResult<TEntity>> Get(
+            [FromRoute] TKey id,
+            [FromQuery] bool ignoreSoftDeleteds = true,
+            [FromQuery] bool useDefaultIncludes = false,
+            CancellationToken cancellationToken = default
+        )
+        {
+            //
+            try
+            {
+                //
+                // Validate ...
+                if (!ModelState.IsValid)
+                {
+                    XException.InvalidArgs.Throw();
+                }
+
+                //
+                var result = await Provider.GetAsync(
+                    id: id,
+                    includeBuilder: !useDefaultIncludes
+                        ? null
+                        : DefaultIncludeBuilder,
+                    cancellationToken: cancellationToken,
+                    ignoreSoftDeleteds: ignoreSoftDeleteds
+                );
+
+                //
+                return Ok(result.ToDynamicObject());
+            }
+            catch (Exception ex)
+            {
+                //
+                var result = GetExceptionActionResult(ex);
+                return result;
+            }
+        }
+
+        /// <summary>
+        /// retrieve all exists Items ...
+        /// </summary>
+        /// <param name="ignoreSoftDeleteds"></param>
+        /// <param name="useDefaultOrders"></param>
+        /// <param name="useDefaultIncludes"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [HttpGet]
+        public virtual async Task<ActionResult<IEnumerable<TEntity>>> GetAll(
+            [FromQuery] bool ignoreSoftDeleteds = true,
+            [FromQuery] bool useDefaultOrders = false,
+            [FromQuery] bool useDefaultIncludes = false,
+            CancellationToken cancellationToken = default
+        )
+        {
+            //
+            try
+            {
+                //
+                // Validate ...
+                if (!ModelState.IsValid)
+                {
+                    XException.InvalidArgs.Throw();
+                }
+
+                //
+                var result = await Provider.GetAllAsync(
+                    orderBuilder: !useDefaultOrders
+                        ? null
+                        : DefaultOrderBuilder,
+                    includeBuilder: !useDefaultIncludes
+                        ? null
+                        : DefaultIncludeBuilder,
+                    cancellationToken: cancellationToken,
+                    ignoreSoftDeleteds: ignoreSoftDeleteds
+                );
+
+                //
+                return Ok(result.ToDynamicObject());
+            }
+            catch (Exception ex)
+            {
+                //
+                var result = GetExceptionActionResult(ex);
+                return result;
+            }
+        }
+
+        /// <summary>
+        /// find an Item by providing a Conditional Expression ...
+        /// </summary>
+        /// <param name="query"></param>
+        /// <param name="ignoreSoftDeleteds"></param>
+        /// <param name="useDefaultIncludes"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        public virtual async Task<ActionResult<TEntity>> FindOne(
+            [FromRoute] string query,
+            [FromQuery] bool ignoreSoftDeleteds = true,
+            [FromQuery] bool useDefaultIncludes = false,
+            CancellationToken cancellationToken = default
+        )
+        {
+            //
+            try
+            {
+                //
+                if (!ModelState.IsValid)
+                {
+                    XException.InvalidArgs.Throw();
+                }
+                ValidationProvider.NotEmpty(query);
+
+                //
+                Expression<Func<TEntity, bool>> predicate = x => x.PropValuesContains(query);
+                var result = await Provider.FindOneAsync(
+                    predicate: predicate,
+                    includeBuilder: !useDefaultIncludes
+                        ? null
+                        : DefaultIncludeBuilder,
+                    cancellationToken: cancellationToken,
+                    ignoreSoftDeleteds: ignoreSoftDeleteds
+                );
+
+                //
+                return Ok(result.ToDynamicObject());
+            }
+            catch (Exception ex)
+            {
+                //
+                var result = GetExceptionActionResult(ex);
+                return result;
+            }
+        }
+
+        /// <summary>
+        /// find a collection of Items by proving a Conditional Expression ...
+        /// </summary>
+        /// <param name="query"></param>
+        /// <param name="ignoreSoftDeleteds"></param>
+        /// <param name="useDefaultOrders"></param>
+        /// <param name="useDefaultIncludes"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        public virtual async Task<ActionResult<IEnumerable<TEntity>>> FindMany(
+            [FromRoute] string query,
+            [FromQuery] bool ignoreSoftDeleteds = true,
+            [FromQuery] bool useDefaultOrders = false,
+            [FromQuery] bool useDefaultIncludes = false,
+            CancellationToken cancellationToken = default
+        )
+        {
+            //
+            try
+            {
+                //
+                if (!ModelState.IsValid)
+                {
+                    XException.InvalidArgs.Throw();
+                }
+                ValidationProvider.NotEmpty(query);
+
+                //
+                Expression<Func<TEntity, bool>> predicate = x => x.PropValuesContains(query);
+                var result = await Provider.FindManyAsync(
+                    predicate: predicate,
+                    orderBuilder: !useDefaultOrders
+                        ? null
+                        : DefaultOrderBuilder,
+                    includeBuilder: !useDefaultIncludes
+                        ? null
+                        : DefaultIncludeBuilder,
+                    cancellationToken: cancellationToken,
+                    ignoreSoftDeleteds: ignoreSoftDeleteds
+                );
+
+                //
+                return Ok(result.ToDynamicObject());
+            }
+            catch (Exception ex)
+            {
+                //
+                var result = GetExceptionActionResult(ex);
+                return result;
+            }
+        }
+
+        /// <summary>
+        /// retrieve Items based on XQuery Pagination structure ...
+        /// </summary>
+        /// <param name="query"></param>
+        /// <param name="ignoreSoftDeleteds"></param>
+        /// <param name="useDefaultOrders"></param>
+        /// <param name="useDefaultIncludes"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        public virtual async Task<ActionResult<XQueryResult<TEntity>>> Query(
+            [FromQuery] XQuery query,
+            [FromQuery] bool ignoreSoftDeleteds = true,
+            [FromQuery] bool useDefaultOrders = false,
+            [FromQuery] bool useDefaultIncludes = false,
+            CancellationToken cancellationToken = default
+        )
+        {
+            //
+            try
+            {
+                //
+                // Validate ...
+                if (!ModelState.IsValid)
+                {
+                    XException.InvalidArgs.Throw();
+                }
+
+                //
+                // Normalize ...
+                if (query.IsNullOrDefault())
+                {
+                    query = query.NormalizeQuery(Provider.DataConfiguration);
+                }
+
+                //
+                var result = await Provider.QueryAsync(
+                    query: query,
+                    predicate: null,
+                    orderBuilder: !useDefaultOrders
+                        ? null
+                        : DefaultOrderBuilder,
+                    includeBuilder: !useDefaultIncludes
+                        ? null
+                        : DefaultIncludeBuilder,
+                    cancellationToken: cancellationToken,
+                    ignoreSoftDeleteds: ignoreSoftDeleteds
+                );
+
+                //
+                return Ok(result.ToDynamicObject());
+            }
+            catch (Exception ex)
+            {
+                //
+                var result = GetExceptionActionResult(ex);
+                return result;
+            }
+        }
+        #endregion
+
+        //
+        #region NonActions ...
+        /// <summary>
+        /// Send Custom Push Message ...
+        /// </summary>
+        /// <param name="action"></param>
+        /// <param name="payLoad"></param>
+        /// <param name="connectionId"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [NonAction]
+        public virtual async Task SendPush(
+            string action,
+            string payLoad,
+            string connectionId = null,
+            CancellationToken cancellationToken = default
+        )
+        {
+            //
+            await Provider.SendPush(
+                action: action,
+                payLoad: payLoad,
+                connectionId: connectionId,
+                cancellationToken: cancellationToken
+            );
+        }
+        #endregion
+    }
+}

Controllers/XBaseServiceProviderController.cs

@@ -0,0 +1,572 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore.Query;
+using Microsoft.Extensions.Logging;
+using xCommons.Configurations;
+using xCommons.Extensions;
+using xCommons.Providers;
+using xDataService.Extensions;
+using xExceptions.Constants;
+using xIdentityService.Controllers;
+using xIdentityService.Interfaces;
+using xModels.Base;
+using xModels.Dtos;
+using xPushService.Base;
+using xPushService.Interfaces;
+
+namespace xPushService.Controllers
+{
+    public abstract class XBaseServiceProviderController<TEntity, TDto, TKey, THub> : XBaseIdentityApiV1Controller, IXBaseServiceProviderController<TEntity, TDto, TKey, THub>
+    where TEntity : XBaseEntity<TKey>
+    where TDto : XBaseEntityDto<TKey>
+    where THub : XBaseDtoHub<TEntity, TDto, TKey>
+    {
+        //
+        #region Properties ...
+        public IXBaseDtoProvider<TEntity, TDto, TKey, THub> Provider { get; }
+        public Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> DefaultOrderBuilder { get; }
+        public Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> DefaultIncludeBuilder { get; }
+        #endregion
+
+        //
+        #region Constructor ...
+        public XBaseServiceProviderController(
+            ILogger logger,
+            XAppConfiguration appConfiguration,
+            IXIdentityProvider identityProvider,
+            XValidationProvider validationProvider,
+            IXBaseDtoProvider<TEntity, TDto, TKey, THub> provider,
+            Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> defaultOrderBuilder,
+            Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> defaultIncludeBuilder
+        ) : base(
+            logger,
+            appConfiguration,
+            identityProvider,
+            validationProvider
+        )
+        {
+            //
+            Provider = provider;
+            DefaultOrderBuilder = defaultOrderBuilder;
+            DefaultIncludeBuilder = defaultIncludeBuilder;
+        }
+        #endregion
+
+        //
+        #region Actions ...
+        /// <summary>
+        /// add a new Item ...
+        /// </summary>
+        /// <param name="item"></param>
+        /// <param name="saveChanges"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [HttpPost]
+        public virtual async Task<ActionResult<TDto>> Add(
+            [FromBody] TDto item,
+            [FromQuery] bool saveChanges = true,
+            CancellationToken cancellationToken = default
+        )
+        {
+            //
+            try
+            {
+                //
+                // Validate ...
+                if (!ModelState.IsValid)
+                {
+                    XException.InvalidArgs.Throw();
+                }
+                ValidationProvider.NotNull(item);
+
+                //
+                var connectionId = GetConnectionId();
+
+                //
+                var result = await Provider.AddAsync(
+                    item: item,
+                    saveChanges: saveChanges,
+                    connectionId: connectionId,
+                    cancellationToken: cancellationToken
+                );
+
+                //
+                return Ok(result.ToDynamicObject());
+            }
+            catch (Exception ex)
+            {
+                //
+                var result = GetExceptionActionResult(ex);
+                return result;
+            }
+        }
+
+        /// <summary>
+        /// Update an Item values ...
+        /// </summary>
+        /// <param name="id"></param>
+        /// <param name="item"></param>
+        /// <param name="saveChanges"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [HttpPut("{id}")]
+        public virtual async Task<ActionResult<TDto>> Update(
+            [FromRoute] TKey id,
+            [FromBody] TDto item,
+            [FromQuery] bool saveChanges = true,
+            CancellationToken cancellationToken = default
+        )
+        {
+            //
+            try
+            {
+                //
+                // Validate ...
+                if (!ModelState.IsValid)
+                {
+                    XException.InvalidArgs.Throw();
+                }
+                ValidationProvider.NotNull(item);
+
+                //
+                var connectionId = GetConnectionId();
+
+                //
+                var result = await Provider.UpdateAsync(
+                    id: id,
+                    item: item,
+                    saveChanges: saveChanges,
+                    connectionId: connectionId,
+                    cancellationToken: cancellationToken
+                );
+
+                //
+                return Ok(result.ToDynamicObject());
+            }
+            catch (Exception ex)
+            {
+                //
+                var result = GetExceptionActionResult(ex);
+                return result;
+            }
+        }
+
+        /// <summary>
+        /// remove an Item by it's Id ...
+        /// </summary>
+        /// <param name="id"></param>
+        /// <param name="softDelete"></param>
+        /// <param name="saveChanges"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [HttpDelete("{id}")]
+        public virtual async Task<ActionResult<TDto>> Remove(
+            [FromRoute] TKey id,
+            [FromQuery] bool softDelete = true,
+            [FromQuery] bool saveChanges = true,
+            CancellationToken cancellationToken = default
+        )
+        {
+            //
+            try
+            {
+                //
+                // Validate ...
+                if (!ModelState.IsValid)
+                {
+                    XException.InvalidArgs.Throw();
+                }
+
+                //
+                var connectionId = GetConnectionId();
+
+                //
+                var result = await Provider.RemoveAsync(
+                    id: id,
+                    softDelete: softDelete,
+                    saveChanges: saveChanges,
+                    connectionId: connectionId,
+                    cancellationToken: cancellationToken
+                );
+
+                //
+                return Ok(result.ToDynamicObject());
+            }
+            catch (Exception ex)
+            {
+                //
+                var result = GetExceptionActionResult(ex);
+                return result;
+            }
+        }
+
+        /// <summary>
+        /// Check an Item exists or not ...
+        /// </summary>
+        /// <param name="id"></param>
+        /// <param name="ignoreSoftDeleteds"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [HttpGet("{id}/[action]")]
+        public virtual async Task<ActionResult<bool>> IsExists(
+            [FromRoute] TKey id,
+            [FromQuery] bool ignoreSoftDeleteds = true,
+            CancellationToken cancellationToken = default
+        )
+        {
+            //
+            try
+            {
+                //
+                // Validate ...
+                if (!ModelState.IsValid)
+                {
+                    XException.InvalidArgs.Throw();
+                }
+
+                //
+                var result = await Provider.IsExistsAsync(
+                    id: id,
+                    cancellationToken: cancellationToken,
+                    ignoreSoftDeleteds: ignoreSoftDeleteds
+                );
+
+                //
+                return Ok(result);
+            }
+            catch (Exception ex)
+            {
+                //
+                var result = GetExceptionActionResult(ex);
+                return result;
+            }
+        }
+
+        /// <summary>
+        /// count all exists Items ...
+        /// </summary>
+        /// <param name="ignoreSoftDeleteds"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [HttpGet("Count")]
+        public virtual async Task<ActionResult<long>> Count(
+            [FromQuery] bool ignoreSoftDeleteds = true,
+            CancellationToken cancellationToken = default
+        )
+        {
+            //
+            try
+            {
+                //
+                // Validate ...
+                if (!ModelState.IsValid)
+                {
+                    XException.InvalidArgs.Throw();
+                }
+
+                //
+                var result = await Provider.CountAsync(
+                    cancellationToken: cancellationToken,
+                    ignoreSoftDeleteds: ignoreSoftDeleteds
+                );
+
+                //
+                return Ok(result);
+            }
+            catch (Exception ex)
+            {
+                //
+                var result = GetExceptionActionResult(ex);
+                return result;
+            }
+        }
+
+        /// <summary>
+        /// retrieve an Item by it's Id ...
+        /// </summary>
+        /// <param name="id"></param>
+        /// <param name="ignoreSoftDeleteds"></param>
+        /// <param name="useDefaultIncludes"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [HttpGet("{id}")]
+        public virtual async Task<ActionResult<TDto>> Get(
+            [FromRoute] TKey id,
+            [FromQuery] bool ignoreSoftDeleteds = true,
+            [FromQuery] bool useDefaultIncludes = false,
+            CancellationToken cancellationToken = default
+        )
+        {
+            //
+            try
+            {
+                //
+                // Validate ...
+                if (!ModelState.IsValid)
+                {
+                    XException.InvalidArgs.Throw();
+                }
+
+                //
+                var result = await Provider.GetAsync(
+                    id: id,
+                    includeBuilder: !useDefaultIncludes
+                        ? null
+                        : DefaultIncludeBuilder,
+                    cancellationToken: cancellationToken,
+                    ignoreSoftDeleteds: ignoreSoftDeleteds
+                );
+
+                //
+                return Ok(result.ToDynamicObject());
+            }
+            catch (Exception ex)
+            {
+                //
+                var result = GetExceptionActionResult(ex);
+                return result;
+            }
+        }
+
+        /// <summary>
+        /// retrieve all exists Items ...
+        /// </summary>
+        /// <param name="ignoreSoftDeleteds"></param>
+        /// <param name="useDefaultOrders"></param>
+        /// <param name="useDefaultIncludes"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [HttpGet]
+        public virtual async Task<ActionResult<IEnumerable<TDto>>> GetAll(
+            [FromQuery] bool ignoreSoftDeleteds = true,
+            [FromQuery] bool useDefaultOrders = false,
+            [FromQuery] bool useDefaultIncludes = false,
+            CancellationToken cancellationToken = default
+        )
+        {
+            //
+            try
+            {
+                //
+                // Validate ...
+                if (!ModelState.IsValid)
+                {
+                    XException.InvalidArgs.Throw();
+                }
+
+                //
+                var result = await Provider.GetAllAsync(
+                    orderBuilder: !useDefaultOrders
+                        ? null
+                        : DefaultOrderBuilder,
+                    includeBuilder: !useDefaultIncludes
+                        ? null
+                        : DefaultIncludeBuilder,
+                    cancellationToken: cancellationToken,
+                    ignoreSoftDeleteds: ignoreSoftDeleteds
+                );
+
+                //
+                return Ok(result.ToDynamicObject());
+            }
+            catch (Exception ex)
+            {
+                //
+                var result = GetExceptionActionResult(ex);
+                return result;
+            }
+        }
+
+        /// <summary>
+        /// find an Item by providing a Conditional Expression ...
+        /// </summary>
+        /// <param name="query"></param>
+        /// <param name="ignoreSoftDeleteds"></param>
+        /// <param name="useDefaultIncludes"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        public virtual async Task<ActionResult<TDto>> FindOne(
+            [FromRoute] string query,
+            [FromQuery] bool ignoreSoftDeleteds = true,
+            [FromQuery] bool useDefaultIncludes = false,
+            CancellationToken cancellationToken = default
+        )
+        {
+            //
+            try
+            {
+                //
+                if (!ModelState.IsValid)
+                {
+                    XException.InvalidArgs.Throw();
+                }
+                ValidationProvider.NotEmpty(query);
+
+                //
+                Expression<Func<TEntity, bool>> predicate = x => x.PropValuesContains(query);
+                var result = await Provider.FindOneAsync(
+                    predicate: predicate,
+                    includeBuilder: !useDefaultIncludes
+                        ? null
+                        : DefaultIncludeBuilder,
+                    cancellationToken: cancellationToken,
+                    ignoreSoftDeleteds: ignoreSoftDeleteds
+                );
+
+                //
+                return Ok(result.ToDynamicObject());
+            }
+            catch (Exception ex)
+            {
+                //
+                var result = GetExceptionActionResult(ex);
+                return result;
+            }
+        }
+
+        /// <summary>
+        /// find a collection of Items by proving a Conditional Expression ...
+        /// </summary>
+        /// <param name="query"></param>
+        /// <param name="ignoreSoftDeleteds"></param>
+        /// <param name="useDefaultOrders"></param>
+        /// <param name="useDefaultIncludes"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        public virtual async Task<ActionResult<IEnumerable<TDto>>> FindMany(
+            [FromRoute] string query,
+            [FromQuery] bool ignoreSoftDeleteds = true,
+            [FromQuery] bool useDefaultOrders = false,
+            [FromQuery] bool useDefaultIncludes = false,
+            CancellationToken cancellationToken = default
+        )
+        {
+            //
+            try
+            {
+                //
+                if (!ModelState.IsValid)
+                {
+                    XException.InvalidArgs.Throw();
+                }
+                ValidationProvider.NotEmpty(query);
+
+                //
+                Expression<Func<TEntity, bool>> predicate = x => x.PropValuesContains(query);
+                var result = await Provider.FindManyAsync(
+                    predicate: predicate,
+                    orderBuilder: !useDefaultOrders
+                        ? null
+                        : DefaultOrderBuilder,
+                    includeBuilder: !useDefaultIncludes
+                        ? null
+                        : DefaultIncludeBuilder,
+                    cancellationToken: cancellationToken,
+                    ignoreSoftDeleteds: ignoreSoftDeleteds
+                );
+
+                //
+                return Ok(result.ToDynamicObject());
+            }
+            catch (Exception ex)
+            {
+                //
+                var result = GetExceptionActionResult(ex);
+                return result;
+            }
+        }
+
+        /// <summary>
+        /// retrieve Items based on XQuery Pagination structure ...
+        /// </summary>
+        /// <param name="query"></param>
+        /// <param name="ignoreSoftDeleteds"></param>
+        /// <param name="useDefaultOrders"></param>
+        /// <param name="useDefaultIncludes"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        public virtual async Task<ActionResult<XQueryResult<TDto>>> Query(
+            [FromQuery] XQuery query,
+            [FromQuery] bool ignoreSoftDeleteds = true,
+            [FromQuery] bool useDefaultOrders = false,
+            [FromQuery] bool useDefaultIncludes = false,
+            CancellationToken cancellationToken = default
+        )
+        {
+            //
+            try
+            {
+                //
+                // Validate ...
+                if (!ModelState.IsValid)
+                {
+                    XException.InvalidArgs.Throw();
+                }
+
+                //
+                // Normalize ...
+                if (query.IsNullOrDefault())
+                {
+                    query = query.NormalizeQuery(Provider.DataConfiguration);
+                }
+
+                //
+                var result = await Provider.QueryAsync(
+                    query: query,
+                    predicate: null,
+                    orderBuilder: !useDefaultOrders
+                        ? null
+                        : DefaultOrderBuilder,
+                    includeBuilder: !useDefaultIncludes
+                        ? null
+                        : DefaultIncludeBuilder,
+                    cancellationToken: cancellationToken,
+                    ignoreSoftDeleteds: ignoreSoftDeleteds
+                );
+
+                //
+                return Ok(result.ToDynamicObject());
+            }
+            catch (Exception ex)
+            {
+                //
+                var result = GetExceptionActionResult(ex);
+                return result;
+            }
+        }
+        #endregion
+
+        //
+        #region NonActions ...
+        /// <summary>
+        /// Send Custom Push Message ...
+        /// </summary>
+        /// <param name="action"></param>
+        /// <param name="payLoad"></param>
+        /// <param name="connectionId"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [NonAction]
+        public virtual async Task SendPush(
+            string action,
+            string payLoad,
+            string connectionId = null,
+            CancellationToken cancellationToken = default
+        )
+        {
+            //
+            await Provider.SendPush(
+                action: action,
+                payLoad: payLoad,
+                connectionId: connectionId,
+                cancellationToken: cancellationToken
+            );
+        }
+        #endregion
+    }
+}

DI/XDIHelperExtension.cs

@@ -14,6 +14,7 @@ using xExceptions.Constants;
 using xPushService.Configurations;
 using xPushService.Constants;
 using xPushService.Helpers;
+using xPushService.Interfaces;
 using xPushService.Providers;
 
 namespace xPushService.DI
@@ -160,8 +161,10 @@ namespace xPushService.DI
                         //
                         var hubRoute = config.BaseRoute + "/" + hubDescriptor.Route;
                         hubRoutes.Add(hubRoute);
-                        Console.WriteLine($"XPushService HubRoute: {hubRoute}");
 
+                        //
+                        try
+                        {
                             //
                             Type routesType = routes.GetType();
                             MethodInfo mapHubMethod = routesType
@@ -179,6 +182,14 @@ namespace xPushService.DI
                             object[] genericMapHubMethodArgs = { new PathString(hubRoute) };
                             MethodInfo genericMapHubMethod = mapHubMethod.MakeGenericMethod(hubDescriptor.Hub);
                             genericMapHubMethod.Invoke(routes, genericMapHubMethodArgs);
+
+                            //
+                            Log($"Register {hubDescriptor.Hub} Hub: {hubRoute}");
+                        }
+                        catch
+                        {
+                            throw;
+                        }
                     });
                 });
             }
@@ -250,7 +261,7 @@ namespace xPushService.DI
 
             //
             // Register XPushService Configuration ...
-            services.AddSingleton<XPushServiceConfiguration>(config);
+            services.AddSingleton(config);
 
             //
             // Register SignalR ...
@@ -268,6 +279,10 @@ namespace xPushService.DI
                 x.PayloadSerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
             });
             
+            //
+            // Register HubContext Factory ...
+            services.AddSingleton<IXHubContextFactory, XHubContextFactory>();
+
             //
             // Register XPushServiceUserNameProvider ...
             services.AddSingleton<IUserIdProvider, XPushServiceUserNameProvider>();

Interfaces/IXBaseDtoProvider.cs

@@ -15,15 +15,16 @@ using xPushService.Base;
 
 namespace xPushService.Interfaces
 {
-    public interface IXBaseDtoProvider<TEntity, TDto, TKey>
+    public interface IXBaseDtoProvider<TEntity, TDto, TKey, THub>
     where TEntity : XBaseEntity<TKey>
     where TDto : XBaseEntityDto<TKey>
+    where THub : XBaseDtoHub<TEntity, TDto, TKey>
     {
         //
         #region Props ...
+        IHubContext<THub> Hub { get; }
         IXIdentityProvider IdentityProvider { get; }
         XDataServiceConfiguration DataConfiguration { get; }
-        IHubContext<XBaseDtoHub<TEntity, TDto, TKey>> Hub { get; }
         IXBaseRepositoryService<TEntity, TDto, TKey> Service { get; }
         #endregion
 

Interfaces/IXBaseEntityProvider.cs

@@ -21,15 +21,16 @@ namespace xPushService.Interfaces
     /// </summary>
     /// <typeparam name="TEntity"></typeparam>
     /// <typeparam name="TKey"></typeparam>
-    public interface IXBaseEntityProviderr<TEntity, TKey>
+    public interface IXBaseEntityProviderr<TEntity, TKey, THub>
     where TEntity : XBaseEntity<TKey>
+    where THub : XBaseEntityHub<TEntity, TKey>
     {
         //
         #region Props ...
+        IHubContext<THub> Hub { get; }
         IXIdentityProvider IdentityProvider { get; }
         IXBaseRepository<TEntity, TKey> Repository { get; }
         XDataServiceConfiguration DataConfiguration { get; }
-        IHubContext<XBaseEntityHub<TEntity, TKey>> Hub { get; }
         #endregion
 
         //

Interfaces/IXBaseRepositoryProviderController.cs

@@ -0,0 +1,200 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore.Query;
+using xModels.Base;
+using xModels.Dtos;
+using xPushService.Base;
+
+namespace xPushService.Interfaces
+{
+    public interface IXBaseRepositoryProviderController<TEntity, TKey, THub>
+    where TEntity : XBaseEntity<TKey>
+    where THub : XBaseEntityHub<TEntity, TKey>
+    {
+        //
+        #region Properties ...
+        IXBaseEntityProviderr<TEntity, TKey, THub> Provider { get; }
+        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> DefaultOrderBuilder { get; }
+        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> DefaultIncludeBuilder { get; }
+        #endregion
+
+        //
+        #region Actions ...
+        /// <summary>
+        /// add a new Item ...
+        /// </summary>
+        /// <param name="item"></param>
+        /// <param name="saveChanges"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [HttpPost]
+        Task<ActionResult<TEntity>> Add(
+            [FromBody] TEntity item,
+            [FromQuery] bool saveChanges = true,
+            CancellationToken cancellationToken = default
+        );
+
+        /// <summary>
+        /// Update an Item values ...
+        /// </summary>
+        /// <param name="id"></param>
+        /// <param name="item"></param>
+        /// <param name="saveChanges"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [HttpPut("{id}")]
+        Task<ActionResult<TEntity>> Update(
+            [FromRoute] TKey id,
+            [FromBody] TEntity item,
+            [FromQuery] bool saveChanges = true,
+            CancellationToken cancellationToken = default
+        );
+
+        /// <summary>
+        /// remove an Item by it's Id ...
+        /// </summary>
+        /// <param name="id"></param>
+        /// <param name="softDelete"></param>
+        /// <param name="saveChanges"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [HttpDelete("{id}")]
+        Task<ActionResult<TEntity>> Remove(
+            [FromRoute] TKey id,
+            [FromQuery] bool softDelete = true,
+            [FromQuery] bool saveChanges = true,
+            CancellationToken cancellationToken = default
+        );
+
+        /// <summary>
+        /// Check an Item exists or not ...
+        /// </summary>
+        /// <param name="id"></param>
+        /// <param name="ignoreSoftDeleteds"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [HttpGet("{id}/[action]")]
+        Task<ActionResult<bool>> IsExists(
+            [FromRoute] TKey id,
+            [FromQuery] bool ignoreSoftDeleteds = true,
+            CancellationToken cancellationToken = default
+        );
+
+        /// <summary>
+        /// count all exists Items ...
+        /// </summary>
+        /// <param name="ignoreSoftDeleteds"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [HttpGet("Count")]
+        Task<ActionResult<long>> Count(
+            [FromQuery] bool ignoreSoftDeleteds = true,
+            CancellationToken cancellationToken = default
+        );
+
+        /// <summary>
+        /// retrieve an Item by it's Id ...
+        /// </summary>
+        /// <param name="id"></param>
+        /// <param name="ignoreSoftDeleteds"></param>
+        /// <param name="useDefaultIncludes"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [HttpGet("{id}")]
+        Task<ActionResult<TEntity>> Get(
+            [FromRoute] TKey id,
+            [FromQuery] bool ignoreSoftDeleteds = true,
+            [FromQuery] bool useDefaultIncludes = false,
+            CancellationToken cancellationToken = default
+        );
+
+        /// <summary>
+        /// retrieve all exists Items ...
+        /// </summary>
+        /// <param name="ignoreSoftDeleteds"></param>
+        /// <param name="useDefaultOrders"></param>
+        /// <param name="useDefaultIncludes"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [HttpGet]
+        Task<ActionResult<IEnumerable<TEntity>>> GetAll(
+            [FromQuery] bool ignoreSoftDeleteds = true,
+            [FromQuery] bool useDefaultOrders = false,
+            [FromQuery] bool useDefaultIncludes = false,
+            CancellationToken cancellationToken = default
+        );
+
+        /// <summary>
+        /// find an Item by providing a Conditional Expression ...
+        /// </summary>
+        /// <param name="query"></param>
+        /// <param name="ignoreSoftDeleteds"></param>
+        /// <param name="useDefaultIncludes"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        Task<ActionResult<TEntity>> FindOne(
+            [FromRoute] string query,
+            [FromQuery] bool ignoreSoftDeleteds = true,
+            [FromQuery] bool useDefaultIncludes = false,
+            CancellationToken cancellationToken = default
+        );
+
+        /// <summary>
+        /// find a collection of Items by proving a Conditional Expression ...
+        /// </summary>
+        /// <param name="query"></param>
+        /// <param name="ignoreSoftDeleteds"></param>
+        /// <param name="useDefaultOrders"></param>
+        /// <param name="useDefaultIncludes"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        Task<ActionResult<IEnumerable<TEntity>>> FindMany(
+            [FromRoute] string query,
+            [FromQuery] bool ignoreSoftDeleteds = true,
+            [FromQuery] bool useDefaultOrders = false,
+            [FromQuery] bool useDefaultIncludes = false,
+            CancellationToken cancellationToken = default
+        );
+
+        /// <summary>
+        /// retrieve Items based on XQuery Pagination structure ...
+        /// </summary>
+        /// <param name="query"></param>
+        /// <param name="ignoreSoftDeleteds"></param>
+        /// <param name="useDefaultOrders"></param>
+        /// <param name="useDefaultIncludes"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        Task<ActionResult<XQueryResult<TEntity>>> Query(
+            [FromQuery] XQuery query,
+            [FromQuery] bool ignoreSoftDeleteds = true,
+            [FromQuery] bool useDefaultOrders = false,
+            [FromQuery] bool useDefaultIncludes = false,
+            CancellationToken cancellationToken = default
+        );
+        #endregion
+
+        //
+        #region Non Actions ...
+        /// <summary>
+        /// Send Custom Push Message ...
+        /// </summary>
+        /// <param name="action"></param>
+        /// <param name="payLoad"></param>
+        /// <param name="connectionId"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [NonAction]
+        Task SendPush(
+            string action,
+            string payLoad,
+            string connectionId = null,
+            CancellationToken cancellationToken = default
+        );
+        #endregion
+    }
+}

Interfaces/IXBaseServiceProviderController.cs

@@ -0,0 +1,201 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore.Query;
+using xModels.Base;
+using xModels.Dtos;
+using xPushService.Base;
+
+namespace xPushService.Interfaces
+{
+    public interface IXBaseServiceProviderController<TEntity, TDto, TKey, THub>
+    where TEntity : XBaseEntity<TKey>
+    where TDto : XBaseEntityDto<TKey>
+    where THub : XBaseDtoHub<TEntity, TDto, TKey>
+    {
+        //
+        #region Properties ...
+        IXBaseDtoProvider<TEntity, TDto, TKey, THub> Provider { get; }
+        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> DefaultOrderBuilder { get; }
+        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> DefaultIncludeBuilder { get; }
+        #endregion
+
+        //
+        #region Actions ...
+        /// <summary>
+        /// add a new Item ...
+        /// </summary>
+        /// <param name="item"></param>
+        /// <param name="saveChanges"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [HttpPost]
+        Task<ActionResult<TDto>> Add(
+            [FromBody] TDto item,
+            [FromQuery] bool saveChanges = true,
+            CancellationToken cancellationToken = default
+        );
+
+        /// <summary>
+        /// Update an Item values ...
+        /// </summary>
+        /// <param name="id"></param>
+        /// <param name="item"></param>
+        /// <param name="saveChanges"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [HttpPut("{id}")]
+        Task<ActionResult<TDto>> Update(
+            [FromRoute] TKey id,
+            [FromBody] TDto item,
+            [FromQuery] bool saveChanges = true,
+            CancellationToken cancellationToken = default
+        );
+
+        /// <summary>
+        /// remove an Item by it's Id ...
+        /// </summary>
+        /// <param name="id"></param>
+        /// <param name="softDelete"></param>
+        /// <param name="saveChanges"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [HttpDelete("{id}")]
+        Task<ActionResult<TDto>> Remove(
+            [FromRoute] TKey id,
+            [FromQuery] bool softDelete = true,
+            [FromQuery] bool saveChanges = true,
+            CancellationToken cancellationToken = default
+        );
+
+        /// <summary>
+        /// Check an Item exists or not ...
+        /// </summary>
+        /// <param name="id"></param>
+        /// <param name="ignoreSoftDeleteds"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [HttpGet("{id}/[action]")]
+        Task<ActionResult<bool>> IsExists(
+            [FromRoute] TKey id,
+            [FromQuery] bool ignoreSoftDeleteds = true,
+            CancellationToken cancellationToken = default
+        );
+
+        /// <summary>
+        /// count all exists Items ...
+        /// </summary>
+        /// <param name="ignoreSoftDeleteds"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [HttpGet("Count")]
+        Task<ActionResult<long>> Count(
+            [FromQuery] bool ignoreSoftDeleteds = true,
+            CancellationToken cancellationToken = default
+        );
+
+        /// <summary>
+        /// retrieve an Item by it's Id ...
+        /// </summary>
+        /// <param name="id"></param>
+        /// <param name="ignoreSoftDeleteds"></param>
+        /// <param name="useDefaultIncludes"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [HttpGet("{id}")]
+        Task<ActionResult<TDto>> Get(
+            [FromRoute] TKey id,
+            [FromQuery] bool ignoreSoftDeleteds = true,
+            [FromQuery] bool useDefaultIncludes = false,
+            CancellationToken cancellationToken = default
+        );
+
+        /// <summary>
+        /// retrieve all exists Items ...
+        /// </summary>
+        /// <param name="ignoreSoftDeleteds"></param>
+        /// <param name="useDefaultOrders"></param>
+        /// <param name="useDefaultIncludes"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [HttpGet]
+        Task<ActionResult<IEnumerable<TDto>>> GetAll(
+            [FromQuery] bool ignoreSoftDeleteds = true,
+            [FromQuery] bool useDefaultOrders = false,
+            [FromQuery] bool useDefaultIncludes = false,
+            CancellationToken cancellationToken = default
+        );
+
+        /// <summary>
+        /// find an Item by providing a Conditional Expression ...
+        /// </summary>
+        /// <param name="query"></param>
+        /// <param name="ignoreSoftDeleteds"></param>
+        /// <param name="useDefaultIncludes"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        Task<ActionResult<TDto>> FindOne(
+            [FromRoute] string query,
+            [FromQuery] bool ignoreSoftDeleteds = true,
+            [FromQuery] bool useDefaultIncludes = false,
+            CancellationToken cancellationToken = default
+        );
+
+        /// <summary>
+        /// find a collection of Items by proving a Conditional Expression ...
+        /// </summary>
+        /// <param name="query"></param>
+        /// <param name="ignoreSoftDeleteds"></param>
+        /// <param name="useDefaultOrders"></param>
+        /// <param name="useDefaultIncludes"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        Task<ActionResult<IEnumerable<TDto>>> FindMany(
+            [FromRoute] string query,
+            [FromQuery] bool ignoreSoftDeleteds = true,
+            [FromQuery] bool useDefaultOrders = false,
+            [FromQuery] bool useDefaultIncludes = false,
+            CancellationToken cancellationToken = default
+        );
+
+        /// <summary>
+        /// retrieve Items based on XQuery Pagination structure ...
+        /// </summary>
+        /// <param name="query"></param>
+        /// <param name="ignoreSoftDeleteds"></param>
+        /// <param name="useDefaultOrders"></param>
+        /// <param name="useDefaultIncludes"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        Task<ActionResult<XQueryResult<TDto>>> Query(
+            [FromQuery] XQuery query,
+            [FromQuery] bool ignoreSoftDeleteds = true,
+            [FromQuery] bool useDefaultOrders = false,
+            [FromQuery] bool useDefaultIncludes = false,
+            CancellationToken cancellationToken = default
+        );
+        #endregion
+
+        //
+        #region Non Actions ...
+        /// <summary>
+        /// Send Custom Push Message ...
+        /// </summary>
+        /// <param name="action"></param>
+        /// <param name="payLoad"></param>
+        /// <param name="connectionId"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        [NonAction]
+        Task SendPush(
+            string action,
+            string payLoad,
+            string connectionId = null,
+            CancellationToken cancellationToken = default
+        );
+        #endregion    
+    }
+}

Interfaces/IXHubContextFactory.cs

@@ -0,0 +1,9 @@
+using Microsoft.AspNetCore.SignalR;
+
+namespace xPushService.Interfaces
+{
+    public interface IXHubContextFactory
+    {
+        IHubContext<THub> Create<THub>() where THub : Hub;
+    }
+}

Providers/XHubContextFactory.cs

@@ -0,0 +1,23 @@
+using System;
+using Microsoft.AspNetCore.SignalR;
+using Microsoft.Extensions.DependencyInjection;
+using xPushService.Interfaces;
+
+namespace xPushService.Providers
+{
+    public class XHubContextFactory : IXHubContextFactory
+    {
+        private readonly IServiceProvider services;
+
+        public XHubContextFactory(IServiceProvider services)
+        {
+            this.services = services;
+        }
+
+        public IHubContext<THub> Create<THub>()
+        where THub : Hub
+        {
+            return services.GetRequiredService<IHubContext<THub>>();
+        }
+    }
+}