App_V2.3/SourceCode/WeApp.Application/TrainingEval/EvalAppService.cs

using Abp.Auditing;
using Abp.Authorization;
using Abp.Configuration;
using Abp.Domain.Repositories;
using Abp.Runtime.Caching;

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

using Microsoft.AspNet.SignalR;

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;

using WeApp.BaseInfo;
using WeApp.BasicInfo;
using WeApp.CommonManager.MqttClient;
using WeApp.Configuration;
using WeApp.Configuration.Cache;
using WeApp.Hubs;
using WeApp.TrainingCamp;
using WeApp.TrainingEval.Dto;

using WeEngine.CommonDto;
using WeEngine.Packages;

namespace WeApp.TrainingEval
{
    [AbpAuthorize, AuditLog("演练培训营评估")]
    public class EvalAppService : IwbAppServiceBase, IEvalAppService
    {
        public EvalAppService(IRepository<CampInfo, string> campRepository, IRepository<CampGroupInfo, string> groupRepository, IRepository<GroupScoreInfo> gsRepository, IRepository<GroupLogInfo> glRepository, ICacheManager cacheManager, IRepository<TrainingGroupRelateRoleInfo> grrRepository, IRepository<GroupRoleInfo> groupRoleRepository, IRepository<CampSceneMapInfo> sceneMapRepository, IRepository<SysAttachFile> attachRepository, WeAppMsgClientManager msgClientManager, IRepository<PhoneQuestionInfo, string> questionRepository, IRepository<PhoneAnswerInfo> answerRepository)
        {
            CampRepository = campRepository;
            GroupRepository = groupRepository;
            GsRepository = gsRepository;
            GlRepository = glRepository;
            GrrRepository = grrRepository;
            GroupRoleRepository = groupRoleRepository;
            SceneMapRepository = sceneMapRepository;
            AttachRepository = attachRepository;
            MsgClientManager = msgClientManager;
            QuestionRepository = questionRepository;
            AnswerRepository = answerRepository;
            CacheManager = cacheManager;
            IwbHubContext = GlobalHost.ConnectionManager.GetHubContext<IwbHub>();
        }

        //private string DataCenterUrl =>  SettingManager.GetSettingValue(IwbSettingNames.WeDataCenterIp).Ew("/");
        private string EngineApiUrl => SettingManager.GetSettingValue(IwbSettingNames.WeEngineIp).Ew("/");

        protected IHubContext IwbHubContext { get; }
        private bool HasReStart { get; set; }

        protected WeAppMsgClientManager MsgClientManager { get; }
        protected IRepository<CampInfo, string> CampRepository { get; }
        protected IRepository<CampGroupInfo, string> GroupRepository { get; }
        protected IRepository<GroupScoreInfo> GsRepository { get; }
        protected IRepository<GroupLogInfo> GlRepository { get; }
        protected IRepository<TrainingGroupRelateRoleInfo> GrrRepository { get; }
        protected IRepository<GroupRoleInfo> GroupRoleRepository { get; }
        protected IRepository<CampSceneMapInfo> SceneMapRepository { get; }
        protected IRepository<SysAttachFile> AttachRepository { get; }
        protected IRepository<PhoneQuestionInfo, string> QuestionRepository { get; }
        protected IRepository<PhoneAnswerInfo> AnswerRepository { get; }

        #region Operation

        /// <summary>
        /// 进入演练页面成功后反馈
        /// </summary>
        /// <param name="no"></param>
        [AbpAllowAnonymous]
        public bool StartFeedback(string no)
        {
            return WeAppMsgClientManager.StartPushScene(no);
        }

        /// <summary>
        /// 启动培训营
        /// </summary>
        /// <param name="campNo"></param>
        /// <param name="groupNo"></param>
        /// <returns></returns>
        [AuditLog("启动培训营")]
        public async Task StartCamp(string campNo, string groupNo)
        {
            CampInfo camp;
            List<string> groupNos = new List<string>();
            CampGroupInfo group = null;
            if (groupNo == "none")
            {
                camp = await CampRepository.FirstOrDefaultAsync(a => a.Id == campNo);
                if (camp.CampState == CampStateDefinition.Run)
                {
                    CheckErrors("培训营已运行，不能操作！");
                }
                var groups = await GroupRepository.GetAll().Where(a => a.CampNo == campNo).OrderBy(a => a.Id).ToListAsync();
                foreach (var g in groups)
                {
                    if (g.CampGroupState >= CampGroupStateDefinition.Run &&
                        g.CampGroupState < CampGroupStateDefinition.Ready)
                    {
                        continue;
                    }
                    group = g;
                    groupNos.Add(g.Id);
                    WeAppMsgClientManager.StopPushScene(g.Id);
                    await WriteLog(g.CampNo, g.Id, g.RoundIndex, LogCommandDefinition.Start);
                    //if (WeAppMsgClientManager.StartGroupNos.Contains(g.Id))
                    //{
                    //    WeAppMsgClientManager.StartGroupNos.Remove(g.Id);
                    //}
                }
            }
            else
            {
                group = await CheckGroup(groupNo, isStart: true);
                await WriteLog(group.CampNo, groupNo, group.RoundIndex, LogCommandDefinition.Start);
                groupNos.Add(groupNo);
                camp = group.CampInfo;
                if (group.CampGroupState == CampGroupStateDefinition.Run)
                {
                    CheckErrors($"培训营[{group.Name}]已运行，不能操作！");
                }
                //if (WeAppMsgClientManager.StartGroupNos.Contains(groupNo))
                //{
                //    WeAppMsgClientManager.StartGroupNos.Remove(groupNo);
                //}
            }
            if (camp == null)
            {
                CheckErrors($"未查询编号为【{campNo}】到培训营！");
                return;
            }
            if (camp.CampState == CampStateDefinition.New)
            {
                CheckErrors("培训营未审核，请先通过审核后再试！");
            }
            else if (camp.CampState == CampStateDefinition.End)
            {
                CheckErrors("培训营已结束，不能操作！");
            }
            WeAppMsgClientManager.StopPushScene(groupNo);

            RunStartPackageDto dto = new RunStartPackageDto()
            {
                PackageId = camp.PackageNo,
                AssessAuto = camp.AssessAuto,
                AssessRoles = camp.AssessRoleNames?.Split(',').ToList() ?? new List<string>(),
                AutoNextRound = false,
                RoundScore = camp.RoundScore,
                Variable = camp.Variable,
                GroupNos = groupNos,
                TargetClientId = MsgClientManager.ClientId
            };
            var url = $"{EngineApiUrl}api/services/Engine/Run/Start";
            var result = url.RequestPost(dto.Obj2String());
            if (result.Contains("\"success\":false"))
            {
                CheckErrors("培训营启动失败！");
            }
            if (group != null)
                await UpdateStep(new StepDto()
                {
                    CampNo = campNo,
                    StepId = "1_1"
                });
        }

        /// <summary>
        /// 停止培训营
        /// </summary>
        /// <param name="campNo"></param>
        /// <param name="groupNo"></param>
        /// <returns></returns>
        [AuditLog("停止培训营")]
        public async Task StopCamp(string campNo, string groupNo)
        {
            if (groupNo == "none")
            {
                var groups = await GroupRepository.GetAll().Where(a => a.CampNo == campNo && a.CampGroupState != CampGroupStateDefinition.End).OrderBy(a => a.Id).ToListAsync();
                foreach (var g in groups)
                {
                    await WriteLog(g.CampNo, g.Id, g.RoundIndex, LogCommandDefinition.End);
                    g.EngDate = g.EngDate ?? DateTime.Now;

                    g.CampGroupState = CampGroupStateDefinition.End;
                    await GroupRepository.UpdateAsync(g);
                    ReloadPage(g.CampNo);
                }
            }
            else
            {
                var group = await CheckGroup(groupNo);
                if (group.CampGroupState != CampGroupStateDefinition.End)
                {
                    group.EngDate = group.EngDate ?? DateTime.Now;
                    group.CampGroupState = CampGroupStateDefinition.End;
                    await GroupRepository.UpdateAsync(group);
                    await WriteLog(group.CampNo, groupNo, group.RoundIndex, LogCommandDefinition.End);
                    await UnitOfWorkManager.Current.SaveChangesAsync();
                    ReloadPage(group.CampNo);
                }
            }
        }

        /// <summary>
        /// 结束培训营
        /// </summary>
        /// <param name="campNo"></param>
        /// <returns></returns>
        [AuditLog("结束培训营")]
        public async Task EndCamp(string campNo)
        {
            var camp = await CampRepository.FirstOrDefaultAsync(a => a.Id == campNo);
            if (camp != null && camp.CampState != CampStateDefinition.End)
            {
                camp.EngDate = camp.EngDate ?? DateTime.Now;
                camp.CampState = CampStateDefinition.End;
                await CampRepository.UpdateAsync(camp);
            }
        }

        /// <summary>
        /// 等待报告生成
        /// </summary>
        /// <param name="campNo"></param>
        /// <param name="groupNo"></param>
        /// <returns></returns>
        [AuditLog("等待报告生成")]
        public async Task WaitReport(string campNo, string groupNo)
        {
            var date = DateTime.Now;
            CampInfo camp;
            if (groupNo == "none")
            {
                camp = await CampRepository.FirstOrDefaultAsync(a => a.Id == campNo);
                if (camp.CampState == CampStateDefinition.End)
                {
                    CheckErrors("演练已结束，不能操作");
                }
                var groups = await GroupRepository.GetAll().Where(a => a.CampNo == campNo).OrderBy(a => a.Id).ToListAsync();
                foreach (var g in groups)
                {
                    await WriteLog(g.CampNo, g.Id, g.RoundIndex, LogCommandDefinition.End);
                    g.CampGroupState = CampGroupStateDefinition.Report;
                    g.EngDate = date;
                    g.TrainingMinute = Convert.ToDateTime(g.StartDate).GetTimeSpanMinute(date);
                    await GroupRepository.UpdateAsync(g);
                    ReloadPage(g.CampNo);
                }
            }
            else
            {
                var group = await CheckGroup(groupNo);
                camp = group.CampInfo;
                if (camp.CampState == CampStateDefinition.End)
                {
                    CheckErrors("演练已结束，不能操作");
                }
                group.CampGroupState = CampGroupStateDefinition.Report;
                group.EngDate = date;
                group.TrainingMinute = Convert.ToDateTime(group.StartDate).GetTimeSpanMinute(date);
                await GroupRepository.UpdateAsync(group);
                await WriteLog(group.CampNo, groupNo, group.RoundIndex, LogCommandDefinition.End);
                ReloadPage(group.CampNo);
            }
            camp.EngDate = date;
            await CampRepository.UpdateAsync(camp);
        }

        /// <summary>
        /// 重启培训营
        /// </summary>
        /// <param name="campNo"></param>
        /// <param name="groupNo"></param>
        /// <returns></returns>
        [AuditLog("重启培训营")]
        public async Task ReStartCamp(string campNo, string groupNo)
        {
            CampInfo camp;
            var groups = new List<CampGroupInfo>();
            if (groupNo == "none")
            {
                camp = await CampRepository.FirstOrDefaultAsync(a => a.Id == campNo);
                groups = await GroupRepository.GetAll().Where(a => a.CampNo == campNo).OrderBy(a => a.Id).ToListAsync();
                //groupNos = groups.Select(a => a.Id).ToList();
                foreach (var g in groups)
                {
                    await WriteLog(g.CampNo, g.Id, g.RoundIndex, LogCommandDefinition.Start);
                }
            }
            else
            {
                var group = await CheckGroup(groupNo, isStart: true);
                await WriteLog(group.CampNo, groupNo, group.RoundIndex, LogCommandDefinition.Start);
                groups.Add(group);
                camp = group.CampInfo;
            }
            if (camp == null)
            {
                CheckErrors($"未查询编号为【{campNo}】到培训营！");
                return;
            }
            if (camp.CampState == CampStateDefinition.New)
            {
                CheckErrors("培训营未审核，请先通过审核后再试！");
            }
            else if (camp.CampState == CampStateDefinition.End)
            {
                CheckErrors("培训营已结束，不能操作！");
            }

            foreach (var g in groups)
            {
                //ReStartPackageDto dto = new ReStartPackageDto()
                //{
                //    PackageId = camp.PackageNo,
                //    AutoNextRound = false,
                //    RunningInfo = g.RunningInfo,
                //    TargetClientId = MsgClientManager.ClientId
                //};
                //var url = $"{EngineApiUrl}api/services/Engine/Run/ReStart";
                //var result = url.RequestPost(dto.Obj2String());
                //if (result.Contains("\"success\":false"))
                //{
                //    CheckErrors("培训营启动失败！");
                //}
                ReStartGroup(g);
                Thread.Sleep(3000);
            }
        }

        /// <summary>
        /// 重启分组
        /// </summary>
        /// <param name="group"></param>
        /// <returns></returns>
        private bool ReStartGroup(CampGroupInfo group)
        {
            ReStartPackageDto dto = new ReStartPackageDto()
            {
                PackageId = group.CampInfo?.PackageNo,
                AutoNextRound = false,
                RunningInfo = group.RunningInfo,
                TargetClientId = MsgClientManager.ClientId
            };
            var url = $"{EngineApiUrl}api/services/Engine/Run/ReStart";
            var result = url.RequestPost(dto.Obj2String());
            if (result.Contains("\"success\":false"))
            {
                return false;
            }

            return true;
        }

        /// <summary>
        /// 下一轮次
        /// </summary>
        /// <param name="campNo"></param>
        /// <param name="groupNo"></param>
        /// <returns></returns>
        [AuditLog("下一轮次")]
        public async Task NextRound(string campNo, string groupNo)
        {
            string dataStr = "";
            string url = $"{EngineApiUrl}api/services/Engine/Run/NextRound";
            CampGroupInfo group = null;
            if (groupNo == "none")
            {
                var entity = await CampRepository.FirstOrDefaultAsync(a => a.Id == campNo);
                if (entity == null)
                {
                    CheckErrors($"未查询编号为【{campNo}】到培训营！");
                    return;
                }
                if (entity.CampState == CampStateDefinition.New)
                {
                    CheckErrors("培训营未审核，请先通过审核后再试！");
                }

                if (entity.CampState == CampStateDefinition.End)
                {
                    CheckErrors("培训营已结束！");
                }

                var groups = await GroupRepository.GetAll().Where(a => a.CampNo == campNo).OrderBy(a => a.Id).ToListAsync();
                //var groupNos = groups.Select(a => a.Id).ToList();
                //dataStr = new {GroupNos = groupNos}.Obj2String();

                foreach (var g in groups)
                {
                    var postUrl = $"{url}?groupNo={g.Id}";
                    Post(postUrl, dataStr, g);
                    group = g;
                    await WriteLog(g.CampNo, g.Id, g.RoundIndex, LogCommandDefinition.NextRound);
                    Thread.Sleep(1000);
                }
            }
            else
            {
                group = await CheckGroup(groupNo);
                await WriteLog(campNo, groupNo, group.RoundIndex, LogCommandDefinition.NextRound);
                url = $"{url}?groupNo={groupNo}";
                Post(url, dataStr, group);
            }

            if (group != null)
                await UpdateStep(new StepDto()
                {
                    CampNo = campNo,
                    StepId = $"{group.RoundIndex + 1}_1"
                });
        }

        /// <summary>
        /// 操作培训营分组
        /// </summary>
        /// <param name="url"></param>
        /// <param name="dataStr"></param>
        /// <param name="group"></param>
        /// <param name="send"></param>
        private void Post(string url, string dataStr, CampGroupInfo group = null, bool send = true)
        {
            var result = url.RequestPost(dataStr);
            if (result.Contains("\"success\":false"))
            {
                if (!HasReStart && group != null && ReStartGroup(group))
                {
                    HasReStart = true;
                    Post(url, dataStr, group, send);
                }
                else
                {
                    HasReStart = false;
                    CheckErrors("培训营操作失败！");
                }
            }
            else if (send && group != null)
            {
                IwbHubContext.Clients.Group(group.CampNo).getDisabledScene(group.Id);
            }
        }

        /// <summary>
        /// 下一情景流节点
        /// </summary>
        /// <param name="campNo"></param>
        /// <param name="groupNo"></param>
        /// <returns></returns>
        [AbpAllowAnonymous, AuditLog("下一情景流节点")]
        public async Task NextFlowNode(string campNo, string groupNo)
        {
            string url = "", dataStr = "";
            url = $"{EngineApiUrl}api/services/Engine/Run/NextGroupFlowNodes{url}";
            if (groupNo == "none")
            {
                var entity = await CampRepository.FirstOrDefaultAsync(a => a.Id == campNo);
                if (entity == null)
                {
                    CheckErrors($"未查询编号为【{campNo}】到培训营！");
                    return;
                }
                if (entity.CampState == CampStateDefinition.New)
                {
                    CheckErrors("培训营未审核，请先通过审核后再试！");
                }

                if (entity.CampState == CampStateDefinition.End)
                {
                    CheckErrors("培训营已结束！");
                }

                var groups = await GroupRepository.GetAll().Where(a => a.CampNo == campNo).ToListAsync();
                //var groupNos = await GroupRepository.GetAll().Where(a => a.CampNo == campNo).Select(a => a.Id).ToListAsync();

                //var dto = new RunGroupPackageDto()
                //{
                //    GroupNos = groupNos
                //};
                //dataStr = dto.Obj2String();
                foreach (var g in groups)
                {
                    var postUrl = $"{url}?groupNo={g.Id}";
                    Post(postUrl, dataStr, g);
                    await WriteLog(g.CampNo, g.Id, g.RoundIndex, LogCommandDefinition.NextNode);
                    await ChangeLogState(g.Id);
                    Thread.Sleep(1000);
                    await SyncSysScore(g);
                }
                //for (int i = 0; i < groupNos.Count; i++)
                //{
                //    if (i == 0)
                //    {
                //        var group = await GroupRepository.FirstOrDefaultAsync(a => a.Id == groupNos[0]);
                //        if (group != null)
                //        {
                //        }
                //    }

                //    await ChangeLogState(g.Id);

                //}
            }
            else
            {
                var group = await CheckGroup(groupNo);
                await ChangeLogState(group);
                await WriteLog(group.CampNo, groupNo, group.RoundIndex, LogCommandDefinition.NextNode);
                url = $"{url}?groupNo={groupNo}";
                Post(url, dataStr, group);
                await SyncSysScore(group);
            }

            //var result = url.RequestPost(dataStr);
            //if (result.Contains("\"success\":false"))
            //{
            //    CheckErrors("培训营操作失败！");
            //}
        }

        /// <summary>
        /// 情景流下一阶段后延迟10秒主动同步系统得分
        /// </summary>
        /// <param name="group"></param>
        /// <returns></returns>
        private Task SyncSysScore(CampGroupInfo group)
        {
            Task task = Task.Factory.StartNew(async () =>
            {
                var gs = CacheManager.GetGroupRoundScore(group.Id, group.RoundIndex, GsRepository).Result;
                if (gs != null)
                {
                    await Task.Delay(1000 * 10);
                    var runningInfo = await CacheManager.GetGroupRunningInfo(group.Id, GroupRepository);
                    gs.SystemScore = runningInfo.FullScore != 0 ? runningInfo.RoundScore * runningInfo.SystemScore / runningInfo.FullScore : 0;
                    await GsRepository.UpdateAsync(gs);
                }
            });

            return task;
        }

        /// <summary>
        /// 更新当前演练阶段
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [AuditLog("更新当前演练阶段")]
        public async Task UpdateStep(StepDto input)
        {
            var step = StepList.GetStepInfo(input.StepId);
            if (step != null)
            {
                await WriteLog(input.CampNo, null, 0, LogCommandDefinition.Step, step.Obj2String());
                IwbHubContext.Clients.Group(input.CampNo).getUpdateStep(step);
            }
        }

        private async Task<CampGroupInfo> CheckGroup(string groupNo, CampGroupInfo group = null, bool isStart = false)
        {
            group = group ?? await GroupRepository.GetAllIncluding(a => a.CampInfo).FirstOrDefaultAsync(a => a.Id == groupNo);
            if (group == null)
            {
                CheckErrors($"未查询编号为【{groupNo}】到培训营！");
                return null;
            }
            if (group.CampGroupState == CampGroupStateDefinition.End)
            {
                CheckErrors("培训营已结束，不能操作！");
            }
            else if (group.CampGroupState != CampGroupStateDefinition.Run && !isStart)
            {
                CheckErrors("培训营未运行，不能操作！");
            }

            return group;
        }

        private async Task ChangeLogState(string no)
        {
            var group = await GroupRepository.FirstOrDefaultAsync(a => a.Id == no);
            if (group != null)
            {
                await ChangeLogState(group);
            }
        }

        private async Task ChangeLogState(CampGroupInfo group)
        {
            var logList = await GlRepository.GetAllListAsync(a =>
                a.GroupNo == group.Id && a.RoundIndex == group.RoundIndex &&
                a.LogType == LogTypeDefinition.SceneOperation &&
                (a.LogState == LogStateDefinition.New || a.LogState == LogStateDefinition.Submit || a.LogState == LogStateDefinition.HasMatch));
            if (logList.Any())
            {
                foreach (var log in logList)
                {
                    log.LogState = log.LogState == LogStateDefinition.New ? LogStateDefinition.NotSend :
                        log.LogState == LogStateDefinition.Submit ? LogStateDefinition.Send : log.LogState == LogStateDefinition.HasMatch ? LogStateDefinition.HasSendMatch : log.LogState;
                    await GlRepository.UpdateAsync(log);
                }
            }
        }

        /// <summary>
        /// 提交情景处理
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [AbpAllowAnonymous, AuditLog("提交情景处理")]
        public async Task SaveOperationScene(RunOperationDto input)
        {
            var group = await GroupRepository.FirstOrDefaultAsync(a => a.Id == input.GroupNo);
            if (group == null)
            {
                CheckErrors($"未查询编号为【{input.GroupNo}】到培训营！");
                return;
            }
            var groupLog = new GroupLogInfo()
            {
                CampNo = group.CampNo,
                GroupNo = input.GroupNo,
                LogType = LogTypeDefinition.SceneOperation,
                LogCommand = LogCommandDefinition.SceneOperation,
                LogState = LogStateDefinition.New,
                LogScore = 0,
                RoleName = input.BehaviorRole,
                LogMessage = input.BehaviorWord,
                RoundIndex = group.RoundIndex
            };
            await GlRepository.InsertAsync(groupLog);
            await CurrentUnitOfWork.SaveChangesAsync();
            IwbHubContext.Clients.Group(group.CampNo).getOperationLog(new
            {
                id = groupLog.Id,
                no = group.Id,
                role = input.BehaviorRole,
                word = input.BehaviorWord,
                logState = LogStateDefinition.New
            }.Obj2String());
        }

        /// <summary>
        /// 处理情景
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [AbpAllowAnonymous, AuditLog("处理情景")]
        public async Task OperationScene(int id)
        {
            var log = await GlRepository.FirstOrDefaultAsync(a => a.Id == id);

            if (log == null)
            {
                CheckErrors("未查询到处理记录！");
                return;
            }
            var group = await GroupRepository.GetAllIncluding(a => a.CampInfo).FirstOrDefaultAsync(a => a.Id == log.GroupNo);
            if (group == null)
            {
                CheckErrors($"未查询编号为【{log.GroupNo}】到培训营！");
                return;
            }

            if (group.CampGroupState != CampGroupStateDefinition.Run)
            {
                CheckErrors("培训营未运行！");
            }
            var checkRole = (await SettingManager.GetSettingValueAsync(IwbSettingNames.EvalCheckRole)).UAndT() == "Y" && group.CampInfo.AssessRoleNames.IsNotEmpty();
            log.LogState = LogStateDefinition.Submit;
            await GlRepository.UpdateAsync(log);
            var dataStr = new
            {
                log.GroupNo,
                BehaviorRole = log.RoleName,
                BehaviorWord = $"{log.Id}|{log.LogMessage}",
                CheckRole = checkRole
            }.Obj2String();

            string url = $"{EngineApiUrl}api/services/Engine/Run/MatchWord";
            Post(url, dataStr, group, false);
            //var result = url.RequestPost(dataStr);
            //if (result.Contains("\"success\":false"))
            //{
            //    CheckErrors("培训营操作失败！");
            //}

            IwbHubContext.Clients.Group(group.CampNo).getOperationLogSubmit(new { no = group.Id, logId = log.Id }.Obj2String());
        }

        /// <summary>
        /// 处理情景
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [AbpAllowAnonymous, AuditLog("处理电话提问")]
        public async Task OperationPhone(OpPhoneQuestionDto input)
        {
            var log = await GlRepository.FirstOrDefaultAsync(a => a.Id == input.Id);
            var questionAnswers = await AnswerRepository.GetAllIncluding(a => a.QuestionInfo)
                .Where(a => a.QuestionNo == log.ExtendInfo1).ToListAsync();

            var score = 0;
            foreach (var answer in questionAnswers)
            {
                var arr = answer.Keywords.Split(',');
                foreach (var k in arr)
                {
                    if (input.HandleContent.Contains(k))
                    {
                        score += answer.Type == PhoneAnswerTypeDefinition.Right ? 10 : -10;
                        break;
                    }
                }
            }
            var gs = await GsRepository.FirstOrDefaultAsync(a =>
                a.GroupNo == log.GroupNo && a.RoundIndex == log.RoundIndex);
            if (gs == null)
            {
                gs = new GroupScoreInfo
                {
                    GroupNo = log.GroupNo,
                    CampNo = log.CampNo,
                    RoundIndex = log.RoundIndex,
                    PhoneScore = score
                };
                await GsRepository.InsertAsync(gs);
            }
            else
            {
                gs.PhoneScore += score;
                await GsRepository.UpdateAsync(gs);
            }
            IwbHubContext.Clients.Group(log.GroupNo).getRoundScore2(new { no = log.GroupNo, round = gs.RoundIndex, phoneScore = gs.PhoneScore }.Obj2String());
            log.ExtendInfo4 = input.HandleContent;
            await GlRepository.UpdateAsync(log);
            IwbHubContext.Clients.Group(log.GroupNo).getPhoneQuestionSubmit(new { no = log.GroupNo }.Obj2String());
        }

        /// <summary>
        /// 变更状态
        /// </summary>
        /// <param name="campNo"></param>
        /// <param name="groupNo"></param>
        /// <param name="groupState"></param>
        /// <returns></returns>
        [AuditLog("变更状态")]
        public async Task ChangeState(string campNo, string groupNo, int groupState)
        {
            if (groupState != CampGroupStateDefinition.Ready && groupState != CampGroupStateDefinition.HeadQuarterBuilding && groupState != CampGroupStateDefinition.HeadQuarterBuilded)
            {
                CheckErrors($"非法状态！");
            }

            string text = groupState == CampGroupStateDefinition.Ready ? "演练已就绪" :
                groupState == CampGroupStateDefinition.HeadQuarterBuilding ? "正在组建指挥部" :
                groupState == CampGroupStateDefinition.HeadQuarterBuilded ? "指挥部已组建" : "";
            if (groupNo == "none")
            {
                var groups = await GroupRepository.GetAllIncluding(a => a.CampInfo).Where(a => a.CampNo == campNo)
                    .ToListAsync();
                foreach (var g in groups)
                {
                    await ChangGroupState(g, groupState);
                    await CurrentUnitOfWork.SaveChangesAsync();
                    IwbHubContext.Clients.Group(campNo).getHeadquarter(new { no = g.Id, text }.Obj2String());
                }
                ReloadPage(campNo);
            }
            else
            {
                var group = await GroupRepository.GetAllIncluding(a => a.CampInfo).FirstOrDefaultAsync(a => a.Id == groupNo);
                if (group == null)
                {
                    CheckErrors($"未查询编号为【{groupNo}】到培训营！");
                    return;
                }
                campNo = group.CampNo;
                await ChangGroupState(group, groupState);
                await CurrentUnitOfWork.SaveChangesAsync();
                ReloadPage(groupNo);
                IwbHubContext.Clients.Group(group.CampNo).getHeadquarter(new { no = groupNo, text }.Obj2String());
            }

            if (groupState == CampGroupStateDefinition.Ready)
            {
                await UpdateStep(new StepDto()
                {
                    CampNo = campNo,
                    StepId = "0_1"
                });
            }
            else if (groupState == CampGroupStateDefinition.HeadQuarterBuilding)
            {
                await UpdateStep(new StepDto()
                {
                    CampNo = campNo,
                    StepId = "0_2"
                });
            }
        }

        /// <summary>
        /// 保存分组评分
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [AuditLog("保存分组评分")]
        public async Task SaveGroupScore(List<GroupScoreDto> input)
        {
            foreach (var gs in input)
            {
                var group = await GroupRepository.FirstOrDefaultAsync(a => a.Id == gs.GroupNo);
                if (group == null || group.CampGroupState == CampGroupStateDefinition.New)
                {
                    CheckErrors($"分组【{gs.GroupNo}】不在运行状态，不能操作");
                }

                var entity = await GsRepository.FirstOrDefaultAsync(a => a.GroupNo == gs.GroupNo && a.RoundIndex == gs.RoundIndex);
                if (entity == null)
                {
                    entity = ObjectMapper.Map<GroupScoreInfo>(gs);
                    await GsRepository.InsertAsync(entity);
                }
                else
                {
                    entity = ObjectMapper.Map(gs, entity);
                    await GsRepository.UpdateAsync(entity);
                }
                await CurrentUnitOfWork.SaveChangesAsync();
                await CacheManager.GetCache(IwbCacheNames.GroupRunningInfoCache)
                    .SetAsync($"SCORE-{gs.GroupNo}-{gs.RoundIndex}", entity);
                if (gs.IsSend)
                {
                    string url = $"{EngineApiUrl}api/services/Engine/Run/CorrectScore?groupNo={entity.GroupNo}&score={entity.FinalTotalScore}";
                    var result = url.RequestPost("");
                    if (result.Contains("\"success\":false"))
                    {
                        CheckErrors("培训营评分发送失败！");
                    }
                }
            }
            foreach (var gs in input)
            {
                if (gs.IsSend)
                {
                    IwbHubContext.Clients.Group(gs.CampNo)
                        .getSendScore(new { no = gs.GroupNo, systemScore = gs.FinalTotalScore }.Obj2String());
                }
            }
        }

        /// <summary>
        /// 保存分组角色
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [AbpAllowAnonymous, AuditLog("保存分组角色")]
        public async Task CreateGroupRole(RoleGroupDto input)
        {
            var entity = await GroupRepository.GetAllIncluding(a => a.CampInfo)
                .FirstOrDefaultAsync(a => a.Id == input.GroupNo);
            if (entity == null)
            {
                CheckErrors($"未查询到编号未【{input.GroupNo}】的培训营分组");
                return;
            }
            var list = new List<string>();
            string roleGroupNos = "", customRoles = "";
            if (input.SelfRoleNames != null && input.SelfRoleNames.Any())
            {
                list.AddRange(input.SelfRoleNames);
                customRoles = string.Join(",", input.SelfRoleNames.ToArray());
            }

            if (input.RoleGroupNos != null)
            {
                roleGroupNos = string.Join(",", input.RoleGroupNos.ToArray());
                foreach (var no in input.RoleGroupNos)
                {
                    var roleNames = await GrrRepository.GetAllIncluding(a => a.TrainingRoleInfo)
                        .Where(a => a.RoleGroupNo == no).Select(a => a.TrainingRoleInfo.RoleName).ToListAsync();
                    if (roleNames.Any())
                    {
                        foreach (var name in roleNames)
                        {
                            if (!list.Contains(name)) list.Add(name);
                        }
                    }
                }
            }

            string names = string.Join(",", list.ToArray());
            var roleInfo = await GroupRoleRepository.FirstOrDefaultAsync(a => a.GroupNo == input.GroupNo);
            if (roleInfo == null)
            {
                roleInfo = new GroupRoleInfo
                {
                    GroupNo = input.GroupNo,
                    RoleNames = names,
                    RoleGroupNos = roleGroupNos,
                    CustomRoles = customRoles,
                };
                await GroupRoleRepository.InsertAsync(roleInfo);
            }
            else
            {
                roleInfo.RoleNames = names;
                roleInfo.RoleGroupNos = roleGroupNos;
                roleInfo.CustomRoles = customRoles;
                await GroupRoleRepository.UpdateAsync(roleInfo);
            }

            await CurrentUnitOfWork.SaveChangesAsync();

            entity.CampGroupState = CampGroupStateDefinition.HeadQuarterBuilded;
            await GroupRepository.UpdateAsync(entity);
            await CurrentUnitOfWork.SaveChangesAsync();
            await CacheManager.GetCache(IwbCacheNames.GroupInfoCache).RemoveAsync($"Plan-{input.GroupNo}");
            ReloadPage(entity.Id);
            IwbHubContext.Clients.Group(entity.Id).getGroupRole(new { no = entity.Id }.Obj2String());
            IwbHubContext.Clients.Group(entity.Id).getHeadquarter(new { no = entity.Id, text = "指挥部已组建" }.Obj2String());
        }

        /// <summary>
        /// 刷新前台页面
        /// </summary>
        /// <param name="no"></param>
        private void ReloadPage(string no)
        {
            IwbHubContext.Clients.Group(no).getReloadStu(new { no }.Obj2String());
            IwbHubContext.Clients.Group(no).getReloadLeader(new { no }.Obj2String());
            IwbHubContext.Clients.Group(no).getReloadPublic(new { no }.Obj2String());
        }

        /// <summary>
        /// 手动记录
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [AbpAllowAnonymous, AuditLog("手动记录")]
        public async Task ManualLog(LogDto input)
        {
            var group = await GroupRepository.FirstOrDefaultAsync(a => a.Id == input.No);
            if (group == null)
            {
                CheckErrors($"未查询编号为【{input.No}】到培训营！");
                return;
            }
            await WriteLog(group.CampNo, input.No, group.RoundIndex, LogCommandDefinition.Manual, input.Msg,
                logType: LogTypeDefinition.Manual);
        }

        /// <summary>
        /// 专家评语
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [AbpAllowAnonymous, AuditLog("专家评语")]
        public async Task ZhuanJiaLog(LogDto input)
        {
            var group = await GroupRepository.FirstOrDefaultAsync(a => a.Id == input.No);
            if (group == null)
            {
                CheckErrors($"未查询编号为【{input.No}】到培训营！");
                return;
            }
            await WriteLog(group.CampNo, input.No, group.RoundIndex, LogCommandDefinition.ZhuanJia, input.Msg,
                logType: LogTypeDefinition.ZhuanJia);
        }

        /// <summary>
        /// 专家点评
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [AbpAllowAnonymous, AuditLog("专家点评")]
        public async Task<int> SendLogReviews(ReviewsDto input)
        {
            //await WriteLog(group.CampNo, input.No, group.RoundIndex, LogCommandDefinition.ZhuanJiaEffect, input.Effect,
            //    logType: LogTypeDefinition.ZhuanJia);
            var log = await GlRepository.FirstOrDefaultAsync(a => a.Id == input.Id);

            if (log == null)
            {
                CheckErrors("未查询到处理记录！");
                return 0;
            }
            var group = await GroupRepository.GetAllIncluding(a => a.CampInfo).FirstOrDefaultAsync(a => a.Id == log.GroupNo);
            if (group == null)
            {
                CheckErrors($"未查询编号为【{log.GroupNo}】到培训营！");
                return 0;
            }

            if (group.CampGroupState != CampGroupStateDefinition.Run)
            {
                CheckErrors("培训营未运行！");
            }

            int value;
            var reviews = new List<NameValue>();
            if (string.IsNullOrEmpty(log.ExtendInfo1))
            {
                reviews.Add(new NameValue(input.ReviewsType, "1"));
                value = 1;
            }
            else
            {
                reviews = log.ExtendInfo1.Str2Obj<List<NameValue>>();
                var review = reviews.FirstOrDefault(a => a.Name == input.ReviewsType);
                if (review != null)
                {
                    int.TryParse(review.Value, out value);
                    value++;
                    review.Value = value + "";
                }
                else
                {
                    value = 1;
                    reviews.Add(new NameValue(input.ReviewsType, "1"));
                }
            }

            log.ExtendInfo1 = reviews.Obj2String();
            await GlRepository.UpdateAsync(log);
            IwbHubContext.Clients.Group(group.Id).getEffectCmd(new { no = group.Id, effect = input.ReviewsType });
            return value;
        }

        /// <summary>
        /// 更新日志
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [AbpAllowAnonymous, DisableAuditing]
        public async Task UpdateLog(UpdateLogDto input)
        {
            var log = await GlRepository.FirstOrDefaultAsync(a => a.Id == input.Id);
            if (log != null)
            {
                log.LogMessage = input.Text;
                await GlRepository.UpdateAsync(log);
            }
        }

        #endregion Operation

        #region Query

        /// <summary>
        /// 查询当前情景的处理日志
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<List<GroupRoleLogDto>> GetCurrentSceneLog(string no)
        {
            var group = await GroupRepository.FirstOrDefaultAsync(a => a.Id == no);
            if (group == null)
            {
                CheckErrors($"未查询编号为【{no}】到培训营！");
                return null;
            }

            var query = GlRepository.GetAll().Where(a =>
                    a.GroupNo == no && a.LogType == LogTypeDefinition.SceneOperation &&
                    a.RoundIndex == group.RoundIndex &&
                    (a.LogState == LogStateDefinition.New || a.LogState == LogStateDefinition.Submit || a.LogState == LogStateDefinition.HasMatch))
                .OrderByDescending(a => a.Id).Select(a => new GroupRoleLogDto()
                {
                    Id = a.Id,
                    GroupNo = no,
                    Role = a.RoleName,
                    Word = a.LogMessage,
                    LogState = a.LogState
                });
            var dtoList = await query.ToListAsync();
            return dtoList;
        }

        /// <summary>
        /// 查询当前轮次的处理日志
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<List<GroupRoleLogDto>> GetRoundLog(string no)
        {
            var group = await GroupRepository.FirstOrDefaultAsync(a => a.Id == no);
            if (group == null)
            {
                CheckErrors($"未查询编号为【{no}】到培训营！");
                return null;
            }

            var query = GlRepository.GetAll().Where(a =>
                    a.GroupNo == no && a.LogType == LogTypeDefinition.SceneOperation &&
                    a.RoundIndex == group.RoundIndex)
                .OrderByDescending(a => a.Id).Select(a => new GroupRoleLogDto()
                {
                    Id = a.Id,
                    GroupNo = no,
                    Role = a.RoleName,
                    Word = a.LogMessage,
                    LogState = a.LogState
                });
            var dtoList = await query.ToListAsync();
            return dtoList;
        }

        /// <summary>
        /// 查询所有处理日志
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<List<GroupRoleLogDto>> GetAllLog(string no)
        {
            var group = await GroupRepository.FirstOrDefaultAsync(a => a.Id == no);
            if (group == null)
            {
                CheckErrors($"未查询编号为【{no}】到培训营！");
                return null;
            }

            var query = GlRepository.GetAll().Where(a => a.GroupNo == no && a.LogType == LogTypeDefinition.SceneOperation)
                .OrderByDescending(a => a.Id).Select(a => new GroupRoleLogDto()
                {
                    Id = a.Id,
                    GroupNo = no,
                    Role = a.RoleName,
                    Word = a.LogMessage,
                    LogState = a.LogState
                });
            var dtoList = await query.ToListAsync();
            return dtoList;
        }

        /// <summary>
        /// 查询所有处理日志
        /// </summary>
        /// <param name="no"></param>
        /// <param name="roleName"></param>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<List<GroupRoleLogDto>> GetAllRoleLog(string no, string roleName)
        {
            var group = await GroupRepository.FirstOrDefaultAsync(a => a.Id == no);
            if (group == null)
            {
                CheckErrors($"未查询编号为【{no}】到培训营！");
                return null;
            }

            var query = GlRepository.GetAll().Where(a => a.GroupNo == no && a.LogType == LogTypeDefinition.SceneOperation && a.RoleName == roleName)
                .OrderByDescending(a => a.Id).Select(a => new GroupRoleLogDto()
                {
                    GroupNo = no,
                    Role = a.RoleName,
                    Word = a.LogMessage,
                    LogState = a.LogState
                });
            var dtoList = await query.ToListAsync();
            return dtoList;
        }

        /// <summary>
        /// 记录日志
        /// </summary>
        /// <param name="campNo"></param>
        /// <param name="groupNo"></param>
        /// <param name="round"></param>
        /// <param name="cmd"></param>
        /// <param name="logMsg"></param>
        /// <param name="role"></param>
        /// <param name="score"></param>
        /// <param name="logType"></param>
        /// <returns></returns>
        private async Task WriteLog(string campNo, string groupNo, int round, string cmd, string logMsg = "", string role = "", decimal score = 0, int? logType = null)
        {
            logType = logType ?? LogTypeDefinition.System;
            var groupLog = new GroupLogInfo()
            {
                CampNo = campNo,
                GroupNo = groupNo,
                RoundIndex = round,
                LogCommand = cmd,
                LogMessage = logMsg,
                RoleName = role,
                LogType = (int)logType,
                LogScore = score
            };
            await GlRepository.InsertAsync(groupLog);
            await CurrentUnitOfWork.SaveChangesAsync();

            if (logType == LogTypeDefinition.System)
            {
                var group = await GroupRepository.FirstOrDefaultAsync(a => a.Id == groupNo);
                IwbHubContext.Clients.Group(campNo).getSysLog(new
                {
                    id = groupLog.Id,
                    name = group?.Name ?? "系统",
                    msg = cmd,
                    date = DateTime.Now
                }.Obj2String());
            }
        }

        /// <summary>
        /// 变更分组状态
        /// </summary>
        /// <param name="group"></param>
        /// <param name="groupState"></param>
        /// <returns></returns>
        private async Task ChangGroupState(CampGroupInfo group, int groupState)
        {
            var camp = group.CampInfo;
            if (group.CampGroupState == CampGroupStateDefinition.Run)
            {
                CheckErrors("培训营已运行！");
            }
            if (camp == null)
            {
                CheckErrors($"未查询编号为【{group.CampNo}】到培训营！");
                return;
            }
            if (camp.CampState == CampStateDefinition.New)
            {
                CheckErrors("培训营未审核，请先通过审核后再试！");
            }

            group.CampGroupState = groupState;
            await GroupRepository.UpdateAsync(group);
        }

        /// <summary>
        /// 获取培训营详情
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<CampDetailDto> GetCampDetail(string no)
        {
            var entity = await CampRepository.FirstOrDefaultAsync(a => a.Id == no);
            if (entity == null)
            {
                CheckErrors($"未查询编号为【{no}】到培训营！");
                return null;
            }
            if (entity.CampState == CampStateDefinition.New)
            {
                CheckErrors("培训营未审核，请先通过审核后再试！");
            }
            if (entity.CampState == CampStateDefinition.End)
            {
                CheckErrors("培训营已结束！");
            }
            var groupInfos = await GroupRepository.GetAllListAsync(a => a.CampNo == no);
            var groups = new List<GroupDto>();

            foreach (var group in groupInfos)
            {
                var groupDto = await MapGroupDto(group);
                groups.Add(groupDto);
            }
            return new CampDetailDto()
            {
                Id = no,
                Name = entity.Name,
                PackageNo = entity.PackageNo,
                PackageName = entity.PackageName,
                CampState = entity.CampState,
                ScoreRule = entity.ScoreRule,
                RoundScore = entity.RoundScore,
                EvalBehaviorTags = entity.EvalBehaviorTags,
                Groups = groups
            };
        }

        /// <summary>
        /// 获取培训营分组详情
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        [AbpAllowAnonymous, DisableAuditing]
        public async Task<GroupDto> GetGroupDetail(string no)
        {
            var group = await GroupRepository.FirstOrDefaultAsync(a => a.Id == no);
            if (group == null)
            {
                CheckErrors($"未查询编号为【{no}】到培训营！");
                return null;
            }

            var dto = await MapGroupDto(group);
            return dto;
        }

        /// <summary>
        /// 映射分组详情
        /// </summary>
        /// <param name="group"></param>
        /// <returns></returns>
        private async Task<GroupDto> MapGroupDto(CampGroupInfo group)
        {
            var dto = new GroupDto()
            {
                Id = group.Id,
                Name = group.Name,
                CampNo = group.CampNo,
                CampGroupState = group.CampGroupState,
                StartDate = group.StartDate,
                EngDate = group.EngDate,
                TrainingMinute = group.TrainingMinute,
                RunningInfo = await GetGroupRunningInfo(group.Id),
                //GroupScore = (await GsRepository.GetAllListAsync(s => s.GroupNo == group.Id)).Select(ObjectMapper.Map<GroupScoreDto>).ToList()
            };
            var gsList = await GsRepository.GetAllListAsync(a => a.GroupNo == group.Id);
            dto.GroupScore = new List<GroupScoreDto>();
            foreach (var gs in gsList)
            {
                var groupScore = await CacheManager.GetGroupRoundScore(group.Id, gs.RoundIndex, GsRepository);
                if (groupScore != null)
                {
                    dto.GroupScore.Add(ObjectMapper.Map<GroupScoreDto>(groupScore));
                }
            }
            return dto;
        }

        /// <summary>
        /// 获取分组运行信息
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<PackageDataNode> GetGroupRunningInfo(string no)
        {
            var runGroupInfo = await CacheManager.GetGroupRunningInfo(no, GroupRepository);
            return runGroupInfo;
        }

        #endregion Query
    }
}