xPushService/Providers/XBaseProvided.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore.Query;
using xCommons.Extensions;
using xExceptions.Constants;
using xIdentityModels.Extensions;
using xIdentityModels.Models;
using xModels.Base;
using xModels.Dtos;
using xPushService.Base;
using xPushService.Interfaces;

namespace xPushService.Providers
{
    /// <summary>
    /// a Provided Service Used for Providing Data Based on Validations of Users ...
    /// </summary>
    /// <typeparam name="TEntity"></typeparam>
    /// <typeparam name="TDto"></typeparam>
    /// <typeparam name="TKey"></typeparam>
    /// <typeparam name="THub"></typeparam>
    public abstract class XBaseProvided<TEntity, TDto, TKey, THub> : IXBaseProvided<TEntity, TDto, TKey, THub>
    where TEntity : XBaseEntity<TKey>
    where TDto : XBaseEntityDto<TKey>
    where THub : XBaseDtoHub<TEntity, TDto, TKey>
    {
        //
        #region Props ...
        private readonly string[] permittedRoles;
        private readonly IXBaseDtoProvider<TEntity, TDto, TKey, THub> provider;
        #endregion

        //
        #region Constructor ...
        protected XBaseProvided(
            IXBaseDtoProvider<TEntity, TDto, TKey, THub> provider,
            string[] permittedRoles = null
        )
        {
            this.provider = provider;
            this.permittedRoles = permittedRoles;
        }
        #endregion

        /// <summary>
        /// Check an Items is Owned for User or not ...
        /// </summary>
        /// <param name="item"></param>
        /// <param name="userInfo"></param>
        /// <returns></returns>
        public abstract bool IsOwned(
            TDto item,
            XUserClaimsInfoDto userInfo
        );
        public abstract bool IsOwned(
            TEntity item,
            XUserClaimsInfoDto userInfo
        );

        /// <summary>
        /// Check User Has Permission for Manipulate Data or not ...
        /// </summary>
        /// <param name="userInfo"></param>
        /// <returns></returns>
        public bool HasPermision(
            XUserClaimsInfoDto userInfo
        )
        {
            //
            var result =
                !permittedRoles.HasChild() ||
                (!userInfo.IsNullOrDefault() &&
                userInfo.HasAccess(permittedRoles));

            //
            return result;
        }

        //
        #region Provided Actions ...
        /// <summary>
        /// Get Specified Item by ID ...
        /// </summary>
        /// <param name="id"></param>
        /// <param name="includeBuilder"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task<TDto> Get(
            TKey id,
            Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> includeBuilder = null,
            CancellationToken cancellationToken = default
        )
        {
            //
            var result = await provider.GetAsync(
                id: id,
                includeBuilder: null,
                ignoreSoftDeleteds: true,
                cancellationToken: cancellationToken
            );

            //
            return result;
        }

        /// <summary>
        /// Get All Exists Items ...
        /// </summary>
        /// <param name="orderBuilder"></param>
        /// <param name="includeBuilder"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task<IEnumerable<TDto>> GetAll(
            Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBuilder = null,
            Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> includeBuilder = null,
            CancellationToken cancellationToken = default
        )
        {
            //
            var result = await provider.GetAllAsync(
                ignoreSoftDeleteds: true,
                orderBuilder: orderBuilder,
                includeBuilder: includeBuilder,
                cancellationToken: cancellationToken
            );

            //
            return result;
        }

        /// <summary>
        /// find an item by providing a Conditional Expression ...
        /// </summary>
        /// <param name="predicate"></param>
        /// <param name="includeBuilder"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task<TDto> FindOne(
            Expression<Func<TEntity, bool>> predicate,
            Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> includeBuilder = null,
            CancellationToken cancellationToken = default
        )
        {
            //
            var result = await provider.FindOneAsync(
                predicate: predicate,
                ignoreSoftDeleteds: true,
                includeBuilder: includeBuilder,
                cancellationToken: cancellationToken
            );

            //
            return result;
        }

        /// <summary>
        /// find a collection of Items by proving a Conditional Expression ...
        /// </summary>
        /// <param name="predicate"></param>
        /// <param name="orderBuilder"></param>
        /// <param name="includeBuilder"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task<IEnumerable<TDto>> FindMany(
            Expression<Func<TEntity, bool>> predicate,
            Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBuilder = null,
            Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> includeBuilder = null,
            CancellationToken cancellationToken = default
        )
        {
            //
            var result = await provider.FindManyAsync(
                predicate: predicate,
                ignoreSoftDeleteds: true,
                orderBuilder: orderBuilder,
                includeBuilder: includeBuilder,
                cancellationToken: cancellationToken
            );

            //
            return result;
        }

        /// <summary>
        /// retrieve Items based on XQuery Pagination structure ...
        /// </summary>
        /// <param name="query"></param>
        /// <param name="predicate"></param>
        /// <param name="orderBuilder"></param>
        /// <param name="includeBuilder"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task<XQueryResult<TDto>> Query(
            XQuery query,
            Expression<Func<TEntity, bool>> predicate = null,
            Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBuilder = null,
            Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> includeBuilder = null,
            CancellationToken cancellationToken = default
        )
        {
            //
            var result = await provider.QueryAsync(
                query: query,
                predicate: predicate,
                ignoreSoftDeleteds: true,
                orderBuilder: orderBuilder,
                includeBuilder: includeBuilder,
                cancellationToken: cancellationToken
            );

            //
            return result;
        }

        /// <summary>
        /// retrieve Owned Items based on XQuery Pagination structure ...
        /// if supported ...
        /// </summary>
        /// <param name="query"></param>
        /// <param name="userInfo"></param>
        /// <param name="predicate"></param>
        /// <param name="orderBuilder"></param>
        /// <param name="includeBuilder"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task<XQueryResult<TDto>> QueryOwned(
            XQuery query,
            XUserClaimsInfoDto userInfo = null,
            Expression<Func<TEntity, bool>> predicate = null,
            Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBuilder = null,
            Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> includeBuilder = null,
            CancellationToken cancellationToken = default
        )
        {
            //
            Expression<Func<TEntity, bool>> predicateor = null;
            if (!predicate.IsNull())
            {
                //
                var predicateFnc = predicate.Compile();
                predicateor = x =>
                    predicateFnc(x) &&
                    IsOwned(x, userInfo);
            }
            else
            {
                predicateor = x => IsOwned(x, userInfo);
            }

            //
            var result = await provider.QueryAsync(
                query: query,
                predicate: predicateor,
                ignoreSoftDeleteds: true,
                orderBuilder: orderBuilder,
                includeBuilder: includeBuilder,
                cancellationToken: cancellationToken
            );

            //
            return result;
        }

        /// <summary>
        /// Add an item values ...
        /// </summary>
        /// <param name="item"></param>
        /// <param name="userInfo"></param>
        /// <param name="connectionId"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task<TDto> Add(
            TDto item,
            XUserClaimsInfoDto userInfo = null,
            string connectionId = null,
            CancellationToken cancellationToken = default
        )
        {
            //
            var result = await provider.AddAsync(
                item: item,
                saveChanges: true,
                connectionId: connectionId,
                cancellationToken: cancellationToken
            );

            //
            return result;
        }

        /// <summary>
        /// Update an item values ...
        /// </summary>
        /// <param name="id"></param>
        /// <param name="item"></param>
        /// <param name="userInfo"></param>
        /// <param name="connectionId"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task<TDto> Update(
            TKey id,
            TDto item,
            XUserClaimsInfoDto userInfo = null,
            string connectionId = null,
            CancellationToken cancellationToken = default
        )
        {
            //
            // Check Permission ...
            var hasPermission =
                IsOwned(item, userInfo) ||
                HasPermision(userInfo);
            if (!hasPermission)
            {
                XException.NotAllowed.Throw();
            }

            //
            var result = await provider.UpdateAsync(
                id: id,
                item: item,
                saveChanges: true,
                connectionId: connectionId,
                cancellationToken: cancellationToken
            );

            //
            return result;
        }

        /// <summary>
        /// remove an Item ...
        /// </summary>
        /// <param name="id"></param>
        /// <param name="userInfo"></param>
        /// <param name="connectionId"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task<TDto> Remove(
            TKey id,
            XUserClaimsInfoDto userInfo = null,
            string connectionId = null,
            CancellationToken cancellationToken = default
        )
        {
            //
            // Check Permission ...
            var item = await Get(
                id: id,
                cancellationToken: cancellationToken
            );
            var hasPermission =
                IsOwned(item, userInfo) ||
                HasPermision(userInfo);
            if (!hasPermission)
            {
                XException.NotAllowed.Throw();
            }

            //
            var result = await provider.RemoveAsync(
                id: id,
                saveChanges: true,
                softDelete: false,
                connectionId: connectionId,
                cancellationToken: cancellationToken
            );

            //
            return result;
        }

        /// <summary>
        /// count all exists Items ...
        /// </summary>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task<int> Count(
            CancellationToken cancellationToken = default
        )
        {
            //
            var result = await provider.CountAsync(
                ignoreSoftDeleteds: true,
                cancellationToken: cancellationToken
            );

            //
            return result;
        }

        /// <summary>
        /// Check an Item exists or not ...
        /// </summary>
        /// <param name="id"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task<bool> IsExists(
            TKey id,
            CancellationToken cancellationToken = default
        )
        {
            //
            var result = await provider.IsExistsAsync(
                id: id,
                cancellationToken: cancellationToken
            );

            //
            return result;
        }
        #endregion
    }
}