public TestContentForm(TestorData data)
{
InitializeComponent();
_data = data;
int i = 0;
foreach (var test in ProjectState.TestHelpers.OrderBy(c => c.TestName))
{
if (test.IsMasterTest)
{
continue;
}
if (test.IsTestorDataLoaded && test.TestorData == data)
{
_index = i;
}
tscbTests.Items.Add(test);
i++;
}
tscbTests.SelectedIndex = _index;
bool canBackForward = ProjectState.TestHelpers.Count > 1;
tsbBackTest.Enabled = canBackForward;
tsbForwardTest.Enabled = canBackForward;
_provider = new EditProvider(HtmlStore.GetHtmlStore(_data, 1));
_provider.ProviderMode = ProviderMode.EditMode;
TestingHttpServer.StartServer(_provider);
TestingHttpServer.ServerNotStarted.WaitOne();
webBrowserQuestion.Navigate(TestingHttpServer.BaseUrl);
}
public void SendTests(TestorData testorData, List<int> groupIds)
{
SystemStateManager.OnStateChanged(true);
TreeNode selectedNode = this.SelectedNode;
SynchronizationContext context = SynchronizationContext.Current;
_currentThread = new Thread(new ThreadStart(() =>
{
byte[] arr = DataCompressor.CompressData(testorData);
try
{
TestorTreeItem[] newItems = StaticServerProvider.TestEdit.SendTests(arr,
_selectedItem.ItemId, groupIds.ToArray());
foreach (var item in newItems)
item.ItemOwner = StaticServerProvider.CurrentUser.UserId;
context.Send(d =>
{
AddTreeNodes(newItems, selectedNode, false);
if (selectedNode != null)
selectedNode.Expand();
}, null);
}
catch (Exception ex)
{
SystemMessage.ShowErrorMessage(ex);
}
finally
{
context.Send(d =>
{
SystemStateManager.OnStateChanged(false);
}, null);
}
}));
_currentThread.Start();
}
public LocalTestingProvider(TestorData tests, TestHelper testHelper)
{
_studentName = "Иванов Иван Иванович";
State = ProviderState.PreTesting;
_testHelper = testHelper;
_testorData = tests;
_coreTest = CoreTestRowAdapter.GetAdapter(testHelper.TestorData.CoreTests.Where(
c => c.TestKey == new Guid(testHelper.TestKey)).First());
if (!_testHelper.IsMasterTest)
{
if (_coreTest.QuestionsNumber != 0)
{
_questCount = _coreTest.QuestionsNumber;
}
else
{
_questCount = _testHelper.QuestCount;
}
}
else
{
_questCount = 0;
foreach (var quest in _testHelper.SubTests)
{
_questCount += quest.Value;
}
}
}
public static void AddToDataset(TestorData dataSet,
TestorData.CoreTestsRow testRow, HtmlStore[] store)
{
if (dataSet == null)
{
return;
}
foreach (var question in store.OrderBy(c => c.QuestIndex))
{
TestorData.CoreQuestionsRow newRow = dataSet.CoreQuestions.NewCoreQuestionsRow();
newRow.QuestionId = question.QuestIndex;
newRow.QuestionType = (byte)question.QuestionType;
newRow.Question = question.Html;
newRow.TestId = testRow.TestId;
newRow.QuestionMark = 1;
dataSet.CoreQuestions.AddCoreQuestionsRow(newRow);
ProcessBLOBs(dataSet, question, newRow.QuestionId);
foreach (var answer in question.SubItems)
{
TestorData.CoreAnswersRow ansRow = dataSet.CoreAnswers.NewCoreAnswersRow();
ansRow.QuestionId = newRow.QuestionId;
ansRow.Answer = answer.Html;
ansRow.IsTrue = answer.IsTrue;
dataSet.CoreAnswers.AddCoreAnswersRow(ansRow);
ProcessBLOBs(dataSet, answer, newRow.QuestionId);
}
}
}
public static HtmlStore GetHtmlStore(TestorData testorData, int questionId)
{
HtmlStore retValue = new HtmlStore();
var currentRows = testorData.CoreQuestions.Where(c => c.QuestionId == questionId);
if (currentRows.Count() == 0)
{
return(null);
}
var currentRow = currentRows.FirstOrDefault();
retValue.QuestIndex = currentRow.QuestionId;
retValue.Html = currentRow.Question;
retValue.QuestionType = (QuestionType)currentRow.QuestionType;
foreach (var blob in currentRow.GetCoreBLOBsRows())
{
retValue.Images.Add(blob.BLOBId, blob.BLOBContent);
}
foreach (var ans in currentRow.GetCoreAnswersRows())
{
HtmlStore answer = new HtmlStore();
answer.QuestIndex = ans.AnswerId;
answer.Html = ans.Answer;
answer.IsTrue = ans.IsTrue;
retValue.SubItems.Add(answer);
}
return(retValue);
}
public static void CreateMasterTest()
{
InputBox ib = new InputBox("Имя мастер теста", "Введите имя мастер теста:");
if (ib.ShowDialog() != DialogResult.OK)
{
return;
}
if (ProjectState.TestHelpers.Where(c => c.TestName == ib.Input).Count() > 0)
{
SystemMessage.ShowWarningMessage("Данное имя теста уже используется.");
return;
}
TestorData td = new TestorData();
TestorData.CoreTestsRow testRow = HtmlStore.CreateCoreTest(td, ib.Input);
testRow.IsMasterTest = true;
td.CoreTests.AddCoreTestsRow(testRow);
TestHelper testHelper = new TestHelper(ProjectState.DataPackageManager);
testHelper.TestKey = testRow.TestKey.ToString();
testHelper.ConvTime = DateTime.Now;
testHelper.FullFileName = String.Empty;
testHelper.TestorData = td;
testHelper.TestName = ib.Input;
testHelper.QuestCount = 0;
testHelper.IsMasterTest = true;
List <TestHelper> helperList = new List <TestHelper>();
helperList.Add(testHelper);
ProjectState.AddTests(helperList);
}
public void CreateMasterTest(string testName)
{
TestorData data = new TestorData();
TestorData.CoreTestsRow row = HtmlStore.CreateCoreTest(data, testName);
row.IsMasterTest = true;
data.CoreTests.Rows.Add(row);
SendTests(data, new List<int>());
}
private void toolStripComboBoxTests_SelectedIndexChanged(object sender, EventArgs e)
{
_index = tscbTests.SelectedIndex;
_testHelper = tscbTests.SelectedItem as TestHelper;
_data = _testHelper.TestorData;
bindingSource.DataSource = _data.CoreQuestions;
InitParams();
}
public static TestorData GetDataSet(HtmlStore[] store, string testName)
{
TestorData retValue = new TestorData();
TestorData.CoreTestsRow testRow = CreateCoreTest(retValue, testName);
retValue.CoreTests.AddCoreTestsRow(testRow);
HtmlStore.AddToDataset(retValue, testRow, store);
return(retValue);
}
private static void ProcessBLOBs(TestorData dataSet,
HtmlStore store, int questionId)
{
foreach (var image in store.Images)
{
TestorData.CoreBLOBsRow blobRow = dataSet.CoreBLOBs.NewCoreBLOBsRow();
blobRow.BLOBId = image.Key;
blobRow.QuestionId = questionId;
blobRow.BLOBContent = image.Value;
dataSet.CoreBLOBs.AddCoreBLOBsRow(blobRow);
}
}
public QuestAnswerResult ProcessAnswer(int questId, Dictionary <string, List <string> > requestParams)
{
Debug.Assert(questId > 0);
QuestAnswerResult retValue = new QuestAnswerResult();
using (DataClassesTestorCoreDataContext dataContext = new DataClassesTestorCoreDataContext(TestorSecurityProvider.ConnectionString))
{
var session = (from c in dataContext.TestSessions
join x in dataContext.CoreTests on c.TestId equals x.TestId
where c.EndTime == null && c.UserId == Provider.CurrentUser.UserId
select new
{
x.TestId,
x.TimeLimit,
c.TestSessionId,
c.StartTime,
c.AdditionalTime
}).First();
int timeLimit = session.TimeLimit;
if (timeLimit != 0 && session.AdditionalTime.HasValue)
{
timeLimit += session.AdditionalTime.Value;
}
if (session.TimeLimit != 0 && (DateTime.Now - session.StartTime).TotalMinutes > timeLimit + 1)
{
throw new Exception("Время истекло");
}
TestorData testorData = GetQuestion(questId, true, false, false);
HtmlStore currentQuestion = HtmlStore.GetHtmlStore(testorData, questId);
BaseQuestionProvider qp = QuestionsHtmlFactory.GetQuestionProvider(currentQuestion);
string message = null;
string answer = null;
retValue.isRightAnswer = qp.IsRightAnswer(requestParams, ref message, ref answer);
retValue.Message = message;
retValue.Score = 0;
if (!retValue.isRightAnswer.HasValue)
{
return(retValue);
}
if (retValue.isRightAnswer.Value)
{
retValue.Score = testorData.CoreQuestions.Where(c => c.QuestionId == questId).FirstOrDefault().QuestionMark;
}
var tsq = dataContext.TestSessionQuestions.Where(
c => c.QuestionId == questId && c.TestSessionId == session.TestSessionId).First();
tsq.IsRightAnswer = retValue.isRightAnswer;
tsq.Answer = answer;
dataContext.SubmitChanges();
}
return(retValue);
}
public TestorData GetTestData(Uri uri)
{
TestorData dataSet = new TestorData();
PackagePart part = _manager.CurrentPackage.GetPart(uri);
using (Stream stream = part.GetStream())
{
BinaryFormatter bin = new BinaryFormatter();
dataSet = (TestorData)bin.Deserialize(stream);
stream.Close();
}
return(dataSet);
}
public TestorData GetTestSettingsData(int testId)
{
using (DataClassesTestorCoreDataContext dataContext = new DataClassesTestorCoreDataContext(TestorSecurityProvider.ConnectionString))
{
CoreTest test = dataContext.CoreTests.Where(c => c.TestId == testId).FirstOrDefault();
TestorData data = new TestorData();
TestorData.CoreTestsRow coreTestRow = data.CoreTests.NewCoreTestsRow();
coreTestRow.AllowAdmitQuestions = test.AllowAdmitQuestions;
coreTestRow.BeginTime = test.BeginTime;
coreTestRow.Description = test.Description;
coreTestRow.EndTime = test.EndTime;
coreTestRow.IsActive = test.IsActive;
coreTestRow.IsMasterTest = test.IsMasterTest;
coreTestRow.PassagesNumber = test.PassagesNumber;
coreTestRow.PassingScore = test.PassingScore;
coreTestRow.QuestionsNumber = test.QuestionsNumber;
coreTestRow.IsDeleted = test.IsDeleted;
if (coreTestRow.QuestionsNumber == 0)
{
if (test.IsMasterTest)
{
var masterParts = dataContext.CoreMasterParts.Where(c => c.MasterTestId == testId);
if (masterParts.Count() > 0)
{
coreTestRow.QuestionsNumber = (short)masterParts.Sum(c => c.QuestionsNumber);
}
else
{
coreTestRow.QuestionsNumber = 0;
}
}
else
{
coreTestRow.QuestionsNumber = (short)test.CoreQuestions.Count();
}
}
coreTestRow.ShowRightAnswersCount = test.ShowRightAnswersCount;
coreTestRow.ShowTestResult = test.ShowTestResult;
coreTestRow.ShowDetailsTestResult = test.ShowDetailsTestResult;
coreTestRow.TestId = test.TestId;
coreTestRow.TestKey = test.TestKey;
coreTestRow.TestName = test.TestName;
coreTestRow.TimeLimit = test.TimeLimit;
coreTestRow.VariantsMode = test.VariantsMode;
coreTestRow.AdaptiveMode = test.AdaptiveMode;
data.CoreTests.AddCoreTestsRow(coreTestRow);
return(data);
}
}
public TestorData[] GetAllTestData()
{
List <TestorData> retValue = new List <TestorData>();
foreach (var part in _manager.GetParts(ContentType.Test))
{
using (Stream stream = part.GetStream())
{
TestorData dataSet = new TestorData();
dataSet.ReadXml(stream);
stream.Close();
retValue.Add(dataSet);
}
}
return(retValue.ToArray());
}
private void TestIsDone(FileInfo file, HtmlStore[] htmlStore)
{
string testName = String.Empty;
EndConvertingDelegate endConvertingDelegate = new EndConvertingDelegate(EndConverting);
if (htmlStore == null)
{
SystemMessage.ShowErrorMessage("Ошибка конвертации тестов.");
_cancel = true;
this.Invoke(endConvertingDelegate, new object[] { });
return;
}
if (_isUpdate)
{
BeginUpdateDelegate updateDelegate = new BeginUpdateDelegate(UpdateTest);
this.Invoke(updateDelegate, new object[] { file.FullName, htmlStore });
return;
}
TestorData testorData = HtmlStore.GetDataSet(htmlStore, file, out testName);
TestHelper testHelper = new TestHelper(ProjectState.DataPackageManager);
testHelper.ConvTime = file.LastWriteTime;
testHelper.TestId = testorData.CoreTests[0].TestId;
testHelper.FullFileName = file.FullName;
testHelper.TestorData = testorData;
testHelper.TestName = testName;
testHelper.QuestCount = testorData.CoreQuestions.Count();
foreach (var test in testorData.CoreTests)
{
testHelper.TestKey = test.TestKey.ToString();
}
_tests.Add(testHelper);
RefreshListDelegate refreshListDelegate = new RefreshListDelegate(RefreshList);
this.Invoke(refreshListDelegate, new object[] { testHelper.TestName });
lock (this)
{
_testCount--;
if (_testCount == 0 || _cancel)
{
this.Invoke(endConvertingDelegate, new object[] { });
return;
}
ConvertNext();
}
}
public SendTestsForm()
{
InitializeComponent();
_testorData = ProjectState.FullTestorDataSet;
treeView.InitTreeView(TestingServerItemType.TestTree, cmsContext, false);
treeView.EnableDragDrop = true;
tvGroups.InitTreeView(TestingServerItemType.GroupTree, null, false);
treeView.ItemSelected += new EventHandler <TestorItemSelectedEventArgs>(_serviceProvider_ItemSelected);
foreach (var testHelper in ProjectState.TestHelpers)
{
ListViewItem lvi = new ListViewItem(new string[] { testHelper.TestName }, 0);
lvi.Group = clbTests.Groups[testHelper.IsMasterTest ? 1 : 0];
lvi.Tag = testHelper;
clbTests.Items.Add(lvi);
}
SystemStateManager.StateChanged += new EventHandler <EventArgs>(SystemStateManager_StateChanged);
}
public void SetTestSettings(TestorData testorData)
{
SystemStateManager.OnStateChanged(true);
byte[] data = DataCompressor.CompressData(testorData);
SynchronizationContext context = SynchronizationContext.Current;
_currentThread = new Thread(new ThreadStart(() =>
{
StaticServerProvider.TestEdit.SetTestSettings(data);
if ((this.TopLevelControl as Form).IsHandleCreated)
{
context.Send(d =>
{
SystemStateManager.OnStateChanged(false);
}, null);
}
}));
_currentThread.Start();
}
public void SetTestSettings(byte[] testSettings)
{
Debug.Assert(testSettings != null);
Provider.TestRoles(TestorUserRole.Administrator, TestorUserRole.Teacher, TestorUserRole.Laboratorian);
using (DataClassesTestorCoreDataContext dataContext = new DataClassesTestorCoreDataContext(TestorSecurityProvider.ConnectionString))
{
TestorData data = DataCompressor.DecompressData <TestorData>(testSettings);
TestorData.CoreTestsRow test = data.CoreTests[0];
Provider.TestCoreTestsAccess(test.TestId);
CoreTest coreTest = dataContext.CoreTests.Where(c => c.TestId == test.TestId).FirstOrDefault();
CreateCoreTest(test, coreTest);
dataContext.SubmitChanges();
}
}
public RemoteTestingProvider(IServerProvider webServerProvider, TestorTreeItem selectedTest, TestorData testorData, StartTestParams startParams, bool useCompression)
{
_webServerProvider = webServerProvider;
_selectedTest = selectedTest;
_testorData = testorData;
_coreTest = CoreTestRowAdapter.GetAdapter(_testorData.CoreTests[0]);
_useCompression = useCompression;
_startParams = startParams;
if (_startParams != null)
{
InitStartParams();
_ansIds.AddRange(_startParams.AnsIds);
_score = _startParams.CurrentScore;
}
else
{
State = ProviderState.PreTesting;
}
}
private void buttonOK_Click(object sender, EventArgs e)
{
foreach (var helper in checkedListBoxTests.CheckedItems)
{
TestHelper testHelper = (TestHelper)helper;
TestorData td = testHelper.TestorData;
if (td == null)
{
continue;
}
testHelper.TestRequirements = new List <string>();
ProjectState.TestHelpers.Add(testHelper);
}
if (checkedListBoxTests.CheckedItems.Count > 0)
{
ProjectState.HasChanges = true;
ProjectState.OnTestHelpersChanged();
}
this.DialogResult = DialogResult.OK;
}
public TestorTreeItem CreateFolder(int parentId, string folderName)
{
Debug.Assert(parentId >= 0);
Debug.Assert(!String.IsNullOrEmpty(folderName));
Provider.TestRoles(TestorUserRole.Administrator, TestorUserRole.Teacher, TestorUserRole.Laboratorian);
using (DataClassesTestorCoreDataContext dataContext = new DataClassesTestorCoreDataContext(TestorSecurityProvider.ConnectionString))
{
TestorData td = new TestorData();
TestorData.CoreTestsRow testRow = HtmlStore.CreateCoreTest(td, folderName);
CoreTest coreTest = new CoreTest();
CreateCoreTest(testRow, coreTest);
dataContext.CoreTests.InsertOnSubmit(coreTest);
dataContext.SubmitChanges();
int result = dataContext.AddTestTreeItem(GetId(parentId), (int)TestorItemType.Folder, coreTest.TestId, Provider.CurrentUser.UserId);
TestorTreeItem retValue = new TestorTreeItem(
result, coreTest.TestId, folderName, TestorItemType.Folder, new TestorTreeItem[] { });
retValue.ItemOwner = Provider.CurrentUser.UserId;
return(retValue);
}
}
void _serviceProvider_ItemSelected(object sender, TestorItemSelectedEventArgs e)
{
ProcessControlsEnableProp();
if (_adapter != null)
{
if (_adapter.HasChanges)
{
_preNode.Text = _adapter.TestName;
treeView.SetTestSettings(_adapter.TestorData);
}
tvGroups.SetTestGroups((_preNode.Tag as TestorTagItem).TreeItem.TestId.Value);
}
TestorTreeItem item = e.Item;
if (StaticServerProvider.CurrentUser.UserRole != TestorUserRole.Administrator && StaticServerProvider.CurrentUser.UserId != item.ItemOwner)
{
testSettings.Enabled = false;
tvGroups.Enabled = false;
_adapter = null;
return;
}
bool isTest = item.ItemType == TestorItemType.Test || item.ItemType == TestorItemType.MasterTest;
testSettings.Enabled = isTest;
tvGroups.Enabled = testSettings.Enabled;
if (isTest)
{
int testId = item.TestId ?? 0;
tvGroups.ProcessTestGroups(testId);
TestorData settings = treeView.GetTestSettings(testId);
_adapter = new TestSettingsAdapter(settings);
testSettings.SetDataSet(_adapter);
_preNode = e.TreeEventArgs.Node;
}
else if (item.ItemType == TestorItemType.Folder && item.ItemId != 0)
{
tsbIsActive.Checked = item.IsActive;
}
}
public static TestorData.CoreTestsRow CreateCoreTest(TestorData data, string testName)
{
TestorData.CoreTestsRow testRow = data.CoreTests.NewCoreTestsRow();
testRow.TestKey = Guid.NewGuid();
testRow.TestName = testName;
testRow.VariantsMode = true;
testRow.IsActive = true;
testRow.IsMasterTest = false;
testRow.ShowRightAnswersCount = true;
testRow.ShowDetailsTestResult = false;
testRow.ShowTestResult = true;
testRow.AllowAdmitQuestions = true;
testRow.Description = String.Empty;
testRow.QuestionsNumber = 0;
testRow.PassagesNumber = 0;
testRow.PassingScore = 0;
testRow.TimeLimit = 0;
testRow.BeginTime = DateTime.MinValue;
testRow.EndTime = DateTime.MinValue;
testRow.AdaptiveMode = (short)TestorAdaptiveMode.None;
testRow.IsDeleted = false;
return(testRow);
}
public TestorTreeItem[] SendTests(byte[] testorData, int folderId, int[] groupIds)
{
Debug.Assert(testorData != null);
Debug.Assert(folderId >= 0);
Provider.TestRoles(TestorUserRole.Administrator, TestorUserRole.Teacher, TestorUserRole.Laboratorian);
using (DataClassesTestorCoreDataContext dataContext = new DataClassesTestorCoreDataContext(TestorSecurityProvider.ConnectionString))
{
TestorData data = DataCompressor.DecompressData <TestorData>(testorData);
//data.WriteXml("C:/locator.xml", System.Data.XmlWriteMode.IgnoreSchema);
Dictionary <int, CoreTest> xTests = new Dictionary <int, CoreTest>();
foreach (TestorData.CoreTestsRow coreTest in data.CoreTests)
{
CoreTest test = new CoreTest();
test.TestKey = coreTest.TestKey;
test.IsMasterTest = coreTest.IsMasterTest;
CreateCoreTest(coreTest, test);
xTests.Add(coreTest.TestId, test);
dataContext.CoreTests.InsertOnSubmit(test);
foreach (int groupId in groupIds)
{
TestGroup group = new TestGroup();
group.CoreTest = test;
group.GroupId = groupId;
dataContext.TestGroups.InsertOnSubmit(group);
}
foreach (var coreQuest in coreTest.GetCoreQuestionsRows())
{
CoreQuestion quest = new CoreQuestion();
quest.CoreTest = test;
quest.QuestionType = coreQuest.QuestionType;
quest.Question = coreQuest.Question;
quest.QuestionMark = coreQuest.QuestionMark;
try
{
if (!Convert.IsDBNull(coreQuest.QuestionMetadata))
{
quest.QuestionMetadata = coreQuest.QuestionMetadata;
}
}
catch
{
quest.QuestionMetadata = null;
}
dataContext.CoreQuestions.InsertOnSubmit(quest);
foreach (var coreAnswer in coreQuest.GetCoreAnswersRows())
{
CoreAnswer answer = new CoreAnswer();
answer.CoreQuestion = quest;
answer.Answer = coreAnswer.Answer;
answer.IsTrue = coreAnswer.IsTrue;
try
{
if (!Convert.IsDBNull(coreAnswer.AnswerMetadata))
{
answer.AnswerMetadata = coreAnswer.AnswerMetadata;
}
}
catch
{
answer.AnswerMetadata = null;
}
dataContext.CoreAnswers.InsertOnSubmit(answer);
}
foreach (var coreBlob in coreQuest.GetCoreBLOBsRows())
{
CoreBLOB blob = new CoreBLOB();
blob.CoreQuestion = quest;
blob.BLOBId = coreBlob.BLOBId;
blob.BLOBContent = coreBlob.BLOBContent;
dataContext.CoreBLOBs.InsertOnSubmit(blob);
}
}
}
foreach (var masterTest in data.CoreTests.Where(c => c.IsMasterTest == true))
{
var parts = data.CoreMasterParts.Where(c => c.MasterTestId == masterTest.TestId);
var test = xTests.Where(c => c.Value.TestKey == masterTest.TestKey).FirstOrDefault();
foreach (var part in parts)
{
CoreMasterPart masterPart = new CoreMasterPart();
masterPart.CoreTest1 = test.Value;
masterPart.CoreTest = xTests.Where(
c => c.Key == part.PartTestId).FirstOrDefault().Value;
masterPart.QuestionsNumber = part.QuestionsNumber;
dataContext.CoreMasterParts.InsertOnSubmit(masterPart);
}
}
foreach (var coreReq in data.CoreRequirements)
{
CoreRequirement req = new CoreRequirement();
Guid testKey = data.CoreTests.Where(c => c.TestId == coreReq.TestId).FirstOrDefault().TestKey;
Guid reqKey = data.CoreTests.Where(c => c.TestId == coreReq.Requirement).FirstOrDefault().TestKey;
req.CoreTest = xTests.Where(c => c.Value.TestKey == testKey).FirstOrDefault().Value;
req.CoreTest1 = xTests.Where(c => c.Value.TestKey == reqKey).FirstOrDefault().Value;
dataContext.CoreRequirements.InsertOnSubmit(req);
}
try
{
dataContext.SubmitChanges();
}
catch (Exception ex)
{
throw ex;
}
List <TestorTreeItem> retValue = new List <TestorTreeItem>();
foreach (var test in xTests)
{
CoreTest coreTest = test.Value;
TestorItemType type = TestorItemType.Test;
if (coreTest.IsMasterTest)
{
type = TestorItemType.MasterTest;
}
int result = dataContext.AddTestTreeItem(GetId(folderId), (byte)type, coreTest.TestId, Provider.CurrentUser.UserId);
TestorTreeItem item = new TestorTreeItem(result, coreTest.TestId,
coreTest.TestName, type, null);
retValue.Add(item);
}
return(retValue.ToArray());
}
}
public void SaveTestorData(TestorData testorData, TestConfig config)
{
testorData.AcceptChanges();
Dictionary <string, string> testKeys = new Dictionary <string, string>();
Dictionary <string, string> questCounts = new Dictionary <string, string>();
foreach (TestorData.CoreTestsRow test in testorData.CoreTests)
{
testKeys.Add(test.TestKey.ToString(), test.TestName);
questCounts.Add(test.TestKey.ToString(),
testorData.CoreQuestions.Where(c => c.TestId == test.TestId).Count().ToString());
}
PackagePart dataPart;
PackagePart configPart;
bool createNew = true;
Guid fname = Guid.NewGuid();
Uri partUri = new Uri(
String.Format("/tests/{0}.bin", fname.ToString()), UriKind.Relative);
Uri configUri = new Uri(
String.Format("/tests/{0}.conf", fname.ToString()), UriKind.Relative);
List <Uri> parts = new List <Uri>();
foreach (var rel in _manager.CurrentPackage.GetRelationships())
{
if (testKeys.Keys.Contains(rel.RelationshipType) &&
!parts.Contains(rel.TargetUri))
{
parts.Add(rel.TargetUri);
}
}
if (parts.Count == 1)
{
createNew = false;
configUri = _manager.GetConfigUri(parts[0]);
partUri = parts[0];
}
else if (parts.Count > 1)
{
throw new Exception("Невозможно сохранить тесты в разных parts.");
}
if (createNew)
{
dataPart = _manager.CurrentPackage.CreatePart(partUri,
_manager.CnitType + ContentType.Test.ToString(), _testCompression);
configPart = _manager.CurrentPackage.CreatePart(configUri,
_manager.CnitType + ContentType.TestConfig.ToString(), _testCompression);
foreach (var id in testKeys)
{
config.Uri = partUri;
config.TestName = id.Value;
config.QuestionCount = int.Parse(questCounts[id.Key]);
_manager.CurrentPackage.CreateRelationship(partUri, TargetMode.Internal, id.Key);
}
}
else
{
dataPart = _manager.CurrentPackage.GetPart(partUri);
configPart = _manager.CurrentPackage.GetPart(configUri);
Dictionary <string, TestConfig> testObjects = GetTestObjects(partUri);
foreach (var key in testKeys)
{
if (!testObjects.ContainsKey(key.Key))
{
_manager.CurrentPackage.CreateRelationship(partUri, TargetMode.Internal, key.Key);
}
config.Uri = partUri;
config.TestName = key.Value;
config.QuestionCount = int.Parse(questCounts[key.Key]);
}
}
Uri versionUri = new Uri("/version.dat", UriKind.Relative);
if (!_manager.CurrentPackage.PartExists(versionUri))
{
_manager.CurrentPackage.CreatePart(versionUri, _manager.CnitType + ContentType.VersionData.ToString());
PackagePart versionPart = _manager.CurrentPackage.GetPart(versionUri);
using (Stream versionStream = versionPart.GetStream())
{
StreamWriter sw = new StreamWriter(versionStream);
sw.WriteLine("FileFormatVersion:{0}", _fileFormatVersion);
sw.Close();
versionStream.Close();
}
}
BinaryFormatter bin = new BinaryFormatter();
using (Stream stream = dataPart.GetStream())
{
bin.Serialize(stream, testorData);
stream.Close();
}
using (Stream stream = configPart.GetStream())
{
bin.Serialize(stream, config);
stream.Close();
}
}
public static TestorData.CoreTestsRow AddToDataset(TestorData dataSet, HtmlStore[] store)
{
TestorData.CoreTestsRow retValue = CreateCoreTest(dataSet, String.Empty);
AddToDataset(dataSet, retValue, store);
return(retValue);
}
public static TestorData CreateFullTestorDataSet(List <TestHelper> helpers)
{
TestorData retValue = new TestorData();
int testId = 1, questId = 1, ansId = 1;
foreach (var helper in helpers)
{
TestorData td = helper.TestorData;
object[] arr = td.CoreTests.Rows[0].ItemArray;
arr[0] = testId;
retValue.CoreTests.Rows.Add(arr);
foreach (TestorData.CoreQuestionsRow row in td.CoreQuestions)
{
object[] questArr = row.ItemArray;
questArr[0] = questId;
questArr[1] = testId;
retValue.CoreQuestions.Rows.Add(questArr);
foreach (var answer in td.CoreAnswers.Where(c => c.CoreQuestionsRow == row))
{
object[] ansArr = answer.ItemArray;
ansArr[0] = ansId;
ansArr[1] = questId;
retValue.CoreAnswers.Rows.Add(ansArr);
ansId++;
}
foreach (var blob in td.CoreBLOBs.Where(c => c.CoreQuestionsRow == row))
{
object[] blobArr = blob.ItemArray;
blobArr[1] = questId;
retValue.CoreBLOBs.Rows.Add(blobArr);
}
questId++;
}
testId++;
}
foreach (var helper in helpers)
{
var test = retValue.CoreTests.Where(c => c.TestKey == new Guid(helper.TestKey)).First();
foreach (var req in helper.TestRequirements)
{
TestorData.CoreRequirementsRow reqRow = retValue.CoreRequirements.NewCoreRequirementsRow();
reqRow.TestId = test.TestId;
reqRow.Requirement = retValue.CoreTests.Where(
c => c.TestKey == new Guid(req)).First().TestId;
retValue.CoreRequirements.AddCoreRequirementsRow(reqRow);
}
if (helper.IsMasterTest)
{
foreach (var subTest in helper.SubTests)
{
try
{
TestorData.CoreMasterPartsRow subTestRow = retValue.CoreMasterParts.NewCoreMasterPartsRow();
subTestRow.MasterTestId = test.TestId;
subTestRow.PartTestId = retValue.CoreTests.Where(
c => c.TestKey == new Guid(subTest.Key)).First().TestId;
subTestRow.QuestionsNumber = subTest.Value;
retValue.CoreMasterParts.AddCoreMasterPartsRow(subTestRow);
}
catch
{
continue;
}
}
}
}
return(retValue);
}
public void GetTestStatistics()
{
TestorData td = DataCompressor.DecompressData <TestorData>(
LocalUser.TestEdit.GetTestSettings(_testId));
var test = td.CoreTests[0];
lblTest.Text = test.TestName;
lblQuestionsNumber.Text = test.QuestionsNumber.ToString();
lblPassingScore.Text = test.PassingScore.ToString();
var tStat = LocalUser.TestClient.GetTestStatistics(_testId, _groupId);
if (tStat.AverageScore.HasValue)
{
lblAverageScore.Text = tStat.AverageScore.Value.ToString("0.00");
}
else
{
lblAverageScore.Text = "-";
}
lblPassedPercent.Text = tStat.PassedPercent.ToString("0.00");
if (tStat.TestStatistics.Length > 20)
{
List <TestStatistics> stat1 = new List <TestStatistics>();
List <TestStatistics> stat2 = new List <TestStatistics>();
int x = tStat.TestStatistics.Length / 2;
if (tStat.TestStatistics.Length % 2 > 0)
{
x++;
}
for (int i = 0; i < tStat.TestStatistics.Count(); i++)
{
if (i < x && x > 5)
{
stat1.Add(tStat.TestStatistics[i]);
}
else
{
stat2.Add(tStat.TestStatistics[i]);
}
}
rpScore.DataSource = stat1;
rpScoreCount.DataSource = stat1;
rpScore.DataBind();
rpScoreCount.DataBind();
rpScore1.DataSource = stat2;
rpScoreCount1.DataSource = stat2;
rpScore1.DataBind();
rpScoreCount1.DataBind();
phScores.Visible = true;
}
else
{
rpScore.DataSource = tStat.TestStatistics;
rpScoreCount.DataSource = tStat.TestStatistics;
rpScore.DataBind();
rpScoreCount.DataBind();
phScores.Visible = false;
}
testChart.DataSource = tStat.TestStatistics;
testChart.DataBind();
}
protected void Page_Load(object sender, EventArgs e)
{
if (LocalUser.IsIntranet && !Context.User.Identity.IsAuthenticated)
{
Response.Redirect("~/Login.aspx");
}
StartTestParams ncs = LocalUser.TestClient.GetNotCommitedSessions(0, false);
if (ncs != null)
{
Server.Transfer("~/Testing.aspx");
}
MultiViewMain.ActiveViewIndex = 0;
LabelTestname.Visible = false;
requirementsPanel.Visible = false;
if (Context.User.Identity.IsAuthenticated)
{
var currentUser = LocalUser.SecurityProvider.CurrentUser;
if (currentUser == null)
{
FormsAuthentication.SignOut();
Response.Redirect("~/Login.aspx");
}
string userName = String.Format(":: {0} {1} {2}", HtmlStore.GetString(currentUser.LastName),
HtmlStore.GetString(currentUser.FirstName), HtmlStore.GetString(currentUser.SecondName));
Label lbl = (this.Master.FindControl("userName") as Label);
if (String.IsNullOrEmpty(userName.Trim()))
{
lbl.Text = currentUser.Login;
}
else
{
lbl.Text = userName;
}
}
if (InitPageMode())
{
InitTree();
}
else
{
InitTestList();
InitNavigator();
if (_currentItem.ItemType == TestorItemType.Test ||
_currentItem.ItemType == TestorItemType.MasterTest)
{
MultiViewMain.ActiveViewIndex = 2;
postButton.Text = "Приступить к тестированию";
_currentTest = DataCompressor.DecompressData <TestorData>(
LocalUser.TestEdit.GetTestSettings(_currentItem.TestId.Value));
testDetails.Text = HttpHandler.GetPreTestingHtml(_currentTest.CoreTests[0]);
TestorData.CoreTestsRow test = _currentTest.CoreTests[0];
LabelTestname.Visible = true;
RemoteTestingProvider _provider = new RemoteTestingProvider(LocalUser.WebServerProvider, _currentItem,
_currentTest, null, false);
if (!_provider.IsTestActive)
{
postButton.Enabled = false;
LabelTestname.ForeColor = Color.Red;
LabelTestname.Text = _provider.NotActiveMessage;
if (_provider.RequirementsTests != null)
{
postButton.Enabled = false;
LabelTestname.Text = "Перед прохлждением данного теста необходимо пройти предыдущие тесты";
LabelTestname.ForeColor = Color.Red;
requirementsPanel.Visible = true;
requirementsRepeater.DataSource = _provider.RequirementsTests;
requirementsRepeater.DataBind();
}
return;
}
if (LocalUser.SecurityProvider.CurrentUser.UserRole == TestorUserRole.Administrator ||
LocalUser.SecurityProvider.CurrentUser.UserRole == TestorUserRole.Teacher ||
LocalUser.SecurityProvider.CurrentUser.UserRole == TestorUserRole.Laboratorian)
{
LabelTestname.Text = String.Format("Тест: <a href=\"/Manage/Statistics.aspx?testId={0}\">{1}</a>", _currentItem.TestId, _currentItem.ItemName.Trim());
}
else
{
LabelTestname.Text = String.Format("Тест: \"{0}\"", _currentItem.ItemName.Trim());
}
if (postButton.Attributes[BUTTON_MODE] == NULL_VALUE)
{
postButton.Attributes[BUTTON_MODE] = NTMODE_VALUE;
}
else
{
postButton.Attributes[BUTTON_MODE] = TESTING_VALUE;
}
postButton.Attributes[BUTTON_VALUE] = _currentItem.ItemId.ToString();
}
}
}
//Не является операцией сервиса
private TestorData GetQuestion(int questId, bool getRightAnswer, bool isAppeal, bool getBLOBs)
{
TestorData retValue = new TestorData();
using (DataClassesTestorCoreDataContext dataContext = new DataClassesTestorCoreDataContext(TestorSecurityProvider.ConnectionString))
{
if (!isAppeal)
{
if (QueriesUtility.IsQuestInSessionFunc(dataContext, Provider.CurrentUser.UserId, questId) <= 0)
{
throw new Exception("Данный вопрос не входит в тест");
}
}
var questRow = retValue.CoreQuestions.NewCoreQuestionsRow();
var quest = (from c in dataContext.CoreQuestions
where c.QuestionId == questId
select new
{
c.TestId,
c.QuestionType,
c.QuestionId,
c.Question,
c.QuestionMark
}).First();
questRow.TestId = quest.TestId;
questRow.QuestionType = quest.QuestionType;
questRow.QuestionId = quest.QuestionId;
questRow.Question = quest.Question;
questRow.QuestionMark = quest.QuestionMark;
questRow.QuestionMetadata = String.Empty;
var questProvider = QuestionsHtmlFactory.GetQuestionProvider((QuestionType)quest.QuestionType, null);
if (getRightAnswer || questProvider.SendAnswersToClient)
{
var answers = from c in dataContext.CoreAnswers
where c.QuestionId == quest.QuestionId
select new
{
c.Answer,
c.AnswerId,
c.IsTrue
};
foreach (var answer in answers)
{
var answerRow = retValue.CoreAnswers.NewCoreAnswersRow();
answerRow.Answer = answer.Answer;
answerRow.AnswerId = answer.AnswerId;
answerRow.AnswerMetadata = String.Empty;
answerRow.QuestionId = questRow.QuestionId;
if (getRightAnswer)
{
answerRow.IsTrue = answer.IsTrue;
}
else
{
answerRow.IsTrue = false;
}
retValue.CoreAnswers.AddCoreAnswersRow(answerRow);
}
}
if (getBLOBs)
{
var blobs = from c in dataContext.CoreBLOBs
where c.QuestionId == quest.QuestionId
select new
{
c.BLOBId,
c.BLOBContent
};
foreach (var blob in blobs)
{
var blobRow = retValue.CoreBLOBs.NewCoreBLOBsRow();
blobRow.BLOBContent = blob.BLOBContent.ToArray();
blobRow.BLOBId = blob.BLOBId;
blobRow.QuestionId = questRow.QuestionId;
retValue.CoreBLOBs.AddCoreBLOBsRow(blobRow);
}
}
retValue.CoreQuestions.AddCoreQuestionsRow(questRow);
}
return(retValue);
}
