HealthMonitor/HealthMonitor.WebApi/Controllers/Base/HealthMonitorControllerBase.cs

using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Linq.Expressions;
using System.Threading.Tasks;
using HealthMonitor.Core.Aop;
using HealthMonitor.Core.Cache;
using HealthMonitor.Core.Dal;
//using HealthMonitor.Core.Dal.Factory;
using HealthMonitor.Core.Operator;
using HealthMonitor.Core.Query;
using HealthMonitor.Core.Query.Extensions;
using HealthMonitor.Util.Common;
using HealthMonitor.Util.Common.Operator;
using HealthMonitor.Util.Entities.Base;
using HealthMonitor.Util.Models;
using HealthMonitor.Util.QueryObjects;
using HealthMonitor.WebApi.Filters;
using IoTSharp.Data.Taos;

namespace HealthMonitor.WebApi.Controllers.Base
{
	[Produces("application/json")]
	[Route("api/HealthMonitor/[controller]/[action]")]
	[ApiController]
	public abstract class HealthMonitorControllerBase<T> : DefaultControllerBase<T> where T : HealthMonitorEntityBase
    {
        //protected readonly GpsCardAccessorFactory _accessorFactory;
        //protected readonly IGpsCardDataAccessor _dataAccessor;
        //protected readonly IGpsCardOperatorManager _operatorGpsCardManager;
        protected readonly IHealthMonitorDataAccessor _dataAccessor;
        protected readonly IHealthMonitorOperatorManager _operatorManager;
        protected readonly IDurableEntityManager _durableManager;
		protected readonly ILogger _logger;

		protected HealthMonitorControllerBase(
            IHealthMonitorDataAccessor dataAccessor,
            //IGpsCardDataAccessor gpsCardDataAccessor,
            IHealthMonitorOperatorManager operatorGpsCardManager, 
            IDurableEntityManager durableManager,
			ILogger logger)
		{
            _dataAccessor = dataAccessor;
            _operatorManager = operatorGpsCardManager;
			_durableManager = durableManager;
			_logger = logger;
		}

		/// <summary>
		/// 通过主键值，获取实体
		/// </summary>
		/// <param name="id"></param>
		/// <param name="requestId">关联服务标识</param>
		/// <returns></returns>
		[HttpGet]
        //[QueryCacheInterceptor]
        public async virtual Task<T> GetById([Required] string id, [FromHeader] string requestId)
		{
			AssertModelStateIsValid();

			//var key = EntityUtils.GetWrapKeyValue<T>(id);
			return await _dataAccessor.GetByIDAsync<T>(id);
		}

        /// <summary>
        /// 通过查询条件，获取符合条件的第一个实体
        /// </summary>
        /// <param name="conditions"></param>
        /// <param name="requestId">关联服务标识</param>
        /// <returns></returns>
        [HttpPost]

        //[QueryCacheInterceptor]
        public async virtual Task<T?> GetFirst([FromBody] GeneralParam conditions, [FromHeader] string requestId)
        {
            AssertModelStateIsValid();

            var parser = new QueryExpressionParser<T>();
            var expression = parser.ParserConditions(conditions.Filters!);
            var list = await _dataAccessor.GetMany(expression).OrderConditions(conditions.OrderBys!).Take(1).ToListAsync();

            return list.Count > 0 ? list[0] : null;
        }

        /// <summary>
        /// 获取实体列表（只提取符合条件的前100条记录）
        /// </summary>
        /// <param name="conditions"></param>
        /// <param name="requestId">关联服务标识</param>
        /// <returns></returns>
        [HttpPost]

        //[QueryCacheInterceptor]
        public async virtual Task<PageData<T>> GetPageList([FromBody] Paging page, [FromHeader] string requestId)
        {
            AssertModelStateIsValid();
			

            var all = _dataAccessor.GetAll<T>();
            var list = await all.Skip((page.CurPage - 1) * page.PageSize).Take(page.PageSize).ToListAsync();
			int totals = await all.CountAsync();
            return new PageData<T> { Totals= totals, Rows =list};
        }

        [HttpPost]

        public async virtual Task<IEnumerable<T>> GetList([FromBody] GeneralParam conditions, [FromHeader] string requestId)
        {
            AssertModelStateIsValid();
            var parser = new QueryExpressionParser<T>();
            var expression = parser.ParserConditions(conditions.Filters!);
            var list = await _dataAccessor.GetMany(expression).OrderConditions(conditions.OrderBys!).Take(100).ToListAsync();
            return list;


        }

        [HttpPost]
        public async virtual Task<IEnumerable<T>> GetPages([FromBody] GeneralParam conditions, [FromHeader] string requestId)
        {
            AssertModelStateIsValid();

            //var parser = new QueryExpressionParser<T>();
            //var expression = parser.ParserConditions(conditions.Filters!);
            // var aa = await _dataAccessor.GetPageListAsync(1,1, expression, conditions.OrderBys!);
            //var parser = new QueryExpressionParser<T>();
            //var expression = parser.ParserConditions(conditions.Filters!);
            var pageSize = 1;
            var pageIdx = 1;
            //var bb = await _dataAccessor.OrderBy(conditions.OrderBys!).Skip(pageSize * (pageIdx - 1)).Take(pageSize);
            var list = await _dataAccessor.GetAll<T>().OrderConditions(conditions.OrderBys!).Skip(pageSize * (pageIdx - 1)).Take(pageSize).ToListAsync();
            return list;
        }


        /// <summary>
        /// Insert实体
        /// </summary>
        /// <param name="model"></param>
        /// <param name="requestId">关联服务标识</param>
        [HttpPost]
        //[InsertCacheInterceptor]
        public virtual void Add([FromBody] T model, [FromHeader] string requestId)
		{
			AssertModelStateIsValid(model);
            
            _dataAccessor.Add(model);
            _dataAccessor.Save();
        }

		/// <summary>
		/// Update实体
		/// </summary>
		/// <param name="model"></param>
		/// <param name="requestId">关联服务标识</param>
		[HttpPut]  
        //[UpdateCacheInterceptor]
        public virtual void Update([FromBody] T model, [FromHeader] string requestId)
		{
			AssertModelStateIsValid(model);
            //_dataAccessor.GetByIDAsync<T>(model.GetPrimaryKey());
            _dataAccessor.Update(model);
            _dataAccessor.Save();

            //var item = new OperateCacheItem
            //{
            //	Type = DelayOperateTypeEnum.Update,
            //	CreateTime = DateTime.Now,
            //	EntityType = typeof(T),
            //	JsonData = JsonConvert.SerializeObject(model)
            //};
            //_operatorManager.Append(model.GetRequiredUniqueKey(), item);
        }

		/// <summary>
		/// Delete实体
		/// </summary>
		/// <param name="model"></param>
		/// <param name="requestId">关联服务标识</param>
		[HttpDelete]
        
        //[DeleteCacheInterceptor]
        public virtual void Delete([FromBody] T model, [FromHeader] string requestId)
		{



            //删除操作不需要验证模型的有效性
            //AssertModelStateIsValid();
            _dataAccessor.Delete(model);
            _dataAccessor.Save();

            //var item = new OperateCacheItem
            //{
            //	Type = DelayOperateTypeEnum.Delete,
            //	CreateTime = DateTime.Now,
            //	EntityType = typeof(T),
            //	JsonData = JsonConvert.SerializeObject(model),
            //};
            //_operatorManager.Append(model.GetRequiredUniqueKey(), item);
        }
	}
}