/// <summary>
/// 设置试题类型
/// </summary>
/// <param name="subject"></param>
public static void SetSubjectType(Subject subject)
{
//是父节点,则为阅读理解题
if (subject.ListChild.Count > 0)
{
subject.题目类型 = Subject.SubjecttypeEnum.阅读理解题;
subject.客观题 = Subject.ObjectiveEnum.否;
//subject.选项个数 = 1;
}
else
{
//判断题干中有多少个选项，超过2个为选择题
//if (Regex.Matches(subject.subjecthtmlcontent, "[A-G][.．、][^A-G]").Count > 1) //mark
if (Regex.Matches(subject.subjecthtmlcontent, "[A-G][.．、]").Count > 1)
{
//没有答案，则为单选题
if ((subject.answer == null || string.IsNullOrEmpty(subject.answer.subjecttextanswer)))
{
subject.题目类型 = Subject.SubjecttypeEnum.单选题;
}
else if ((Regex.IsMatch(subject.subjecthtmlcontent.ToLower(), @"<u[^>]*>\s*?</u[^>]*>", RegexOptions.Singleline)
|| Regex.IsMatch(subject.subjecthtmlcontent.ToLower(), @"_{3,}", RegexOptions.Singleline))
&& !Regex.IsMatch(subject.subjecthtmlcontent, @"（）|\(\)", RegexOptions.Singleline)
&& !Regex.IsMatch(subject.answer.subjecttextanswer.Trim().ToUpper(), @"^[A-G]{1,7}$", RegexOptions.Singleline))
{
subject.题目类型 = Subject.SubjecttypeEnum.填空题;
}
else if (Regex.IsMatch(subject.answer.subjecttextanswer.Trim().ToUpper(), @"^正确{1}$|^错误{1}$|^对{1}$|^错{1}$|^YES{1}$|^NO{1}$", RegexOptions.Singleline))
{
subject.题目类型 = Subject.SubjecttypeEnum.判断题;
}
else if (Regex.IsMatch(subject.answer.subjecttextanswer.Trim().ToUpper(), "^[A-G]{2,26}$") || subject.subjecthtmlcontent.IndexOf("多选") != -1)
{
//如果有多个答案，则为多选题
subject.题目类型 = Subject.SubjecttypeEnum.多选题;
}
else if (Regex.IsMatch(subject.answer.subjecttextanswer.Trim().ToUpper(), "^[A-G]{1}$"))
{
subject.题目类型 = Subject.SubjecttypeEnum.单选题;
}
else
{
//如果题干不存在多选字符，则为单选，否则为多选
subject.题目类型 = Subject.SubjecttypeEnum.简答题;
subject.客观题 = Subject.ObjectiveEnum.否;
return;
}
subject.客观题 = Subject.ObjectiveEnum.是;
}
else if (Regex.IsMatch(subject.subjecthtmlcontent.ToLower(), @"<u[^>]*>\s*?</u[^>]*>", RegexOptions.Singleline) || Regex.IsMatch(subject.subjecthtmlcontent.ToLower(), @"_{3,}", RegexOptions.Singleline))
{
var iTCount = Regex.Matches(subject.subjecthtmlcontent, "<u[^>]*>(( )|[\\s]){3,}</u[ ]*>|(_{3,})", RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.Singleline).Count;
subject.题目类型 = Subject.SubjecttypeEnum.填空题;
subject.客观题 = Subject.ObjectiveEnum.是;
}
//else if ((subject.answer.subjecttextanswer.IndexOf("正确") != -1 || subject.answer.subjecttextanswer.IndexOf("对") != -1 || subject.answer.subjecttextanswer.IndexOf("错误") != -1 || subject.answer.subjecttextanswer.IndexOf("错") != -1) && subject.answer.subjecttextanswer.Length < 10)
else if (Regex.IsMatch(subject.answer.subjecttextanswer.Trim().ToUpper(), @"^正确{1}$|^错误{1}$|^对{1}$|^错{1}$|^YES{1}$|^NO{1}$", RegexOptions.Singleline))
{
subject.题目类型 = Subject.SubjecttypeEnum.判断题;
subject.客观题 = Subject.ObjectiveEnum.是;
}
else
{
subject.题目类型 = Subject.SubjecttypeEnum.简答题;
subject.客观题 = Subject.ObjectiveEnum.否;
}
}
}
/// <summary>
/// 试题类型处理
/// 1.单（多）项选择题拆分选项。
/// 2.填空题添加标识
/// 3.判断题转换数据
/// </summary>
/// <param name="subjectitem">题目内容</param>
/// <param name="subjecttype">题目类型</param>
/// <returns></returns>
public static void SubjectTypeMarkAndCreateOption(Subject subjectitem)
{
int subjecttype =(int)subjectitem.题目类型;
//html = HtmlUtil.htmlreplace(html);
if (subjecttype == Subject.SubjecttypeEnum.单选题.GetHashCode() || subjecttype == Subject.SubjecttypeEnum.多选题.GetHashCode())
{
// var strs = subjectitem.
string tempsubjecthtmlcontent = HtmlUtil.selectSubjectOptionMarkUpload(subjectitem.subjecthtmlcontent);
subjectitem.subjecthtmlcontent = HtmlUtil.selectSubjectOptionMarkUpload(subjectitem.subjecthtmlcontent, "<check>$0</check>");
// subjectitem.subjecthtmlcontent = Regex.Replace(subjectitem.subjecthtmlcontent, " (( )|[\\s])*([ABCDEFG]{1})[\\s]*[^.]", "<nocheck>$0</nocheck>", RegexOptions.Multiline | RegexOptions.Singleline);
bool isanswer = false;
string[] htmls = Regex.Split(tempsubjecthtmlcontent, MatchArray.Select_Option, RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.Singleline);
for (int i = 0; i < htmls.Length; i++)
{
if (i > 0)
{
isanswer = false;
//判断答案是否正确
isanswer = SelectAnswerPair(subjectitem, i, isanswer);
string answercontent = ReplaceHTML(htmls[i]).Replace("</img>", "");
Answer answer = new Answer(answercontent, isanswer, i);
subjectitem.answers.Add(answer);
}
subjectitem.subjecthtmlcontent = subjectitem.subjecthtmlcontent.Replace(htmls[i], new Regex("[A-G]").Replace(new Regex("<.+?>", RegexOptions.Singleline).Replace(htmls[i], (x) => { return x.Groups[0].Value.ToLower(); }), "<nocheck>$0</nocheck>"));
}
return;
}
else if (subjecttype == Subject.SubjecttypeEnum.填空题.GetHashCode())
{
string tempsubjecthtmlcontent = HtmlUtil.spacePlaceMarkUpLoad(subjectitem.subjecthtmlcontent);
Regex regex = new Regex("[^\\<check\\>]<u>.+?</u>",RegexOptions.IgnoreCase|RegexOptions.Singleline);
subjectitem.subjecthtmlcontent = HtmlUtil.spacePlaceMarkUpLoad(subjectitem.subjecthtmlcontent, "<check>$0</check>");
subjectitem.subjecthtmlcontent = regex.Replace(subjectitem.subjecthtmlcontent, "<nocheck>$0</nocheck>");
Regex regspacenum = new Regex(MatchArray.Space_Num);
int i = 0;
// 取得匹配项列表
while (regspacenum.IsMatch(tempsubjecthtmlcontent))
{
tempsubjecthtmlcontent = regspacenum.Replace(tempsubjecthtmlcontent, string.Format(MatchArray.Space_Num_Replace, i + 1), 1);
i++;
}
int sort = 0;//答案顺序
string[] answerarr = subjectitem.answer.subjecthtmlanswer.Split('|');
foreach (string content in answerarr)
{
string html = ReplaceHTML(content).Replace("</img>","");
//如果答案的长度比填空空格多，则去掉为空的答案
if (string.IsNullOrEmpty(html))
{
if (answerarr.Length <= i)
{
sort++;
Answer answer = new Answer(html, true, sort);
subjectitem.answers.Add(answer);
}
}
else
{
sort++;
Answer answer = new Answer(html, true, sort);
subjectitem.answers.Add(answer);
}
}
while (sort < i)
{
sort++;
Answer answer = new Answer("", true, sort);
subjectitem.answers.Add(answer);
}
return;
}
else if (subjecttype == Subject.SubjecttypeEnum.判断题.GetHashCode())
{
string answerstr = "0";
if (subjectitem.answer.subjecttextanswer.IndexOf("正确") >= 0 || subjectitem.answer.subjecttextanswer.IndexOf("对") >= 0)
answerstr = "1";
Answer answer = new Answer(answerstr, true, 1);
subjectitem.answers.Add(answer);
return;
}
Answer answerother = new Answer(subjectitem.answer.subjecttextanswer, true, 1);
subjectitem.answers.Add(answerother);
}
/// <summary>
/// 检测试题类型是否正确
/// </summary>
/// <param name="subject"></param>
/// <returns></returns>
public static Tuple<bool, string, int> CheckSubjectType(Subject subject, List<Subject> listSubject)
{
string strMsg = string.Empty;
string tempStrMsg = string.Empty;
if (!string.IsNullOrEmpty(subject.ParentId))
{
var strsParentId = subject.ParentId.Split('.');
var parentSubject = listSubject.Find(x => x.Id == strsParentId[0]);
string context = parentSubject.subjecttextcontent;
if (context.Length > 10)
{
context = context.Substring(0, 10) + "...";
}
strMsg = context + "下";
if (strsParentId.Length==2)
{
parentSubject = parentSubject.ListChild.Find(x => x.Id == subject.ParentId);
strMsg = strMsg+"第"+ (parentSubject.套卷序号)+"题中";
}
}
if (strMsg == "")
{
strMsg = subject.subjecttextcontent.ToString() + "题";
}
else
{
strMsg = strMsg +"第"+ subject.套卷序号.ToString() + "小题";
}
tempStrMsg = strMsg;
//检查选择题答案中的非法字符
if (!string.IsNullOrEmpty(subject.answer.subjecttextanswer))
{
Regex regex = new Regex(@"^[A-G]{1,26}$", RegexOptions.Singleline);
if (!regex.IsMatch(subject.answer.subjecttextanswer.Trim()))
{
if (subject.题目类型 == Subject.SubjecttypeEnum.单选题)
{
strMsg += "单选题答案内容不正确，请修改为纯字母(A-G)";
return new Tuple<bool, string, int>(false, strMsg, 0);
}
else if (subject.题目类型 == Subject.SubjecttypeEnum.多选题)
{
strMsg += "多选题答案内容不正确，请修改为纯字母(A-G)";
return new Tuple<bool, string, int>(false, strMsg, 0);
}
}
}
//没有答案
if ((subject.answer == null || (string.IsNullOrEmpty(subject.answer.subjecttextanswer) && string.IsNullOrEmpty(NoHTML(subject.answer.subjecthtmlanswer)))) && subject.answer.subjecthtmlanswer.IndexOf("img") == -1 && subject.answer.subjecthtmlanswer.IndexOf("object") == -1 && subject.题目类型 != Subject.SubjecttypeEnum.阅读理解题)
{
//客观题，一定要添加答案
if (subject.客观题 == Subject.ObjectiveEnum.是)
{
//单选题,多选题,判断题 必须要添加答案
if (subject.题目类型 == Subject.SubjecttypeEnum.单选题 || subject.题目类型 == Subject.SubjecttypeEnum.多选题 || subject.题目类型 == Subject.SubjecttypeEnum.判断题)
{
strMsg += "为客观题 ,必须要添加答案";
return new Tuple<bool, string, int>(false, strMsg, 0);
}
else
{
strMsg += "为客观题 ,建议添加答案或者修改为主观题";
return new Tuple<bool, string, int>(true, strMsg, 0);
}
}
else
{
strMsg += "没有答案,建议添加题目答案";
return new Tuple<bool, string,int>(false, strMsg,1);
}
}
else
{
//判断题干中有多少个选项，超过2个为选择题
//if (Regex.Matches(subject.subjecthtmlcontent, "[A-G][.．、][^A-G]").Count > 1) //mark
if (Regex.Matches(subject.subjecthtmlcontent, "[A-G][.．、]").Count > 1)
{
if (subject.题目类型 == Subject.SubjecttypeEnum.阅读理解题)
{
if (subject.ListChild.Count == 0)
{
strMsg += "没有子题，题目类型不能设定为阅读理解题";
return new Tuple<bool, string, int>(false, strMsg, 0);
}
}
//else if ((subject.subjecthtmlcontent.ToLower().IndexOf("</u>") != -1 || subject.subjecthtmlcontent.IndexOf("__") != -1) && subject.题目类型 == Subject.SubjecttypeEnum.填空题)
else if ((Regex.IsMatch(subject.subjecthtmlcontent.ToLower(), @"<u[^>]*>\s*?</u[^>]*>", RegexOptions.Singleline) || Regex.IsMatch(subject.subjecthtmlcontent.ToLower(), @"_{3,}", RegexOptions.Singleline)) && subject.题目类型 == Subject.SubjecttypeEnum.填空题)
{
int iCount = 0;
if (subject.answers != null && subject.answers.Count > 0)
{
iCount = subject.answers.Count;
//存在题目未填写答案
if (subject.answers.Where(x => string.IsNullOrEmpty(x.content)).Count() != 0)
{
if (subject.客观题 == Subject.ObjectiveEnum.是)
{
strMsg += "部分填空空格未填写答案，请补全答案";
return new Tuple<bool, string, int>(false, strMsg, 0);
}
else
{
strMsg += "部分填空空格未填写答案，建议补全答案";
return new Tuple<bool, string, int>(false, strMsg, 1);
}
}
}
else
{
//答案
iCount = subject.answer.subjecttextanswer.Split('|').Length; //填空题答案分割方法..
}
//题干
int iTCount = Regex.Matches(subject.subjecthtmlcontent, "<u[^>]*>(( )|[\\s]){3,}</u[ ]*>|(_{3,})", RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.Singleline).Count;
//题干 和答案不一样，则不能自动修复
if (iTCount != iCount)
{
strMsg += "题干填空空格数目和答案数目不一致";
return new Tuple<bool, string, int>(false, strMsg, 0);
}
}
else
{
//没有答案，则为单选题
if (subject.answer != null && !string.IsNullOrEmpty(subject.answer.subjecttextanswer))
{
if ((Regex.IsMatch(subject.subjecthtmlcontent.ToLower(), @"<u[^>]*>\s*?</u[^>]*>", RegexOptions.Singleline)
|| Regex.IsMatch(subject.subjecthtmlcontent.ToLower(), @"_{3,}", RegexOptions.Singleline))
&& !Regex.IsMatch(subject.subjecthtmlcontent, @"（）|\(\)", RegexOptions.Singleline)
&& !Regex.IsMatch(subject.answer.subjecttextanswer.Trim().ToUpper(), @"^[A-G]{1,7}$", RegexOptions.Singleline))
{
if(subject.题目类型 != Subject.SubjecttypeEnum.填空题)
{
strMsg += "具有填空题特征 ,建议题目类型修改为填空题";
}
}
else if (Regex.IsMatch(subject.answer.subjecttextanswer.Trim().ToUpper(), @"^正确{1}$|^错误{1}$|^对{1}$|^错{1}$|^YES{1}$|^NO{1}$", RegexOptions.Singleline))
{
if (subject.题目类型 != Subject.SubjecttypeEnum.判断题)
{
strMsg += "答案为 " + subject.answer.subjecttextanswer + " ,建议题目类型修改为判断题";
}
}
//如果有多个答案，则为多选题
else if (Regex.IsMatch(subject.answer.subjecttextanswer.Trim().ToUpper(), "^[A-G]{2,26}$") || subject.subjecthtmlcontent.IndexOf("多选") != -1)
{
if (subject.题目类型 != Subject.SubjecttypeEnum.多选题)
{
strMsg += "答案为 " + subject.answer.subjecttextanswer + " ,建议题目类型修改为多选题";
}
}
else if(Regex.IsMatch(subject.answer.subjecttextanswer.Trim().ToUpper(), "^[A-G]{1}$"))
{
if (subject.题目类型 != Subject.SubjecttypeEnum.单选题)
{
strMsg += "答案为 " + subject.answer.subjecttextanswer + " ,建议题目类型修改为单选题";
}
}
else
{
if (subject.题目类型 != Subject.SubjecttypeEnum.简答题)
{
strMsg += "答案为 " + subject.answer.subjecttextanswer + " ,建议题目类型修改为单选题";
}
}
}
else
{
if (subject.题目类型 != Subject.SubjecttypeEnum.单选题)
{
strMsg += "题干中存在多个选项 ,建议题目类型修改为单选题";
}
}
}
}
//else if (subject.subjecthtmlcontent.ToLower().IndexOf("</u>") != -1 || subject.subjecthtmlcontent.IndexOf("__") != -1)
else if (Regex.IsMatch(subject.subjecthtmlcontent.ToLower(), @"<u[^>]*>\s*?</u[^>]*>", RegexOptions.Singleline) || Regex.IsMatch(subject.subjecthtmlcontent.ToLower(), @"_{3,}", RegexOptions.Singleline))
{
if (subject.题目类型 == Subject.SubjecttypeEnum.填空题)
{
int iCount = 0;
if (subject.answers != null && subject.answers.Count > 0)
{
iCount = subject.answers.Count;
//存在题目未填写答案
if (subject.answers.Where(x => string.IsNullOrEmpty(x.content)).Count() != 0)
{
if (subject.客观题 == Subject.ObjectiveEnum.是)
{
strMsg += "部分填空空格未填写答案，请补全答案";
return new Tuple<bool, string, int>(false, strMsg, 0);
}
else
{
strMsg += "部分填空空格未填写答案，建议补全答案";
return new Tuple<bool, string, int>(false, strMsg, 1);
}
}
}
else
{
//答案
iCount = subject.answer.subjecttextanswer.Split('|').Length;
}
//题干
var iTCount = Regex.Matches(subject.subjecthtmlcontent, "<u[^>]*>(( )|[\\s]){3,}</u[ ]*>|(_{3,})", RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.Singleline).Count;
//题干 和答案不一样，则不能自动修复
if (iTCount != iCount)
{
strMsg += "题干填空空格数目和答案数目不一致";
return new Tuple<bool, string, int>(false, strMsg, 0);
}
}
else
{
if (subject.题目类型 == Subject.SubjecttypeEnum.阅读理解题 && subject.ListChild.Count > 0)
{
}
else
{
strMsg += "题干中存在填空空格，建议题目类型修改为填空题";
}
}
}
//else if ((subject.answer.subjecttextanswer.IndexOf("正确") != -1 || subject.answer.subjecttextanswer.IndexOf("对") != -1 || subject.answer.subjecttextanswer.IndexOf("错误") != -1 || subject.answer.subjecttextanswer.IndexOf("错") != -1) && subject.answer.subjecttextanswer.Length < 10)
else if (Regex.IsMatch(subject.answer.subjecttextanswer.Trim().ToUpper(), @"^正确{1}$|^错误{1}$|^对{1}$|^错{1}$|^YES{1}$|^NO{1}$", RegexOptions.Singleline))
{
if (subject.题目类型 != Subject.SubjecttypeEnum.判断题)
{
strMsg += "答案为 " + subject.answer.subjecttextanswer + " ,建议题目类型修改为判断题";
}
}
else if (subject.题目类型 == Subject.SubjecttypeEnum.填空题)
{
//if (subject.subjecthtmlcontent.ToLower().IndexOf("</u>") == -1 || subject.subjecthtmlcontent.IndexOf("__") == -1)
if (Regex.IsMatch(subject.subjecthtmlcontent.ToLower(), @"<u[^>]*>\s*?</u[^>]*>", RegexOptions.Singleline) || Regex.IsMatch(subject.subjecthtmlcontent.ToLower(), @"_{3,}", RegexOptions.Singleline))
{
strMsg += "没有填空空格，题目类型不能设定为填空题";
return new Tuple<bool, string, int>(false, strMsg, 0);
}
}
else if (subject.题目类型 == Subject.SubjecttypeEnum.判断题)
{
//if ((subject.answer.subjecttextanswer.IndexOf("正确") != -1 || subject.answer.subjecttextanswer.IndexOf("对") != -1 || subject.answer.subjecttextanswer.IndexOf("错误") != -1 || subject.answer.subjecttextanswer.IndexOf("错") != -1) && subject.answer.subjecttextanswer.Length < 10)
if (!Regex.IsMatch(subject.answer.subjecttextanswer.Trim().ToUpper(), @"^正确{1}$|^错误{1}$|^对{1}$|^错{1}$|^YES{1}$|^NO{1}$", RegexOptions.Singleline))
{
strMsg += "答案不符合判断题目规则，题目类型不能设定为判断题";
return new Tuple<bool, string, int>(false, strMsg, 0);
}
}
else if (subject.题目类型 == Subject.SubjecttypeEnum.阅读理解题)
{
if (subject.ListChild.Count == 0)
{
strMsg += "没有子题，题目类型不能设定为阅读理解题";
return new Tuple<bool, string, int>(false, strMsg, 0);
}
}
else if (subject.题目类型 == Subject.SubjecttypeEnum.单选题)
{
if (Regex.Matches(subject.subjecthtmlcontent, "[A-G][.．、]").Count < 2)
{
strMsg += "题干选项不够，题目类型不能设定为单选题";
return new Tuple<bool, string, int>(false, strMsg, 0);
}
}
else if (subject.题目类型 == Subject.SubjecttypeEnum.多选题)
{
if (Regex.Matches(subject.subjecthtmlcontent, "[A-G][.．、]").Count < 2)
{
strMsg += "题干选项不够，题目类型不能设定为多选题";
return new Tuple<bool, string, int>(false, strMsg, 0);
}
}
//正常的数据
if (tempStrMsg == strMsg)
{
return new Tuple<bool, string,int>(false, "",-1);
}
else
{
return new Tuple<bool, string,int>(true, strMsg,0);
}
}
}
/// <summary>
/// 获取答案
/// </summary>
/// <param name="treenodecurrectsubject"></param>
public static void GetAnswer(Subject treenodecurrectsubject)
{
//a bug is here
int endIndex = GetStrIndex(treenodecurrectsubject.subjecthtmlcontent, "(<p\\s*>)*答案[：:].+?(</p>)*", false);
int jtslIndex = GetStrIndex(treenodecurrectsubject.subjecthtmlcontent, "(<p\\s*>)*解题思路[：:].+?(</p>)*", false);
//有答案
if (endIndex != 0)
{
string tempText = treenodecurrectsubject.subjecthtmlcontent.Substring(endIndex);
string text = "";
//有解题思路
if (jtslIndex != 0)
{
jtslIndex = jtslIndex - endIndex;
text = tempText.Substring(0, jtslIndex).Replace("答案：", "").Replace("答案:", "");
treenodecurrectsubject.questionthinking = tempText.Substring(jtslIndex).Replace("解题思路：", "").Replace("解题思路:", "");
}
else
{
jtslIndex = GetStrIndex(treenodecurrectsubject.subjecthtmlcontent, "(<p\\s*>)*解析[：:].+?(</p>)*", false);
if (jtslIndex != 0)
{
jtslIndex = jtslIndex - endIndex;
text = tempText.Substring(0, jtslIndex).Replace("答案：", "").Replace("答案:", "");
treenodecurrectsubject.questionthinking = tempText.Substring(jtslIndex).Replace("解析：", "").Replace("解析:", "");
}
else
{
treenodecurrectsubject.questionthinking = "";
text = tempText.Replace("答案：", "").Replace("答案:", "");
}
}
treenodecurrectsubject.answer.subjecthtmlanswer = text;
treenodecurrectsubject.answer.subjecttextanswer = NoHTML(text);
treenodecurrectsubject.subjecthtmlcontent = treenodecurrectsubject.subjecthtmlcontent.Substring(0, endIndex);
}
}
private static void GetAnswer2(Subject item, Subject treenodecurrect,string[] regexs)
{
var htmlAnswer = item.subjecthtmlcontent;
foreach (var sb in regexs)
{
string tempsb = sb;
if (tempsb.IndexOf("^") == 0)
{
tempsb = tempsb.Substring(1);
}
var match = Regex.Match(htmlAnswer, tempsb);
if (match.Success)
{
int endIndex = GetStrIndex(htmlAnswer, match.Groups["pre"].Value, true);
htmlAnswer = htmlAnswer.Substring(0, endIndex) + htmlAnswer.Substring(endIndex + match.Groups["pre"].Value.Length);
}
}
int jtslIndex = GetStrIndex(htmlAnswer, "(<p\\s*>)*解题思路[：:].+?(</p>)*", false);
if (jtslIndex != 0)
{
treenodecurrect.questionthinking = htmlAnswer.Substring(jtslIndex).Replace("解题思路：", "").Replace("解题思路:", "");
htmlAnswer = htmlAnswer.Substring(0, jtslIndex);
}
else
{
jtslIndex = GetStrIndex(htmlAnswer, "(<p\\s*>)*解析[：:].+?(</p>)*", false);
if (jtslIndex != 0)
{
treenodecurrect.questionthinking = htmlAnswer.Substring(jtslIndex).Replace("解析：", "").Replace("解析:", "");
htmlAnswer = htmlAnswer.Substring(0, jtslIndex);
}
}
treenodecurrect.answer.subjecthtmlanswer = htmlAnswer;
treenodecurrect.answer.subjecttextanswer = NoHTML(htmlAnswer).Trim();
}
private static bool SelectAnswerPair(Subject subjectitem, int i, bool isanswer)
{
if (subjectitem.answer.subjecttextanswer != null)
{
switch (i)
{
case 1:
if (subjectitem.answer.subjecttextanswer.Contains("A") || subjectitem.answer.subjecttextanswer.Contains("a"))
isanswer = true;
break;
case 2:
if (subjectitem.answer.subjecttextanswer.Contains("B") || subjectitem.answer.subjecttextanswer.Contains("b"))
isanswer = true;
break;
case 3:
if (subjectitem.answer.subjecttextanswer.Contains("C") || subjectitem.answer.subjecttextanswer.Contains("c"))
isanswer = true;
break;
case 4:
if (subjectitem.answer.subjecttextanswer.Contains("D") || subjectitem.answer.subjecttextanswer.Contains("d"))
isanswer = true;
break;
case 5:
if (subjectitem.answer.subjecttextanswer.Contains("E") || subjectitem.answer.subjecttextanswer.Contains("e"))
isanswer = true;
break;
case 6:
if (subjectitem.answer.subjecttextanswer.Contains("F") || subjectitem.answer.subjecttextanswer.Contains("f"))
isanswer = true;
break;
case 7:
if (subjectitem.answer.subjecttextanswer.Contains("G") || subjectitem.answer.subjecttextanswer.Contains("g"))
isanswer = true;
break;
case 8:
if (subjectitem.answer.subjecttextanswer.Contains("H") || subjectitem.answer.subjecttextanswer.Contains("h"))
isanswer = true;
break;
case 9:
if (subjectitem.answer.subjecttextanswer.Contains("I") || subjectitem.answer.subjecttextanswer.Contains("i"))
isanswer = true;
break;
}
}
return isanswer;
}
/// <summary>
/// 上传前整理treeview中节点内容，并生成最终上传内容
/// </summary>
/// <param name="treenode"></param>
/// <param name="subjectkind"></param>
/// <param name="subjectItem"></param>
private void createSubjectItem(Subject subjectParent, ref SubjectItem subjectItem)
{
foreach (var subject in subjectParent.ListChild)
{
subject.subjecthtmlcontent = subject.subjecthtmlcontent.Replace("<check>", "").Replace("</check>", "").Replace("<nocheck>", "").Replace("</nocheck>", "");
SubjectItem subjectItemtemp = new SubjectItem();
//插入节信息
subjectItemtemp.subjectkinds = subject.subjecttextcontent;
string html = ReplaceImgNbsp(subject.subjecthtmlcontent);
html = Regex.Replace(html, @"^<pre[^>]*>([\s\S]+?)</pre>(.*)", "$1$2", RegexOptions.IgnoreCase);
subjectItemtemp.subjecthtmlcontent = html;
//替换答案中图片中的\r\n
subject.answer.subjecthtmlanswer = ReplaceImgNbsp(subject.answer.subjecthtmlanswer);
//匹配图片中的img src内容返回src地址
//string timedir = "/files/tsubjectfile/" + DateTime.Now.Year + "/" + DateTime.Now.Month + "/" + DateTime.Now.Day + "/" + "image/";
List<string> img = new List<string>();
img.AddRange(HtmlUtil.imgSrcForName(ref subjectItemtemp.subjecthtmlcontent, uploadimgsdic));//防火html中img图片地址列表，并修改地址为网络地址
subjectItemtemp.subjecttextcontent = subject.subjecttextcontent;
subjectItemtemp.questionthinking = SubjectTool.ReplaceHTML(subject.questionthinking,false);
subjectItemtemp.score = subject.分值;
subjectItemtemp.sequence = subject.套卷序号;
//subjectItemtemp.selectItemCount = subject.选项个数;
subjectItemtemp.isobjective = subject.客观题.GetHashCode();
subjectItemtemp.subjecttype = subject.题目类型.GetHashCode().ToString();
//过滤html中vml内容，存入过滤后的字段
//subjectItemtemp.subjectfilterhtmlcontent = SubjectTypeMark(subjectItemtemp.subjecthtmlcontent, subject.题目类型.GetHashCode());
if (subject.answer != null && subject.answer.subjecthtmlanswer != null)//处理答案相关数据
{
//subjectItemtemp.answerbinarycontent = subject.answer.subjectbinaryanswer;
string htmla = subject.answer.subjecthtmlanswer;
subjectItemtemp.answerhtmlcontent = htmla;
img.AddRange(HtmlUtil.imgSrcForName(ref subjectItemtemp.answerhtmlcontent, uploadimgsdic));
subjectItemtemp.answertextcontent = subject.answer.subjecttextanswer;
//过滤html中vml内容，单选题、多选题、对错题才用存文本形式
if (subjectItemtemp.subjecttype.Equals(Subject.SubjecttypeEnum.单选题) || subjectItemtemp.subjecttype.Equals(Subject.SubjecttypeEnum.多选题) || subjectItemtemp.subjecttype.Equals(Subject.SubjecttypeEnum.判断题))
{
subjectItemtemp.answerhtmlcontent = subject.answer.subjecttextanswer.Trim();
}
}
//替换解题思路中的图片
if (!string.IsNullOrEmpty(subject.questionthinking))
{
subjectItemtemp.questionthinking = ReplaceImgNbsp(subject.questionthinking);
img.AddRange(HtmlUtil.imgSrcForName(ref subjectItemtemp.questionthinking, uploadimgsdic));
}
//替换音频
img.AddRange(HtmlUtil.Mp3SrcForName(ref subjectItemtemp.subjecthtmlcontent, uploadimgsdic));
subjectItemtemp.img = img.ToArray();
SubjectTypeMarkAndCreateOption(ref subjectItemtemp, subject.题目类型.GetHashCode());//选项标识并列出选项
subjectItem.subSubjectItemList.Add(subjectItemtemp);
if(subject.ListChild.Count>0)
{
createSubjectItem(subject, ref subjectItemtemp);
}
}
}
private void btnOneIdentify_Click(object sender, EventArgs e)
{
if (!ChkDocExist())
{
return;
}
int start = mainContent.WordBrowers.document.Application.Selection.Range.Start;
int end = mainContent.WordBrowers.document.Application.Selection.Range.End;
var currentItem = allListSubject.Find(x => x.rangestart == start);
if (currentItem == null)
{
MessageBox.Show("系统未匹配到题目，请您选择时，从题号开始");
}
else
{
Subject newSubject = new Subject();
mainContent.WordBrowers.document.Application.Selection.Range.Copy();//不包括题目前ID号内容的范围
string html = ClipboardHelper.getClipboardHtml();
HtmlUtil.HtmlPictureMove(ref html);
html = GetReplaceHTML(html).Replace("<u></u>", "");
if (html == "")
{
return;
}
//是否处理，序列已经处理，则不用再处理
bool isHandle = false;
var strsPre = MatchArray.BigSubjectPre;
foreach (var sb in strsPre)
{
string tempsb = sb;
if (tempsb.IndexOf("^") == 0)
{
tempsb = tempsb.Substring(1);
}
var match = Regex.Match(html, tempsb);
if (match.Success)
{
html = html.Substring(0, html.IndexOf(match.Groups["pre"].Value)) + html.Substring(html.IndexOf(match.Groups["pre"].Value) + match.Groups["pre"].Value.Length);
isHandle = true;
break;
}
}
if (!isHandle)
{
strsPre = MatchArray.SubjectPreStructure.subjectPre;
//第一层需要去掉第二层的内容
foreach (var sb in strsPre)
{
string tempsb = sb;
if (tempsb.IndexOf("^") == 0)
{
tempsb = tempsb.Substring(1);
}
var match = Regex.Match(html, tempsb);
if (match.Success)
{
html = html.Substring(0, html.IndexOf(match.Groups["pre"].Value)) + html.Substring(html.IndexOf(match.Groups["pre"].Value) + match.Groups["pre"].Value.Length);
isHandle = true;
break;
}
}
}
if (!isHandle)
{
strsPre = MatchArray.SubjectPreStructure.childsubjectStructure.subjectPre;
foreach (var sb in strsPre)
{
string tempsb = sb;
if (tempsb.IndexOf("^") == 0)
{
tempsb = tempsb.Substring(1);
}
var match = Regex.Match(html, tempsb);
if (match.Success)
{
html = html.Substring(0, html.IndexOf(match.Groups["pre"].Value)) + html.Substring(html.IndexOf(match.Groups["pre"].Value) + match.Groups["pre"].Value.Length);
break;
}
}
}
//--
newSubject.answer = new AnswerContent();
newSubject.answer.selectType = currentItem.answer.selectType;
newSubject.subjecthtmlcontent = html;
//没有答案，则全部为题干
if (html.IndexOf("答案：") == -1 && html.IndexOf("答案:") == -1)
{
newSubject.answer.subjecthtmlanswer = currentItem.answer.subjecthtmlanswer;
newSubject.answer.subjecttextanswer = currentItem.answer.subjecttextanswer;
}
else
{
//有答案，则要进行分割
SubjectTool.GetAnswer(newSubject);
}
newSubject.subjecttextcontent = SubjectTool.NoHTML(newSubject.subjecthtmlcontent);
newSubject.分值 = currentItem.分值;
newSubject.Index = currentItem.Index;
newSubject.套卷序号 = currentItem.套卷序号;
newSubject.Id = currentItem.Id;
newSubject.ListChild = currentItem.ListChild;
SubjectTool.SetSubjectType(newSubject);
SetSubject(currentItem, newSubject);
var nextItem = allListSubject.Find(x => x.rangestart > currentItem.rangestart);
//不是最后一个
if (nextItem != null)
{
//得到差值
var num = end - nextItem.rangestart;
allListSubject.Where(x => x.rangestart > currentItem.rangestart).ToList().ForEach(x => {
x.rangestart += num;
});
}
ReloadSubject(true);
//--
MessageBox.Show("识别成功", "提示");
}
}
void SetSubject(Subject oldSubject, Subject newSubject)
{
var html = newSubject.subjecthtmlcontent.Replace("<check>", "").Replace("</check>", "").Replace("<nocheck>", "").Replace("</nocheck>", "");
Regex regex = new Regex("<object.*data=\"(.+?)\".*FlashVars=\"(.+?)\".*>(.+?)</object>",RegexOptions.IgnoreCase|RegexOptions.Singleline);
foreach (Match match in regex.Matches(html))
{
if (match.Success)
{
//需要替换
if (match.Groups[3].Value.Trim() == "")
{
html = html.Replace("</object>", "<param name=\"movie\" value=\""+match.Groups[1].Value+"\"><param name=\"FlashVars\" value=\""+match.Groups[2].Value+"\"><param name=\"quality\" value=\"high\"><param name=\"menu\" value=\"false\"><param name=\"wmode\" value=\"transparent\"></object>");
}
}
}
oldSubject.answer.selectType = newSubject.answer.selectType;
oldSubject.answer.subjecthtmlanswer = newSubject.answer.subjecthtmlanswer;
oldSubject.answer.subjecttextanswer = newSubject.answer.subjecttextanswer;
oldSubject.subjecthtmlcontent = html.Replace("<u></u>", "");
oldSubject.subjecttextcontent = newSubject.subjecttextcontent;
oldSubject.答案 = newSubject.答案;
oldSubject.分值 = newSubject.分值;
oldSubject.客观题 = newSubject.客观题;
oldSubject.Index = newSubject.Index;
oldSubject.套卷序号 = newSubject.套卷序号;
oldSubject.题目类型 = newSubject.题目类型;
oldSubject.Id = newSubject.Id;
oldSubject.questionthinking = newSubject.questionthinking;
//oldSubject.选项个数 = newSubject.选项个数;
oldSubject.answers.Clear();
SubjectTool.SubjectTypeMarkAndCreateOption(oldSubject);
}
private void SetNode(Subject subject)
{
//没有答案
if ((subject.answer == null || string.IsNullOrEmpty(subject.answer.subjecttextanswer)) && subject.题目类型 != Subject.SubjecttypeEnum.阅读理解题)
{
//客观题，一定要添加答案
if (subject.客观题 == Subject.ObjectiveEnum.是)
{
subject.客观题 = Subject.ObjectiveEnum.否;
}
}
else
{
//if (Regex.Matches(subject.subjecthtmlcontent, "[A-G][.．、][^A-G]").Count > 1) //mark
if (Regex.Matches(subject.subjecthtmlcontent, "[A-G][.．、]").Count > 1)
{
//没有答案，则为单选题
if ((subject.answer != null && !string.IsNullOrEmpty(subject.answer.subjecttextanswer)))
{
if ((Regex.IsMatch(subject.subjecthtmlcontent.ToLower(), @"<u[^>]*>\s*?</u[^>]*>", RegexOptions.Singleline)
|| Regex.IsMatch(subject.subjecthtmlcontent.ToLower(), @"_{3,}", RegexOptions.Singleline))
&& !Regex.IsMatch(subject.subjecthtmlcontent, @"（）|\(\)", RegexOptions.Singleline)
&& !Regex.IsMatch(subject.answer.subjecttextanswer.Trim().ToUpper(), @"^[A-G]{1,7}$", RegexOptions.Singleline))
{
subject.题目类型 = Subject.SubjecttypeEnum.填空题;
}
else if (Regex.IsMatch(subject.answer.subjecttextanswer.Trim().ToUpper(), @"^正确{1}$|^错误{1}$|^对{1}$|^错{1}$|^YES{1}$|^NO{1}$", RegexOptions.Singleline))
{
if (subject.题目类型 != Subject.SubjecttypeEnum.判断题)
{
subject.题目类型 = Subject.SubjecttypeEnum.判断题;
subject.客观题 = Subject.ObjectiveEnum.是;
}
}
//如果有多个答案，则为多选题
else if (Regex.IsMatch(subject.answer.subjecttextanswer.Trim().ToUpper(), "^[A-G]{2,26}$") || subject.subjecthtmlcontent.IndexOf("多选") != -1)
{
if (subject.题目类型 != Subject.SubjecttypeEnum.多选题)
{
subject.题目类型 = Subject.SubjecttypeEnum.多选题;
subject.客观题 = Subject.ObjectiveEnum.是;
}
}
else if(Regex.IsMatch(subject.answer.subjecttextanswer.Trim().ToUpper(), "^[A-G]{1}$"))
{
if (subject.题目类型 != Subject.SubjecttypeEnum.单选题)
{
subject.题目类型 = Subject.SubjecttypeEnum.单选题;
subject.客观题 = Subject.ObjectiveEnum.是;
}
}
else
{
if (subject.题目类型 != Subject.SubjecttypeEnum.简答题)
{
subject.题目类型 = Subject.SubjecttypeEnum.简答题;
subject.客观题 = Subject.ObjectiveEnum.否;
}
}
}
else
{
if (subject.题目类型 != Subject.SubjecttypeEnum.单选题)
{
subject.题目类型 = Subject.SubjecttypeEnum.单选题;
subject.客观题 = Subject.ObjectiveEnum.是;
}
}
}
//else if (subject.subjecthtmlcontent.ToLower().IndexOf("</u>") != -1 || subject.subjecthtmlcontent.IndexOf("__") != -1)
else if (Regex.IsMatch(subject.subjecthtmlcontent.ToLower(), @"<u[^>]*>\s*?</u[^>]*>", RegexOptions.Singleline) || Regex.IsMatch(subject.subjecthtmlcontent.ToLower(), @"_{3,}", RegexOptions.Singleline))
{
if (subject.题目类型 != Subject.SubjecttypeEnum.填空题)
{
if (!(subject.题目类型 == Subject.SubjecttypeEnum.阅读理解题 && subject.ListChild.Count > 0))
{
subject.题目类型 = Subject.SubjecttypeEnum.填空题;
subject.客观题 = Subject.ObjectiveEnum.是;
}
}
}
//else if ((subject.answer.subjecttextanswer.IndexOf("正确") != -1 || subject.answer.subjecttextanswer.IndexOf("对") != -1 || subject.answer.subjecttextanswer.IndexOf("错误") != -1 || subject.answer.subjecttextanswer.IndexOf("错") != -1) && subject.answer.subjecttextanswer.Length < 10)
else if (Regex.IsMatch(subject.answer.subjecttextanswer.Trim().ToUpper(), @"^正确{1}$|^错误{1}$|^对{1}$|^错{1}$|^YES{1}$|^NO{1}$", RegexOptions.Singleline))
{
if (subject.题目类型 != Subject.SubjecttypeEnum.判断题)
{
subject.题目类型 = Subject.SubjecttypeEnum.判断题;
subject.客观题 = Subject.ObjectiveEnum.是;
}
}
else
{
subject.题目类型 = Subject.SubjecttypeEnum.简答题;
subject.客观题 = Subject.ObjectiveEnum.否;
}
}
}
private int LoadMsg(int height, Subject item, List<Subject> listSubject)
{
var rtMsg = SubjectTool.CheckSubjectType(item,listSubject);
if (!rtMsg.Item1 && rtMsg.Item2 == "")
{
}else if(item.Level ==1)
{
listError.Add(new Tuple<bool, string, int, Subject>(rtMsg.Item1, rtMsg.Item2, rtMsg.Item3, item));
}
else
{
listError.Add(new Tuple<bool, string, int, Subject>(rtMsg.Item1,rtMsg.Item2,rtMsg.Item3,item));
//添加复选框
panel4.Controls.Add(new CheckBox()
{
Top = height,
Width = 18,
Enabled = rtMsg.Item1,
Checked = rtMsg.Item1,
Tag = item,
Name = item.Id
});
panel4.ForeColor = Color.Red;
//添加提示文本
Label lb1 = new Label()
{
Top = height + 7,
Left = 18,
Height = 22,
Text = rtMsg.Item2,
Width = 640,
ForeColor = rtMsg.Item1 ? Color.Red : (rtMsg.Item3 == 0 ? Color.Blue : Color.Blue)
};
panel4.Controls.Add(lb1);
string text = "修复此项[必须]";
if(!rtMsg.Item1)
{
if(rtMsg.Item3==1)
{
text = "手动修复[建议]";
}else if(rtMsg.Item3==0)
{
text = "手动修复[必须]";
}
}
//添加修复按钮
var linklable = new LinkLabel()
{
Top = height + 7,
Left = 668,
Height = 22,
Text = text,
Width = 90,
Tag = item,
Name = "linklable_" + item.Id,
Enabled = rtMsg.Item1
};
linklable.LinkClicked += linklable_LinkClicked;
panel4.Controls.Add(linklable);
height += 22;
}
return height;
}
