xSaherElmAiApi/Controllers/V1/Entities/TestsController.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.SignalR;
using Microsoft.EntityFrameworkCore.Query;
using Microsoft.Extensions.Logging;
using xAiApi.Base;
using xAiApi.Data.Interfaces;
using xAiApi.Data.Models.Entities;
using xCommons.Configurations;
using xCommons.Extensions;
using xCommons.Providers;
using xIdentityHelper;
using xIdentityService.Interfaces;
using xModels.Base;
using xModels.Dtos;
using xPushService.Base;
using xPushService.Constants;

namespace xAiApi.Controllers.V1.Entities
{
    /// <summary>
    /// Simple XTest Entity Controller ...
    /// </summary>
    public class TestsController : XIBaseV1EntityHubController<XTest, int>
    {
        //
        #region Constructor ...
        public TestsController(
            ILogger<TestsController> logger,
            XAppConfiguration appConfiguration,
            IXIdentityProvider identityProvider,
            XValidationProvider validationProvider,
            IXTestRepository repository,
            IHubContext<XBaseEntityHub<XTest, int>> hub = null,
            Func<IQueryable<XTest>, IOrderedQueryable<XTest>> defaultOrderBuilder = null,
            Func<IQueryable<XTest>, IIncludableQueryable<XTest, object>> defaultIncludeBuilder = null
        ) : base(
            hub: hub,
            logger: logger,
            repository: repository,
            appConfiguration: appConfiguration,
            identityProvider: identityProvider,
            validationProvider: validationProvider,
            defaultOrderBuilder: defaultOrderBuilder,
            defaultIncludeBuilder: defaultIncludeBuilder
        )
        { }
        #endregion

        //
        #region Actions ...
        //
        #region Add ...
        /// <summary>
        /// Add Specified Item ...
        /// </summary>
        /// <remarks>
        /// Sample request:
        /// 
        ///     {
        ///         "title": ""
        ///     }
        /// 
        /// </remarks>
        /// <param name="item"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpPost]
        [Authorize(Policy = XPolicies.EnabledAdminOrAgent)]
        public override async Task<ActionResult<XTest>> Add(
            [FromBody] XTest item,
            CancellationToken cancellationToken = default
        )
        {
            //
            var entity = await base
                .Add(
                    item: item,
                    cancellationToken: cancellationToken
                );

            //
            // Handle Sending Push Notification ...
            if (!entity.IsNullOrDefault())
            {
                //
                await SendPush(
                    payLoad: entity.ToJSON(),
                    cancellationToken: cancellationToken,
                    action: XBaseEntityHubAction.Add.GetStringValue()
                );
            }

            //
            return entity;
        }

        /// <summary>
        /// Update Specified Item ...
        /// </summary>
        /// <remarks>
        /// Sample request:
        /// 
        ///     {
        ///         "title": ""
        ///     }
        /// 
        /// </remarks>
        /// <param name="item"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpPost("AddOrUpdate")]
        [Authorize(Policy = XPolicies.EnabledAdminOrAgent)]
        public override async Task<ActionResult<XTest>> AddOrUpdate(
            [FromBody] XTest item,
            CancellationToken cancellationToken = default
        )
        {
            //
            var entity = await base
                .AddOrUpdate(
                    item: item,
                    cancellationToken: cancellationToken
                );

            //
            // Handle Sending Push Notification ...
            if (!entity.IsNullOrDefault())
            {
                //
                await SendPush(
                    payLoad: entity.ToJSON(),
                    cancellationToken: cancellationToken,
                    action: XBaseEntityHubAction.AddOrUpdate.GetStringValue()
                );
            }

            //
            return entity;
        }

        /// <summary>
        /// Add Many Specified Items ...
        /// </summary>
        /// <remarks>
        /// Sample request:
        ///     
        ///     {
        ///         "items": [
        ///              {
        ///                  "title": ""
        ///              }
        ///         ]
        ///     }
        /// 
        /// </remarks>
        /// <param name="request"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpPost("AddMany")]
        [Authorize(Policy = XPolicies.EnabledAdminOrAgent)]
        public override async Task<ActionResult> AddMany(
            [FromBody] XBaseRangeRequest<XTest> request,
            CancellationToken cancellationToken = default
        )
        {
            //
            var result = await base
                .AddMany(
                    request: request,
                    cancellationToken: cancellationToken
                );

            //
            if (!(result as OkObjectResult).IsNull())
            {
                //
                await SendPush(
                    payLoad: request.Items.ToJSON(),
                    cancellationToken: cancellationToken,
                    action: XBaseEntityHubAction.AddMany.GetStringValue()
                );
            }

            //
            return result;
        }
        #endregion

        //
        #region Retrieve ...
        /// <summary>
        /// Get Specified Item by Providing Identifier ...
        /// </summary>
        /// <param name="id"></param>
        /// <param name="ignoreSoftDeleteds"></param>
        /// <param name="useDefaultIncludes"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpGet("{id}")]
        [Authorize(Policy = XPolicies.EnabledUser)]
        public override async Task<ActionResult<XTest>> Get(
            [FromRoute] int id,
            [FromQuery] bool ignoreSoftDeleteds = true,
            [FromQuery] bool useDefaultIncludes = false,
            CancellationToken cancellationToken = default
        )
        {
            //
            return await base
                .Get(
                    id: id,
                    cancellationToken: cancellationToken,
                    ignoreSoftDeleteds: ignoreSoftDeleteds,
                    useDefaultIncludes: useDefaultIncludes
                );
        }

        /// <summary>
        /// Get all Exists Items ...
        /// </summary>
        /// <param name="ignoreSoftDeleteds"></param>
        /// <param name="useDefaultOrders"></param>
        /// <param name="useDefaultIncludes"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpGet]
        [Authorize(Policy = XPolicies.EnabledUser)]
        public override async Task<ActionResult<IEnumerable<XTest>>> GetAll(
            [FromQuery] bool ignoreSoftDeleteds = true,
            [FromQuery] bool useDefaultOrders = false,
            [FromQuery] bool useDefaultIncludes = false,
            CancellationToken cancellationToken = default
        )
        {
            //
            return await base
                .GetAll(
                    useDefaultOrders: useDefaultOrders,
                    cancellationToken: cancellationToken,
                    ignoreSoftDeleteds: ignoreSoftDeleteds,
                    useDefaultIncludes: useDefaultIncludes
                );
        }

        /// <summary>
        /// Find Item based on Provided Query ....
        /// </summary>
        /// <param name="query"></param>
        /// <param name="ignoreSoftDeleteds"></param>
        /// <param name="useDefaultIncludes"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpGet("FindOne/{query}")]
        [Authorize(Policy = XPolicies.EnabledUser)]
        public override async Task<ActionResult<XTest>> FindOne(
            [FromRoute] string query,
            [FromQuery] bool ignoreSoftDeleteds = true,
            [FromQuery] bool useDefaultIncludes = false,
            CancellationToken cancellationToken = default
        )
        {
            //
            return await base
                .FindOne(
                    query: query,
                    cancellationToken: cancellationToken,
                    ignoreSoftDeleteds: ignoreSoftDeleteds,
                    useDefaultIncludes: useDefaultIncludes
                );
        }

        /// <summary>
        /// Find Items based on Provided Query ...
        /// </summary>
        /// <param name="query"></param>
        /// <param name="ignoreSoftDeleteds"></param>
        /// <param name="useDefaultOrders"></param>
        /// <param name="useDefaultIncludes"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpGet("FindMany/{query}")]
        [Authorize(Policy = XPolicies.EnabledUser)]
        public override async Task<ActionResult<IEnumerable<XTest>>> FindMany(
            [FromRoute] string query,
            [FromQuery] bool ignoreSoftDeleteds = true,
            [FromQuery] bool useDefaultOrders = false,
            [FromQuery] bool useDefaultIncludes = false,
            CancellationToken cancellationToken = default
        )
        {
            //
            return await base
                .FindMany(
                    query: query,
                    useDefaultOrders: useDefaultOrders,
                    cancellationToken: cancellationToken,
                    ignoreSoftDeleteds: ignoreSoftDeleteds,
                    useDefaultIncludes: useDefaultIncludes
                );
        }

        /// <summary>
        /// Retrieve Items based on Query Mechanism ...  
        /// </summary>
        /// <param name="query"></param>
        /// <param name="ignoreSoftDeleteds"></param>
        /// <param name="useDefaultOrders"></param>
        /// <param name="useDefaultIncludes"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpGet("Query")]
        [Authorize(Policy = XPolicies.EnabledUser)]
        public override async Task<ActionResult<XQueryResult<XTest>>> Query(
            [FromQuery] XQuery query,
            [FromQuery] bool ignoreSoftDeleteds = true,
            [FromQuery] bool useDefaultOrders = false,
            [FromQuery] bool useDefaultIncludes = false,
            CancellationToken cancellationToken = default
        )
        {
            //
            return await base
                .Query(
                    query: query,
                    useDefaultOrders: useDefaultOrders,
                    cancellationToken: cancellationToken,
                    ignoreSoftDeleteds: ignoreSoftDeleteds,
                    useDefaultIncludes: useDefaultIncludes
                );
        }
        #endregion

        //
        #region Update ...
        /// <summary>
        /// Update an Item ...
        /// </summary>
        /// <remarks>
        /// Sample request:
        /// 
        ///     {
        ///         "title": ""
        ///     }
        /// 
        /// </remarks>
        /// <param name="id"></param>
        /// <param name="item"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpPut("{id}")]
        [Authorize(Policy = XPolicies.EnabledAdminOrAgent)]
        public override async Task<ActionResult<XTest>> Update(
            [FromRoute] int id,
            [FromBody] XTest item,
            CancellationToken cancellationToken = default
        )
        {
            //
            var entity = await base
                .Update(
                    id: id,
                    item: item,
                    cancellationToken: cancellationToken
                );

            //
            if (!entity.IsNullOrDefault())
            {
                //
                await SendPush(
                    payLoad: entity.ToJSON(),
                    cancellationToken: cancellationToken,
                    action: XBaseEntityHubAction.Update.GetStringValue()
                );
            }

            //
            return entity;
        }

        /// <summary>
        /// Update a Collection of Items ...
        /// </summary>
        /// <remarks>
        /// Sample request:
        ///     
        ///     {
        ///         "items": [
        ///              {
        ///                  "id": 1,
        ///                  "title": "Hi there ..."
        ///              }
        ///         ]
        ///     }
        /// 
        /// </remarks>
        /// <param name="request"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpPost("UpdateMany")]
        [Authorize(Policy = XPolicies.EnabledAdminOrAgent)]
        public override async Task<ActionResult<bool>> UpdateMany(
            [FromBody] XBaseRangeRequest<XTest> request,
            CancellationToken cancellationToken = default
        )
        {
            //
            var result = await base
                .UpdateMany(
                    request: request,
                    cancellationToken: cancellationToken
                );

            //
            var resultObject = (result.Result as OkObjectResult).Value;
            if (!resultObject.IsNull() && (bool)resultObject)
            {
                //
                await SendPush(
                    payLoad: request.Items.ToJSON(),
                    cancellationToken: cancellationToken,
                    action: XBaseEntityHubAction.UpdateMany.GetStringValue()
                );
            }

            //
            return result;
        }
        #endregion

        //
        #region Exists ...
        /// <summary>
        /// Check an Item Exists or not ...
        /// </summary>
        /// <param name="id"></param>
        /// <param name="ignoreSoftDeleteds"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpGet("{id}/IsExists")]
        [Authorize(Policy = XPolicies.EnabledUser)]
        public override async Task<ActionResult<bool>> IsExists(
            [FromRoute] int id,
            [FromQuery] bool ignoreSoftDeleteds = true,
            CancellationToken cancellationToken = default
        )
        {
            //
            return await base
                .IsExists(
                    id: id,
                    cancellationToken: cancellationToken,
                    ignoreSoftDeleteds: ignoreSoftDeleteds
                );
        }
        #endregion

        //
        #region Remove ...
        /// <summary>
        /// Remove an Item ...
        /// </summary>
        /// <param name="id"></param>
        /// <param name="softDelete"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpDelete("{id}")]
        [Authorize(Policy = XPolicies.EnabledAdminOrAgent)]
        public override async Task<ActionResult<XTest>> Remove(
            [FromRoute] int id,
            [FromQuery] bool softDelete = true,
            CancellationToken cancellationToken = default
        )
        {
            //
            var entity = await base
                .Remove(
                    id: id,
                    softDelete: softDelete,
                    cancellationToken: cancellationToken
                );

            //
            if (!entity.IsNullOrDefault())
            {
                //
                await SendPush(
                    payLoad: entity.ToJSON(),
                    cancellationToken: cancellationToken,
                    action: XBaseEntityHubAction.Delete.GetStringValue()
                );
            }

            //
            return entity;
        }

        /// <summary>
        /// Remove Many Items ...
        /// </summary>
        /// <remarks>
        /// Sample request:
        ///     
        ///     {
        ///         "items": [
        ///              {
        ///                  "id": 1,
        ///                  "title": "Hi there ..."
        ///              }
        ///         ]
        ///     }
        /// 
        /// </remarks>
        /// <param name="request"></param>
        /// <param name="softDelete"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpPost("RemoveMany")]
        [Authorize(Policy = XPolicies.EnabledAdminOrAgent)]
        public override async Task<ActionResult> RemoveMany(
            [FromBody] XBaseRangeRequest<XTest> request,
            [FromQuery] bool softDelete = true,
            CancellationToken cancellationToken = default
        )
        {
            //
            var result = await base
                .RemoveMany(
                    request: request,
                    softDelete: softDelete,
                    cancellationToken: cancellationToken
                );

            //
            if (!(result as OkObjectResult).IsNull())
            {
                //
                await SendPush(
                    payLoad: request.Items.ToJSON(),
                    cancellationToken: cancellationToken,
                    action: XBaseEntityHubAction.DeleteMany.GetStringValue()
                );
            }

            //
            return result;
        }
        #endregion
        #endregion  
    }
}