public async Task <IActionResult> CreateQuestionnaireQuestionAsync([FromBody] CreateQuestionnaireQuestionRequestDto requestDto)
{
QuestionnaireQuestionModel model = null;
var answers = new List <QuestionnaireAnswerModel>();
var questionBiz = new QuestionnaireQuestionBiz();
var cancelDependQuestionModels = new List <QuestionnaireQuestionModel>(); //由于问题类型变化或答案选项被删除，需要删除依赖关系的问题列表
var isCreate = true; //是否是创建问题
//新增
if (string.IsNullOrWhiteSpace(requestDto.QuestionGuid))
{
model = new QuestionnaireQuestionModel
{
QuestionGuid = Guid.NewGuid().ToString("N"),
CreatedBy = UserID,
LastUpdatedBy = UserID
};
}
else//编辑
{
model = await questionBiz.GetAsync(requestDto.QuestionGuid);
if (model == null)
{
return(Failed(ErrorCode.UserData, $"未找到编辑的问题"));
}
if (model.QuestionnaireGuid != requestDto.QuestionnaireGuid)
{
return(Failed(ErrorCode.UserData, $"传入的问卷guid和待编辑问题的问卷guid不一致"));
}
//由于问题类型变化或答案选项被删除，需要删除依赖关系的问题列表
if (model.QuestionType != requestDto.QuestionType.ToString())
{
//获取依赖此问题的问题列表
var dependonQuestionModel = await questionBiz.GetModelsByDependQuestionGuidAsync(model.QuestionGuid);
dependonQuestionModel.ForEach(a =>
{
a.DependAnswer = string.Empty;
a.DependQuestion = string.Empty;
a.IsDepend = false;
});
cancelDependQuestionModels.AddRange(dependonQuestionModel);
}
else if (model.QuestionType == QuestionnaireQuestionTypeEnum.Bool.ToString() || model.QuestionType == QuestionnaireQuestionTypeEnum.Enum.ToString())
{
var answerModels = await new QuestionnaireAnswerBiz().GetModelsByQuestionGuidAsync(model.QuestionGuid);
//获取被删除的选项id集合
var exceptAnswerIds = answerModels.Select(a => a.AnswerGuid)
.Except(requestDto.Answers
.Where(a => !string.IsNullOrWhiteSpace(a.AnswerGuid))
.Select(a => a.AnswerGuid));
//获取依赖此问题的问题列表
var dependonQuestionModel = await questionBiz.GetModelsByDependQuestionGuidAsync(model.QuestionGuid);
//获取依赖此问题中被删除选项的问题列表，这些问题的对此问题的依赖将被取消
var cancelDependQuestionModelList = dependonQuestionModel.Join(exceptAnswerIds, d => d.DependAnswer, a => a, (d, a) => d).ToList();
cancelDependQuestionModelList.ForEach(a =>
{
a.DependAnswer = string.Empty;
a.DependQuestion = string.Empty;
a.IsDepend = false;
});
cancelDependQuestionModels.AddRange(cancelDependQuestionModelList);
}
model.LastUpdatedBy = UserID;
model.LastUpdatedDate = DateTime.Now;
isCreate = false;
}
model.QuestionnaireGuid = requestDto.QuestionnaireGuid;
model.QuestionName = requestDto.QuestionName;
model.QuestionType = requestDto.QuestionType.ToString();
model.Unit = requestDto.Unit;
model.Sort = requestDto.Sort;//判断有无重复的sort
model.PromptText = requestDto.PromptText;
if (!string.IsNullOrWhiteSpace(requestDto.DependAnswer))
{
var dependAnswerModel = await new QuestionnaireAnswerBiz().GetAsync(requestDto.DependAnswer);
if (dependAnswerModel == null)
{
return(Failed(ErrorCode.UserData, $"依赖的答案未找到"));
}
model.DependAnswer = requestDto.DependAnswer;
model.DependQuestion = dependAnswerModel.QuestionGuid;
model.IsDepend = true;
}
else
{
model.DependAnswer = string.Empty;
model.DependQuestion = string.Empty;
model.IsDepend = false;
}
if (requestDto.Answers != null)
{
answers = requestDto.Answers.Select((item, index) => new QuestionnaireAnswerModel
{
AnswerGuid = Guid.NewGuid().ToString("N"),
QuestionnaireGuid = model.QuestionnaireGuid,
QuestionGuid = model.QuestionGuid,
AnswerLabel = item.AnswerLabel,
IsDefault = item.IsDefault,
Sort = index + 1,
CreatedBy = UserID,
LastUpdatedBy = UserID
}).ToList();
}
var result = await questionBiz.CreateQuestionnaireQuestionAsync(model, answers, isCreate, cancelDependQuestionModels);
if (!result)
{
return(Failed(ErrorCode.UserData, $"保存问题失败"));
}
var dependQuestions = await questionBiz.GetQuestionWithDependAsync(requestDto.QuestionnaireGuid);
var questionnaireModel = await new QuestionnaireBiz().GetAsync(requestDto.QuestionnaireGuid);
if (questionnaireModel.HasDepend != dependQuestions.Any())
{
questionnaireModel.HasDepend = dependQuestions.Any();
await new QuestionnaireBiz().UpdateAsync(questionnaireModel);
}
#region 将提交的数据返回（携带问题guid）
var response = new CreateQuestionnaireQuestionResponseDto
{
QuestionnaireGuid = model.QuestionnaireGuid,
QuestionGuid = model.QuestionGuid,
QuestionName = model.QuestionName,
QuestionType = requestDto.QuestionType,
IsDepend = model.IsDepend,
DependAnswer = model.DependAnswer,
Sort = model.Sort,
Answers = requestDto.Answers
};
if (model.IsDepend)
{
var dependAnswerModel = await new QuestionnaireAnswerBiz().GetAsync(model.DependAnswer);
var dependQuestionModel = await questionBiz.GetAsync(model.DependQuestion);
response.DependDescription = $"*依赖于第{dependQuestionModel?.Sort}题的第{dependAnswerModel?.Sort}个选项，当题目{dependQuestionModel?.Sort}选择[{dependAnswerModel?.AnswerLabel}]时，此题才显示。";
}
#endregion
return(Success(response));
}
//[HttpGet]
//public IActionResult RabbitMqFanout()
//{
// try
// {
// var bus = Communication.MQ.Client.CreateConnection();
// var advancedBus = bus.Advanced;
// if (advancedBus.IsConnected)
// {
// var queueName = "hzl";
// //var queue = advancedBus.QueueDeclare(queueName);
// ////获取员工的审批中待审批的数量 和 我的绩效中待处理的绩效
// //advancedBus.Publish(EasyNetQ.Topology.Exchange.GetDefault(), queue.Name, false, new EasyNetQ.Message<ApprovalNotificationDto>(new ApprovalNotificationDto
// //{
// // MyApprovalCount = 1,
// // MyPerformanceCount = 20
// //}));
// var exchange = advancedBus.ExchangeDeclare("HZLExchange", EasyNetQ.Topology.ExchangeType.Fanout);
// var queue1 = advancedBus.QueueDeclare("hzl1");
// var queue2 = advancedBus.QueueDeclare("hzl2");
// advancedBus.Bind(exchange, queue1, queue1.Name);
// advancedBus.Bind(exchange, queue2, queue2.Name);
// advancedBus.Publish(exchange, "", false, new EasyNetQ.Message<ApprovalNotificationDto>(new ApprovalNotificationDto
// {
// MyApprovalCount = 10,
// MyPerformanceCount = 11
// }));
// }
// bus.Dispose();
// }
// catch (Exception ex)
// {
// }
// return Success();
//}
#endregion
/// <summary>
/// 获取问题的依赖描述
/// </summary>
/// <param name="questions">问题集合</param>
/// <param name="answers">答案项集合</param>
/// <param name="targetQuestion">目标问题</param>
/// <returns></returns>
private string GetDependDescription(List <QuestionnaireQuestionModel> questions, List <QuestionnaireAnswerModel> answers, QuestionnaireQuestionModel targetQuestion)
{
if (!targetQuestion.IsDepend)
{
return(null);
}
if (answers == null)
{
return(null);
}
var dependQuestionModel = questions.FirstOrDefault(a => a.QuestionGuid == targetQuestion.DependQuestion);
var dependAnswerModel = answers.FirstOrDefault(a => a.AnswerGuid == targetQuestion.DependAnswer);
return($"*依赖于第{dependQuestionModel.Sort}题的第{dependAnswerModel?.Sort}个选项，当题目{dependQuestionModel.Sort}选择[{dependAnswerModel?.AnswerLabel}]时，此题才显示。");
}
/// <summary>
/// 给返回对象赋值
/// </summary>
/// <param name="questionnaireQuestionResponse"></param>
/// <param name="i"></param>
/// <param name="qestionnaireQestion"></param>
/// <returns></returns>
private static async Task Assignment(GetQuestionnaireQuestionResponseDto questionnaireQuestionResponse, int i, QuestionnaireQuestionModel qestionnaireQestion, QuestionnaireResultModel questionnaireResultModel = null)
{
questionnaireQuestionResponse.QuestionnaireQuestionDto = new GetQuestionnaireQuestionDto
{
QuestionGuid = qestionnaireQestion.QuestionGuid,
QuestionNumber = i,
QuestionnaireGuid = qestionnaireQestion.QuestionnaireGuid,
QuestionName = qestionnaireQestion.QuestionName,
QuestionType = qestionnaireQestion.QuestionType,
Unit = qestionnaireQestion.Unit,
PromptText = qestionnaireQestion.PromptText
};
//查找答案列表
questionnaireQuestionResponse.QuestionnaireQuestionDto.QuestionnaireAnswerDtoList = await new QuestionnaireAnswerBiz().GetQuestionnaireAnswerModelAsync(questionnaireQuestionResponse.QuestionnaireQuestionDto.QuestionnaireGuid, questionnaireQuestionResponse.QuestionnaireQuestionDto.QuestionGuid);
////获取问卷指定问题
//var nextQestionnaireQestion = await new QestionnaireQestionBiz().AppointQuestionnaireQuestionModelAsync(qestionnaireQestion.QuestionnaireGuid, i + 1);
////若下一题不为空
//if (nextQestionnaireQestion != null)
//{
// //下一题存在依赖
// if (nextQestionnaireQestion.IsDepend)
// {
// //如果下一题依赖的是当前题目，则需要遍历当前题目的选择项
// if (nextQestionnaireQestion.DependQuestion == questionnaireQuestionResponse.QuestionnaireQuestionDto.QuestionGuid)
// {
// questionnaireQuestionResponse.QuestionnaireQuestionDto.HasNext = true;
// questionnaireQuestionResponse.QuestionnaireQuestionDto.QuestionnaireAnswerDtoList.ForEach(a => a.HasNext = nextQestionnaireQestion.DependAnswer == a.AnswerGuid);
// }
// else//如果依赖的不是当前题目，则需要检测之前的答卷结果有没有选择被依赖的选择项
// {
// var theAnswer = await new QuestionnaireResultDetailBiz().AppointQuestionnaireResultDetailModelAsync(questionnaireResultModel.ResultGuid, nextQestionnaireQestion.QuestionGuid);
// if (theAnswer.AnswerGuids.Contains(nextQestionnaireQestion.DependAnswer))
// {
// questionnaireQuestionResponse.QuestionnaireQuestionDto.HasNext = true;
// questionnaireQuestionResponse.QuestionnaireQuestionDto.QuestionnaireAnswerDtoList.ForEach(a => a.HasNext = true);
// }
// }
// }
// else
// {
// questionnaireQuestionResponse.QuestionnaireQuestionDto.HasNext = true;
// questionnaireQuestionResponse.QuestionnaireQuestionDto.QuestionnaireAnswerDtoList.ForEach(a => a.HasNext = true);
// }
//}
}
