omega-router/Services/ApiGroupService.cs

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

namespace Services
{
    /// <summary>
    /// api接口分组Service业务层处理
    /// </summary>
    [AppService(ServiceType = typeof(IApiGroupService), ServiceLifetime = LifeTime.Transient)]
    public class ApiGroupService : BaseService<ApiGroup>, IApiGroupService
    {
        /// <summary>
        /// api接口分组-列表
        /// </summary>
        /// <param name="parm">请求参数</param>
        /// <returns>api接口分组列表</returns>
        public PagedInfo<ApiGroupListVo> List([FromQuery] ApiGroupListDto parm)
        {
            //开始拼装查询条件
            var predicate = Expressionable.Create<ApiGroup>();
            predicate = predicate.AndIF(!string.IsNullOrEmpty(parm.groupName), m => m.groupName.Contains(parm.groupName));
            var response = Queryable()
                .Where(predicate.ToExpression())
                .OrderByDescending(m => m.id)
                .ToPage<ApiGroup, ApiGroupListVo>(new PagerInfo());
            return response;
        }

        /// <summary>
        /// api分组-列表
        /// </summary>
        /// <param name="parm">请求参数</param>
        /// <returns>api分组列表</returns>
        public List<ApiGroup> ApiList([FromBody] Dto.Client.ApiInfoDto param)
        {
            List<ApiGroup> groups = RedisServer.Cache.LRange<ApiGroup>("appapiinfo:" + param.groupKind + ":" + param.projectId, 0, -1).ToList();
            if (groups.Count <= 0)
            {
                groups = GetList(m => m.groupKind == param.groupKind && m.version == param.projectId);
                RedisServer.Cache.LPush("appapiinfo:" + param.groupKind + ":" + param.projectId, groups.ToArray());
            }
            return groups;
        }



        /// <summary>
        /// api分组-列表
        /// </summary>
        /// <param name="parm">请求参数</param>
        /// <returns>api分组列表</returns>
        public List<ApiListVo> groups([FromBody] Dto.Client.ApiGroupDto param)
        {
            if (param.key != "ym#2024")
            {
                throw new CustomException(ResultCode.FAIL, "无权限");
            }
            List<ApiListVo> list = RedisServer.Cache.LRange<ApiListVo>("appapigroup:" + param.groupKind + ":" + param.projectId, 0, -1).ToList();
            if (list.Count > 0)
            {
                return list;
            }
            var groups = GetList(m => m.groupKind == param.groupKind && m.version == param.projectId).Select(m => new ApiListVo() { groupName = m.groupName, groupVersion = m.groupVersion }).ToArray();
            RedisServer.Cache.LPush("appapigroup:" + param.groupKind + ":" + param.projectId, groups);
            return groups.ToList();
        }





        /// <summary>
        /// api接口分组-下拉框数据
        /// </summary>
        /// <returns>api接口分组下拉框数据</returns>
        public PagedInfo<ApiGroupSelectListVo> SelectList()
        {
            //开始拼装查询条件
            var predicate = Expressionable.Create<ApiGroup>();
            var response = Queryable()
                .Where(predicate.ToExpression())
                .OrderByDescending(m => m.id)
                .ToPage<ApiGroup, ApiGroupSelectListVo>(new PagerInfo());
            return response;
        }




        /// <summary>
        /// api接口分组-列表
        /// </summary>
        /// <param name="parm">请求参数</param>
        /// <returns>api接口分组列表</returns>
        public List<ApiGroup> apiList([FromQuery] Dto.Client.ApiGroupListDto param)
        {
            if(param.key != "omega")
            {
                throw new CustomException("口令不正确");
            }
            //开始拼装查询条件
            var predicate = Expressionable.Create<ApiGroup>();
            predicate = predicate.And(m => m.version == param.projectId && m.groupKind == param.groupKind);
            var response = Queryable()
                .Where(predicate.ToExpression())
                .Includes(m => m.apiInfo)
                .ToList();
            return response;
        }




        /// <summary>
        /// 通知-同步接口分组数据
        /// </summary>
        /// <param name="parm">请求参数</param>
        /// <returns>通知-同步接口分组数据</returns>
        public int notice([FromBody] Dto.Client.NoticeGroupDto param)
        {
            string id = param.id;
            string groupName = param.groupName;
            string groupRemark = param.groupRemark;
            int groupKind = param.groupKind;
            int groupProject = param.groupProject;
            int groupId = 0;
            ApiGroup group = GetFirst(m => m.groupName == groupName && m.groupKind == groupKind && m.version == groupProject);
            if (group == null)
            {
                groupId = InsertReturnIdentity(new ApiGroup()
                {
                    createDate = DateTime.Now,
                    groupName = groupName,
                    groupRemark = groupRemark,
                    groupKind = groupKind,
                    groupVersion = "1",
                    version = groupProject,
                });
            }
            else
            {
                groupId = group.id;
                group.updateDate = DateTime.Now;
                group.groupRemark = groupRemark;
                int groupVersion = int.Parse(group.groupVersion) + 1;
                group.groupVersion = groupVersion.ToString();
                Update(group, true);
            }
            return groupId;
        }
    }
}