omega-router/Services/ApiInfoService.cs

using Attribute;
using Dto;
using Vo;
using Model;
using Model.Base;
using Repository;
using Service;
using Microsoft.AspNetCore.Mvc;
using Common;
using Dto.Client;
using Infrastructure;
using Feign;

namespace Services
{
    /// <summary>
    /// api接口Service业务层处理
    /// </summary>
    [AppService(ServiceType = typeof(IApiInfoService), ServiceLifetime = LifeTime.Transient)]
    public class ApiInfoService : BaseService<ApiInfo>, IApiInfoService
    {
        /// <summary>
        /// api接口-列表
        /// </summary>
        /// <param name="parm">请求参数</param>
        /// <returns>api接口列表</returns>
        public PagedInfo<ApiInfoListVo> List([FromQuery] PagerInfo page, [FromQuery] ApiInfoListDto parm)
        {
            //开始拼装查询条件
            var predicate = Expressionable.Create<ApiInfo>();
            predicate = predicate.AndIF(parm.groupId > 0, m => m.groupId == parm.groupId);
            predicate = predicate.AndIF(!string.IsNullOrEmpty(parm.apiName), m => m.apiName.Contains(parm.apiName));
            var response = Queryable()
                .Where(predicate.ToExpression())
                .OrderByDescending(m => m.id)
                .Includes(m => m.apiGroupJoin)
                .ToPage<ApiInfo, ApiInfoListVo>(page);
            return response;
        }

        /// <summary>
        /// api接口-列表
        /// </summary>
        /// <param name="parm">请求参数</param>
        /// <returns>api接口列表</returns>
        public List<ApiInfo> ApiList([FromBody] ApiInfoDto param, List<ApiGroup> groups)
        {
            List<ApiInfo> groupSubs = RedisServer.Cache.LRange<ApiInfo>("appapiinfosub:" + param.groupKind + ":" + param.projectId, 0, -1).ToList();
            if (groupSubs.Count <= 0)
            {
                List<int> ids = groups.Select(m => m.id).ToList();
                groupSubs = GetList(m => ids.Contains(m.groupId)).ToList();
                RedisServer.Cache.LPush("appapiinfosub:" + param.groupKind + ":" + param.projectId, groupSubs.ToArray());
            }
            return groupSubs;
        }


        /// <summary>
        /// 列表属性结构-适配后台的tree-select
        /// </summary>
        /// <returns>列表</returns>
        // public List<TreeVo> getTreeList(List<ApiGroup> groups)
        // {
        //     List<TreeVo> result = new List<TreeVo>();
        //     foreach(var sub in groups)
        //     {
        //         TreeVo item = new TreeVo();
        //         item.label = sub.groupRemark;
        //         item.value = sub.groupName;
        //         var list2 = GetList(m => m.groupId == sub.id);
        //         if(list2.Count > 0)
        //         {
        //             item.children = new List<TreeVo>();
        //             foreach(var sub2 in list2)
        //             {
        //                 TreeVo item2 = new TreeVo();
        //                 item2.label = sub2.apiName;
        //                 item2.value = sub2.apiKey;
        //                 item.children.Add(item2);
        //             }
        //         }
        //         result.Add(item);
        //     }
        //     return result;
        // }



        /// <summary>
        /// 通知-同步接口数据
        /// </summary>
        /// <param name="parm">请求参数</param>
        /// <returns>通知-同步接口数据</returns>
        public void notice([FromBody] Dto.Client.NoticeInfoDto param, int groupId, int groupProject, int groupKind)
        {
            string ApiRouter = param.apiRouter;
            string ApiPort = param.apiPort;
            string ApiHost = param.apiHost;
            string ApiKey = param.apiKey;
            string ApiName = param.apiName;
            string ApiMethod = param.apiMethod;

            ApiInfo apiInfo = GetFirst(m => m.groupId == groupId && m.apiKey == ApiKey && m.version == groupProject);
            if (apiInfo == null)
            {
                Add(new ApiInfo()
                {
                    createDate = DateTime.Now,
                    apiKey = string.Concat(ApiKey[..1].ToLower(), ApiKey.AsSpan(1)),
                    apiRouter = ApiRouter,
                    apiPort = int.Parse(Function.CheckInt(ApiPort)),
                    apiHost = ApiHost,
                    apiName = ApiName,
                    apiMethod = ApiMethod,
                    groupId = groupId,
                    version = groupProject,
                });
                if (groupKind == 1)
                {
                    string ApiPath = param.apiPath;
                    string ApiEnName = param.apiEnName;
                    string module = ApiPath.Split('/')[1];
                    string rootPath = ApiPath.Split('/')[2];
                    IAdmin.sycnMenu(new AddMenuFromApiDto()
                    {
                        module = module,
                        apiEnName = ApiEnName,
                        apiPath = ApiPath,
                        apiName = ApiName,
                        rootPath = rootPath,
                    });
                }
            }
            else
            {
                apiInfo.apiRouter = ApiRouter;
                apiInfo.apiPort = int.Parse(Function.CheckInt(ApiPort));
                apiInfo.apiHost = ApiHost;
                apiInfo.apiName = ApiName;
                apiInfo.apiMethod = ApiMethod;
                Update(apiInfo, true);
            }
        }

        /// <summary>
        /// 通知-同步接口数据
        /// </summary>
        /// <param name="parm">请求参数</param>
        /// <returns>通知-同步接口数据</returns>
        public void noticeAll([FromBody] List<NoticeGroupDto> param)
        {
            var apiGroupService = App.GetService<IApiGroupService>();
            foreach (NoticeGroupDto data in param)
            {
                int groupId = apiGroupService.notice(data);
                List<NoticeInfoDto> apiLists = data.child;
                foreach (NoticeInfoDto apiList in apiLists)
                {
                    notice(apiList, groupId, data.groupProject, data.groupKind);
                }
                RedisServer.Cache.Del(new string[] { "appapigroup:" + data.groupKind + ":" + data.groupProject, "appapiinfo:" + data.groupKind + ":" + data.groupProject, "appapiinfosub:" + data.groupKind + ":" + data.groupProject });
            }
        }

        /// <summary>
        /// 获取接口数据
        /// </summary>
        /// <param name="parm">请求参数</param>
        /// <returns>获取接口数据</returns>
        public Dictionary<string, object> apiInfoList([FromBody] ApiInfoDto param, List<ApiGroup> groups, List<ApiInfo> groupSubs)
        {
            Dictionary<string, object> obj = new Dictionary<string, object>();
            Dictionary<string, int> groupobj = new Dictionary<string, int>();
            if (param.groups.Count > 0)
            {
                foreach (ApiInfoSubDto sub in param.groups)
                {
                    string name = sub.name;
                    int version = sub.version;
                    groupobj.Add(name, version);
                }
            }
            foreach (var group in groups)
            {
                int curVersion = int.Parse(Function.CheckInt(group.groupVersion));
                if (groupobj.Any(m => m.Key == group.groupName && m.Value < curVersion))
                {
                    Dictionary<string, object> groupData = new Dictionary<string, object>();
                    var apis = groupSubs.Where(m => m.groupId == group.id && m.version == param.projectId).ToList();
                    foreach (var api in apis)
                    {
                        Dictionary<string, object> apiData = new Dictionary<string, object>();
                        string url = api.apiHost;
                        if (api.apiPort != 80 && api.apiPort != 443)
                        {
                            url += ":" + api.apiPort;
                        }
                        url += api.apiRouter;
                        apiData.Add("name", api.apiName);
                        apiData.Add("url", url);
                        apiData.Add("method", api.apiMethod);
                        groupData.Add(api.apiKey, apiData);
                    }
                    groupData.Add("groupVersion", group.groupVersion);
                    groupData.Add("groupInfo", group.groupRemark);
                    obj.Add(group.groupName, groupData);
                }
            }
            return obj;
        }
    }
}