public async Task <IActionResult> RemoveQuestionnaireQuestionAsync(string questionGuid)
{
var questionBiz = new QuestionnaireQuestionBiz();
var model = await questionBiz.GetAsync(questionGuid);
if (model == null)
{
return(Failed(ErrorCode.UserData, "未找到此问题"));
}
var questionnaireModel = await new QuestionnaireBiz().GetAsync(model.QuestionnaireGuid);
if (questionnaireModel.IssuingStatus)
{
return(Failed(ErrorCode.UserData, "问卷已发放不能修改"));
}
var dependModels = await questionBiz.GetModelsByDependQuestionGuidAsync(model.QuestionGuid);
if (dependModels.Any())
{
return(Failed(ErrorCode.UserData, $"该问题被第{string.Join("、", dependModels.OrderBy(a => a.Sort).Select(a => a.Sort))}题依赖，无法删除"));
}
var result = await questionBiz.RemoveQuestionAsync(model);
return(result ? Success() : Failed(ErrorCode.DataBaseError, "移除问题失败"));
}
public async Task <IActionResult> ChangeQuestionSortAsync([FromBody] ChangeQuestionSortRequestDto requestDto)
{
var biz = new QuestionnaireQuestionBiz();
var model = await biz.GetAsync(requestDto.QuestionGuid);
if (model == null)
{
return(Failed(ErrorCode.UserData, "未找到此问题"));
}
var newSort = requestDto.Sort;
if (model.Sort == newSort)
{
return(Failed(ErrorCode.UserData, "问题序号未产生变化，请核对"));
}
if (model.IsDepend)
{
var dependQuestionModel = await biz.GetAsync(model.DependQuestion);
if (dependQuestionModel == null)
{
return(Failed(ErrorCode.UserData, "当前问题的依赖数据异常"));
}
if (newSort <= dependQuestionModel.Sort)
{
return(Failed(ErrorCode.UserData, $"当前问题的序号不能先于其依赖问题[第{dependQuestionModel.Sort}题]"));
}
}
//查询依赖当前问题的题目列表
var dependModels = await biz.GetModelsByDependQuestionGuidAsync(model.QuestionGuid);
if (dependModels.Any())
{
var minSortModel = dependModels.OrderBy(a => a.Sort).FirstOrDefault();
if (minSortModel.Sort <= newSort)
{
return(Failed(ErrorCode.UserData, $"第{minSortModel.Sort}题依赖当前题目，移动序号不能大于{minSortModel.Sort}"));
}
}
// 一.其他问题为待变化问题顺次移动位置
// 1.若向前移动，则原序号和新序号之间所有问题序号+1 (不包括待变化问题)
// 2.若向后移动，则原序号和新序号之间所有问题序号-1 (不包括待变化问题)
// 二.将待变化问题序号变为新序号
var result = await biz.ChangeQuestionSortAsync(model, newSort, UserID);
return(result ? Success() : Failed(ErrorCode.DataBaseError, "问题变化序号失败"));
}
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));
}
