xCategoryService/Controllers/XCategoryProviderControllerBase.cs

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 Microsoft.Extensions.Logging;
using xCategoryService.Interfaces;
using xCategoryService.Models.Dtos;
using xCategoryService.Models.Entities;
using xCategoryService.Providers.Dtos;
using xCommons.Configurations;
using xCommons.Extensions;
using xCommons.Providers;
using xExceptions.Constants;
using xIdentityService.Interfaces;
using xModels.Dtos;
using xPushService.Controllers;

namespace xCategoryService.Controllers
{
    public abstract class XCategoryProviderControllerBase : XBaseProvidedController<XCategory, XCategoryDto, int, XCategoryDtoHub>, IXCategoryProviderController
    {
        private readonly IXCategoryProvider provider;

        protected XCategoryProviderControllerBase(
            ILogger<XCategoryProviderControllerBase> logger,
            XAppConfiguration appConfiguration,
            IXIdentityProvider identityProvider,
            XValidationProvider validationProvider,
            IXCategoryProvider provider,
            Func<IQueryable<XCategory>, IOrderedQueryable<XCategory>> defaultOrderBuilder = null,
            Func<IQueryable<XCategory>, IIncludableQueryable<XCategory, object>> defaultIncludeBuilder = null
        ) : base(
            logger,
            appConfiguration,
            identityProvider,
            validationProvider,
            provider,
            defaultOrderBuilder,
            defaultIncludeBuilder
        )
        {
            this.provider = provider;
        }

        //
        #region Overrides ...
        [NonAction]
        [HttpGet("{id}")]
        public override async Task<ActionResult<XCategoryDto>> Get(
            [FromRoute] int id,
            [FromQuery] bool useDefaultIncludes = false,
            CancellationToken cancellationToken = default
        )
        {
            //
            return await base.Get(
                id: id,
                useDefaultIncludes: useDefaultIncludes,
                cancellationToken: cancellationToken
            );
        }

        [NonAction]
        [HttpGet("")]
        public override async Task<ActionResult<IEnumerable<XCategoryDto>>> GetAll(
            [FromQuery] bool useDefaultOrders = false,
            [FromQuery] bool useDefaultIncludes = false,
            CancellationToken cancellationToken = default
        )
        {
            //
            return await base.GetAll(
                useDefaultOrders: useDefaultOrders,
                cancellationToken: cancellationToken,
                useDefaultIncludes: useDefaultIncludes
            );
        }

        [NonAction]
        [HttpGet("Find/One")]
        public override async Task<ActionResult<XCategoryDto>> FindOne(
            [FromRoute] string query,
            [FromQuery] bool useDefaultIncludes = false,
            CancellationToken cancellationToken = default
        )
        {
            //
            return await base.FindOne(
                query: query,
                cancellationToken: cancellationToken,
                useDefaultIncludes: useDefaultIncludes
            );
        }

        [NonAction]
        [HttpGet("Find/Many")]
        public override async Task<ActionResult<IEnumerable<XCategoryDto>>> FindMany(
            [FromRoute] string query,
            [FromQuery] bool useDefaultOrders = false,
            [FromQuery] bool useDefaultIncludes = false,
            CancellationToken cancellationToken = default
        )
        {
            //
            return await base.FindMany(
                query: query,
                useDefaultOrders: useDefaultOrders,
                cancellationToken: cancellationToken,
                useDefaultIncludes: useDefaultIncludes
            );
        }

        [NonAction]
        [HttpGet("Query")]
        public override async Task<ActionResult<XQueryResult<XCategoryDto>>> Query(
            [FromQuery] XQuery query,
            [FromQuery] bool useDefaultOrders = false,
            [FromQuery] bool useDefaultIncludes = false,
            CancellationToken cancellationToken = default
        )
        {
            //
            return await base.Query(
                query: query,
                useDefaultOrders: useDefaultOrders,
                cancellationToken: cancellationToken,
                useDefaultIncludes: useDefaultIncludes
            );
        }

        [NonAction]
        [HttpGet("Query/Owned")]
        public override async Task<ActionResult<XQueryResult<XCategoryDto>>> QueryOwned(
            [FromQuery] XQuery query,
            [FromQuery] bool useDefaultOrders = false,
            [FromQuery] bool useDefaultIncludes = false,
            CancellationToken cancellationToken = default
        )
        {
            //
            return await base.QueryOwned(
                query: query,
                useDefaultOrders: useDefaultOrders,
                cancellationToken: cancellationToken,
                useDefaultIncludes: useDefaultIncludes
            );
        }

        [NonAction]
        [HttpPost("")]
        public override async Task<ActionResult<XCategoryDto>> Add(
            [FromBody] XCategoryDto item,
            CancellationToken cancellationToken = default
        )
        {
            //
            return await base.Add(
                item: item,
                cancellationToken: cancellationToken
            );
        }

        [NonAction]
        [HttpPut("{id}")]
        public override async Task<ActionResult<XCategoryDto>> Update(
            [FromRoute] int id,
            [FromBody] XCategoryDto item,
            CancellationToken cancellationToken = default
        )
        {
            //
            return await base.Update(
                id: id,
                item: item,
                cancellationToken: cancellationToken
            );
        }

        [NonAction]
        [HttpDelete("{id}")]
        public override async Task<ActionResult<XCategoryDto>> Remove(
            [FromRoute] int id,
            CancellationToken cancellationToken = default
        )
        {
            //
            return await base.Remove(
                id: id,
                cancellationToken: cancellationToken
            );
        }
        #endregion

        //
        #region Actions ...
        /// <summary>
        /// Check Has Specified Locale or not ...
        /// </summary>
        /// <param name="id"></param>
        /// <param name="language"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpGet("Resources/{id}/HasLocale")]
        public virtual async Task<ActionResult<bool>> HasLocale(
            [FromRoute] int id,
            [FromQuery] string language,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (!ModelState.IsValid ||
                    !id.IsValidIntId())
                {
                    XException.InvalidArgs.Throw();
                }
                ValidationProvider.NotEmpty(language);

                //
                var result = await provider.HasLocale(
                    id: id,
                    language: language,
                    cancellationToken: cancellationToken
                );

                //
                return Ok(result);
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);
                return result;
            }
        }

        /// <summary>
        /// Load an Item by all of it's Related Translations ...
        /// </summary>
        /// <param name="id"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpGet("Resources/{id}")]
        public virtual async Task<ActionResult<XCategoryResourceDto>> GetResource(
            [FromRoute] int id,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (!ModelState.IsValid ||
                    !id.IsValidIntId())
                {
                    XException.InvalidArgs.Throw();
                }

                //
                var result = await provider.GetResource(
                    id: id,
                    cancellationToken: cancellationToken
                );

                //
                return Ok(result.ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);
                return result;
            }
        }

        /// <summary>
        /// Add Category Item for Specified Language ...
        /// </summary>
        /// <param name="item"></param>
        /// <param name="language"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpPost("Resources")]
        public virtual async Task<ActionResult<XCategoryResourceDto>> Add(
            [FromBody] XCategoryDto item,
            [FromQuery] string language = null,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotNull(item)
                    .AddNotEmpty(language)
                    .AddNotEmpty(item.Title)
                    .AddNotEmpty(item.Description)
                    .ValidateGroupAsync();

                //
                // Reading Requirements ...
                var userInfo = await GetUserInfo();
                var connectionId = GetConnectionId();

                //
                var result = await provider.Add(
                    item: item,
                    language: language,
                    userInfo: userInfo,
                    connectionId: connectionId,
                    cancellationToken: cancellationToken
                );

                //
                return Ok(result.ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);
                return result;
            }
        }

        /// <summary>
        /// Add Category Item for by It's Locales ...
        /// </summary>
        /// <param name="item"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpPost("Resources/AddResource")]
        public virtual async Task<ActionResult<XCategoryResourceDto>> AddResource(
            [FromBody] XCategoryResourceDto item,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotNull(item)
                    .AddNotNull(item.Titles)
                    .AddNotZeroChilds(item.Titles.Locales)
                    .ValidateGroupAsync();

                //
                // Reading Requirements ...
                var userInfo = await GetUserInfo();
                var connectionId = GetConnectionId();

                //
                var result = await provider.AddResource(
                    item: item,
                    userInfo: userInfo,
                    connectionId: connectionId,
                    cancellationToken: cancellationToken
                );

                //
                return Ok(result.ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);
                return result;
            }
        }

        /// <summary>
        /// Remove Item for Specified Language ...
        /// </summary>
        /// <param name="id"></param>
        /// <param name="language">if null, Remove All</param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpDelete("Resources/{id}")]
        public virtual async Task<ActionResult<XCategoryResourceDto>> Remove(
            [FromRoute] int id,
            [FromQuery] string language = null,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (!ModelState.IsValid ||
                    !id.IsValidIntId())
                {
                    XException.InvalidArgs.Throw();
                }

                //
                // Reading Requirements ...
                var userInfo = await GetUserInfo();
                var connectionId = GetConnectionId();

                //
                var result = await provider.Remove(
                    id: id,
                    language: language,
                    userInfo: userInfo,
                    connectionId: connectionId,
                    cancellationToken: cancellationToken
                );

                //
                return Ok(result.ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);
                return result;
            }            
        }

        /// <summary>
        /// Update a Category Item for Specified Language ...
        /// </summary>
        /// <param name="id"></param>
        /// <param name="item"></param>
        /// <param name="language"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpPut("Resources/{id}")]
        public virtual async Task<ActionResult<XCategoryResourceDto>> Update(
            [FromRoute] int id,
            [FromBody] XCategoryDto item,
            [FromQuery] string language = null,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (!ModelState.IsValid ||
                    !id.IsValidIntId())
                {
                    XException.InvalidArgs.Throw();
                }
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotNull(item)
                    .AddNotEmpty(language)
                    .AddNotEmpty(item.Title)
                    .AddNotEmpty(item.Description)
                    .ValidateGroupAsync();

                //
                // Reading Requirements ...
                var userInfo = await GetUserInfo();
                var connectionId = GetConnectionId();

                //
                var result = await provider.Update(
                    id: id,
                    item: item,
                    language: language,
                    userInfo: userInfo,
                    connectionId: connectionId,
                    cancellationToken: cancellationToken
                );

                //
                return Ok(result.ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);
                return result;
            }
        }

        /// <summary>
        /// Refresh a Resource ...
        /// </summary>
        /// <param name="resource"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpPost("Resources/Refresh")]
        public virtual async Task<ActionResult<XCategoryResourceDto>> Refresh(
            [FromBody] XCategoryResourceDto resource,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotNull(resource)
                    .AddNotNull(resource.Item)
                    .ValidateGroupAsync();

                //
                // Reading Requirements ...
                var userInfo = await GetUserInfo();
                var connectionId = GetConnectionId();

                //
                var result = await provider.Refresh(
                    resource: resource,
                    userInfo: userInfo,
                    connectionId: connectionId,
                    cancellationToken: cancellationToken
                );

                //
                return Ok(result.ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);
                return result;
            }
        }

        /// <summary>
        /// Get All Resources ...
        /// </summary>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpGet("Resources/All")]
        public virtual async Task<ActionResult<IEnumerable<XCategoryResourceDto>>> GetAllResources(
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }

                //
                var result = await provider.GetAllResources(
                    cancellationToken: cancellationToken
                );

                //
                return Ok(result.ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);
                return result;
            }
        }

        /// <summary>
        /// Find One Resource ...
        /// </summary>
        /// <param name="query"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpGet("Resources/Find/One")]
        public virtual async Task<ActionResult<XCategoryResourceDto>> FindOneResource(
            [FromQuery] string query,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotEmpty(query)
                    .ValidateGroupAsync();

                //
                var result = await provider.FindOneResource(
                    cancellationToken: cancellationToken,
                    predicate: x => x.PropValuesContains(query)
                );

                //
                return Ok(result.ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);
                return result;
            }
        }

        /// <summary>
        /// Find Many Resource ...
        /// </summary>
        /// <param name="query"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpGet("Resources/Find/Many")]
        public virtual async Task<ActionResult<IEnumerable<XCategoryResourceDto>>> FindManyResource(
            [FromQuery] string query,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotEmpty(query)
                    .ValidateGroupAsync();

                //
                var result = await provider.FindManyResource(
                    cancellationToken: cancellationToken,
                    predicate: x => x.PropValuesContains(query),
                    orderBuilder: x => x.OrderBy(y => y.Item.Id)
                );

                //
                return Ok(result.ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);
                return result;
            }
        }

        /// <summary>
        /// Retrieve Resources by Query Pattern ...
        /// </summary>
        /// <param name="query"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpGet("Resources/Query")]
        public virtual async Task<ActionResult<XQueryResult<XCategoryResourceDto>>> QueryResources(
            [FromQuery] XQuery query = null,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotNull(query)
                    .ValidateGroupAsync();

                //
                var result = await provider.QueryResources(
                    query: query,
                    predicate: null,
                    cancellationToken: cancellationToken,
                    orderBuilder: x => x.OrderBy(y => y.Item.Id)
                );

                //
                return Ok(result.ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);
                return result;
            }
        }
        #endregion
    }
}