App_V2.3/SourceCode/WeApp.Application/TrainingCamp/CampApplicationService.cs

using Abp.Application.Services.Dto;
using Abp.Auditing;
using Abp.Authorization;
using Abp.Configuration;
using Abp.Domain.Repositories;
using Abp.Domain.Uow;
using Abp.Runtime.Caching;

using IwbZero.AppServiceBase;
using IwbZero.Auditing;
using IwbZero.ToolCommon.StringModel;

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using System.Threading.Tasks;
using System.Web.Mvc;

using WeApp.Authorization;
using WeApp.BaseInfo;
using WeApp.BasicInfo;
using WeApp.BasicInfo.PhoneQuestion.Dto;
using WeApp.BasicInfo.StudentTip.Dto;
using WeApp.BasicInfo.TrainingRoleGroup.Dto;
using WeApp.Configuration;
using WeApp.Configuration.Cache;
using WeApp.TrainingCamp.Dto;
using WeApp.TrainingCamp.Dto.Package;

using WeEngine.CommonDto.WeInfo;

namespace WeApp.TrainingCamp
{
    [AbpAuthorize, AuditLog("演练培训营管理")]
    public class CampAppService : IwbAsyncCrudAppService<CampInfo, CampDto, string, IwbPagedRequestDto, CampCreateDto, CampUpdateDto>, ICampAppService
    {
        public CampAppService(
            ICacheManager cacheManager,
            IRepository<CampInfo, string> repository, IRepository<CampGroupInfo, string> groupRepository, IRepository<SysAttachFile> attachRepository, IRepository<CampSceneMapInfo> sceneMapRepository, IRepository<TrainingRoleGroupInfo, string> groupRoleRepository, IRepository<CampRelateGroupRoleInfo> crgRepository, IRepository<PhoneQuestionInfo, string> questionRepository, IRepository<StudentTipInfo, string> studentTipRepository) : base(repository, "Id")
        {
            GroupRepository = groupRepository;
            AttachRepository = attachRepository;
            SceneMapRepository = sceneMapRepository;
            GroupRoleRepository = groupRoleRepository;
            CrgRepository = crgRepository;
            QuestionRepository = questionRepository;
            StudentTipRepository = studentTipRepository;
            CacheManager = cacheManager;
        }

        private string DataCenterUrl => IwbSettingNames.GetWeDataCenterIp(SettingManager);
        protected override bool KeyIsAuto { get; set; } = false;
        protected IRepository<CampGroupInfo, string> GroupRepository { get; }
        protected IRepository<TrainingRoleGroupInfo, string> GroupRoleRepository { get; }
        protected IRepository<CampRelateGroupRoleInfo> CrgRepository { get; }
        protected IRepository<SysAttachFile> AttachRepository { get; }
        protected IRepository<CampSceneMapInfo> SceneMapRepository { get; }
        public IRepository<PhoneQuestionInfo, string> QuestionRepository { get; }
        public IRepository<StudentTipInfo, string> StudentTipRepository { get; }

        #region GetSelect

        [DisableAuditing]
        public override async Task<List<SelectListItem>> GetSelectList()
        {
            var list = await Repository.GetAllListAsync();
            var sList = new List<SelectListItem> { new SelectListItem { Text = @"请选择...", Value = "", Selected = true } };
            foreach (var l in list)
            {
                sList.Add(new SelectListItem { Value = l.Id, Text = l.Name });
            }
            return sList;
        }

        [DisableAuditing]
        public override async Task<string> GetSelectStr()
        {
            var list = await Repository.GetAllListAsync();
            string str = "<option value=\"\" selected>请选择...</option>";
            foreach (var l in list)
            {
                str += $"<option value=\"{l.Id}\">{l.Name}</option>";
            }
            return str;
        }

        /// <summary>
        /// 方案包select
        /// </summary>
        /// <returns></returns>
        [AbpAuthorize(PermissionNames.PagesTrainMgCampMgQuery)]
        public Task<string> GetPackageSelectStr()
        {
            var list = CacheManager.GetPackageInfos(DataCenterUrl);
            string str = "<option value=\"\" selected>请选择方案包...</option>";
            if (list != null && list.Any())
            {
                foreach (var l in list)
                {
                    str += $"<option value=\"{l.Id}\" data-model-type=\"{l.EngineModelType}\" data-model-name=\"{l.EngineModelName}\">{l.PackageName}</option>";
                }
            }

            return Task.FromResult(str);
        }

        /// <summary>
        /// 附件select
        /// </summary>
        /// <returns></returns>
        [AbpAuthorize(PermissionNames.PagesTrainMgCampMgAttach)]
        public async Task<string> GetAttachSelectStr(string no)
        {
            var list = await AttachRepository.GetAllListAsync(a => a.TableName == "Train" && a.ColumnName == "CampPackage" && a.SourceKey.StartsWith(no));
            string str = "<option value=\"\" selected>请选择附件...</option>";
            if (list != null && list.Any())
            {
                foreach (var l in list)
                {
                    str += $"<option value=\"{l.AttachNo}\" >{l.FileTitle}</option>";
                }
            }

            return str;
        }

        #endregion GetSelect

        #region CURD

        [AbpAuthorize(PermissionNames.PagesTrainMgCampMgCreate)]
        public override async Task Create(CampCreateDto input)
        {
            input.Id = await AppGuidManager.GetNextRecordIdAsync(DataLibType.Camp);
            input.CampState = CampStateDefinition.New;
            if (input.AssessRoleNames.IsEmpty())
            {
                input.AssessAuto = false;
            }
            await CreateEntity(input);
        }

        [AbpAuthorize(PermissionNames.PagesTrainMgCampMgUpdate)]
        public override async Task Update(CampUpdateDto input)
        {
            if (input.AssessRoleNames.IsEmpty())
            {
                input.AssessAuto = false;
            }
            var entity = await CheckEntity(input.Id);
            if (input.CampState == CampStateDefinition.Audit)
            {
                if (entity.EvalBehaviorTags.IsEmpty())
                {
                    CheckErrors("请先配置好行为评估标签，再通过审核！");
                }
                if ((await CrgRepository.CountAsync(a => a.CampNo == entity.Id)) == 0)
                {
                    CheckErrors("请先配置好角色预案，再通过审核！");
                }
            }

            await UpdateEntity(input, entity);
        }

        [AbpAuthorize(PermissionNames.PagesTrainMgCampMgDelete)]
        public override async Task Delete(EntityDto<string> input)
        {
            await CheckEntity(input.Id);
            await base.Delete(input);
        }

        [DisableAuditing]
        [AbpAuthorize(PermissionNames.PagesTrainMgCampMgQuery)]
        public override async Task<PagedResultDto<CampDto>> GetAll(IwbPagedRequestDto input)
        {
            var query = CreateFilteredQuery(input);
            query = ApplyFilter(query, input);
            var totalCount = await AsyncQueryableExecuter.CountAsync(query);
            query = ApplySorting(query, input);
            query = ApplyPaging(query, input);
            var entities = await AsyncQueryableExecuter.ToListAsync(query);
            var dtoList = new PagedResultDto<CampDto>(totalCount, entities.Select(MapToEntityDto).ToList());
            return dtoList;
        }

        #region GetEntity/Dto

        /// <summary>
        ///  查询实体Dto
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [DisableAuditing]
        [AbpAuthorize(PermissionNames.PagesTrainMgCampMgQuery)]
        public override async Task<CampDto> GetDto(EntityDto<string> input)
        {
            var entity = await GetEntity(input);
            return MapToEntityDto(entity);
        }

        /// <summary>
        ///  查询实体Dto
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [DisableAuditing]
        [AbpAuthorize(PermissionNames.PagesTrainMgCampMgQuery)]
        public override async Task<CampDto> GetDtoById(string id)
        {
            var entity = await GetEntityById(id);
            return MapToEntityDto(entity);
        }

        /// <summary>
        /// 查询实体Dto（需指明自定义字段）
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        [DisableAuditing]
        [AbpAuthorize(PermissionNames.PagesTrainMgCampMgQuery)]
        public override async Task<CampDto> GetDtoByNo(string no)
        {
            var entity = await GetEntityByNo(no);
            return MapToEntityDto(entity);
        }

        /// <summary>
        /// 查询实体
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [DisableAuditing]
        [AbpAuthorize(PermissionNames.PagesTrainMgCampMgQuery)]
        public override async Task<CampInfo> GetEntity(EntityDto<string> input)
        {
            var entity = await GetEntityById(input.Id);
            return entity;
        }

        /// <summary>
        /// 查询实体
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [DisableAuditing]
        [AbpAuthorize(PermissionNames.PagesTrainMgCampMgQuery)]
        public override async Task<CampInfo> GetEntityById(string id)
        {
            return await Repository.FirstOrDefaultAsync(a => a.Id == id);
        }

        /// <summary>
        /// 查询实体（需指明自定义字段）
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        [DisableAuditing]
        [AbpAuthorize(PermissionNames.PagesTrainMgCampMgQuery)]
        public override async Task<CampInfo> GetEntityByNo(string no)
        {
            //CheckGetPermission();
            if (string.IsNullOrEmpty(KeyFiledName))
            {
                ThrowError("NoKeyFieldName");
            }
            return await base.GetEntityByNo(no);
        }

        #endregion GetEntity/Dto

        #region Hide

        ///// <summary>
        ///// 根据给定的<see cref="IwbPagedRequestDto"/>创建 <see cref="IQueryable{CampInfo}"/>过滤查询.
        ///// </summary>
        ///// <param name="input">The input.</param>
        //protected override IQueryable<CampInfo> CreateFilteredQuery(IwbPagedRequestDto input)
        //{
        //    var query = Repository.GetAll();
        //    var pagedInput = input as IIwbPagedRequest;
        //    if (pagedInput == null)
        //    {
        //        return query;
        //    }
        //    if (!string.IsNullOrEmpty(pagedInput.KeyWords))
        //    {
        //        object keyWords = pagedInput.KeyWords;
        //        LambdaObject obj = new LambdaObject()
        //        {
        //            FieldType = (LambdaFieldType)pagedInput.FieldType,
        //            FieldName = pagedInput.KeyField,
        //            FieldValue = keyWords,
        //            ExpType = (LambdaExpType)pagedInput.ExpType
        //        };
        //        var exp = obj.GetExp<CampInfo>();
        //        query = exp != null ? query.Where(exp) : query;
        //    }
        //    if (pagedInput.SearchList != null && pagedInput.SearchList.Count > 0)
        //    {
        //        List<LambdaObject> objList = new List<LambdaObject>();
        //       foreach (var o in pagedInput.SearchList)
        //        {
        //            if (string.IsNullOrEmpty(o.KeyWords))
        //                continue;
        //           object keyWords = o.KeyWords;
        //            objList.Add(new LambdaObject
        //            {
        //                FieldType = (LambdaFieldType)o.FieldType,
        //                FieldName = o.KeyField,
        //                FieldValue = keyWords,
        //                ExpType = (LambdaExpType)o.ExpType
        //            });
        //        }
        //        var exp = objList.GetExp<CampInfo>();
        //        query = exp != null ? query.Where(exp) : query;
        //    }
        //    return query;
        //}

        //protected override IQueryable<CampInfo> ApplySorting(IQueryable<CampInfo> query, IwbPagedRequestDto input)
        //{
        //    return query.OrderBy(a => a.No);
        //}

        //protected override IQueryable<CampInfo> ApplyPaging(IQueryable<CampInfo> query, IwbPagedRequestDto input)
        //{
        //    if (input is IPagedResultRequest pagedInput)
        //    {
        //        return query.Skip(pagedInput.SkipCount).Take(pagedInput.MaxResultCount);
        //    }
        //    return query;
        //}

        #endregion Hide

        #endregion CURD

        #region CampGroup

        /// <summary>
        /// 检查方案包是否分组
        /// </summary>
        /// <returns></returns>
        [AbpAuthorize(PermissionNames.PagesTrainMgCampMgGroup), DisableAuditing]
        public async Task<string> CheckCampGroup(string no)
        {
            using (CurrentUnitOfWork.DisableFilter(AbpDataFilters.SoftDelete))
            {
                if ((await GroupRepository.GetAllListAsync(a => a.CampNo == no)).Any())
                {
                    return $"/Train/CampGroup/{no}";
                }
            }
            return "";
        }

        /// <summary>
        /// 方案包分组
        /// </summary>
        /// <returns></returns>
        [AbpAuthorize(PermissionNames.PagesTrainMgCampMgGroup), AuditLog("方案包分组")]
        public async Task<string> Group(GroupCreateDto input)
        {
            var entity = await CheckEntity(input.CampNo);

            for (int i = 1; i <= input.Count; i++)
            {
                var group = new CampGroupInfo()
                {
                    CampNo = input.CampNo,
                    Id = $"{input.CampNo}_{i.LeftPad(3)}",
                    Name = $"第{i}组",
                    CampGroupState = CampGroupStateDefinition.New,
                };
                await GroupRepository.InsertAsync(group);
            }

            return $"/Train/CampGroup/{entity.Id}";
        }

        #endregion CampGroup

        #region Attach

        /// <summary>
        /// 配置附件
        /// </summary>
        /// <returns></returns>
        [AbpAuthorize(PermissionNames.PagesTrainMgCampMgAttach), DisableAuditing]
        public async Task<string> CheckAttach(string no)
        {
            var entity = await CheckEntity(no);
            return $"/Train/CampAttach/{entity.Id}";
        }

        /// <summary>
        /// 配置附件
        /// </summary>
        /// <returns></returns>
        [AbpAuthorize(PermissionNames.PagesTrainMgCampMgAttach), AuditLog("配置附件")]
        public async Task AttachFile(CampSceneAttachDto input)
        {
            var entity = await CheckEntity(input.CampNo);
            var sceneAttach = await
                SceneMapRepository.FirstOrDefaultAsync(a => a.CampNo == entity.Id && a.SceneNo == input.SceneNo);
            if (sceneAttach == null)
            {
                sceneAttach = new CampSceneMapInfo()
                {
                    CampNo = input.CampNo,
                    SceneNo = input.SceneNo,
                    SceneName = input.SceneName,
                    AttachNos = input.AttachNos,
                    TipNos = input.TipNos,
                    PhoneQuestionNo = input.PhoneQuestionNos
                };
                await SceneMapRepository.InsertAsync(sceneAttach);
            }
            else
            {
                sceneAttach.AttachNos = input.AttachNos;
                sceneAttach.TipNos = input.TipNos;
                sceneAttach.PhoneQuestionNo = input.PhoneQuestionNos;
                await SceneMapRepository.UpdateAsync(sceneAttach);
                await CurrentUnitOfWork.SaveChangesAsync();
                await CacheManager.GetCache(IwbCacheNames.SceneInfoCache).RemoveAsync($"{entity.Id}-{input.SceneNo}");
                await CacheManager.GetCache(IwbCacheNames.SceneInfoCache).RemoveAsync($"A-{entity.Id}-{input.SceneNo}");
            }
        }

        /// <summary>
        /// 删除情景附件
        /// </summary>
        /// <returns></returns>
        [AbpAuthorize(PermissionNames.PagesTrainMgCampMgAttach), AuditLog("删除情景附件")]
        public async Task DeleteAttach(string no)
        {
            var sceneAttach = await SceneMapRepository.FirstOrDefaultAsync(a => a.AttachNos.Contains(no));
            if (sceneAttach != null)
            {
                CheckErrors($"此附件已被配置，无法删除！");
                return;
            }
            await AttachRepository.DeleteAsync(a => a.AttachNo == no);
        }

        /// <summary>
        /// 获取培训营相关附件
        /// </summary>
        /// <param name="input"></param>
        /// <param name="no"></param>
        /// <returns></returns>
        [AbpAuthorize(PermissionNames.PagesTrainMgCampMgAttach), DisableAuditing]
        public async Task<PagedResultDto<CampSceneAttachDto>> GetSceneAttaches(IwbPagedRequestDto input, string no)
        {
            //var no = input.SearchList?.FirstOrDefault(a=>a.KeyField=="CampNo")?.KeyWords??"";
            var entity = await CheckEntity(no);
            var sceneAttach = await SceneMapRepository.GetAllListAsync(a => a.CampNo == no);
            var package = GetPackageDetail(entity.PackageNo);
            var scenes = package.Scenes;
            var totalCount = scenes.Count;
            var query = scenes.AsQueryable();
            scenes = ApplyFilter(query, input).ToList();
            scenes = scenes.OrderBy(a => a.Id).Skip(input.SkipCount).Take(input.MaxResultCount).ToList();
            var dtoList = new List<CampSceneAttachDto>();
            foreach (var scene in scenes)
            {
                var dto = new CampSceneAttachDto()
                {
                    SceneNo = scene.Id,
                    SceneName = scene.Name,
                    CampNo = no,
                    CampName = entity.Name
                };
                var sceneMap = sceneAttach.FirstOrDefault(a => a.SceneNo == scene.Id);
                if (sceneMap != null)
                {
                    dto.AttachNos = sceneMap.AttachNos;
                    dto.AttachInfos = await AttachRepository.GetAll()
                        .Where(a => sceneMap.AttachNos.Contains(a.AttachNo)).Select(attach => new CampAttachDto()
                        {
                            AttachNo = attach.AttachNo,
                            CampNo = no,
                            FileType = attach.FileType,
                            FileTitle = attach.FileTitle,
                            FileName = attach.FileName,
                            FilePath = attach.FilePath
                        }).ToListAsync();

                    dto.TipNos = sceneMap.TipNos;
                    dto.TipInfos = await StudentTipRepository.GetAll().Where(a => sceneMap.TipNos.Contains(a.Id))
                        .Select(a => new StudentTipDto()
                        {
                            Id = a.Id,
                            Name = a.Name,
                            RoleName = a.RoleName,
                            Content = a.Content
                        }).ToListAsync();
                    dto.PhoneQuestionNos = sceneMap.PhoneQuestionNo;
                    dto.QuestionInfo = await QuestionRepository.GetAll().Where(a => a.Id == sceneMap.PhoneQuestionNo).Select(a => new PhoneQuestionDto
                    {
                        Id = a.Id,
                        Name = a.Name,
                    }).FirstOrDefaultAsync();
                }
                dtoList.Add(dto);
            }
            return new PagedResultDto<CampSceneAttachDto>(totalCount, dtoList);
        }

        /// <summary>
        /// 获取培训营相关附件
        /// </summary>
        /// <param name="input"></param>
        /// <param name="no"></param>
        /// <returns></returns>
        [AbpAuthorize(PermissionNames.PagesTrainMgCampMgAttach), DisableAuditing]
        public async Task<PagedResultDto<CampAttachDto>> GetAttachFiles(IwbPagedRequestDto input, string no)
        {
            //var no = input.SearchList?.FirstOrDefault(a=>a.KeyField=="CampNo")?.KeyWords??"";
            var query = AttachRepository.GetAll()
                .Where(a => a.TableName == "Train" && a.ColumnName == "CampPackage" && a.SourceKey.StartsWith(no)).Select(a =>
                    new CampAttachDto()
                    {
                        AttachNo = a.AttachNo,
                        CampNo = a.SourceKey,
                        FileName = a.FileName,
                        FilePath = a.FilePath,
                        FileType = a.FileType,
                        FileTitle = a.FileTitle,
                        FileExt = a.FileExt
                    });
            query = ApplyFilter(query, input);
            var totalCount = await AsyncQueryableExecuter.CountAsync(query);
            query = query.OrderBy(a => a.CampNo);
            query = query.Skip(input.SkipCount).Take(input.MaxResultCount);
            var entities = await query.ToListAsync();
            return new PagedResultDto<CampAttachDto>(totalCount, entities);
        }

        #endregion Attach

        #region Tag

        /// <summary>
        /// 配置标签
        /// </summary>
        /// <returns></returns>
        [AbpAuthorize(PermissionNames.PagesTrainMgCampMgTag), DisableAuditing]
        public async Task<CampTagDto> GetBehaviorTags(string no)
        {
            var entity = await CheckEntity(no);
            var dto = new CampTagDto()
            {
                CampNo = no,
                BehaviorTagNos = entity.EvalBehaviorTags,
            };
            var package = GetPackageDetail(entity.PackageNo);
            dto.AllTags = package.BehaviorTags.IwbDistinct(a => a.TagNo).OrderBy(a => a.TagNo).ToList();
            return dto;
        }

        /// <summary>
        /// 配置标签
        /// </summary>
        /// <returns></returns>
        [AbpAuthorize(PermissionNames.PagesTrainMgCampMgTag), AuditLog("配置标签")]
        public async Task BehaviorTag(CampTagDto input)
        {
            if (input.BehaviorTagNos.IsEmpty())
            {
                CheckErrors("至少选择一个评估标签！");
            }
            var entity = await CheckEntity(input.CampNo);
            entity.EvalBehaviorTags = input.BehaviorTagNos;
            await Repository.UpdateAsync(entity);
            await CacheManager.GetCache(IwbCacheNames.CampInfoCache).RemoveAsync($"TAG{input.CampNo}");
        }

        #endregion Tag

        #region RoleGroup

        /// <summary>
        /// 获取全部角色预案
        /// </summary>
        /// <returns></returns>
        [AbpAuthorize(PermissionNames.PagesTrainMgCampMgRole), DisableAuditing]
        public async Task<CampRoleGroupDto> GetGroupRoles(string no)
        {
            var entity = await CheckEntity(no);
            var roleGroups = (await GroupRoleRepository.GetAllListAsync()).Select(ObjectMapper.Map<TrainingRoleGroupDto>).ToList();
            var roleGroupNos = await CrgRepository.GetAll().Where(a => a.CampNo == entity.Id).Select(a => a.RoleGroupNo)
                .ToListAsync();
            var dto = new CampRoleGroupDto()
            {
                AllGroups = roleGroups,
                CampNo = no,
                GroupNos = roleGroupNos
            };
            return dto;
        }

        /// <summary>
        /// 角色预案
        /// </summary>
        /// <returns></returns>
        [AbpAuthorize(PermissionNames.PagesTrainMgCampMgRole), AuditLog("角色预案")]
        public async Task RoleGroup(CampRoleGroupDto input)
        {
            var entity = await CheckEntity(input.CampNo);
            if (input.GroupNos != null && input.GroupNos.Any())
            {
                var oldGroupNos = await CrgRepository.GetAll().Where(a => a.CampNo == entity.Id).Select(a => a.RoleGroupNo).ToListAsync();
                foreach (var no in input.GroupNos)
                {
                    if (oldGroupNos.Contains(no))
                    {
                        oldGroupNos.Remove(no);
                    }
                    else
                    {
                        var cgr = new CampRelateGroupRoleInfo()
                        {
                            CampNo = entity.Id,
                            RoleGroupNo = no,
                        };
                        await CrgRepository.InsertAsync(cgr);
                    }
                }
                if (oldGroupNos.Any())
                {
                    await CrgRepository.DeleteAsync(a => oldGroupNos.Contains(a.RoleGroupNo));
                }
            }
            else
            {
                CheckErrors("至少选择一个角色预案！");
            }
        }

        #endregion RoleGroup

        private async Task<CampInfo> CheckEntity(string no)
        {
            var entity = await Repository.FirstOrDefaultAsync(a => a.Id == no);
            if (entity == null)
            {
                CheckErrors($"未查询编号为【{no}】到培训营！");
                return null;
            }
            if (entity.CampState != CampStateDefinition.New && entity.CampState != CampStateDefinition.Audit)
            {
                CheckErrors("培训营已运行，不能操作！");
            }

            return entity;
        }

        #region Package

        /// <summary>
        /// 查询方案包配置信息
        /// </summary>
        /// <param name="id"></param>
        /// <param name="packageNo"></param>
        /// <returns></returns>
        public async Task<PackageSettingDto> GetPackageSetting(string id, string packageNo)
        {
            var dto = new PackageSettingDto();
            if (packageNo.IsEmpty())
            {
                CheckErrors($"方案包编号不能为空！");
                return null;
            }
            var package = CacheManager.GetPackageInfo(packageNo, DataCenterUrl);
            dto.AllRoles = package.AllRoles;
            dto.AssessAuto = package.AssessAuto;
            dto.AssessRoleNames = package.AssessRoleNames;
            dto.RoundScore = 0;
            dto.Variable = package.Variable;
            if (id.IsNotEmpty() && id != "none")
            {
                var entity = await Repository.FirstOrDefaultAsync(a => a.Id == id);
                if (entity == null)
                {
                    CheckErrors($"未查询编号为【{id}】到培训营！");
                    return null;
                }

                if (entity.PackageNo == packageNo)
                {
                    dto.AssessAuto = entity.AssessAuto;
                    dto.AssessRoleNames = entity.AssessRoleNames;
                    dto.RoundScore = entity.RoundScore == 0 ? dto.RoundScore : entity.RoundScore;
                    dto.Variable = entity.Variable.IsEmpty() ? dto.Variable : entity.Variable;
                }
            }
            return dto;
        }

        /// <summary>
        /// 方案包详情
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        [AbpAuthorize(PermissionNames.PagesTrainMgCampMgQuery)]
        public WePackageDetailDto GetPackageDetail(string no)
        {
            var dto = CacheManager.GetPackageDetail(no, DataCenterUrl);
            return dto;
        }

        #endregion Package
    }
}