// Admin.NET 项目的版权、商标、专利和其他相关权利均受相应法律法规的保护。使用本项目应遵守相关法律法规和许可证的要求。
//
// 本项目主要遵循 MIT 许可证和 Apache 许可证（版本 2.0）进行分发和使用。许可证位于源代码树根目录中的 LICENSE-MIT 和 LICENSE-APACHE 文件。
//
// 不得利用本项目从事危害国家安全、扰乱社会秩序、侵犯他人合法权益等法律法规禁止的活动！任何基于本项目二次开发而产生的一切法律纠纷和责任，我们不承担任何责任！

using DocumentFormat.OpenXml.Office2010.ExcelAc;
using DocumentFormat.OpenXml.Vml.Office;
using DocumentFormat.OpenXml.Wordprocessing;
using Elastic.Clients.Elasticsearch;
using Flurl;
using Flurl.Http;
using Flurl.Util;
using iText.Layout.Element;
using Microsoft.AspNetCore.Identity;
using Microsoft.Extensions.Caching.Distributed;
using Microsoft.Extensions.Caching.Memory;
using MongoDB.Bson;
using MongoDB.Driver;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using OfficeOpenXml.FormulaParsing.Excel.Functions.Math;
using Org.BouncyCastle.Asn1.Bsi;
using Org.BouncyCastle.Asn1.Ocsp;
using RazorEngine.Compilation.ImpromptuInterface.InvokeExt;
using SqlSugar.Extensions;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.Encodings.Web;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Threading.Tasks;
using static SKIT.FlurlHttpClient.Wechat.Api.Models.CgibinGetCurrentAutoReplyInfoResponse.Types.KeywordAutoReplyRule.Types;

namespace Admin.NET.Core.Service;


/// <summary>
/// 志愿填报开放基础服务
/// </summary>
[AllowAnonymous]
[ApiDescriptionSettings(ApplicationConst.ZYGroupName, Order = 900)]
[Route("api/zhiYuan")]
public class ZhiYuanBaseService : IDynamicApiController, ITransient
{
    private const string _cachekey = "base_";
    private readonly IDistributedCache _distributed;
    private readonly SqlSugarRepository<SysDictData> _sysDictDataRep;
    private readonly SqlSugarRepository<SysUnCollection> _uncollectionrep;

    private readonly IMongoDBRepository _mongoRepository;
    private readonly IHttpContextAccessor _httpContextAccessor;
    private readonly SqlSugarRepository<BusProvince> _proviceRep;
    private readonly UserManager _userManager;
    public ZhiYuanBaseService(IDistributedCache distributedCache, SqlSugarRepository<SysDictData> sysDictDataRep, IMongoDBRepository mongoDBRepository,
        IHttpContextAccessor httpContextAccessor, SqlSugarRepository<SysUnCollection> uncollectionrep, UserManager userManager, SqlSugarRepository<BusProvince> proviceRep)
    {
        _distributed = distributedCache;
        _sysDictDataRep = sysDictDataRep;
        _mongoRepository = mongoDBRepository;
        _httpContextAccessor = httpContextAccessor;
        _uncollectionrep = uncollectionrep;
        _userManager = userManager;
        _proviceRep = proviceRep;
    }

    /// <summary>
    /// 获取省份信息
    /// </summary>
    /// <returns></returns>
    [HttpGet]
    public async Task<dynamic> Province()
    {
        var key = _cachekey + "province";
        var result = await _distributed.GetAsync(key);
        if (result == null)
        {
            var baseurl = App.GetConfig<OutExApi>("OutExApi", true).BaseUrl;
            var _option = new DistributedCacheEntryOptions()
              .SetSlidingExpiration(TimeSpan.FromHours(4));
            //var dyresult = await string.Format("{0}api/SysRegion/GetRegionList?code=0", baseurl).SetJsonSerialization<NewtonsoftJsonSerializerProvider>().GetAsAsync<CustomPropertyResult<dynamic>>();
            var dyresult = await string.Format("{0}api/SysRegion/GetRegionList?code=0", baseurl).GetJsonAsync<CustomPropertyResult<List<Region>>>();
            //   string str = dyresult.ToString();
            var jsons = JsonConvert.SerializeObject(dyresult.response);
            byte[] byresult = Encoding.UTF8.GetBytes(jsons);
            await _distributed.SetAsync(key, byresult, _option);
            result = byresult;
        }
        return JsonConvert.DeserializeObject<dynamic>(Encoding.UTF8.GetString(result).ToLowerInvariant());

    }


    /// <summary>
    /// 各省份年份对应政策规则(已弃用)
    /// </summary>
    /// <returns></returns>
    [HttpGet]
    public async Task<dynamic> VolunteerInitialization()
    {
        var key = _cachekey + "volunteerInit";
        var result = await _distributed.GetAsync(key);
        if (result == null)
        {
            var baseurl = App.GetConfig<OutExApi>("OutExApi", true).BaseUrl;
            var _option = new DistributedCacheEntryOptions()
             .SetSlidingExpiration(TimeSpan.FromHours(4));
            //var dyresult = await string.Format("{0}api/SeVolunteerInitialization/Get", baseurl).SetJsonSerialization<NewtonsoftJsonSerializerProvider>().GetAsAsync<CustomPropertyResult<dynamic>>();
            var dyresult = await string.Format("{0}api/SeVolunteerInitialization/Get", baseurl).GetJsonAsync<CustomPropertyResult<List<SeVolunterInitializationDto>>>();
            //  string str = dyresult.ToString();
            var jsons = JsonConvert.SerializeObject(dyresult.response);
            byte[] byresult = Encoding.UTF8.GetBytes(jsons);
            await _distributed.SetAsync(key, byresult, _option);
            result = byresult;
        }
        return JsonConvert.DeserializeObject<dynamic>(Encoding.UTF8.GetString(result).ToLowerInvariant());
    }




    /// <summary>
    ///  院校甄别    //野鸡大学
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [HttpGet]
    public async Task<dynamic> FackUniversitys([FromQuery] FackUniversityRequestDto dto)
    {
        // 检查是否至少有一个查询条件
        if (string.IsNullOrWhiteSpace(dto.keyword) && string.IsNullOrWhiteSpace(dto.provinceName))
        {
            throw Oops.Oh("至少需要提供一个查询条件（关键字或省份名称）");
        }
        // 获取数据库客户端
        var dbclient = _mongoRepository.Context.GetDatabase("zhiyuan");
        // 获取集合
        var bejson = dbclient.GetCollection<FackUniversityDto>("d_fackuniversity");
        // 动态条件列表
        var filterBuilders = new List<FilterDefinition<FackUniversityDto>>();
        // 如果 keyword 不为空，添加大学名称的正则查询条件
        if (!string.IsNullOrWhiteSpace(dto.keyword))
        {
            filterBuilders.Add(Builders<FackUniversityDto>.Filter.Regex(p => p.universityName, new BsonRegularExpression($"/{dto.keyword}/")));
        }

        if (!string.IsNullOrWhiteSpace(dto.provinceName))
        {
            filterBuilders.Add(Builders<FackUniversityDto>.Filter.Regex(p => p.locationName, new BsonRegularExpression($"/{dto.provinceName.Replace("省", "").Replace("市", "")}/")));
        }
        // 构建最终的过滤器
        FilterDefinition<FackUniversityDto> filter = filterBuilders.Count > 0
            ? Builders<FackUniversityDto>.Filter.And(filterBuilders)
            : new BsonDocument(); // 如果没有条件，则使用空过滤器

        // 执行查询并将结果转换为列表
        var list = await bejson.Find(filter).ToListAsync();
        list.ForEach(a =>
        {
            a.locationName = a.locationName.Replace("省", "").Replace("市", "");
        });
        return list;
    }


    /// <summary>
    /// 获取院校类型
    /// </summary>
    /// <param name="typeId">539074685816901</param>
    /// <returns></returns>
    [HttpGet]
    //[UnifyResult(typeof(CustomPropertyResult<>))]
    public async Task<dynamic> UniversityType([Required] long typeId = 539074685816901)
    {
        var key = _cachekey + "untype_" + typeId;
        var result = await _distributed.GetAsync(key);
        if (result == null)
        {
            var _option = new DistributedCacheEntryOptions()
                .SetSlidingExpiration(TimeSpan.FromHours(4));
            var dyresult = await _sysDictDataRep.AsQueryable()
            .Where(u => u.DictTypeId == typeId)
            .OrderBy(u => new { u.Code }).Select(c => new
            DicBaseDto
            { id = c.Code, name = c.Value })
            .ToListAsync();
            byte[] byresult = Encoding.UTF8.GetBytes(dyresult.ToJson());
            await _distributed.SetAsync(key, byresult, _option);
            result = byresult;
        }
        return JsonConvert.DeserializeObject<dynamic>(Encoding.UTF8.GetString(result));
    }

    /// <summary>
    /// 办学性质
    /// </summary>
    /// <param name="typeId">539083286085701</param>
    /// <returns></returns>
    [HttpGet]
    //[UnifyResult(typeof(CustomPropertyResult<>))]
    public async Task<dynamic> Nature([Required] long typeId = 539083286085701)
    {
        var key = _cachekey + "nature_" + typeId;
        var result = await _distributed.GetAsync(key);
        if (result == null)
        {
            var _option = new DistributedCacheEntryOptions()
              .SetSlidingExpiration(TimeSpan.FromHours(4));
            var dyresult = await _sysDictDataRep.AsQueryable()
            .Where(u => u.DictTypeId == typeId)
            .OrderBy(u => new { u.Code }).Select(c => new
            DicBaseDto
            { id = c.Code, name = c.Value })
            .ToListAsync();
            byte[] byresult = Encoding.UTF8.GetBytes(dyresult.ToJson());
            await _distributed.SetAsync(key, byresult, _option);
            result = byresult;
        }
        return JsonConvert.DeserializeObject<dynamic>(Encoding.UTF8.GetString(result));
    }




    /// <summary>
    /// 院校排行
    /// </summary>
    /// <param name="request"></param>
    /// <returns></returns>
    [HttpGet]
    public async Task<PageBaseResult<UniversityRank>> UniversityRank([FromQuery] UniversityRankRequest request)
    {
        var dbclient = _mongoRepository.Context.GetDatabase("zhiyuan");
        var bejson = dbclient.GetCollection<UniversityRank>("universityrank");

        if (!request.Type.HasValue)
        {
            throw Oops.Oh("院校类型不能为空");
        }

        if (!request.Year.HasValue)
        {
            throw Oops.Oh("年份不能为空");
        }

        // 动态条件列表  
        var filterBuilders = new List<FilterDefinition<UniversityRank>>();
        if (request.Year.HasValue)
        {
            filterBuilders.Add(Builders<UniversityRank>.Filter.Eq(p => p.Year, request.Year.Value.ToString()));
        }
        if (request.Type.HasValue)
        {
            filterBuilders.Add(Builders<UniversityRank>.Filter.Eq(p => p.UniversityType, request.Type.Value.ToString()));
        }
        if (!string.IsNullOrWhiteSpace(request.Name))
        {
            filterBuilders.Add(Builders<UniversityRank>.Filter.Regex(p => p.UniversityName, new BsonRegularExpression($"/{request.Name}/")));
        }
        // 使用And组合所有过滤条件  
        FilterDefinition<UniversityRank> filter = filterBuilders.Count > 0
            ? Builders<UniversityRank>.Filter.And(filterBuilders)
            : new BsonDocument(); // 如果没有条件，则使用空过滤器  
        //var list = await bejson.Find(filter).ToListAsync();

        var sort = Builders<UniversityRank>.Sort.Ascending(x => x._id); // 替换YourField为实际的排序字段
        // 创建分页对象并获取分页数据  
        var pagination = new MongoPagination<UniversityRank>(bejson, filter, sort, request.PageSize, request.PageIndex);
        var (items, totalCount, totalPages) = await pagination.GetPagedDataAsync();

        var universitylistbejson = dbclient.GetCollection<UniversityDto>("university");
        var universitylist = await universitylistbejson.Find(new BsonDocument()).ToListAsync();

        items.ForEach(a =>
        {

            a.cityName = universitylist.Where(e => e.name == a.UniversityName).Any() ? universitylist.Where(e => e.name == a.UniversityName)?.FirstOrDefault().cityName.Replace("市", "") : "";
            a.logo = universitylist.Where(e => e.name == a.UniversityName).Any() ? universitylist.Where(e => e.name == a.UniversityName)?.FirstOrDefault().logo : "https://static-data.ycymedu.com/daxuelogo.jpg";
            a.uType = universitylist.Where(e => e.name == a.UniversityName).Any() ? universitylist.Where(e => e.name == a.UniversityName)?.FirstOrDefault().utype.FirstOrDefault() : "";
        });
        return new PageBaseResult<UniversityRank>()
        {
            PageNo = request.PageIndex,
            PageSize = request.PageSize,
            TotalPage = totalPages,
            TotalRows = totalCount,
            Rows = items,
        };

    }


    //批次线（各省份）
    //位次（各省份）
    //一分一段（各省份）



    //专业大类
    //专业小类
    //专业名称

    /// <summary>
    /// 专业大类和专业二级分类
    /// </summary>
    /// <param name="level"></param>
    /// <returns></returns>
    [HttpGet]
    public async Task<dynamic> BaseMajor([FromQuery] int level)
    {
        var key = _cachekey + "basemajor_" + level;
        var result = await _distributed.GetAsync(key);
        if (result == null)
        {
            var baseurl = App.GetConfig<OutExApi>("OutExApi", true).BaseUrl;
            var _option = new DistributedCacheEntryOptions()
              .SetSlidingExpiration(TimeSpan.FromDays(1));
            /* var dyresult = await string.Format("{0}api/front/Library/uniGetMajorInfo?SchoolLevel={1}", baseurl, level).SetJsonSerialization<NewtonsoftJsonSerializerProvider>().GetAsAsync<CustomPropertyResult<dynamic>>();*/
            var dyresult = await string.Format("{0}api/front/Library/uniGetMajorInfo?SchoolLevel={1}", baseurl, level).GetJsonAsync<CustomPropertyResult<List<uniMajorInfoResult>>>();
            //  string str = dyresult.ToString();
            var jsons = JsonConvert.SerializeObject(dyresult.response);
            byte[] byresult = Encoding.UTF8.GetBytes(jsons);
            await _distributed.SetAsync(key, byresult, _option);
            result = byresult;
        }
        return JsonConvert.DeserializeObject<dynamic>(Encoding.UTF8.GetString(result).ToLowerInvariant());
    }


    /// <summary>
    /// 一分一段
    /// </summary>
    /// <param name="request"></param>
    /// <returns></returns>
    [HttpGet]
    public async Task<dynamic> ScoreLine([FromQuery] ScoreLineRequest request)
    {
        var baseurl = App.GetConfig<OutExApi>("OutExApi", true).BaseUrl;
        var headers = _httpContextAccessor.HttpContext.Request.Headers;
        var token = headers["Authorization"].ToString();
        //var dyresult = await string.Format("{0}api/front/Library/GetScoreLine", baseurl)
        //    .SetHeaders(new Dictionary<string, object> { { "Authorization", string.Format("Bearer {0}", token) } })
        //    .SetQueries(request)
        //    .SetJsonSerialization<NewtonsoftJsonSerializerProvider>(new JsonSerializerSettings() { ContractResolver = new CamelCasePropertyNamesContractResolver() }).GetAsAsync<CustomPropertyResult<dynamic>>();
        var dyresult = await string.Format("{0}api/front/Library/GetScoreLine", baseurl).WithOAuthBearerToken(token).SetQueryParams(request).GetStringAsync();
        var result = JsonConvert.DeserializeObject<CustomPropertyResult<List<ScoreLineResponseDto>>>(dyresult);

        return result.response;
    }




    /// <summary>
    /// 院校列表
    /// </summary>
    /// <param name="request"></param>
    /// <returns></returns>
    [HttpPost]
    public async Task<PageBaseResult<UniversityDto>> University([FromBody] UniversityRequest request)
    {
        var dbclient = _mongoRepository.Context.GetDatabase("zhiyuan");
        var bejson = dbclient.GetCollection<UniversityDto>("university");
        // 动态条件列表  
        var filterBuilders = new List<FilterDefinition<UniversityDto>>();

        if (!string.IsNullOrWhiteSpace(request.name))
        {
            filterBuilders.Add(Builders<UniversityDto>.Filter.Regex(p => p.name, new BsonRegularExpression($"/{request.name}/")));
        }

        if (request.level.HasValue)
        {
            filterBuilders.Add(Builders<UniversityDto>.Filter.Eq("level", request.level.Value));
        }

        if (request.provinceName != null && request.provinceName.Count() > 0)//省份
        {
            filterBuilders.Add(Builders<UniversityDto>.Filter.In(p => p.provinceName, request.provinceName));
        }
        if (request.nature != null && request.nature.Count() > 0)//包含--公办 民办
        {
            filterBuilders.Add(Builders<UniversityDto>.Filter.In(p => p.nature, request.nature));
        }
        if (request.utype != null && request.utype.Count() > 0)//包含--院校类型 综合 理工
        {
            filterBuilders.Add(Builders<UniversityDto>.Filter.AnyIn(p => p.utype, request.utype));
        }
        //// 构建查询条件：SubItems数组中的某个元素的Description字段包含subItemDescriptionSubstring  
        //var subItemFilter = filterBuilder.ElemMatch(x => x.SubItems, filterBuilder.Regex(y => y.Description, new BsonRegularExpression($".*{subItemDescriptionSubstring}.*", "i")));
        if (request.feature != null && request.feature.Count() > 0) //985、211
        {
            filterBuilders.Add(Builders<UniversityDto>.Filter.AnyIn(p => p.features, request.feature));
        }



        // 使用And组合所有过滤条件  
        FilterDefinition<UniversityDto> filter = filterBuilders.Count > 0
            ? Builders<UniversityDto>.Filter.And(filterBuilders)
            : new BsonDocument(); // 如果没有条件，则使用空过滤器  
        // 你可以根据需要添加排序字段  
        var sort = Builders<UniversityDto>.Sort.Ascending(x => x._id); // 替换YourField为实际的排序字段
        // 创建分页对象并获取分页数据  
        var pagination = new MongoPagination<UniversityDto>(bejson, filter, sort, request.PageSize, request.PageIndex);
        var (items, totalCount, totalPages) = await pagination.GetPagedDataAsync();
        #region 更新院校数据
        //var university_w = dbclient.GetCollection<University_wwDto>("university_ww");
        //var enmtyfilter = Builders<University_wwDto>.Filter.Empty; // 创建一个空筛选器，获取所有文档
        //var listrectiy = await university_w.Find(enmtyfilter).ToListAsync();
        //items.ForEach(async a =>
        //{
        //    var update = Builders<UniversityDto>.Update;
        //    var updates = new List<UpdateDefinition<UniversityDto>>();
        //    var newmodel = listrectiy.Where(e => e.name == a.name).FirstOrDefault();
        //    if (newmodel != null)
        //    {
        //        if (a.rank <= 0)
        //        {
        //            a.rank = newmodel.rank;
        //            updates.Add(update.Set("rank", newmodel.rank));
        //        }
        //if (string.IsNullOrWhiteSpace(a.address))
        //{
        //    a.address = newmodel.address;

        //    updates.Add(update.Set("address", newmodel.address));
        //}
        //if (string.IsNullOrWhiteSpace(a.builddate))
        //{
        //    a.builddate = newmodel.builddate;
        //    updates.Add(update.Set("builddate", newmodel.builddate));
        //}
        //if (string.IsNullOrWhiteSpace(a.cityName))
        //{
        //    a.cityName = newmodel.cityName;
        //    updates.Add(update.Set("cityName", newmodel.cityName));
        //}
        //if (string.IsNullOrWhiteSpace(a.phone))
        //{
        //    a.phone = newmodel.phone;
        //    updates.Add(update.Set("phone", newmodel.phone));
        //}
        //if (a.utype == null || a.utype.Count() <= 0)
        //{
        //    a.utype = JsonConvert.DeserializeObject<List<string>>(newmodel.utype);
        //    updates.Add(update.Set("utype", a.utype));
        //}
        //if (string.IsNullOrWhiteSpace(a.weburl))
        //{
        //    a.weburl = newmodel.weburl;
        //    updates.Add(update.Set("weburl", newmodel.weburl));
        //}

        //        var filter = Builders<UniversityDto>.Filter.Eq("_id", a._id); // 使用文档的ID

        //        if (updates.Count() > 0)
        //        {
        //            var result = await bejson.UpdateOneAsync(filter, update.Combine(updates));
        //        }
        //    }
        //});
        #endregion
        return new PageBaseResult<UniversityDto>()
        {
            PageNo = request.PageIndex,
            PageSize = request.PageSize,
            TotalPage = totalPages,
            TotalRows = totalCount,
            Rows = items,
        };

    }






    /// <summary>
    /// 院校对比
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [HttpPost]
    public async Task<List<University_wDto>> ComparUk([FromBody] CompiarUnkRequestDto dto)
    {
        string years = dto.years ?? "2024";

        var dbclient = _mongoRepository.Context.GetDatabase("zhiyuan");
        var bejson = dbclient.GetCollection<UniversityDto>("university");
        // 动态条件列表  
        var filterBuilders = new List<FilterDefinition<UniversityDto>>();

        if (dto.ids == null && dto.ids.Count() <= 0)//省份
        {
            throw Oops.Oh("请传入院校Id");
        }
        filterBuilders.Add(Builders<UniversityDto>.Filter.In(p => p._id, dto.ids));

        FilterDefinition<UniversityDto> filter = filterBuilders.Count > 0
           ? Builders<UniversityDto>.Filter.And(filterBuilders)
           : new BsonDocument(); // 如果没有条件，则使用空过滤器  
        var list = await bejson.Find(filter).ToListAsync();
        var planjson = dbclient.GetCollection<PlanProResponseDto>(string.Format("zsplanpro_{0}_{1}", dto.locationCode, years));
        // 动态条件列表  
        var pBuilders = new List<FilterDefinition<PlanProResponseDto>>();
        pBuilders.Add(Builders<PlanProResponseDto>.Filter.In(p => p._uid.Value, dto.ids));
        FilterDefinition<PlanProResponseDto> ffilter = filterBuilders.Count > 0
         ? Builders<PlanProResponseDto>.Filter.And(pBuilders)
         : new BsonDocument(); // 如果没有条件，则使用空过滤器  
        var planlist = await planjson.Find(ffilter).ToListAsync();

        var result = new List<University_wDto>();
        list.ForEach(a =>
        {

            result.Add(new University_wDto()
            {
                address = a.address,
                belong = a.belong,
                builddate = a.builddate,
                cityName = a.cityName,
                collegeCode = a.collegeCode,
                level = a.level.Value,
                logo = a.logo,
                MajorCount = planlist.Where(e => e._uid == a._id).Select(c => c.major).Count(),
                planCount = planlist.Where(e => e._uid == a._id).Select(c => c.plancount.Value).Sum(),
                _id = a._id,
                name = a.name,
                nature = a.nature,
                phone = a.phone,
                provinceName = a.provinceName,
                utype = string.Join('/', a.utype),
                weburl = a.weburl
            });
        });
        return result;
    }


    /// <summary>
    ///学校招生计划新版本V2
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [ApiDescriptionSettings(Name = "PlanListPro/V2"), HttpGet]
    public async Task<PlanProV2ResponseDto> PlanListProV2([FromQuery] PlanProV2RequestDto dto)
    {
        var result = new PlanProV2ResponseDto();
        var dbclient = _mongoRepository.Context.GetDatabase("zhiyuan");

        DateTime dt = DateTime.Now;
        DateTime fixedDate = new DateTime(dt.Year, 7, 20); // 创建当前年份的7月20日
        int year = dt > fixedDate ? dt.Year : dt.Year - 1; // 比较当前日期与固定日期
        var planjson = dbclient.GetCollection<PlanProResponseDto>(string.Format("zsplanpro_{0}_{1}", dto.locationCode, year));

        var filter = Builders<PlanProResponseDto>.Filter.Eq(e => e._uid, dto.uid);
        var query = await planjson.Find(filter).ToListAsync();
        if (query == null)
        {
            throw Oops.Oh("暂无数据");
        }
        result.year = year.ToString();
        result.items = query;
        return result;
    }



    /// <summary>
    /// 院校列表
    /// </summary>
    /// <returns></returns>
    [HttpGet]
    public async Task<bool> SaveUniversity([FromQuery] UniversityRequest request)
    {

        var baseurl = App.GetConfig<OutExApi>("OutExApi", true).BaseUrl;
        var headers = _httpContextAccessor.HttpContext.Request.Headers;
        var token = headers["Authorization"].ToString();
        //var dyresult = await "https://api.static.ycymedu.com/universityinfo.json"
        //    .SetJsonSerialization<NewtonsoftJsonSerializerProvider>().GetAsAsync<CustomPropertyResult<List<UniversityMongoResult>>>();
        var dyresult = await "https://api.static.ycymedu.com/universityinfo.json".GetJsonAsync<CustomPropertyResult<List<UniversityMongoResult>>>();
        var jsons = dyresult.response;

        var dbclient = _mongoRepository.Context.GetDatabase("zhiyuan");
        var collection = dbclient.GetCollection<BsonDocument>("university_ww");
        var list = new List<BsonDocument>();
        //待添加的document
        jsons.ForEach(c =>
        {
            if (c.Web == null)
            {
                c.Web = "";
            }
            if (c.Description == null)
            {
                c.Description = "";
            }
            if (c.Address == null)
            {
                c.Address = "";
            }
            if (c.AreaName == null)
            {
                c.AreaName = "";
            }
            if (c.AscriptionName == null)
            {
                c.AscriptionName = "";
            }
            if (c.Belong == null)
            {
                c.Belong = "";
            }
            if (c.BuildDate == null)
            {
                c.BuildDate = "";
            }
            if (c.CityName == null)
            {
                c.CityName = "";
            }
            if (c.collegeCode == null)
            {
                c.collegeCode = "";
            }

            if (c.Logo == null)
            {
                c.Logo = "";
            }
            if (c.Nature == null)
            {
                c.Nature = "";
            }
            if (c.Phone == null)
            {
                c.Phone = "";
            }
            if (c.SubjectLevel == null)
            {
                c.SubjectLevel = -1;
            }
            if (c.VrUrl == null)
            {
                c.VrUrl = "";
            }

            var featurearray = new BsonArray() { };
            if (c.features != null)
            {
                var feature = c.features.Split("/", StringSplitOptions.RemoveEmptyEntries).ToList();
                feature.ForEach(a =>
                {
                    if (a == "双一流大学")
                    {
                        a = "双一流";
                    }
                    if (a == "保研资格")
                    {
                        a = "保研";
                    }
                    featurearray.Add(a);
                });
            }
            var utype = new BsonArray() { };
            if (c.UniversityType != null)
            {

                utype.AddRange(c.UniversityType);
            }
            var imglist = new BsonArray() { };
            if (c.Imglist != null)
            {
                var jbeson = JsonConvert.DeserializeObject<List<string>>(c.Imglist);
                imglist.AddRange(jbeson);
            }

            list.Add(new BsonDocument{
                { "_id",c.Id },
                { "name", c.Name },
                { "provinceName", c.AreaName },
                { "cityName",c.CityName},
                { "resourcecount", new BsonDocument
                    {
                        { "academician", c.AcademicianCount },
                        { "doctorate",c.DoctorateCount },
                        { "master",c.MasterCount },
                    }
                 },   { "rank", c.Rank },
                      { "weburl", c.Web },
                      { "logo", c.Logo },
                      { "collegeCode", c.collegeCode },
                      { "address", c.Address },
                      { "imglist", imglist },
                         { "vrurl", string.IsNullOrEmpty(c.VrUrl)?"":c.VrUrl },
                      { "phone", c.Phone },
                      { "features",featurearray},
                       { "belong", string.IsNullOrEmpty(c.AscriptionName)?"":c.AscriptionName },
                        { "level",c.SubjectLevel },//0是本科，1 是专科
                        { "builddate",c.BuildDate },
                       { "utype", utype },
                    {"nature",c.Nature}

            });
        });

        collection.InsertMany(list);

        return true;
    }




    /// <summary>
    /// 院校详情
    /// </summary>
    /// <param name="request"></param>
    /// <returns></returns>
    [HttpGet]
    public async Task<dynamic> UniversityDetail([FromQuery] UniversityDetailRequest request)
    {
        var baseurl = App.GetConfig<OutExApi>("OutExApi", true).BaseUrl;
        var url = string.Format("{0}api/front/Library/GetUniversityDetails", baseurl);
        //var result = await url
        //    .SetQueries(new OldUniversityRequest()
        //    {
        //        CustomerId = request.CId,
        //        Id = (int)request.Id
        //    })
        //    .SetJsonSerialization<NewtonsoftJsonSerializerProvider>(new JsonSerializerSettings() { ContractResolver = new CamelCasePropertyNamesContractResolver() })
        //   .GetAsAsync<CustomPropertyResult<OldUniversityDetailResponse>>();
        var dyresult = await url.SetQueryParams(new OldUniversityRequest()
        {
            CustomerId = request.CId,
            Id = (int)request.Id
        }).GetStringAsync();
        var result = JsonConvert.DeserializeObject<CustomPropertyResult<OldUniversityDetailResponse>>(dyresult);
        var response = new UniversityDetailResponse();
        if (result != null && result.success && result.response != null)
        {
            var rpm = result.response.universityResult;
            var dbclient = _mongoRepository.Context.GetDatabase("zhiyuan");
            var collection = dbclient.GetCollection<UniversityDetailDto>("university");

            var filter = Builders<UniversityDetailDto>.Filter.Eq("_id", rpm.id);
            // 获取单条数据
            var document = collection.Find(filter).FirstOrDefault();

            if (_userManager.UserId > 0)
            {
                var collect = await _uncollectionrep.AsQueryable().Where(e => e.WxId == _userManager.UserId && e.Id == request.Id).ToListAsync();
                if (collect.Any() && collect.Count() > 0)
                {
                    document.isCollect = true;
                }
            }

            document.detail = rpm.description;
            response.universityResult = document;
            response.graduateModels = result.response.graduateModels;
            response.relatedMajors = result.response.relatedMajors;
        }

        return response;
    }




    /// <summary>
    /// 融合院校专业模糊查询
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [HttpGet]
    public async Task<CombinResponseDto> CombineList([FromQuery] CombineRequestDto dto)
    {
        var majorlist = new List<MajorSearchDto>();
        var baseurl = App.GetConfig<OutExApi>("OutExApi", true).BaseUrl;
        var url = string.Format("{0}api/front/Library/SeachMajor?Name={1}", baseurl, dto.KeyWord);
        //var MajorResult = await url
        //    .SetJsonSerialization<NewtonsoftJsonSerializerProvider>(new JsonSerializerSettings() { ContractResolver = new CamelCasePropertyNamesContractResolver() })
        //   .GetAsAsync<CustomPropertyResult<List<MajorSearchDto>>>();
        var MajorResult = await url.GetJsonAsync<CustomPropertyResult<List<MajorSearchDto>>>();
        if (MajorResult.success)
        {
            majorlist = MajorResult.response;
        }
        var dbclient = _mongoRepository.Context.GetDatabase("zhiyuan");
        var bejson = dbclient.GetCollection<UniversityDto>("university");
        // 动态条件列表  
        var filterBuilders = new List<FilterDefinition<UniversityDto>>();

        filterBuilders.Add(Builders<UniversityDto>.Filter.Regex(p => p.name, new BsonRegularExpression($"/{dto.KeyWord}/")));
        FilterDefinition<UniversityDto> filter = filterBuilders.Count > 0
        ? Builders<UniversityDto>.Filter.And(filterBuilders)
        : new BsonDocument(); // 如果没有条件，则使用空过滤器  
        var list = await bejson.Find(filter).ToListAsync();
        return new CombinResponseDto()
        {
            universitys = list.Select(c => new CombinUniversityDto()
            {
                cityName = c.cityName,
                collegeCode = c.collegeCode,
                logo = c.logo,
                name = c.name,
                provinceName = c.provinceName,
                _id = c._id,
                utype = c.utype
            }).ToList(),
            majors = majorlist
        };
    }




    /// <summary>
    /// 根据省份和年份查询批次结果
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [ApiDescriptionSettings(Name = "BatchList"), HttpGet]
    [AllowAnonymous]
    public async Task<dynamic> BatchList([FromQuery] BatchResultRequestDto dto)
    {
        if (string.IsNullOrWhiteSpace(dto.locationCode))
        {
            throw Oops.Oh("必填信息为空");
        }
        var years = new int[] { 2024, 2023, 2022, 2021 }.ToList();
        var dbclient = _mongoRepository.Context.GetDatabase("zhiyuan");

        if (!string.IsNullOrWhiteSpace(dto.year))
        {
            var bejson = dbclient.GetCollection<BatchResultDto>($"batchlist_{dto.locationCode}_{dto.year}");
            var result = await bejson.Find(new BsonDocument()).ToListAsync();
            var list = result.FirstOrDefault();
            if (!result.Any() || !list.configList.subjectList.Any() || !list.list.Any())
            {
                return "暂无数据";
            }
            var yearlist = new List<gYearlist>();
            yearlist.Add(new gYearlist() { check = string.IsNullOrWhiteSpace(dto.year) ? true : false, year = "不限" });
            yearlist.AddRange(years.Select(s => new gYearlist()
            {
                check = dto.year == s.ToString() ? true : false,
                year = s.ToString()
            }).ToList());
            list.configList.yearList = yearlist;
            list.configList.subjectList.ForEach(a => { a.check = a.subject_id == dto.type ? true : false; });
            list.configList.subjectList.Insert(0, new gSubjectlist() { check = dto.type.HasValue ? false : true, subject_name = "不限" });

            list.list = list.list.WhereIF(dto.type.HasValue, i => i.subject_id == dto.type).ToList();
            return list;
        }
        else
        {

            var batchlist = new List<BatchResultDto>();
            years.ForEach(a =>
            {
                var bejson = dbclient.GetCollection<BatchResultDto>($"batchlist_{dto.locationCode}_{a.ToString()}");
                var result = bejson.Find(new BsonDocument()).ToList();
                if (result.Any())
                {
                    batchlist.Add(result.FirstOrDefault());
                }
            });
            var resultlist = batchlist.FirstOrDefault();
            var yearlist = new List<gYearlist>();
            yearlist.Add(new gYearlist() { check = string.IsNullOrWhiteSpace(dto.year) ? true : false, year = "不限" });
            yearlist.AddRange(years.Select(s => new gYearlist()
            {
                check = false,
                year = s.ToString()
            }).ToList());
            resultlist.configList.yearList = yearlist;
            resultlist.configList.subjectList.Insert(0, new gSubjectlist() { check = dto.type.HasValue ? false : true, subject_name = "不限" });
            resultlist.configList.subjectList.ForEach(a => { a.check = a.subject_id == dto.type ? true : false; });
            resultlist.list = batchlist.SelectMany(s => s.list).WhereIF(dto.type.HasValue, i => i.subject_id == dto.type).ToList();
            return resultlist;
        }
    }


    [ApiDescriptionSettings(Name = "SyncBatchGaokao"), HttpPost]
    public async Task SyncBatchGaokao()
    {

        //   string baseUrl = "http://api.xuexingaokao.com/api/tool/batch/index?pro=";
        var dbclient = _mongoRepository.Context.GetDatabase("zhiyuan");

        var provinceinfo = await _proviceRep.AsQueryable().Where(e => e.IsDelete == false).ToListAsync();
        var years = new string[] { "2024", "2023", "2022", "2021" }.ToList();

        //provinceinfo.ForEach(a =>
        //{
        //    years.ForEach(y =>
        //    {

        //        //var goresult = $"{baseUrl}{a.Code}&year={y}&subject=&batch=&timestamp={DateTimeOffset.Now.ToUnixTimeSeconds()}".SetJsonSerialization<NewtonsoftJsonSerializerProvider>().GetAsAsync<gaokaoRootobject>().Result;
        //        //if (goresult.code == 1 && goresult.data.list.Any())
        //        //{
        //        //    var newbatchlist = goresult.data.list.Select(s => new gGbatchlist
        //        //    {
        //        //        batch_id = s.batch_id,
        //        //        batch_name = s.batch_name,
        //        //    }).ToList();
        //        //    var subjectList = goresult.data.configList.subjectList.Select(s => new gSubjectlist
        //        //    {
        //        //        subject_id = CalcuScoreFinder.ChangeSubjectName(s.subject_name),
        //        //        subject_name = s.subject_name,
        //        //        check = s.selected,
        //        //    }).ToList();
        //        //    var gbatchList = goresult.data.list.Select(s => new gbatchList()
        //        //    {
        //        //        batch_name = s.batch_name,
        //        //        batch_id = s.batch_id,
        //        //        province_name = s.province_name,
        //        //        year = s.year,
        //        //        subject_id = CalcuScoreFinder.ChangeSubjectName(s.subject_name),
        //        //        subject_name = s.subject_name,
        //        //        province_code = s.province_code,
        //        //        score = s.score
        //        //    }).ToList();

        //        //    var models = new BatchResultDto() { configList = new gConfiglist() { batchList = newbatchlist, subjectList = subjectList }, list = gbatchList, id = 1 };
        //        //    var bejson = dbclient.GetCollection<BatchResultDto>($"batchlist_{a.Code}_{y}");
        //        //    bejson.InsertOne(models);
        //        }

        //    });
        //});
    }



    /// <summary>
    /// 专业数据结构（三层）
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [ApiDescriptionSettings(Name = "Majors"), HttpGet]
    [AllowAnonymous]
    public async Task<dynamic> Majors([FromQuery] MajorRootRequestInput input)
    {

        if (string.IsNullOrWhiteSpace(input.Type))
        {
            return new { code = 0, msg = "Type为必传字段" };
        }
        var filterBuilders = new List<FilterDefinition<GaoKaoMajorRootDto>>();
        filterBuilders.Add(Builders<GaoKaoMajorRootDto>.Filter.Eq(p => p.type, input.Type));
        FilterDefinition<GaoKaoMajorRootDto> filters = filterBuilders.Count > 0
        ? Builders<GaoKaoMajorRootDto>.Filter.And(filterBuilders)
        : new BsonDocument(); // 如果没有条件，则使用空过滤器 
        var result = new List<MajorRootResponseDto>();
        var dbclient = _mongoRepository.Context.GetDatabase("zhiyuan");
        var majortroot = dbclient.GetCollection<GaoKaoMajorRootDto>("zmajorroots");
        var rootlist = await majortroot.Find(filters).ToListAsync();


        // 初始化查询条件
        FilterDefinition<GaoKaoMajorItemDto> filter = Builders<GaoKaoMajorItemDto>.Filter.Empty;
        // 用于存储多个条件的列表
        var filter2 = new List<FilterDefinition<GaoKaoMajorItemDto>>();

        // 如果传入了 nameQuery，则添加 name 模糊查询条件
        if (!string.IsNullOrEmpty(input.KeyWord))
        {
            var nameFilter = Builders<GaoKaoMajorItemDto>.Filter.ElemMatch(x => x.majorMsgs,
                Builders<GaokaoMajorMsgItems>.Filter.Regex(y => y.name, new MongoDB.Bson.BsonRegularExpression(input.KeyWord, "i")));
            filter2.Add(nameFilter);
        }

        // 如果传入了 zymcQuery，则添加 zymc 模糊查询条件
        if (!string.IsNullOrEmpty(input.KeyWord))
        {
            var zymcFilter = Builders<GaoKaoMajorItemDto>.Filter.ElemMatch(x => x.majorMsgs,
                Builders<GaokaoMajorMsgItems>.Filter.ElemMatch(y => y.childMajors,
                    Builders<MajorChildMsg>.Filter.Regex(z => z.zymc, new MongoDB.Bson.BsonRegularExpression(input.KeyWord, "i"))));
            filter2.Add(zymcFilter);
        }

        // 如果有条件，则用 OR 组合，否则使用空过滤器
        if (filter2.Count > 0)
        {
            filter = Builders<GaoKaoMajorItemDto>.Filter.Or(filter2);
        }

        // 查询数据
        var majorChild = dbclient.GetCollection<GaoKaoMajorItemDto>("zmajorchild");
        var childlist = await majorChild.Find(filter).ToListAsync();

        result = rootlist.Select(s => new MajorRootResponseDto()
        {
            type = s.type,
            RootDtos = s.majorMsgs
                .Select(a => new GKMajorRootDto()
                {
                    key = a.key,
                    name = a.name,
                    Count = childlist
                        .Where(e => e.type == a.key)
                        .SelectMany(c => c.majorMsgs)
                        .Where(e => e.childMajors != null && e.childMajors.WhereIF(!string.IsNullOrWhiteSpace(input.KeyWord), f => f.zymc.Contains(input.KeyWord)).Any()) // 过滤掉 childMajors 为空的项
                        .Select(e => new GaokaoMajorMsgItems()
                        {
                            key = e.key,
                            name = e.name,
                            childMajors = e.childMajors
                        }).Count(),
                    ItemsCount = childlist
                        .Where(e => e.type == a.key)
                        .SelectMany(c => c.majorMsgs)
                        .Where(e => e.childMajors != null && e.childMajors.WhereIF(!string.IsNullOrWhiteSpace(input.KeyWord), f => f.zymc.Contains(input.KeyWord)).Any()) // 过滤掉 childMajors 为空的项
                        .Select(e => new GaokaoMajorMsgItems()
                        {
                            key = e.key,
                            name = e.name,
                            childMajors = e.childMajors
                        }).SelectMany(l => l.childMajors).Count(),
                    items = childlist
                        .Where(e => e.type == a.key)
                        .SelectMany(c => c.majorMsgs)
                        .Where(e => e.childMajors != null && e.childMajors.WhereIF(!string.IsNullOrWhiteSpace(input.KeyWord), f => f.zymc.Contains(input.KeyWord)).Any()) // 过滤掉 childMajors 为空的项
                        .Select(e => new GaokaoMajorMsgItems()
                        {
                            key = e.key,
                            name = e.name,
                            childMajors = e.childMajors
                        })
                        .ToList()
                })
                .Where(dto => dto.items.Any()) // 
                .ToList()
        }).ToList();
        // 统计总数
        return result;
    }




    /// <summary>
    /// 专业详情
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [ApiDescriptionSettings(Name = "MajorDetail"), HttpGet]
    [AllowAnonymous]
    public async Task<dynamic> MajorDetail([FromQuery] MajorDetailRequestInput input)
    {
        if (string.IsNullOrWhiteSpace(input.SpecId))
        {
            return "专业id不能为空";
        }
        var dbclient = _mongoRepository.Context.GetDatabase("zhiyuan");
        var majordetail = dbclient.GetCollection<MajorDetailMsg>("zmajordetailmsg");
        // 构造查询条件
        var filter = Builders<MajorDetailMsg>.Filter.Eq(e => e.specId, input.SpecId);
        // 查询单条记录
        var result = await majordetail.Find(filter).FirstOrDefaultAsync();
        if (result == null)
        {
            return "专业数据为空！！！";
        }

        return result;
    }


    /// <summary>
    /// 专业详情-按UI来的数据源
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [ApiDescriptionSettings(Name = "MajorBase"), HttpGet]
    [AllowAnonymous]
    public async Task<dynamic> MajorBase([FromQuery] MajorCarrerInput input)
    {
        if (string.IsNullOrWhiteSpace(input.zydm))
        {
            return "专业id不能为空";
        }
        var dbclient = _mongoRepository.Context.GetDatabase("zhiyuan");
        var majordetail = dbclient.GetCollection<base_Subject>("zbase_majors");
        // 构造查询条件，忽略 subject_code_three 的后缀 T 或 K
        var escapedZydm = Regex.Escape(input.zydm); // 确保输入安全
        var filter = Builders<base_Subject>.Filter.Regex(
            e => e.subject_code_three,
            new BsonRegularExpression($"^{escapedZydm}[TK]?$"));

        // 查询单条记录
        var result = await majordetail.Find(filter).FirstOrDefaultAsync();
        if (result == null)
        {
            return new base_Subject()
            {

                subject_name_two = "专业数据为空！！！"
            };
        }

        return result;
    }



    /// <summary>
    /// 专业关联课程
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [ApiDescriptionSettings(Name = "ZkskcMajor"), HttpGet]
    [AllowAnonymous]
    public async Task<dynamic> ZkskcMajor([FromQuery] MajorDetailRequestInput input)
    {
        if (string.IsNullOrWhiteSpace(input.SpecId))
        {
            return "专业id不能为空";
        }
        var dbclient = _mongoRepository.Context.GetDatabase("zhiyuan");
        var majordetail = dbclient.GetCollection<KskcMsg>("zkskcmajormap");
        // 构造查询条件
        var filter = Builders<KskcMsg>.Filter.Eq(e => e.specId, input.SpecId);
        // 查询单条记录
        var result = await majordetail.Find(filter).FirstOrDefaultAsync();
        if (result == null)
        {
            return "专业数据为空！！！";
        }

        return result;
    }



    /// <summary>
    /// 专业关联院校
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [ApiDescriptionSettings(Name = "ZksyxMajor"), HttpGet]
    [AllowAnonymous]
    public async Task<dynamic> ZksyxMajor([FromQuery] MajorDetailRequestInput input)
    {
        if (string.IsNullOrWhiteSpace(input.SpecId))
        {
            return "专业id不能为空";
        }
        var dbclient = _mongoRepository.Context.GetDatabase("zhiyuan");
        var majordetail = dbclient.GetCollection<KyfxMsg>("zksyxmajormap");
        // 构造查询条件
        var filter = Builders<KyfxMsg>.Filter.Eq(e => e.specId, input.SpecId);
        // 查询单条记录
        var result = await majordetail.Find(filter).FirstOrDefaultAsync();
        if (result == null)
        {
            return "专业数据为空！！！";
        }
        var unviersity = dbclient.GetCollection<UniversityDto>("university");
        // 先确保 result.schSpecList 不为空
        var specNames = result.schSpecList?.Select(x => x.yxmc).ToList();
        if (specNames == null || specNames.Count == 0)
        {
            return "未找到对应院校信息";
        }
        // 构造查询条件，匹配 UniversityDto.name 在 specNames 之中
        var universityFilter = Builders<UniversityDto>.Filter.In(u => u.name, specNames);
        // 查询匹配的大学信息
        var uresult = await unviersity.Find(universityFilter).ToListAsync();
        result.schSpecList.ForEach(a =>
        {

            if (uresult.Any(e => e.name == a.yxmc))
            {
                string featuretag = string.Empty;
                if (uresult.First(e => e.name == a.yxmc).features.Any())
                {
                    featuretag = string.Join("/", uresult.First(e => e.name == a.yxmc).features);
                }
                a.logo = uresult.First(e => e.name == a.yxmc).logo;
                a.ulevel = uresult.First(e => e.name == a.yxmc).level == 0 ? "本科" : "专科";
                a.cityname = uresult.First(e => e.name == a.yxmc).cityName;
                a.featuretag = featuretag;
            }
        });
        result.ssdmList = result.ssdmList.Where(w => !string.IsNullOrWhiteSpace(w.code)).ToList();
        return result;
    }


    /// <summary>
    /// 专业相关就业前景
    /// </summary>
    /// <param name="input">注意这个传入专业代码就是 Key 不是spid</param>
    /// <returns></returns>
    [ApiDescriptionSettings(Name = "CareerProspects"), HttpGet]
    [AllowAnonymous]
    public async Task<CareerProspectItems> CareerProspects([FromQuery] MajorCarrerInput input)
    {
        var result = new CareerProspectItems();
        if (string.IsNullOrWhiteSpace(input.zydm))
        {
            throw Oops.Oh("KeyWord不能为空");
        }
        var dbclient = _mongoRepository.Context.GetDatabase("zhiyuan");
        var carrerprosp = dbclient.GetCollection<CareerProspectsDto>("zz_careerprospects");
        var filter = Builders<CareerProspectsDto>.Filter.Eq(e => e.majorcode, input.zydm);
        var query = await carrerprosp.Find(filter).ToListAsync();
        if (query == null)
        {
            throw Oops.Oh("专业数据为空！！！");
        }
        result.rates = query.Select(s => new DicRate()
        {
            key = s.profession,
            value = s.rate
        }).ToList();
        result.profession = $"{string.Join("、", query.Select(s => s.profession).ToList())}";
        result.jobs = $"该专业毕业生可从事{string.Join(";", query.Select(s => s.jobs).ToList())}";
        return result;

    }





    /// <summary>
    /// 院校招生简章列表根据院校id获取
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [ApiDescriptionSettings(Name = "Recruits"), HttpGet]
    [AllowAnonymous]
    public async Task<dynamic> Recruits([FromQuery] UniversityRecruitsDto dto)
    {
        if (dto.uid <= 0)
        {
            throw Oops.Oh("uid不能为空");
        }
        var dbclient = _mongoRepository.Context.GetDatabase("zhiyuan");
        var recruits = dbclient.GetCollection<RecruitlistRecruit>("zrecruitlist");
        var filter = Builders<RecruitlistRecruit>.Filter.Eq(e => e.base_college_id, dto.uid);
        var result = await recruits.Find(filter).ToListAsync();

        return result;
    }


    /// <summary>
    /// 院校招生简章详情
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [ApiDescriptionSettings(Name = "Recruitdetail"), HttpGet]
    [AllowAnonymous]
    public async Task<dynamic> Recruitdetail([FromQuery] RecruitsDetailDto dto)
    {
        if (dto.id <= 0)
        {
            throw Oops.Oh("id不能为空");
        }
        var dbclient = _mongoRepository.Context.GetDatabase("zhiyuan");
        var recruits = dbclient.GetCollection<RecruitDetailDto>("zrecruitdetail");
        var filter = Builders<RecruitDetailDto>.Filter.Eq(e => e.id, dto.id);
        var result = await recruits.Find(filter).FirstOrDefaultAsync();

        if (recruits == null)
        {
            return "数据为空";
        }

        return result;
    }


    /// <summary>
    /// 高校院系列表根据院校Id获取
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [ApiDescriptionSettings(Name = "Zfacultylist"), HttpGet]
    [AllowAnonymous]
    public async Task<dynamic> Zfacultylist([FromQuery] RecruitsDetailDto dto)
    {
        if (dto.id <= 0)
        {
            throw Oops.Oh("id不能为空");
        }
        var dbclient = _mongoRepository.Context.GetDatabase("zhiyuan");
        var facultys = dbclient.GetCollection<Facultylist>("zfacultylist");
        var filter = Builders<Facultylist>.Filter.Eq(e => e.base_college_id, dto.id);
        var result = await facultys.Find(filter).ToListAsync();

        if (!result.Any())
        {
            return "数据为空";
        }
        // 转换逻辑
        var uniTreeMajorItems = result.Select(faculty => new uniTreeMajorItems
        {
            ParnetId = 0, // Root node
            Id = (int)faculty._id,
            Name = faculty.college_faculty,
            MajorNum = faculty.subject.Count,
            Item = faculty.subject.Select(subject => new uniTreeMajorItems
            {
                ParnetId = (int)faculty._id,
                Id = (int)subject.id,
                Name = subject.faculty_subject,
                MajorNum = 0, // Leaf node
                Item = null
            }).ToList()
        }).ToList();
        return uniTreeMajorItems;
    }


    /// <summary>
    /// 获取院校学科评估
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [ApiDescriptionSettings(Name = "SubjectIntroducelist"), HttpGet]
    [AllowAnonymous]
    public async Task<dynamic> SubjectIntroducelist([FromQuery] RecruitsDetailDto dto)
    {
        if (dto.id <= 0)
        {
            throw Oops.Oh("id不能为空");
        }
        var dbclient = _mongoRepository.Context.GetDatabase("zhiyuan");
        var facultys = dbclient.GetCollection<SubjectIntroduceData>("zsubjectintroduces");
        var filter = Builders<SubjectIntroduceData>.Filter.Eq(e => e.base_college_id, dto.id);
        var result = await facultys.Find(filter).FirstOrDefaultAsync();

        if (facultys == null)
        {
            return "数据为空";
        }
        result.first_subject_list = result.first_subject_list.Where(e => e != "").ToList();
        result.second_subject_list = result.second_subject_list.Where(e => e != "").ToList();
        result.feature_subject_list = result.feature_subject_list.Where(e => e != "").ToList();
        result.stress_subject_list = result.stress_subject_list.Where(e => e != "").ToList();
        result.double_subject_list=result.double_subject_list.Where(e => e != "").ToList();
        result.assessment_subject_list = result.assessment_subject_list.Where(e => e != "").ToList();
        result.assessment_subject_list_new = result.assessment_subject_list_new.Where(e => e.data.Any()).ToList();
        return result;
    }




    /// <summary>
    /// 职业基础数据架构
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [ApiDescriptionSettings(Name = "BaseProfession"), HttpGet]
    [AllowAnonymous]
    public async Task<dynamic> BaseProfession([FromQuery] BaseProfessionRequestInputDto dto)
    {
        var dbclient = _mongoRepository.Context.GetDatabase("zhiyuan");
        var zprofessionitems = dbclient.GetCollection<BaseProfessions>("z_professionitems");
        var filter = Builders<BaseProfessions>.Filter.Empty; // 默认查询所有数据

        if (!string.IsNullOrEmpty(dto.KeyWord))
        {
            filter = Builders<BaseProfessions>.Filter.Or(
                Builders<BaseProfessions>.Filter.Regex("rootName", new BsonRegularExpression(dto.KeyWord, "i")),
                Builders<BaseProfessions>.Filter.Regex("itemDtos.name", new BsonRegularExpression(dto.KeyWord, "i"))
            );
        }
        var list = await zprofessionitems.Find(filter).ToListAsync();
        return list;
    }



    /// <summary>
    /// 职业详情
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [ApiDescriptionSettings(Name = "Professiondetails"), HttpGet]
    [AllowAnonymous]
    public async Task<dynamic> Professiondetails([FromQuery] RecruitsDetailDto dto)
    {
        var dbclient = _mongoRepository.Context.GetDatabase("zhiyuan");
        var zprofession = dbclient.GetCollection<BaseProData>("z_professiondetails");
        var filter = Builders<BaseProData>.Filter.Eq(e => e.id, dto.id);
        var result = await zprofession.Find(filter).FirstOrDefaultAsync();
        if (zprofession == null)
        {
            return "数据为空";
        }
        return result;
    }




    /// <summary>
    /// 获取AIGC问题
    /// </summary>
    /// <returns></returns>
    [ApiDescriptionSettings(Name = "aigcquestionswords"), HttpGet]
    [AllowAnonymous]
    public async Task<dynamic> GetAIGCQuestionsWords()
    {
        var dicy = await _sysDictDataRep.GetListAsync(e => e.DictTypeId == 660782446960709);
        return dicy.Select(s => s.Remark).ToList();
    }





}