/// <summary>
/// 获取Yw_SubjectContent对象,以及对对象如何操作(添加/更新)
/// 用于向数据库添加或更新数据
/// </summary>
/// <param name="subject"></param>
/// <param name="bll"></param>
/// <param name="currentUser"></param>
/// <param name="entity"></param>
/// <returns></returns>
public Action <Yw_SubjectContent> Fetch(
QuestionInputModel subject,
SubjectBll bll,
int currentUser,
out Yw_SubjectContent entity)
{
Check.IfNull(subject, nameof(subject));
if (currentUser < 10000)
{
throw new ArgumentException(
"当前登录用户的ID不能小于10000",
nameof(currentUser));
}
Action <Yw_SubjectContent> saveContentMethod = null;
Yw_SubjectContent contentInDb = bll.GetSubjectContent(subject.Id);
if (contentInDb == null)
{
saveContentMethod = bll.InsertContent;
}
else
{
saveContentMethod = bll.UpdateContent;
}
Yw_SubjectContent content = GetContent(subject, bll, currentUser, contentInDb);
entity = content;
return(saveContentMethod);
}
protected override QuestionInputModel ConvertToDerived2(
Yw_SubjectContent content)
{
var inputModel = new MultipleChoice();
if (content != null)
{
var c = content as Yw_SubjectSelectContent;
inputModel.StemType = (UeditorType)c.Ysc_Content_Obj.StemType;
inputModel.ContentType = (UeditorType)c.Ysc_Content_Obj.ContentType;
inputModel.Display = c.Ysc_Content_Obj.Display;
UeditorType contentType = (UeditorType)c.Ysc_Content_Obj.ContentType;
inputModel.Options = c.Ysc_Content_Obj.Options
.Select(o => UeditorContentFactory.RestoreContent(o.Text, contentType)).ToList();
inputModel.Random = c.Ysc_Content_Obj.Random;
UeditorType t = (UeditorType)c.Ysc_Content_Obj.StemType;
string name = UeditorContentFactory.RestoreContent(c.Ysc_Content_Obj.Stem, t);
inputModel.Name = name;
inputModel.Answers = c.Ysc_Answer_Obj.Answers;
}
else
{
inputModel.StemType = UeditorType.Text;
inputModel.ContentType = UeditorType.Text;
inputModel.Display = 1;
inputModel.Options = new List <string>();
inputModel.Random = 1;
inputModel.Name = string.Empty;
inputModel.Answers = new List <int>();
}
return(inputModel);
}
protected override Yw_SubjectContent GetContent(
QuestionInputModel sub,
SubjectBll bll,
int currentUser,
Yw_SubjectContent content)
{
FillInBlank subject = sub as FillInBlank;
Yw_FillInBlankContent derivedContent = null;
if (content == null)
{
derivedContent = new Yw_FillInBlankContent();
derivedContent.Ysc_CreateTime = DateTime.Now;
derivedContent.Ysc_Creator = currentUser;
derivedContent.Ysc_SubjectType = subject.SubjectType;
}
else
{
derivedContent = content as Yw_FillInBlankContent;
}
derivedContent.Ysc_Editor = currentUser;
derivedContent.Ysc_Explain = subject.Explain;
derivedContent.Ysc_Content_Obj = new FillInBlankContentObj
{
Stem = UeditorContentFactory.Blank(subject.Name)
};
derivedContent.Ysc_Answer_Obj = new FillInBlankAnswerObj
{
Correct = subject.Correct.Blanks,
Other = subject.Other.Blanks,
Perfect = subject.Perfect.Blanks
};
derivedContent.Ysc_UpdateTime = DateTime.Now;
return(derivedContent);
}
protected override Yw_SubjectContent GetContent(
QuestionInputModel sub,
SubjectBll bll,
int currentUser,
Yw_SubjectContent content)
{
TrueFalse subject = sub as TrueFalse;
Yw_TrueFalseContent derivedContent = null;
if (content == null)
{
derivedContent = new Yw_TrueFalseContent();
derivedContent.Ysc_CreateTime = DateTime.Now;
derivedContent.Ysc_Creator = currentUser;
derivedContent.Ysc_SubjectType = subject.SubjectType;
}
else
{
derivedContent = content as Yw_TrueFalseContent;
}
derivedContent.Ysc_Editor = currentUser;
derivedContent.Ysc_Explain = subject.Explain;
derivedContent.Ysc_Content_Obj = new TrueFalseContentObj
{
StemType = (int)subject.StemType,
Stem = UeditorContentFactory.FetchUrl(subject.Name, subject.StemType)
};
derivedContent.Ysc_Answer_Obj = new TrueFalseAnswerObj
{
Answer = subject.Answer
};
derivedContent.Ysc_UpdateTime = DateTime.Now;
return(derivedContent);
}
public void SubjectContentDtoBuilder_Create_ShouldReturnCorrect()
{
Yw_SubjectContent content = null;
Yw_Subject subject = null;
DtoSubjectContent dto = SubjectContentDtoBuilder.Create(content, subject);
Assert.IsNotNull(dto);
Console.WriteLine(dto.ToJson());
}
protected override QuestionInputModel ConvertToDerived(
Yw_SubjectContent content)
{
var inputModel = new FillInBlank();
var c = content as Yw_FillInBlankContent;
inputModel.Perfect.Blanks = c.Ysc_Answer_Obj.Perfect;
inputModel.Correct.Blanks = c.Ysc_Answer_Obj.Correct;
inputModel.Other.Blanks = c.Ysc_Answer_Obj.Other;
inputModel.Name = c.Ysc_Content_Obj.Stem;
return(inputModel);
}
protected override Yw_SubjectContent GetContent(
QuestionInputModel sub,
SubjectBll bll,
int currentUser,
Yw_SubjectContent content)
{
MultipleChoice subject = sub as MultipleChoice;
Yw_SubjectSelectContent selectContent = null;
if (content == null)
{
selectContent = new Yw_SubjectSelectContent();
selectContent.Ysc_CreateTime = DateTime.Now;
selectContent.Ysc_Creator = currentUser;
selectContent.Ysc_SubjectType = subject.SubjectType;
}
else
{
selectContent = content as Yw_SubjectSelectContent;
}
selectContent.Ysc_Editor = currentUser;
selectContent.Ysc_Explain = subject.Explain;
if (subject.ContentType == UeditorType.Image)
{
subject.Options = subject.Options.Select(o =>
UeditorContentFactory.FetchUrl(o, subject.ContentType)).ToList();
}
var options = subject.Options
.Select((o, i) => new SubjectOption {
Text = o, Key = i
})
.ToList();
selectContent.Ysc_Answer_Obj = new SubjectSelectAnswerObj
{
Answers = subject.Answers
};
string stem = UeditorContentFactory.FetchUrl(subject.Name, subject.StemType);
selectContent.Ysc_Content_Obj = new SubjectSelectContentObj
{
StemType = (int)subject.StemType,
Stem = stem,
ContentType = (int)subject.ContentType,
Options = options,
Display = subject.Display,
Random = subject.Random
};
selectContent.Ysc_UpdateTime = DateTime.Now;
return(selectContent);
}
protected override QuestionInputModel ConvertToDerived(
Yw_SubjectContent content)
{
TrueFalse inputModel = new TrueFalse();
Yw_TrueFalseContent c = content as Yw_TrueFalseContent;
inputModel.Answer = c.Ysc_Answer_Obj.Answer;
inputModel.StemType = (UeditorType)c.Ysc_Content_Obj.StemType;
inputModel.Name = UeditorContentFactory.RestoreContent(
c.Ysc_Content_Obj.Stem,
inputModel.StemType);
return(inputModel);
}
protected override QuestionInputModel ConvertToDerived(
Yw_SubjectContent content)
{
var inputModel = new Free();
var c = content as Yw_SubjectFreeContent;
inputModel.StemType = (UeditorType)c.Ysc_Content_Obj.StemType;
inputModel.Name = UeditorContentFactory.RestoreContent(
c.Ysc_Content_Obj.Stem,
inputModel.StemType);
inputModel.Answer = c.Ysc_Answer_Obj.Answer;
inputModel.ScoreRules = c.Ysc_Content_Obj.ScoreRules;
return(inputModel);
}
protected override QuestionInputModel ConvertToDerived(
Yw_SubjectContent content)
{
var inputModel = new Mark();
var c = content as Yw_SubjectMarkContent;
inputModel.Color = c.Ysc_Content_Obj.Color;
inputModel.Content = c.Ysc_Content_Obj.Content;
inputModel.Alignment = c.Ysc_Content_Obj.Alignment;
inputModel.StemType = (UeditorType)c.Ysc_Content_Obj.StemType;
inputModel.Name = UeditorContentFactory.RestoreContent(
c.Ysc_Content_Obj.Stem,
inputModel.StemType);
return(inputModel);
}
public Tuple <StudentAnswerBase, Yw_SubjectContent, Yw_Subject, Yw_StudentWrongSubject> GetWorngSubjectVm(int studentId, int wrongSubjectId)
{
Yw_StudentWrongSubject wrongSubject = StudentWrongSubjectRepository.Get(wrongSubjectId);
if (wrongSubject == null || wrongSubject.Yws_StudentId != studentId)
{
wrongSubject = null;
}
if (wrongSubject != null)
{
StudentAnswerBase answer = (wrongSubject as Yw_StudentWrongSubjectExt).Yws_Answer_Obj;
Yw_SubjectContent subjectContent = SubjectBll.GetSubjectContent(wrongSubject.Yws_WrongSubjectId);
Yw_Subject subject = SubjectBll.GetSubject(wrongSubject.Yws_WrongSubjectId);
return(new Tuple <StudentAnswerBase, Yw_SubjectContent, Yw_Subject, Yw_StudentWrongSubject>(answer, subjectContent, subject, wrongSubject));
}
return(null);
}
protected override QuestionInputModel ConvertToDerived(
Yw_SubjectContent content)
{
var inputModel = new Match();
var c = content as Yw_MatchContent;
inputModel.StemType = (UeditorType)c.Ysc_Content_Obj.StemType;
inputModel.TitleOptionContentType = (UeditorType)c.Ysc_Content_Obj.LeftOptionContentType;
inputModel.AnswertOptionContentType = (UeditorType)c.Ysc_Content_Obj.RightOptionContentType;
inputModel.Title = c.Ysc_Content_Obj.LeftOptions.Select(s =>
UeditorContentFactory.RestoreContent(s.Text, inputModel.TitleOptionContentType)).ToList();
inputModel.LinedAnswers = c.Ysc_Answer_Obj.Answers.Select(s => s[1]).ToList();
inputModel.Answer = c.Ysc_Content_Obj.RightOptions.Select(s =>
UeditorContentFactory.RestoreContent(s.Text, inputModel.AnswertOptionContentType)).ToList();
inputModel.Name = UeditorContentFactory.RestoreContent(
c.Ysc_Content_Obj.Stem,
inputModel.StemType);
return(inputModel);
}
public void SubjectContentRepository_Insert_ShouldSuccess()
{
SubjectContentRepository repository = new SubjectContentRepository();
DateTime now = DateTime.Now;
Yw_SubjectContent addedEntity = repository.Insert(new Yw_SubjectContent()
{
Ysc_SubjectId = 90000,
Ysc_CreateTime = now,
Ysc_Creator = 1000,
Ysc_Editor = 1000,
Ysc_SubjectType = (int)SubjectTypeEnum.择题,
Ysc_UpdateTime = now,
Ysc_Answer = "answer-zhcy",
Ysc_Content = "content-zhcy",
Ysc_Explain = "explain-zhcy"
});
Assert.IsNotNull(addedEntity);
Assert.AreEqual(90000, addedEntity.Ysc_SubjectId);
}
protected override QuestionInputModel ConvertToDerived2(Yw_SubjectContent content)
{
TrueFalse inputModel = new TrueFalse();
if (content != null)
{
Yw_TrueFalseContent c = content as Yw_TrueFalseContent;
inputModel.Answer = c.Ysc_Answer_Obj.Answer;
inputModel.StemType = (UeditorType)c.Ysc_Content_Obj.StemType;
inputModel.Name = UeditorContentFactory.RestoreContent(
c.Ysc_Content_Obj.Stem,
inputModel.StemType);
}
else
{
inputModel.StemType = UeditorType.Text;
inputModel.Name = string.Empty;
inputModel.Answer = 1;
}
return(inputModel);
}
protected override Yw_SubjectContent GetContent(
QuestionInputModel sub,
SubjectBll bll,
int currentUser,
Yw_SubjectContent content)
{
Mark2 subject = sub as Mark2;
Yw_SubjectMark2Content selectContent = null;
if (content == null)
{
selectContent = new Yw_SubjectMark2Content();
selectContent.Ysc_CreateTime = DateTime.Now;
selectContent.Ysc_Creator = currentUser;
selectContent.Ysc_SubjectType = subject.SubjectType;
}
else
{
selectContent = content as Yw_SubjectMark2Content;
}
selectContent.Ysc_Editor = currentUser;
selectContent.Ysc_Explain = subject.Explain;
selectContent.Ysc_Content_Obj = new SubjectMark2ContentObj
{
Alignment = subject.Alignment,
Color = subject.Color,
Content = subject.Content,
Stem = UeditorContentFactory.FetchUrl(subject.Name, subject.StemType),
StemType = (int)subject.StemType
};
selectContent.Ysc_Answer_Obj = new SubjectMark2AnswerObj
{
Answers = GenareteAnswers(subject.Content)
};
selectContent.Ysc_UpdateTime = DateTime.Now;
return(selectContent);
}
protected override QuestionInputModel ConvertToDerived(
Yw_SubjectContent content)
{
var inputModel = new MultipleChoiceFillInBlank();
var c = content as MultipleChoiceFillInBlankContent;
inputModel.AnswerIndexes = new List <int>();
UeditorType type = (UeditorType)c.Ysc_Content_Obj.ContentType;
inputModel.Options = c.Ysc_Content_Obj.SubjectOptions.Select(o =>
UeditorContentFactory.RestoreContent(o.Text, type)).ToList();
inputModel.Goptions = c.Ysc_Content_Obj.SubjectGOptions.Select(o =>
UeditorContentFactory.RestoreContent(o.Text, type)).ToList();
inputModel.Name = c.Ysc_Content_Obj.Stem;
inputModel.ContentType = (UeditorType)c.Ysc_Content_Obj.ContentType;
//inputModel.GPositions = new List<int>();
//foreach (var item in c.Ysc_Content_Obj.GPositions)
//{
// inputModel.GPositions.Add(item.Key);
//}
return(inputModel);
}
public void SubmitSubject(
Yw_Subject subject,
Yw_SubjectContent content,
IEnumerable <Yw_SubjectIndex> subjectIndexToAdd,
IEnumerable <int> subjectIndexToDelete,
Yw_SubjectKnowledge mainKnowledge,
IEnumerable <Yw_SubjectKnowledge> knowledgesToAdd,
IEnumerable <int> knowledgesToDelete,
Yw_SubjectProcess subjectProcess)
{
using (TransactionScope scope = new TransactionScope())
{
try
{
if (!Saved(subject.Ysj_Id))
{
//SaveSubject(
// subject,
// content,
// subjectIndexToAdd,
// subjectIndexToDelete,
// mainKnowledge,
// knowledgesToAdd,
// knowledgesToDelete);
}
subjectProcess.Ysp_SubjectId = subject.Ysj_Id;
MoveSubjectProcessToNext(subjectProcess);
scope.Complete();
}
catch
{
RollbackTran();
throw;
}
}
}
protected override Yw_SubjectContent GetContent(
QuestionInputModel sub,
SubjectBll bll,
int currentUser,
Yw_SubjectContent content)
{
Free subject = sub as Free;
Yw_SubjectFreeContent selectContent = null;
if (content == null)
{
selectContent = new Yw_SubjectFreeContent();
selectContent.Ysc_CreateTime = DateTime.Now;
selectContent.Ysc_Creator = currentUser;
selectContent.Ysc_SubjectType = subject.SubjectType;
}
else
{
selectContent = content as Yw_SubjectFreeContent;
}
selectContent.Ysc_Editor = currentUser;
selectContent.Ysc_Explain = subject.Explain;
selectContent.Ysc_Answer_Obj = new SubjectFreeAnswerObj
{
Answer = subject.Answer
};
selectContent.Ysc_Content_Obj = new SubjectFreeContentObj
{
ScoreRules = subject.ScoreRules,
Stem = UeditorContentFactory.FetchUrl(subject.Name, subject.StemType),
StemType = (int)subject.StemType
};
selectContent.Ysc_UpdateTime = DateTime.Now;
return(selectContent);
}
public void InsertContent(Yw_SubjectContent content)
{
Service.Insert(content);
}
public static SubjectVm Create(Yw_SubjectContent content)
{
Check.IfNull(content, nameof(content));
SubjectVm vm = null;
SubjectTypeEnum subjectType = (SubjectTypeEnum)content.Ysc_SubjectType;
switch (subjectType)
{
case SubjectTypeEnum.择题:
Yw_SubjectSelectContent select = content as Yw_SubjectSelectContent;
var random = select.Ysc_Content_Obj.Random;
var mOptions = select.Ysc_Content_Obj.Options;
if (random == 1) //随机显示
{
mOptions = mOptions.OrderBy(c => Guid.NewGuid()).ToList();
}
vm = new MultipleChoiceSubjectVm
{
KnowledgeId = 0,
Analysis = select.Ysc_Explain,
Answer = select.Ysc_Answer_Obj.Answers,
StemType = select.Ysc_Content_Obj.StemType,
Stem = select.Ysc_Content_Obj.Stem,
Options = mOptions,
OptionType = select.Ysc_Content_Obj.ContentType,
SubjectType = select.Ysc_SubjectType,
Display = select.Ysc_Content_Obj.Display
};
break;
case SubjectTypeEnum.判断题:
Yw_TrueFalseContent trueFalse = content as Yw_TrueFalseContent;
vm = new TrueFalseSubjectVm
{
KnowledgeId = 0,
Analysis = trueFalse.Ysc_Explain,
Answer = trueFalse.Ysc_Answer_Obj.Answer,
StemType = trueFalse.Ysc_Content_Obj.StemType,
Stem = trueFalse.Ysc_Content_Obj.Stem,
SubjectType = trueFalse.Ysc_SubjectType
};
break;
case SubjectTypeEnum.填空题:
Yw_FillInBlankContent fillInBlank = content as Yw_FillInBlankContent;
string blankStem = UeditorContentFactory.Blank(
fillInBlank.Ysc_Content_Obj.Stem);
vm = new FillInBlankSubjectVm
{
KnowledgeId = 0,
Analysis = fillInBlank.Ysc_Explain,
Answer = new
{
Perfect = fillInBlank.Ysc_Answer_Obj.Perfect,
Correct = fillInBlank.Ysc_Answer_Obj.Correct,
Other = fillInBlank.Ysc_Answer_Obj.Other
},
StemType = (int)UeditorType.Text,
Stem = blankStem,
SubjectType = fillInBlank.Ysc_SubjectType
};
break;
case SubjectTypeEnum.择填空:
MultipleChoiceFillInBlankContent multipleChoiceFillInBlank = content as MultipleChoiceFillInBlankContent;
List <SubjectOption> options = new List <SubjectOption>();
options.AddRange(multipleChoiceFillInBlank.Ysc_Content_Obj.SubjectOptions);
options.AddRange(multipleChoiceFillInBlank.Ysc_Content_Obj.SubjectGOptions);
UeditorType contentType =
(UeditorType)multipleChoiceFillInBlank.Ysc_Content_Obj.ContentType;
RestoreUrl(options, contentType);
options = options.OrderBy(c => Guid.NewGuid()).ToList();
string mBlankStem = UeditorContentFactory.Blank(
multipleChoiceFillInBlank.Ysc_Content_Obj.Stem);
vm = new MultipleChoiceFillInBlankSubjectVm
{
KnowledgeId = 0,
Analysis = multipleChoiceFillInBlank.Ysc_Explain,
Answer = multipleChoiceFillInBlank.Ysc_Answer_Obj.Answers,
StemType = (int)UeditorType.Text,
Stem = mBlankStem,
Options = options,
OptionType = multipleChoiceFillInBlank.Ysc_Content_Obj.ContentType,
SubjectType = multipleChoiceFillInBlank.Ysc_SubjectType
};
break;
case SubjectTypeEnum.连线题:
Yw_MatchContent match = content as Yw_MatchContent;
var contentObj = match.Ysc_Content_Obj;
var leftOptions = new List <SubjectOption>();
leftOptions.AddRange(contentObj.LeftOptions);
RestoreUrl(leftOptions, (UeditorType)contentObj.LeftOptionContentType);
leftOptions = leftOptions.OrderBy(c => Guid.NewGuid()).ToList();
var rightOptions = new List <SubjectOption>();
rightOptions.AddRange(contentObj.RightOptions);
RestoreUrl(rightOptions, (UeditorType)contentObj.RightOptionContentType);
rightOptions = rightOptions.OrderBy(c => Guid.NewGuid()).ToList();
vm = new MatchSubjectVm
{
KnowledgeId = 0,
Analysis = match.Ysc_Explain,
Answer = match.Ysc_Answer_Obj.Answers,
StemType = contentObj.StemType,
Stem = contentObj.Stem,
LeftOptions = leftOptions,
RightOptions = rightOptions,
SubjectType = match.Ysc_SubjectType,
LeftOptionType = match.Ysc_Content_Obj.LeftOptionContentType,
RightOptionType = match.Ysc_Content_Obj.RightOptionContentType
};
break;
case SubjectTypeEnum.主观题:
Yw_SubjectFreeContent free = content as Yw_SubjectFreeContent;
string freeAnswer = free.Ysc_Answer_Obj.Answer;
if (free.Ysc_Content_Obj.AnswerType == (int)UeditorType.Image)
{
freeAnswer = ConfigurationManager.AppSettings["OssHostUrl"]
+ freeAnswer;
}
string freeStandard = free.Ysc_Content_Obj.ScoreRules;
if (free.Ysc_Content_Obj.ScoreRulesType == (int)UeditorType.Image)
{
freeStandard = ConfigurationManager.AppSettings["OssHostUrl"]
+ freeStandard;
}
string freeStem = free.Ysc_Content_Obj.Stem;
if (free.Ysc_Content_Obj.StemType == (int)UeditorType.Image)
{
freeStem = ConfigurationManager.AppSettings["OssHostUrl"]
+ freeStem;
}
vm = new FreeSubjectVm
{
KnowledgeId = 0,
Analysis = free.Ysc_Explain,
Answer = freeAnswer,
AnswerType = free.Ysc_Content_Obj.AnswerType,
StemType = free.Ysc_Content_Obj.StemType,
Stem = freeStem,
SubjectType = free.Ysc_SubjectType,
Standard = freeStandard,
StandardType = free.Ysc_Content_Obj.ScoreRulesType
};
break;
case SubjectTypeEnum.圈点批注标色:
Yw_SubjectMarkContent mark = content as Yw_SubjectMarkContent;
string stem = mark.Ysc_Content_Obj.Stem;
if (mark.Ysc_Content_Obj.StemType == (int)UeditorType.Image)
{
stem = ConfigurationManager.AppSettings["OssHostUrl"]
+ stem;
}
string markContent = mark.Ysc_Content_Obj.Content?
.Replace("{:", string.Empty)
.Replace("{：", string.Empty)
.Replace("}", string.Empty);
vm = new MarkSubjectVm
{
KnowledgeId = 0,
Analysis = mark.Ysc_Explain,
Answer = mark.Ysc_Answer_Obj.Answers,
StemType = mark.Ysc_Content_Obj.StemType,
Stem = stem,
SubjectType = mark.Ysc_SubjectType,
Content = markContent,
Color = mark.Ysc_Content_Obj.Color
};
break;
case SubjectTypeEnum.圈点批注断句:
Yw_SubjectMark2Content mark2 = content as Yw_SubjectMark2Content;
string mark2Stem = mark2.Ysc_Content_Obj.Stem;
if (mark2.Ysc_Content_Obj.StemType == (int)UeditorType.Image)
{
mark2Stem = ConfigurationManager.AppSettings["OssHostUrl"]
+ mark2Stem;
}
string mark2Content = mark2.Ysc_Content_Obj.Content?
.Replace("/", string.Empty);
vm = new Mark2SubjectVm
{
KnowledgeId = 0,
Analysis = mark2.Ysc_Explain,
Answer = mark2.Ysc_Answer_Obj.Answers,
StemType = mark2.Ysc_Content_Obj.StemType,
Stem = mark2Stem,
SubjectType = mark2.Ysc_SubjectType,
Content = mark2Content,
Color = mark2.Ysc_Content_Obj.Color
};
break;
default:
break;
}
return(vm);
}
/// <summary>
/// 生成一个Subject Content对象,该对象用于向数据库中添加/更新数据
/// </summary>
/// <param name="sub">封装着前端传来的数据</param>
/// <param name="bll">SubjectBll对象</param>
/// <param name="currentUser">当前用户</param>
/// <param name="content">Subject Content对象,该对象从数据库中查询所得,用于判断是添加还是更新操作</param>
/// <returns></returns>
protected abstract Yw_SubjectContent GetContent(
QuestionInputModel sub,
SubjectBll bll,
int currentUser,
Yw_SubjectContent content);
public void SaveSubject(Yw_SubjectContent content)
{
Service.Update(content);
}
protected override QuestionInputModel ConvertToDerived2(Yw_SubjectContent content)
{
throw new NotImplementedException();
}
public void UpdateContent(Yw_SubjectContent subjectEntity)
{
Service.Update(subjectEntity);
}
public static DtoSubjectContent Create(Yw_SubjectContent content, Yw_Subject subject)
{
Check.IfNull(content, nameof(content));
Check.IfNull(subject, nameof(subject));
DtoSubjectContent dto = null;
dynamic contentObj = null;
UeditorType optionType = UeditorType.Text;
SubjectTypeEnum subjectType = (SubjectTypeEnum)content.Ysc_SubjectType;
switch (subjectType)
{
case SubjectTypeEnum.择题:
Yw_SubjectSelectContent select = content as Yw_SubjectSelectContent;
contentObj = select.Ysc_Content_Obj;
optionType = (UeditorType)contentObj.ContentType;
AppendUrlIfIsImage(contentObj.Options, optionType);
dto = new DtoSelectSubjectContent
{
Random = contentObj.Random,
Answer = select.Ysc_Answer_Obj.Answers,
Options = contentObj.Options,
OptionType = optionType,
Display = contentObj.Display
};
break;
case SubjectTypeEnum.判断题:
Yw_TrueFalseContent trueFalse = content as Yw_TrueFalseContent;
contentObj = trueFalse.Ysc_Content_Obj;
dto = new DtoTrueFalseSubjectContent
{
Answer = trueFalse.Ysc_Answer_Obj.Answer
};
break;
case SubjectTypeEnum.填空题:
Yw_FillInBlankContent fillInBlank = content as Yw_FillInBlankContent;
contentObj = fillInBlank.Ysc_Content_Obj;
dto = new DtoFillInBlankSubjectContent
{
Answer = new
{
Perfect = fillInBlank.Ysc_Answer_Obj.Perfect,
Correct = fillInBlank.Ysc_Answer_Obj.Correct,
Other = fillInBlank.Ysc_Answer_Obj.Other
}
};
break;
case SubjectTypeEnum.择填空:
MultipleChoiceFillInBlankContent multipleChoiceFillInBlank
= content as MultipleChoiceFillInBlankContent;
contentObj = multipleChoiceFillInBlank.Ysc_Content_Obj;
optionType = (UeditorType)contentObj.ContentType;
AppendUrlIfIsImage(contentObj.SubjectOptions, optionType);
AppendUrlIfIsImage(contentObj.SubjectGOptions, optionType);
dto = new DtoSelectFillInBlankSubjectContent
{
Answer = multipleChoiceFillInBlank.Ysc_Answer_Obj.Answers,
//Options = options,
OptionType = optionType
};
break;
case SubjectTypeEnum.连线题:
Yw_MatchContent match = content as Yw_MatchContent;
contentObj = match.Ysc_Content_Obj;
var leftOptionType = (UeditorType)contentObj.LeftOptionContentType;
AppendUrlIfIsImage(contentObj.LeftOptions, leftOptionType);
var rightOptionType = (UeditorType)contentObj.RightOptionContentType;
AppendUrlIfIsImage(contentObj.RightOptions, rightOptionType);
dto = new DtoMatchSubjectContent
{
Answer = match.Ysc_Answer_Obj.Answers,
LeftOptions = contentObj.LeftOptions,
RightOptions = contentObj.RightOptions,
LeftOptionType = leftOptionType,
RightOptionType = rightOptionType
};
break;
case SubjectTypeEnum.主观题:
Yw_SubjectFreeContent free = content as Yw_SubjectFreeContent;
contentObj = free.Ysc_Content_Obj;
dto = new DtoFreeSubjectContent
{
Answer = free.Ysc_Answer_Obj.Answer,
Standard = contentObj.ScoreRules
};
break;
case SubjectTypeEnum.圈点批注标色:
Yw_SubjectMarkContent mark = content as Yw_SubjectMarkContent;
contentObj = mark.Ysc_Content_Obj;
dto = new DtoMarkSubjectContent
{
Answer = mark.Ysc_Answer_Obj.Answers,
Content = contentObj.Content,
Color = mark.Ysc_Content_Obj.Color
};
break;
case SubjectTypeEnum.圈点批注断句:
Yw_SubjectMark2Content mark2 = content as Yw_SubjectMark2Content;
contentObj = mark2.Ysc_Content_Obj;
dto = new DtoMark2SubjectContent
{
Answer = mark2.Ysc_Answer_Obj.Answers,
Content = contentObj.Content,
Color = contentObj.Color
};
break;
default:
dto = new DtoDefaultSubjectContent();
contentObj = new ExpandoObject();
break;
}
dto.SubjectId = content.Ysc_SubjectId;
dto.KnowledgeId = GetKnowledgeId(subject);
dto.Analysis = content.Ysc_Explain;
dto.Stem = contentObj.Stem;
dto.StemType = (UeditorType)contentObj.StemType;
dto.SubjectType = subjectType;
return(dto);
}
public static ReportVm Create(Yw_SubjectContent content, StudentAnswerBase studentAnswer, Yw_Subject subject)
{
DtoSubjectContent subjectContent = SubjectContentDtoBuilder.Create(content, subject);
ReportVm vm = null;
SubjectTypeEnum subjectType = (SubjectTypeEnum)studentAnswer.Type;
switch (subjectType)
{ //选择、选择填空、连线
case SubjectTypeEnum.择题:
StuSelectAnswer selectAnswer = studentAnswer as StuSelectAnswer;
DtoSelectSubjectContent selectContent = subjectContent as DtoSelectSubjectContent;
vm = new MultipleChoiceReportVm
{
SubjectId = selectAnswer.SubjectId,
Stem = selectContent.Stem,
StemType = (int)selectContent.StemType,
Answer = selectContent.Answer,
Options = selectContent.Options.OrderBy(s => Array.IndexOf(selectAnswer.OptionSequences.ToArray(), s.Key)).ToList(),
OptionType = (int)selectContent.OptionType,
SubjectType = (int)selectContent.SubjectType,
Analysis = selectContent.Analysis,
StudentAnswer = selectAnswer.Answers,
ResultStars = selectAnswer.ResultStars,
Difficulty = subject.Ysj_Difficulty
};
break;
case SubjectTypeEnum.判断题:
StuTrueFalseAnswer trueFalseAns = studentAnswer as StuTrueFalseAnswer;
DtoTrueFalseSubjectContent trueFalseCon = subjectContent as DtoTrueFalseSubjectContent;
vm = new TrueFalseReportVm
{
SubjectId = trueFalseAns.SubjectId,
Stem = trueFalseCon.Stem,
StemType = (int)trueFalseCon.StemType,
Answer = trueFalseCon.Answer,
SubjectType = (int)trueFalseCon.SubjectType,
Analysis = trueFalseCon.Analysis,
StudentAnswer = trueFalseAns.Answer,
ResultStars = trueFalseAns.ResultStars,
Difficulty = subject.Ysj_Difficulty
};
break;
case SubjectTypeEnum.填空题:
StuBlankAnswer blankAnswer = studentAnswer as StuBlankAnswer;
DtoFillInBlankSubjectContent fillInBlank = subjectContent as DtoFillInBlankSubjectContent;
vm = new FillInBlankReportVm
{
SubjectId = blankAnswer.SubjectId,
Stem = fillInBlank.Stem,
StemType = (int)fillInBlank.StemType,
Answer = fillInBlank.Answer,
SubjectType = (int)fillInBlank.SubjectType,
Analysis = fillInBlank.Analysis,
StudentAnswer = blankAnswer.Answers,
ResultStars = blankAnswer.ResultStars,
Difficulty = subject.Ysj_Difficulty
};
break;
case SubjectTypeEnum.择填空:
StuSelectBlankAnswer selectBlankAnswer = studentAnswer as StuSelectBlankAnswer;
DtoSelectFillInBlankSubjectContent multipleChoiceFillInBlank = subjectContent as DtoSelectFillInBlankSubjectContent;
vm = new MultipleChoiceFillInBlankReportVm
{
SubjectId = selectBlankAnswer.SubjectId,
Stem = multipleChoiceFillInBlank.Stem,
StemType = (int)multipleChoiceFillInBlank.StemType,
Answer = multipleChoiceFillInBlank.Answer,
Options = multipleChoiceFillInBlank.Options.OrderBy(s => Array.IndexOf(selectBlankAnswer.OptionSequences.ToArray(), s.Key)).ToList(),
OptionType = (int)multipleChoiceFillInBlank.OptionType,
SubjectType = (int)multipleChoiceFillInBlank.SubjectType,
Analysis = multipleChoiceFillInBlank.Analysis,
StudentAnswer = selectBlankAnswer.Answers,
ResultStars = selectBlankAnswer.ResultStars,
Difficulty = subject.Ysj_Difficulty
};
break;
case SubjectTypeEnum.连线题:
StuMatchAnswer matchAnswer = studentAnswer as StuMatchAnswer;
DtoMatchSubjectContent match = subjectContent as DtoMatchSubjectContent;
vm = new MatchReportVm
{
SubjectId = matchAnswer.SubjectId,
Stem = match.Stem,
StemType = (int)match.StemType,
Answer = match.Answer,
SubjectType = (int)match.SubjectType,
LeftOptions = match.LeftOptions.OrderBy(s => Array.IndexOf(matchAnswer.LeftOptionSequences.ToArray(), s.Key)).ToList(),
RightOptions = match.RightOptions.OrderBy(s => Array.IndexOf(matchAnswer.RightOptionSequences.ToArray(), s.Key)).ToList(),
LeftOptionType = (int)match.LeftOptionType,
RightOptionType = (int)match.RightOptionType,
Analysis = match.Analysis,
StudentAnswer = matchAnswer.Answers,
ResultStars = matchAnswer.ResultStars,
Difficulty = subject.Ysj_Difficulty
};
break;
case SubjectTypeEnum.主观题:
StuFreeAnswer freeAnswer = studentAnswer as StuFreeAnswer;
DtoFreeSubjectContent free = subjectContent as DtoFreeSubjectContent;
vm = new FreeReportVm
{
SubjectId = freeAnswer.SubjectId,
Stem = free.Stem,
StemType = (int)free.StemType,
Answer = free.Answer,
SubjectType = (int)free.SubjectType,
Analysis = free.Analysis,
Standard = free.Standard,
StudentAnswer = freeAnswer.Answer,
ResultStars = freeAnswer.ResultStars,
Difficulty = subject.Ysj_Difficulty
};
break;
case SubjectTypeEnum.圈点批注标色:
StuMarkColorAnswer markColorAnswer = studentAnswer as StuMarkColorAnswer;
DtoMarkSubjectContent mark = subjectContent as DtoMarkSubjectContent;
vm = new MarkReportVm
{
SubjectId = markColorAnswer.SubjectId,
Stem = mark.Stem,
StemType = (int)mark.StemType,
Answer = mark.Answer,
SubjectType = (int)mark.SubjectType,
Analysis = mark.Analysis,
Content = mark.Content,
Color = mark.Color,
StudentAnswer = markColorAnswer.Answers,
ResultStars = markColorAnswer.ResultStars,
Difficulty = subject.Ysj_Difficulty
};
break;
case SubjectTypeEnum.圈点批注断句:
StuMarkCutAnswer markCutAnswer = studentAnswer as StuMarkCutAnswer;
DtoMark2SubjectContent mark2 = subjectContent as DtoMark2SubjectContent;
vm = new Mark2ReportVm
{
SubjectId = markCutAnswer.SubjectId,
Stem = mark2.Stem,
StemType = (int)mark2.StemType,
Answer = mark2.Answer,
SubjectType = (int)mark2.SubjectType,
Analysis = mark2.Analysis,
Content = mark2.Content,
Color = mark2.Color,
StudentAnswer = markCutAnswer.Answers,
ResultStars = markCutAnswer.ResultStars,
Difficulty = subject.Ysj_Difficulty
};
break;
default:
break;
}
return(vm);
}
protected override Yw_SubjectContent GetContent(
QuestionInputModel sub,
SubjectBll bll,
int currentUser,
Yw_SubjectContent content)
{
MultipleChoiceFillInBlank subject = sub as MultipleChoiceFillInBlank;
MultipleChoiceFillInBlankContent selectContent = null;
if (content == null)
{
selectContent = new MultipleChoiceFillInBlankContent();
selectContent.Ysc_CreateTime = DateTime.Now;
selectContent.Ysc_Creator = currentUser;
selectContent.Ysc_SubjectType = subject.SubjectType;
}
else
{
selectContent = content as MultipleChoiceFillInBlankContent;
}
selectContent.Ysc_Editor = currentUser;
selectContent.Ysc_Explain = subject.Explain;
List <int[]> anses = new List <int[]>();
if (subject.Options != null)
{
for (int i = 0; i < subject.Options.Count; i++)
{
int[] ds = new int[2] {
i, i
};
anses.Add(ds);
}
}
selectContent.Ysc_Answer_Obj = new MultipleChoiceFillInBlankAnswerObj
{
Answers = anses
};
//答案的选项
List <SubjectOption> subjectOptions = new List <SubjectOption>();
if (subject.Options != null)
{
for (int i = 0; i < subject.Options.Count; i++)
{
subjectOptions.Add(new SubjectOption
{
Key = i,
Text = UeditorContentFactory.FetchUrl(subject.Options[i],
subject.ContentType)
});
}
}
//干扰项
List <SubjectOption> subjectGOptions = new List <SubjectOption>();
if (subject.Goptions != null)
{
for (int i = 0; i < subject.Goptions.Count; i++)
{
subjectGOptions.Add(new SubjectOption
{
Key = i + 100,//干扰项的key设置值
Text = UeditorContentFactory.FetchUrl(subject.Goptions[i],
subject.ContentType)
});
}
}
selectContent.Ysc_Content_Obj = new MultipleChoiceFillInBlankContentObj
{
Stem = UeditorContentFactory.Blank(subject.Name),
ContentType = (int)subject.ContentType,
SubjectOptions = subjectOptions,
SubjectGOptions = subjectGOptions,
//GPositions = gps
};
selectContent.Ysc_UpdateTime = DateTime.Now;
return(selectContent);
}
protected abstract QuestionInputModel ConvertToDerived2(
Yw_SubjectContent content);
public int SaveSubject(
Action <Yw_Subject> saveSubject, Yw_Subject subject,
Action <Yw_SubjectContent> saveContent, Yw_SubjectContent content,
Action <Yw_SubjectKnowledge> saveKnowledge, Yw_SubjectKnowledge knowledge,
IEnumerable <Yw_SubjectIndex> keywordsToAdd, IEnumerable <int> keywordIdsToDelete,
IEnumerable <Yw_SubjectKnowledge> knowledgesToAdd,
IEnumerable <int> idsOfknowledgeToDelete,
Yw_SubjectProcess process,
FormSubmitButton button)
{
using (TransactionScope scope = new TransactionScope())
{
try
{
Check.IfNull(saveSubject, nameof(saveSubject));
Check.IfNull(saveContent, nameof(saveContent));
Check.IfNull(saveKnowledge, nameof(saveKnowledge));
//题目
saveSubject(subject);
//题目的内容
content.Ysc_SubjectId = subject.Ysj_Id;
saveContent(content);
//主知识点
if (knowledge != null)
{
knowledge.Ysw_SubjectId = subject.Ysj_Id;
saveKnowledge(knowledge);
}
//关键词
if (keywordsToAdd != null)
{
for (int i = 0; i < keywordsToAdd.Count(); i++)
{
var k = keywordsToAdd.ElementAt(i);
k.Ysi_SubjectId = subject.Ysj_Id;
}
}
InsertKeywords(keywordsToAdd);
DeleteKeywords(keywordIdsToDelete);
//次级知识点
if (knowledgesToAdd != null)
{
for (int i = 0; i < knowledgesToAdd.Count(); i++)
{
var k = knowledgesToAdd.ElementAt(i);
k.Ysw_SubjectId = subject.Ysj_Id;
}
}
InsertSecondaryKnowledges(knowledgesToAdd);
DeleteSecondaryKnowledges(idsOfknowledgeToDelete);
//如果是提交操作,进入审批流程
if (button == FormSubmitButton.Submit)
{
process.Ysp_SubjectId = subject.Ysj_Id;
MoveToNext(process);
}
scope.Complete();
return(subject.Ysj_Id);
}
catch
{
RollbackTran();
throw;
}
}
}
protected int SaveSubject(QuestionInputModel subject)
{
SubjectBll bll = new SubjectBll();
//题目信息
Yw_Subject subjectEntity = null;
Action <Yw_Subject> saveSubjectMethod =
SubjectFetcher.Fetch(subject, bll, CurrentUserID, out subjectEntity);
//题目内容
Yw_SubjectContent content = null;
ContentFetcher fetcher = GetContentFetcher();
Action <Yw_SubjectContent> saveContentMethod = fetcher.Fetch(
subject,
bll,
CurrentUserID,
out content);
//要删除的关键词
IList <int> keywordIdsToDelete = null;
//要添加的关键词
IList <Yw_SubjectIndex> keywordsToAdd = KeywordFetcher.Fetch(
subject,
bll,
CurrentUserID,
out keywordIdsToDelete);
//主知识点
Yw_SubjectKnowledge mainKnowledgeEntity = null;
Action <Yw_SubjectKnowledge> saveKnowledgeMethod = MainKnowledgeFetcher.Fetch(
subject,
bll,
CurrentUserID,
out mainKnowledgeEntity);
//次级知识点
//需要删除的次级知识点
IEnumerable <int> idsOfknowledgeToDelete = null;
//需要添加的次级知识点
IEnumerable <Yw_SubjectKnowledge> knowledgesToAdd =
SecondaryKnowledgeFetcher.Fetch(
subject,
bll,
CurrentUserID,
out idsOfknowledgeToDelete);
Yw_SubjectProcess process = null;
if (subject.Button == FormSubmitButton.Submit)
{
process = bll.GetNextProcess(
subject.Id,
CurrentUserID,
subject.NextStatus,
SubjectActionEnum.提交);
subjectEntity.Ysj_Status = process.Ysp_Status;
}
return(bll.SaveSubject(saveSubjectMethod, subjectEntity,
saveContentMethod, content,
saveKnowledgeMethod, mainKnowledgeEntity,
keywordsToAdd, keywordIdsToDelete,
knowledgesToAdd, idsOfknowledgeToDelete,
process, subject.Button));
}
