private void BindAuto(Rubric rub)
{
Rubrics rubda = new Rubrics(Globals.CurrentIdentity);
Result.ResultList ress = rubda.GetResults(rub.ID, GetSubID());
lblEvalID.Text = rub.EvalID.ToString();
if (ress.Count == 0)
{
if (!IsStudent())
{
mpViews.SelectedIndex = 2;
}
else
{
mpViews.SelectedIndex = 5;
}
}
else
{
AutoResult res = ress[0] as AutoResult;
XmlWizard xmlwiz = new XmlWizard();
xmlwiz.DisplayDivXslt(res.XmlResult, Path.Combine(Globals.WWWDirectory, "Xml/reshtml.xslt"), divAuto);
mpViews.SelectedIndex = 3;
}
}
private void BindAuto(Rubric rub)
{
Result.ResultList ress =
new Rubrics(Globals.CurrentIdentity).GetResults(rub.ID, GetCurrentSub());
if (ress.Count == 0)
{
divAuto.InnerHtml = "<i>There are no results for this evaluation item</i>";
return;
}
AutoResult res = ress[0] as AutoResult;
MemoryStream xmlstr = new MemoryStream(Encoding.ASCII.GetBytes(res.XmlResult));
XslTransform xslt = new XslTransform();
XPathDocument xpathdoc = new XPathDocument(xmlstr);
XPathNavigator nav = xpathdoc.CreateNavigator();
XPathDocument xsldoc = new XPathDocument(
Path.Combine(Globals.WWWDirectory, "Xml/reshtml.xslt"));
StringBuilder strb = new StringBuilder();
xslt.Load(xsldoc, null, null);
xslt.Transform(xpathdoc, null, new XmlTextWriter(new StringWriter(strb)), (XmlResolver)null);
divAuto.InnerHtml = strb.ToString();
}
private void LoadTreeView(TreeNode node, string imgPrefix)
{
Rubric.RubricList rubs =
new Rubrics(Globals.CurrentIdentity).GetChildren(GetRubricID(node));
foreach (Rubric rub in rubs)
{
TreeNode rnode;
if (RepressAutos && rub.EvalID >= 0)
{
continue;
}
else
{
rnode = AddRubricNode(node.Nodes, rub, imgPrefix);
}
LoadTreeView(rnode, imgPrefix);
}
//Add subjective results in under books
if (ExpandSubj)
{
Result.ResultList ress = new Rubrics(Globals.CurrentIdentity).GetResults(GetRubricID(node), GetSubID());
foreach (Result res in ress)
{
if (res is SubjResult)
{
AddSubjResultNode(node.Nodes, (SubjResult)res, imgPrefix);
}
}
}
}
public IFigure Combine()
{
if (this.Type == null)
{
try
{
switch (mode)
{
case FigureMode.Reference:
combineDynamicType(new FigureCompilerReference(this, fieldRubrics, propertyRubrics));
break;
case FigureMode.ValueType:
combineDynamicType(new FigureCompilerValueType(this, fieldRubrics, propertyRubrics));
break;
case FigureMode.Derived:
combineDerivedType(new FigureCompilerDerivedType(this, fieldRubrics, propertyRubrics));
break;
default:
break;
}
Rubrics.Update();
}
catch (Exception ex)
{
throw ex;
}
}
return(newFigure());
}
private void ucRubric_RubricSelect(object sender, RubricViewSelectEventArgs args)
{
Rubrics rubda = new Rubrics(Globals.CurrentIdentity);
Rubric rub = args.SelectedRubric;
ddlType.Items.Clear();
ddlComments.Items.Clear();
txtLines.Text = ""; txtCustom.Text = ""; txtPoints.Text = "";
if (rubda.IsHeading(rub))
{
cmdCreate.Enabled = false;
}
else
{
CannedResponse.CannedResponseList cans = rubda.GetCannedResponses(rub.ID);
foreach (CannedResponse can in cans)
{
string canstr = can.Comment.Substring(0, Math.Min(80, can.Comment.Length));
if (canstr.Length == 80)
{
canstr += " ...";
}
ListItem item = new ListItem(canstr, can.ID.ToString());
ddlComments.Items.Add(item);
}
ddlComments.Items.Add(new ListItem("Custom", "-1"));
cmdCreate.Enabled = true;
ddlType.Items.Add(new ListItem("Error", Rubric.ERROR.ToString()));
ddlType.Items.Add(new ListItem("Warning", Rubric.WARNING.ToString()));
ddlType.Items.Add(new ListItem("Good", Rubric.GOOD.ToString()));
}
BindData(GetWindow());
}
private void combineDynamicType(FigureCompiler compiler)
{
var fcvt = compiler;
compiledType = fcvt.CompileFigureType(Name);
Rubrics.KeyRubrics.Add(fcvt.Identities.Values);
this.Type = compiledType.New().GetType();
Size = Marshal.SizeOf(this.Type);
var rf = this.Type.GetRuntimeFields().ToArray();
if (!Rubrics.AsValues().Where(m => m.Name == "SerialCode").Any())
{
var mr = new MemberRubric(rf[0]);
mr.RubricName = "SerialCode";
Rubrics.Insert(0, mr);
}
Rubrics.AsValues().Select((m, y) => m.FigureField = rf[y]).ToArray();
Rubrics.AsValues().Where(m => m.FigureField != null)
.Select((f, y) => new object[] {
f.FieldId = y - 1,
f.RubricId = y - 1,
f.RubricOffset = (int)Marshal.OffsetOf(this.Type, f.FigureField.Name)
})
.ToArray();
}
private void BindCannedResponses(int rubID)
{
CannedResponse.CannedResponseList cans =
new Rubrics(Globals.CurrentIdentity).GetCannedResponses(rubID);
dgCanned.DataSource = cans;
dgCanned.DataBind();
}
private void BindSubj(Rubric rub)
{
Result.ResultList ress =
new Rubrics(Globals.CurrentIdentity).GetResults(rub.ID, GetCurrentSub());
dgSubj.DataSource = ress;
dgSubj.DataBind();
}
private void BindSubj(Rubric rub)
{
Rubrics rubda = new Rubrics(Globals.CurrentIdentity);
Result.ResultList ress = rubda.GetResults(rub.ID, GetSubID());
//Update the rubric
ucRubric.UpdateRubric();
//Reset to 0 if page index greater than numpages
if (dgResults.CurrentPageIndex >= dgResults.PageCount)
{
dgResults.CurrentPageIndex = 0;
}
dgResults.DataSource = ress;
dgResults.DataBind();
if (!IsStudent())
{
ddlCanned.Visible = true;
lnkCreate.Visible = true;
dgResults.Columns[0].Visible = true;
dgResults.Columns[6].Visible = true;
dgResults.Style["TOP"] = "58px";
CannedResponse.CannedResponseList cans = rubda.GetCannedResponses(rub.ID);
ddlCanned.Items.Clear();
foreach (CannedResponse can in cans)
{
string canstr = can.Comment.Substring(0, Math.Min(80, can.Comment.Length));
if (canstr.Length == 80)
{
canstr += " ...";
}
ListItem item = new ListItem(canstr, can.ID.ToString());
ddlCanned.Items.Add(item);
}
ddlCanned.Items.Add(new ListItem("Custom", "-1"));
}
else
{
ddlCanned.Visible = false;
lnkCreate.Visible = false;
dgResults.Columns[0].Visible = false;
dgResults.Columns[6].Visible = false;
lnkRefresh.Style["TOP"] = "0px";
imgRefresh.Style["TOP"] = "0px";
dgResults.Style["TOP"] = "20px";
}
lblRubID.Text = rub.ID.ToString();
mpViews.SelectedIndex = 0;
}
private void cmdJUnitUpload_Click(object sender, System.EventArgs e)
{
//Import tester data
AutoEvaluation eval;
Evaluations evalda = new Evaluations(Globals.CurrentIdentity);
Rubrics rubda = new Rubrics(Globals.CurrentIdentity);
IExternalSource esrc;
if (fiJUnit.PostedFile.ContentLength == 0)
{
PageJUnitError("You must specify a tester suite to upload");
return;
}
else
{
esrc = CreateSource(fiJUnit.PostedFile);
eval = (AutoEvaluation) new Evaluations(Globals.CurrentIdentity).GetInfo(
Convert.ToInt32(lblEvalID.Text));
}
//Load files
try {
evalda.UpdateAuto(eval, esrc);
} catch (CustomException er) {
PageJUnitError(er.Message);
return;
}
//Discover JUnit test
double points = 0;
int time = 0, count = 0;
try {
new JUnitTool().Discover(eval, out points, out time, out count);
} catch (CustomException er) {
PageJUnitError(er.Message);
}
//Update points and time
Rubric rub = rubda.GetInfo(GetCurrentID());
eval.TimeLimit = time;
rub.Points = points;
try {
evalda.UpdateAuto(eval, new EmptySource());
rubda.Update(rub);
PageJUnitError("Upload successful!");
} catch (CustomException er) {
PageJUnitError(er.Message);
}
UpdateRightSide();
}
private void RemoveResults(AutoEvaluation eval)
{
Rubric rub = new Evaluations(Globals.CurrentIdentity).GetRubric(eval.ID);
Result.ResultList ress = new Rubrics(Globals.CurrentIdentity).GetResults(rub.ID);
Results resda = new Results(Globals.CurrentIdentity);
foreach (Result res in ress)
{
resda.Delete(res.ID);
}
}
private string rubricToString(Rubrics rubric)
{
string res = string.Empty;
switch (rubric)
{
case Rubrics.Apartments: res = "kvartyry"; break;
default: res = "kvartyry"; break;
}
return(res);
}
private string GetResultPoints(Rubric rub)
{
Result.ResultList ress =
new Rubrics(Globals.CurrentIdentity).GetResults(rub.ID, GetSubID());
if (ress.Count == 0 && rub.EvalID >= 0)
{
return(String.Format("{0} (Ungraded, {1} points)", rub.Name, rub.Points));
}
return(String.Format("{0} ({1}/{2} points)", rub.Name,
new Rubrics(Globals.CurrentIdentity).GetPoints(rub.ID, GetSubID()), rub.Points));
}
private string GetRubricPoints(Rubric rub, int subID)
{
Rubrics rubda = new Rubrics(Globals.CurrentIdentity);
Result.ResultList ress = rubda.GetResults(rub.ID, subID);
if (ress.Count == 0 && rub.EvalID >= 0)
{
return("??");
}
else
{
return(rubda.GetPoints(rub.ID, subID).ToString());
}
}
public void UpdateRubric()
{
TreeNode node = tvRubric.GetNodeFromIndex(tvRubric.SelectedNodeIndex);
Rubrics rubda = new Rubrics(Globals.CurrentIdentity);
Rubric rub = rubda.GetInfo(GetRubricID(node));
node.Text = GetResultPoints(rub);
TreeNode root = tvRubric.Nodes[0];
rub = rubda.GetInfo(GetRubricID(root));
root.Text =
String.Format("Total - {0}/{1} Points",
new Submissions(Globals.CurrentIdentity).GetPoints(GetSubID()),
rub.Points);
}
private void UpdateRightSide()
{
int rubID = GetCurrentID();
Rubric rub = new Rubrics(Globals.CurrentIdentity).GetInfo(rubID);
txtDescription.Text = rub.Description;
txtName.Text = rub.Name;
txtPoints.Enabled = true;
chkAllowNeg.Checked = rub.AllowNegativePoints;
if (!IsHeading(rub))
{
txtPoints.Visible = true;
txtPoints.Text = rub.Points.ToString();
if (rub.EvalID >= 0)
{
Evaluation eval = new Evaluations(Globals.CurrentIdentity).GetInfo(rub.EvalID);
if (eval.Manager == Evaluation.JUNIT_MANAGER)
{
BindJUnitView((AutoEvaluation)eval);
// txtPoints.Enabled = false;
mpViews.SelectedIndex = JUNITVIEW;
}
else if (eval.Manager == Evaluation.CHECKSTYLE_MANAGER)
{
BindCSView((AutoEvaluation)eval);
mpViews.SelectedIndex = CHECKSTYLEVIEW;
}
else
{
BindAutoView((AutoEvaluation)eval);
mpViews.SelectedIndex = AUTOVIEW;
}
}
else
{
BindCannedResponses(rubID);
mpViews.SelectedIndex = SUBJVIEW;
}
}
else
{
txtPoints.Visible = false;
mpViews.SelectedIndex = NOVIEW;
}
}
private DataTable TabulateUsers(User.UserList users)
{
DataTable resulttab = new DataTable();
int asstID = GetAsstID();
Rubrics rubda = new Rubrics(Globals.CurrentIdentity);
Principals prinda = new Principals(Globals.CurrentIdentity);
Rubric asstrub = new Assignments(Globals.CurrentIdentity).GetRubric(asstID);
//Add rubric columns to data grid
Rubric.RubricList flatrub = rubda.Flatten(asstrub);
resulttab.Columns.Add("UserName");
resulttab.Columns.Add("Status");
resulttab.Columns.Add("Total");
foreach (Rubric rub in flatrub)
{
AddRubricColumn(rub.Name, rub.Name);
resulttab.Columns.Add(rub.Name);
}
//Add user data to the datatable
foreach (User user in users)
{
Components.Submission sub = prinda.GetLatestSubmission(user.PrincipalID, asstID);
DataRow row = resulttab.NewRow();
if (sub == null)
{
continue;
}
row["UserName"] = user.UserName;
row["Status"] = sub.Status;
row["Total"] = rubda.GetPoints(asstrub.ID, sub.ID).ToString() + "/" + asstrub.Points.ToString();
foreach (Rubric rub in flatrub)
{
row[rub.Name] = GetRubricPoints(rub, sub.ID) + "/" + rub.Points.ToString();
}
resulttab.Rows.Add(row);
}
return(resulttab);
}
public int ParseApartments()
{
IEnumerable <VashmagazinApartment> apartments = _vashmagazinRepository.GetListOfLastApartments();
foreach (VashmagazinApartment apartment in apartments)
{
apartment.IsOld = true;
}
_vashmagazinRepository.SaveChanges();
savingTasks = new List <Task>();
Stopwatch time = new Stopwatch();
time.Start();
Task savingTask = saveParsedApartments();
Rubrics rubric = Rubrics.Apartments;
IEnumerable <Subrubrics> subrubrics = Enum.GetValues(typeof(Subrubrics)).Cast <Subrubrics>();
foreach (Subrubrics subrubric in subrubrics)
{
int page = 1;
bool hasError = false;
do
{
string url = _pageLoader.GetUrl(rubric, subrubric, page);
_loger.Log(url);
string pageHtml = _pageLoader.LoadPageHtml(url);
hasError = parseHtmlPage(pageHtml, CITY, getDistrictFromSubrubric(subrubric));
page++;
} while (!hasError);
}
Task.Factory.ContinueWhenAll(savingTasks.ToArray(), (tasks) => {
apartmetsToSave.CompleteAdding();
});
savingTask.Wait();
time.Stop();
_loger.Log("Time elapsed: " + time.Elapsed.ToString());
return(_vashmagazinRepository.GetListOfLastApartments().Count());
}
private void combineDerivedType(FigureCompiler compiler)
{
var fcdt = compiler;
compiledType = fcdt.CompileFigureType(Name);
Rubrics.KeyRubrics.Add(fcdt.Identities.Values);
this.Type = compiledType.New().GetType();
Size = Marshal.SizeOf(this.Type);
if (!Rubrics.AsValues().Where(m => m.Name == "SerialCode").Any())
{
var f = this.Type.GetField("serialcode", BindingFlags.NonPublic | BindingFlags.Instance);
var mr = new MemberRubric(f);
mr.RubricName = "SerialCode";
mr.FigureField = f;
mr.RubricOffset = (int)Marshal.OffsetOf(this.Type, f.Name);
Rubrics.Insert(0, mr);
}
var df = fcdt.derivedFields;
Rubrics.AsValues().Select((m, y) => m.FigureField = df[y].RubricInfo).ToArray();
Rubrics.AsValues().Where(m => m.FigureField != null)
.Select((f, y) => new object[] {
f.FieldId = y - 1,
f.RubricId = y - 1
})
.ToArray();
foreach (var rubric in Rubrics.Skip(1).ToArray())
{
try
{
rubric.RubricOffset = (int)Marshal.OffsetOf(BaseType, rubric.FigureField.Name);
}
catch (Exception ex)
{
rubric.RubricOffset = -1;
}
}
}
private void tvRubric_SelectedIndexChange(object sender, TreeViewSelectEventArgs e)
{
TreeNode node = tvRubric.GetNodeFromIndex(e.NewNode);
if (node.NodeData.Split(" ".ToCharArray())[0] == "Rubric")
{
int rubID = GetRubricID(node);
Rubric rub = new Rubrics(Globals.CurrentIdentity).GetInfo(rubID);
if (RubricSelect != null)
{
RubricSelect(this, new RubricViewSelectEventArgs(rub));
}
}
else
{
int resID = GetResultID(node);
Result res = new Results(Globals.CurrentIdentity).GetInfo(resID);
if (ResultSelect != null)
{
ResultSelect(this, new RubricViewSelectResultEventArgs(res));
}
}
}
private void cmdSave_Click(object sender, System.EventArgs e)
{
Rubric rub = new Rubrics(Globals.CurrentIdentity).GetInfo(GetCurrentID());
rub.Name = txtName.Text; rub.Description = txtDescription.Text;
rub.AllowNegativePoints = chkAllowNeg.Checked;
if (!txtPoints.Visible)
{
rub.Points = -1;
}
else
{
rub.Points = Convert.ToDouble(txtPoints.Text);
}
try {
new Rubrics(Globals.CurrentIdentity).Update(rub);
} catch (DataAccessException er) {
PageError(er.Message);
}
Refresh(this, new RefreshEventArgs("", true, true));
UpdateRightSide();
}
public string GetUrl(Rubrics rubric, Subrubrics subrubric, int page)
{
return(GetUrl(rubricToString(rubric), subrubricToString(subrubric), page));
}
protected ICollection <VashmagazinPhone> parseHtmlPageForGetPhone(string pageHtml, Rubrics rubric, out bool hasError)
{
ICollection <VashmagazinPhone> phones = new List <VashmagazinPhone>();
HtmlDocument page = new HtmlDocument();
page.LoadHtml(pageHtml);
hasError = containErrorBlock(page);
if (!hasError)
{
HtmlNode table = page.DocumentNode.SelectSingleNode(xpathRows);//xpathRows
IEnumerable <HtmlNode> rows = table.Elements("tr");
hasError = rows.Count() == 0;
if (!hasError)
{
IEnumerator <HtmlNode> currentRow = rows.GetEnumerator();
while (currentRow.MoveNext())
{
if (isNewRow(currentRow.Current))
{
if (currentRow.MoveNext())
{
string phone = getPhoneFromRow(currentRow);
VashmagazinPhone vashmagazinPhone = new VashmagazinPhone();
vashmagazinPhone.Phone = phone;
vashmagazinPhone.Rubric = rubric;
phones.Add(vashmagazinPhone);
currentRow.MoveNext();
currentRow.MoveNext();
currentRow.MoveNext();
}
}
}
}
}
return(phones);
}
public string GetUrl(Rubrics rubric, int page)
{
return(GetUrl(rubric, Subrubrics.Frankivskyj, page));
}
public ITreeNode<Result> Find(string conjunctElementCode)
{
return Rubrics.Select(rubric => rubric.Value.Find(conjunctElementCode))
.FirstOrDefault(found => found != null);
}
public Checklist AddRubric(string key, RubricResult rubricResult)
{
Rubrics.TryAdd(key, rubricResult);
return this;
}
