AIPlatform/aipsvr/Services/DatabaseManagers/MongoDb/MongoDbGatherDataManager.cs

using AIPlatform.Protocol.Entities;
using AIPlatform.Protocol.Model;
using MongoDB.Driver;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace aipsvr.Services.DatabaseManagers.MongoDb
{
    internal class MongoDbGatherDataManager : IGatherDataManager
    {
        #region GatherCategory
        /// <summary>
        /// 创建采集分类
        /// </summary>
        /// <param name="gatherCategory"></param>
        /// <returns></returns>
        public async Task CreateGatherCategoryAsync(GatherCategory gatherCategory)
        {
            await MongoDbClient.Instance.GatherCategories.InsertOneAsync(gatherCategory);
        }

        /// <summary>
        /// 更新采集分类
        /// </summary>
        /// <param name="gatherCategory"></param>
        /// <returns></returns>
        public async Task UpdateGatherCategoryAsync(GatherCategory gatherCategory)
        {
            var update = Builders<GatherCategory>.Update.Set(x => x.UpdateTime, DateTime.UtcNow)
                         .Set(x => x.Name, gatherCategory.Name)
                         .Set(x => x.Organization, gatherCategory.Organization)
                         .Set(x => x.Gatherers, gatherCategory.Gatherers);
            await MongoDbClient.Instance.GatherCategories.FindOneAndUpdateAsync(x => x.Id == gatherCategory.Id, update);
        }

        /// <summary>
        /// 根据id获取采集分类
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<GatherCategory> GetGatherCategoryByIdAsync(long id)
        {
            var result = await MongoDbClient.Instance.GatherCategories.FindAsync(x => x.IsDeleted == false && x.Id == id);
            return await result.FirstOrDefaultAsync();
        }

        public async Task<List<GatherCategory>> GetGatherCategoriesByOrganizationIdAsync(long organizationId)
        {
            var filters = Builders<GatherCategory>.Filter.Where(x => x.IsDeleted == false && x.Organization.Id == organizationId);
            return await MongoDbClient.Instance.GatherCategories.Find(filters)
               .SortByDescending(x => x.UpdateTime)
               .ToListAsync();
        }
        /// <summary>
        /// 根据name获取采集分类
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public async Task<GatherCategory> GetGatherCategoryByNameAsync(string name, long organizationId)
        {
            var result = await MongoDbClient.Instance.GatherCategories.FindAsync(x => x.IsDeleted == false && x.Organization.Id == organizationId && x.Name == name);
            return await result.FirstOrDefaultAsync();
        }
        /// <summary>
        /// 获取采集分类
        /// </summary>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <param name="searchGatherCategoryModel"></param>
        /// <returns></returns>
        public async Task<List<GatherCategory>> GetGatherCategoriesAsync(int pageIndex, int pageSize, SearchGatherCategoryModel searchGatherCategoryModel)
        {
            var filters = Builders<GatherCategory>.Filter.Where(x => x.IsDeleted == false && x.Organization.Id == searchGatherCategoryModel.OrganizationId);
            if (!string.IsNullOrEmpty(searchGatherCategoryModel.Name))
            {
                filters &= Builders<GatherCategory>.Filter.Where(x => x.Name.ToLower().Contains(searchGatherCategoryModel.Name.ToLower()));
            }
            if (!string.IsNullOrEmpty(searchGatherCategoryModel.GathererName))
            {
                filters &= Builders<GatherCategory>.Filter.Where(x => x.Gatherers.Any(y => y.Name.ToLower().Contains(searchGatherCategoryModel.GathererName.ToLower())));
            }
            return await MongoDbClient.Instance.GatherCategories.Find(filters)
                .SortByDescending(x => x.UpdateTime)
                .Skip(pageIndex * pageSize)
                .Limit(pageSize)
                .ToListAsync();
        }

        /// <summary>
        /// 获取采集分类
        /// </summary>
        /// <param name="searchGatherCategoryModel"></param>
        /// <returns></returns>
        public async Task<long> GetGatherCategoriesCountAsync(SearchGatherCategoryModel searchGatherCategoryModel)
        {
            var filters = Builders<GatherCategory>.Filter.Where(x => x.IsDeleted == false && x.Organization.Id == searchGatherCategoryModel.OrganizationId);
            if (!string.IsNullOrEmpty(searchGatherCategoryModel.Name))
            {
                filters &= Builders<GatherCategory>.Filter.Where(x => x.Name.ToLower().Contains(searchGatherCategoryModel.Name.ToLower()));
            }
            if (!string.IsNullOrEmpty(searchGatherCategoryModel.GathererName))
            {
                filters &= Builders<GatherCategory>.Filter.Where(x => x.Gatherers.Any(y => y.Name.ToLower().Contains(searchGatherCategoryModel.GathererName.ToLower())));
            }
            return await MongoDbClient.Instance.GatherCategories.CountDocumentsAsync(filters);
        }

        #endregion GatherCategory

        #region GatherData
        /// <summary>
        /// 创建采集数据
        /// </summary>
        /// <param name="gatherData"></param>
        /// <returns></returns>
        public async Task CreateGatherDataAsync(GatherData gatherData)
        {
            await MongoDbClient.Instance.GatherDatas.InsertOneAsync(gatherData);
        }

        /// <summary>
        /// 更新采集数据
        /// </summary>
        /// <param name="gatherData"></param>
        /// <returns></returns>
        public async Task UpdateGatherDataAsync(GatherData gatherData)
        {
            var update = Builders<GatherData>.Update.Set(x => x.UpdateTime, DateTime.UtcNow)
                         .Set(x => x.Category, gatherData.Category)
                         .Set(x => x.Organization, gatherData.Organization)
                         .Set(x => x.Gatherer, gatherData.Gatherer)
                         .Set(x => x.ModelType, gatherData.ModelType)
                         .Set(x => x.Source, gatherData.Source)
                         .Set(x => x.CollectionQuantity, gatherData.CollectionQuantity)
                         .Set(x => x.StartTime, gatherData.StartTime.ToUniversalTime())
                         .Set(x => x.EndTime, gatherData.EndTime.ToUniversalTime())
                         .Set(x => x.SettlementTime, gatherData.SettlementTime.ToUniversalTime());
            await MongoDbClient.Instance.GatherDatas.FindOneAndUpdateAsync(x => x.Id == gatherData.Id, update);
        }

        /// <summary>
        /// 根据id获取采集数据
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<GatherData> GetGatherDataByIdAsync(long id)
        {
            var result = await MongoDbClient.Instance.GatherDatas.FindAsync(x => x.IsDeleted == false && x.Id == id);
            return await result.FirstOrDefaultAsync();
        }

        /// <summary>
        /// 获取采集数据
        /// </summary>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <param name="searchGatherDataModel"></param>
        /// <returns></returns>
        public async Task<List<GatherData>> GetGatherDatasAsync(int pageIndex, int pageSize, SearchGatherDataModel searchGatherDataModel)
        {
            var filters = Builders<GatherData>.Filter.Where(x => x.IsDeleted == false && x.Organization.Id == searchGatherDataModel.OrganizationId);
            if (!string.IsNullOrEmpty(searchGatherDataModel.Name))
            {
                filters &= Builders<GatherData>.Filter.Where(x => x.Category.Name.ToLower().Contains(searchGatherDataModel.Name.ToLower()));
            }
            if (!string.IsNullOrEmpty(searchGatherDataModel.GathererName))
            {
                filters &= Builders<GatherData>.Filter.Where(x => x.Gatherer.Name.ToLower().Contains(searchGatherDataModel.GathererName.ToLower()));
            }
            if (!string.IsNullOrEmpty(searchGatherDataModel.ModelType))
            {
                filters &= Builders<GatherData>.Filter.Where(x => x.ModelType.ToLower().Contains(searchGatherDataModel.ModelType.ToLower()));
            }
            if (!string.IsNullOrEmpty(searchGatherDataModel.Source))
            {
                filters &= Builders<GatherData>.Filter.Where(x => x.Source.ToLower().Contains(searchGatherDataModel.Source.ToLower()));
            }
            if (searchGatherDataModel.SettleStartTime != null && searchGatherDataModel.SettleEndTime != null && searchGatherDataModel.SettleStartTime <= searchGatherDataModel.SettleEndTime)
            {
                filters &= Builders<GatherData>.Filter.Where(x => x.SettlementTime >= searchGatherDataModel.SettleStartTime.Value.ToUniversalTime() && x.SettlementTime <= searchGatherDataModel.SettleEndTime.Value.ToUniversalTime());
            }
            return await MongoDbClient.Instance.GatherDatas.Find(filters)
                .SortByDescending(x => x.UpdateTime)
                .Skip(pageIndex * pageSize)
                .Limit(pageSize)
                .ToListAsync();
        }

        /// <summary>
        /// 获取采集数据数量
        /// </summary>
        /// <param name="searchGatherDataModel"></param>
        /// <returns></returns>
        public async Task<long> GetGatherDatasCountAsync(SearchGatherDataModel searchGatherDataModel)
        {
            var filters = Builders<GatherData>.Filter.Where(x => x.IsDeleted == false && x.Organization.Id == searchGatherDataModel.OrganizationId);
            if (!string.IsNullOrEmpty(searchGatherDataModel.Name))
            {
                filters &= Builders<GatherData>.Filter.Where(x => x.Category.Name.ToLower().Contains(searchGatherDataModel.Name.ToLower()));
            }
            if (!string.IsNullOrEmpty(searchGatherDataModel.GathererName))
            {
                filters &= Builders<GatherData>.Filter.Where(x => x.Gatherer.Name.ToLower().Contains(searchGatherDataModel.GathererName.ToLower()));
            }
            if (!string.IsNullOrEmpty(searchGatherDataModel.ModelType))
            {
                filters &= Builders<GatherData>.Filter.Where(x => x.ModelType.ToLower().Contains(searchGatherDataModel.ModelType.ToLower()));
            }
            if (!string.IsNullOrEmpty(searchGatherDataModel.Source))
            {
                filters &= Builders<GatherData>.Filter.Where(x => x.Source.ToLower().Contains(searchGatherDataModel.Source.ToLower()));
            }
            if (searchGatherDataModel.SettleStartTime != null && searchGatherDataModel.SettleEndTime != null && searchGatherDataModel.SettleStartTime <= searchGatherDataModel.SettleEndTime)
            {
                filters &= Builders<GatherData>.Filter.Where(x => x.SettlementTime >= searchGatherDataModel.SettleStartTime.Value.ToUniversalTime() && x.SettlementTime <= searchGatherDataModel.SettleEndTime.Value.ToUniversalTime());
            }
            return await MongoDbClient.Instance.GatherDatas.CountDocumentsAsync(filters);
        }

        /// <summary>
        /// Get Gather Datas by Category Id
        /// </summary>
        /// <param name="categoryId"></param>
        /// <returns></returns>
        public async Task<List<GatherData>> GetGatherDatasByCategoryIdAsync(long categoryId)
        {
            var filters = Builders<GatherData>.Filter.Where(x => x.IsDeleted == false && x.Category.Id == categoryId);
            return await MongoDbClient.Instance.GatherDatas.Find(filters).SortByDescending(x => x.UpdateTime).ToListAsync();
        }

        #endregion GatherData
    }
}