public List <ResultEntry> GetAllResults()
{
query = "SELECT tbl_results.*, tbl_students.name AS student_name, tbl_classes.name AS class_name, tbl_students.roll AS student_roll, tbl_subjects.name AS subject_name FROM tbl_results " +
"LEFT JOIN tbl_students ON tbl_students.id = tbl_results.student_id " +
"LEFT JOIN tbl_classes ON tbl_classes.id = tbl_students.class_id " +
"LEFT JOIN tbl_subjects ON tbl_subjects.id = tbl_results.subject_id " +
"ORDER BY class_name ASC";
connection.Open();
command = new SqlCommand(query, connection);
reader = command.ExecuteReader();
List <ResultEntry> allResults = new List <ResultEntry>();
while (reader.Read())
{
ResultEntry aResultEntry = new ResultEntry();
aResultEntry.Id = Convert.ToInt32(reader["id"]);
aResultEntry.StudentId = Convert.ToInt32(reader["student_id"]);
aResultEntry.StudentName = reader["student_name"].ToString();
aResultEntry.ClassName = reader["class_name"].ToString();
aResultEntry.Roll = reader["student_roll"].ToString();
aResultEntry.SubjectName = reader["subject_name"].ToString();
aResultEntry.Marks = Convert.ToInt32(reader["marks"]);
allResults.Add(aResultEntry);
}
reader.Close();
connection.Close();
return(allResults);
}
string entryToText(ResultEntry entry)
{
return("Rank: " + entry.Ranking + "\n" +
"Value: " + entry.Value + "\n" +
"Key: " + entry.Key + "\n" +
"Text: " + removeNuls(entry.Text));
}
public void ShouldMergeResults()
{
double permittedGap = 2d;
var aggregator = new StatefulRealtimeResultEntryAggregator(new TrackMatchLengthEntryFilter(5d), GetConfigWithPermittedGap(permittedGap));
var success = new List<ResultEntry>();
var filtered = new List<ResultEntry>();
SimulateEmptyResults(aggregator, success, filtered);
Assert.IsEmpty(success);
Assert.IsEmpty(filtered);
const int queryLength = 1;
const int trackLength = 10;
const int fingerprintLength = 1;
for (int i = 0; i < 10; ++i)
{
var entry = new ResultEntry(GetTrack(trackLength), 0, DateTime.Now, TestUtilities.GetMatchedWith(new[] { 0 }, new[] { i }).EstimateCoverage(queryLength, trackLength, fingerprintLength, permittedGap));
var aggregated = aggregator.Consume(new[] { entry }, queryLength, 0);
AddAll(aggregated.SuccessEntries, success);
AddAll(aggregated.DidNotPassThresholdEntries, filtered);
}
SimulateEmptyResults(aggregator, success, filtered);
Assert.AreEqual(1, success.Count);
Assert.AreEqual(1, filtered.Count);
Assert.IsTrue(success[0].TrackCoverageWithPermittedGapsLength > 5d);
Assert.IsTrue(filtered[0].TrackCoverageWithPermittedGapsLength < 5d);
}
public ActionResult Create(ResultEntry resultentry)
{
if (ModelState.IsValid)
{
var result =
db.ResultEntries.Count(
r => r.StudentId == resultentry.StudentId && r.CourseId == resultentry.CourseId) == 0;
if (result)
{
Grade aGrade = db.Grades.Where(g => g.GradeId == resultentry.GradeId).FirstOrDefault();
EnrollCourse resultEnrollCourse =
db.EnrollCourses.FirstOrDefault(r => r.CourseId == resultentry.CourseId && r.StudentId == resultentry.StudentId);
if (resultEnrollCourse != null)
{
resultEnrollCourse.GradeName = aGrade.GradeName;
}
db.ResultEntries.Add(resultentry);
db.SaveChanges();
TempData["success"] = "Result Successfully Entered";
return(RedirectToAction("Create"));
}
else
{
TempData["Already"] = "Result Of This Course has Already Been Assigned";
return(RedirectToAction("Create"));
}
}
ViewBag.CourseId = new SelectList(db.Courses, "CourseId", "CourseName", resultentry.CourseId);
ViewBag.GradeId = new SelectList(db.Grades, "GradeId", "GradeName", resultentry.GradeId);
ViewBag.StudentId = new SelectList(db.Students, "StudentId", "RegistrationId", resultentry.StudentId);
return(View(resultentry));
}
public void ShouldMergeResults()
{
double permittedGap = 1d;
var aggregator = new StatefulRealtimeResultEntryAggregator(new QueryMatchLengthFilter(5d), permittedGap);
var success = new List <ResultEntry>();
var filtered = new List <ResultEntry>();
SimulateEmptyResults(aggregator, success, filtered);
Assert.IsTrue(!success.Any());
for (int i = 0; i < 10; ++i)
{
var entry = new ResultEntry(GetTrack(), 0, DateTime.Now, TestUtilities.GetMatchedWith(new[] { i }, new[] { i }).EstimateCoverage(1, 10, 1, permittedGap));
var aggregated = aggregator.Consume(new[] { entry }, 1);
AddAll(aggregated.SuccessEntries, success);
AddAll(aggregated.DidNotPassThresholdEntries, filtered);
}
SimulateEmptyResults(aggregator, success, filtered);
Assert.AreEqual(1, success.Count);
Assert.AreEqual(1, filtered.Count);
Assert.IsTrue(success[0].TrackCoverageWithPermittedGapsLength > 5d);
Assert.IsTrue(filtered[0].TrackCoverageWithPermittedGapsLength < 5d);
}
public void ShouldMergeResults()
{
var aggregator = new StatefulRealtimeResultEntryAggregator(new QueryMatchLengthFilter(5d), 1.48d);
var success = new List <ResultEntry>();
var filtered = new List <ResultEntry>();
SimulateEmptyResults(aggregator, success, filtered);
Assert.IsTrue(!success.Any());
for (int i = 0; i < 10; ++i)
{
var entry = new ResultEntry(GetTrack(), 0.01233, 0, DateTime.Now, 1.48d, 0d, 1.48d, 1.48d, 10d + i * 1.48d, -10d - i * 1.48d);
var aggregated = aggregator.Consume(new[] { entry }, 1.48d);
AddAll(aggregated.SuccessEntries, success);
AddAll(aggregated.DidNotPassThresholdEntries, filtered);
}
SimulateEmptyResults(aggregator, success, filtered);
Assert.AreEqual(2, success.Count);
Assert.AreEqual(1, filtered.Count);
Assert.IsTrue(success[0].CoverageWithPermittedGapsLength > 5d);
Assert.IsTrue(success[1].CoverageWithPermittedGapsLength > 5d);
Assert.IsTrue(filtered[0].CoverageWithPermittedGapsLength < 5d);
}
private static ResultEntry CreateResultEntry(double gapAtTheEnd)
{
// query: [0 1 2 3 4 5 6 7 8 9]
// [match w gap][gap]
const double queryLength = 10;
const float queryMatchStartsAt = 1;
const float trackMatchStartsAt = 0;
const double score = 1;
var matchedAt = DateTime.Now;
var discreteCoverageLength = queryLength - queryMatchStartsAt - gapAtTheEnd;
double fingerprintLength = 0.1;
var matchedWith = Enumerable
.Range(0, (int)(discreteCoverageLength / fingerprintLength))
.Select(index => new MatchedWith(
(uint)(index + queryMatchStartsAt / fingerprintLength), // query sequence at
queryMatchStartsAt + (float)(index * fingerprintLength), // query matched at
(uint)(index + trackMatchStartsAt / fingerprintLength), // track sequence at
trackMatchStartsAt + (float)(index * fingerprintLength), // track matched at
100))
.Take((int)(discreteCoverageLength / fingerprintLength))
.ToList();
var coverage = new Coverage(matchedWith, queryLength, 10, fingerprintLength, PermittedGap);
var trackData = new TrackData("id", "artist", "title", 10, new ModelReference <uint>(1));
var entry = new ResultEntry(trackData, score, matchedAt, coverage);
Assert.AreEqual(entry.QueryMatchStartsAt + entry.DiscreteTrackCoverageLength, entry.QueryLength - gapAtTheEnd, Delta);
return(entry);
}
public void ShouldNotMergeAsTracksDoNotMatch()
{
var a = new ResultEntry(new TrackData("123", "artist", "title", "album", 0, 120d, new ModelReference <int>(1)), 0.9d, 120, DateTime.Now, 10d, 0d, 10, 10, 5d, -5d);
var b = new ResultEntry(new TrackData("123", "artist", "title", "album", 0, 120d, new ModelReference <int>(2)), 0.9d, 120, DateTime.Now, 10d, 0d, 10, 10, 5d, -5d);
Assert.Throws <ArgumentException>(() => a.MergeWith(b));
}
public ActionResult DeleteConfirmed(int id)
{
ResultEntry resultentry = db.ResultEntries.Find(id);
db.ResultEntries.Remove(resultentry);
db.SaveChanges();
return(RedirectToAction("Index"));
}
//-----------------------------------------------------------------------------------------------------------------------------------------
//QUICKWATCH PART--------------------------------------------------------------------------------------------------------------------------
/// <summary>
/// Show the results in the Presentation
/// </summary>
private void showResult(String key, double IC)
{
ResultEntry entry = new ResultEntry();
entry.Key = key;
entry.IC = IC.ToString();
quickWatchPresentation.Add(entry);
}
private void DisplayResults(SortedList <double, ArrayList> timingInfos, double[] filtered)
{
lstResults.Items.Clear();
foreach (double val in filtered)
{
ResultEntry entry = new ResultEntry(val, (TimingInfo[])timingInfos[val].ToArray(typeof(TimingInfo)));
lstResults.Items.Add(entry);
}
}
//
// GET: /ResultEntry/Delete/5
public ActionResult Delete(int id = 0)
{
ResultEntry resultentry = db.ResultEntries.Find(id);
if (resultentry == null)
{
return(HttpNotFound());
}
return(View(resultentry));
}
/// <summary>
/// <para>does not map <see cref="ModData.GroupedReleases"/></para>
/// </summary>
/// <param name="entry"></param>
/// <param name="result"></param>
/// <returns></returns>
public ModData MapToModData(ResultEntry entry, ModData result)
{
result.DownloadsCount = entry.DownloadsCount;
//result.Name = entry.Name;
result.Owner = entry.Owner;
result.Summary = entry.Summary;
result.Title = entry.Title;
return(result);
}
private void deleteButton_Click(object sender, EventArgs e)
{
ResultEntry aResultEntry = new ResultEntry();
aResultEntry.Id = Convert.ToInt32(resultIdTextBox.Text);
string message = aResultEntryManager.DeleteResult(aResultEntry.Id);
MessageBox.Show(message);
LoadResultEntryListView();
}
public Result(ResultEntry entry)
{
Entries = new List <ResultEntry>();
if (entry == null)
{
return;
}
AddEntry(entry);
}
public Result Read()
{
Result result = new Result();
if (!File.Exists(_outputFile))
{
return(result);
}
FileStream logFileStream = new FileStream(_outputFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
StreamReader logFileReader = new StreamReader(logFileStream);
try
{
CSVLine csvLine = new CSVLine();
List <string> fields = new List <string>();
while (!logFileReader.EndOfStream)
{
string line = logFileReader.ReadLine();
ParseLine(line, fields);
csvLine.SetAllFields(fields);
csvLine.Directory = csvLine.Directory.RemoveFirst(Application.dataPath + "\\");
csvLine.Directory = csvLine.Directory.Replace("\\", "/");
bool sameAsPrevious = result.ResultEntries.Count > 0 && result.ResultEntries.Last().ProjectDirectory == csvLine.Directory && result.ResultEntries.Last().File == csvLine.File;
ResultEntry entry;
if (!sameAsPrevious)
{
entry = new ResultEntry();
entry.ProjectDirectory = csvLine.Directory;
entry.File = csvLine.File;
}
else
{
entry = result.ResultEntries.Last();
}
entry.Lines.Add($"{csvLine.LineNumber} {csvLine.LineContent}");
result.ResultEntries.Add(entry);
}
}
finally
{
logFileReader.Close();
logFileStream.Close();
}
return(result);
}
public ActionResult Edit([Bind(Include = "ResultEntryId,CourseID,GradeLatterId")] ResultEntry resultentry)
{
if (ModelState.IsValid)
{
db.Entry(resultentry).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.CourseID = new SelectList(db.CourseDbSet, "CourseID", "CourseCode", resultentry.CourseID);
ViewBag.GradeLatterId = new SelectList(db.GradeLatterDbSet, "GradeLatterId", "GradeLatterName", resultentry.GradeLatterId);
return(View(resultentry));
}
public int SaveResult(ResultEntry aResultEntry)
{
query = "INSERT INTO tbl_results (student_id, subject_id, marks) VALUES ('" + aResultEntry.StudentId + "','" + aResultEntry.SubjectId + "','" + aResultEntry.Marks + "')";
connection.Open();
command = new SqlCommand(query, connection);
int rowAffected = command.ExecuteNonQuery();
connection.Close();
return(rowAffected);
}
public int UpdateResult(ResultEntry aResultEntry)
{
query = "UPDATE tbl_results SET student_id = '" + aResultEntry.StudentId + "', subject_id = '" + aResultEntry.SubjectId + "', marks = '" + aResultEntry.Marks + "' WHERE id = '" + aResultEntry.Id + "'";
connection.Open();
command = new SqlCommand(query, connection);
int rowAffected = command.ExecuteNonQuery();
connection.Close();
return(rowAffected);
}
//
// GET: /ResultEntry/Edit/5
public ActionResult Edit(int id = 0)
{
ResultEntry resultentry = db.ResultEntries.Find(id);
if (resultentry == null)
{
return(HttpNotFound());
}
ViewBag.StudentId = new SelectList(db.Students, "StudentId", "RegistrationId", resultentry.StudentId);
ViewBag.CourseId = new SelectList(db.Courses, "CourseId", "Code", resultentry.CourseId);
ViewBag.GradeId = new SelectList(db.Grades, "GradeId", "Name", resultentry.GradeId);
return(View(resultentry));
}
public ActionResult Edit([Bind(Include = "ResultEntryId,StudentId,CourseId,GradeId")] ResultEntry resultentry)
{
if (ModelState.IsValid)
{
db.Entry(resultentry).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.CourseId = new SelectList(db.Courses, "CourseId", "CourseName", resultentry.CourseId);
ViewBag.GradeId = new SelectList(db.Grades, "GradeId", "GradeName", resultentry.GradeId);
ViewBag.StudentId = new SelectList(db.Students, "StudentId", "RegistrationId", resultentry.StudentId);
return(View(resultentry));
}
// GET: /ResultEntry/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ResultEntry resultentry = db.ResultEntries.Find(id);
if (resultentry == null)
{
return(HttpNotFound());
}
return(View(resultentry));
}
public bool IsResultExists(ResultEntry aResultEntry)
{
query = "SELECT * FROM tbl_results WHERE subject_id = '" + aResultEntry.SubjectId + "' AND student_id = '" + aResultEntry.StudentId + "' AND id <> '" + aResultEntry.Id + "'";
connection.Open();
command = new SqlCommand(query, connection);
reader = command.ExecuteReader();
bool isExists = reader.HasRows;
reader.Close();
connection.Close();
return(isExists);
}
//-----------------------------------------------------------------------------------------------------------------------------------------
//PRESENTATION UPDATE----------------------------------------------------------------------------------------------------------------------
void quickWatchPresentation_SelectedIndexChanged(object sender, MouseButtonEventArgs e)
{
ListView lv = sender as ListView;
if (lv != null)
{
ResultEntry rse = lv.SelectedItem as ResultEntry;
if (rse != null)
{
OutputKey = rse.Key;
OnPropertyChanged("OutputKey");
}
}
}
private void DumpTimings(ResultEntry result)
{
StringBuilder builder = new StringBuilder();
TimingInfo[] infos = result.Timings;
lstTimerValues.Items.Clear();
btnWriteConfig.Enabled = false;
foreach (TimingInfo info in infos)
{
TimingInfo infoTimers = new TimingInfo(info);
infoTimers.ShowTimers = true;
lstTimerValues.Items.Add(infoTimers);
}
}
// GET: /ResultEntry/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ResultEntry resultentry = db.ResultEntrieDbSet.Find(id);
if (resultentry == null)
{
return(HttpNotFound());
}
ViewBag.CourseID = new SelectList(db.CourseDbSet, "CourseID", "CourseCode", resultentry.CourseID);
ViewBag.GradeLatterId = new SelectList(db.GradeLatterDbSet, "GradeLatterId", "GradeLatterName", resultentry.GradeLatterId);
return(View(resultentry));
}
public string UpdateResult(ResultEntry aResultEntry)
{
if (aResultEntryGateway.IsResultExists(aResultEntry))
{
return("This Result Already Saved With This Subjects For This Student");
}
else
{
int rowAffected = aResultEntryGateway.UpdateResult(aResultEntry);
if (rowAffected > 0)
{
return("Update Result Successfully");
}
return("Update Failed");
}
}
/// <summary>
/// Add new entry to result entry collection
/// </summary>
/// <param name="entry">Result entry</param>
public void AddEntry(ResultEntry entry)
{
if (entry == null || _preventDuplicates && Entries.Exists(x =>
{
if (x.Message == entry.Message && x.Code == entry.Code)
{
return(x.Status == entry.Status);
}
return(false);
}))
{
return;
}
Entries.Add(entry);
SetStatus(entry.Status);
}
public IActionResult Upload(int id)
{
HttpContext.Session.Set("Student_Fk_New", id);
var result = new ResultEntry
{
StudentId = id,
SubjectId = HttpContext.Session.Get <int>("Subject_Fk_New"),
SessionTermId = _dataBaseQueries.GetCurrentSessionTerm().Id,
ClassId = HttpContext.Session.Get <int>("Class_Fk_New"),
SubjectName = _dataBaseQueries.GetSubject(HttpContext.Session.Get <int>("Subject_Fk_New")).Name,
StudentName = _dataBaseQueries.GetStudent(id).FullName,
ClassName = _dataBaseQueries.GetClass(HttpContext.Session.Get <int>("Class_Fk_New")).Name
};
return(View(result));
}
// GET: /ResultEntry/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ResultEntry resultentry = db.ResultEntries.Find(id);
if (resultentry == null)
{
return(HttpNotFound());
}
ViewBag.CourseId = new SelectList(db.Courses, "CourseId", "CourseName", resultentry.CourseId);
ViewBag.GradeId = new SelectList(db.Grades, "GradeId", "GradeName", resultentry.GradeId);
ViewBag.StudentId = new SelectList(db.Students, "StudentId", "RegistrationId", resultentry.StudentId);
return(View(resultentry));
}
// Use this for initialization
void Start()
{
label = GetComponent<UILabel>();
label.text = MainDatabase.Instance.ConnectDB();
results = new List<ResultEntry>();
SQLiteDataReader reader = MainDatabase.Instance.SelectSql("Select LevelName, A.InteractionID, NPCName, CommText, Category, Q.Text, R.Text, ReplyType, Points, ReplyTimeTaken from Answer as A, Reply as R, Question as Q, Category as C, NPC as N, PointCommunication as P, Interaction as I, Level as L where A.ReplyID = R.ReplyID AND R.QuestionID = Q.QuestionID AND Q.CategoryID = C.CategoryID AND Q.NPCID = N.NPCID AND Q.CommID = P.CommID AND A.InteractionID = I.InteractionID AND I.LevelID = L.LevelID;");
if (reader != null)
{
while(reader.Read()) {
ResultEntry entry = new ResultEntry();
entry.LevelName = reader.GetString(0);
entry.InteractionID = reader.GetInt32(1);
entry.NPCName = reader.GetString(2);
entry.CommText = reader.GetString(3);
entry.Category = reader.GetString(4);
entry.Question = reader.GetString(5);
entry.Reply = reader.GetString(6);
entry.Points = reader.GetInt32(7);
entry.ReplyTimeTaken = reader.GetFloat(8);
results.Add(entry);
}
reader.Close();
reader = null;
if (results.Count > 0)
label.text = results[0].ToString();
else
label.text = "No results retrieved";
}
// MainDatabase.InsertSql("INSERT INTO Progress VALUES (1,3,'Cafeteria','minigame1',2,'false',45)");
MainDatabase.Instance.DisconnectDB();
}
private void DumpTimings(ResultEntry result)
{
StringBuilder builder = new StringBuilder();
TimingInfo[] infos = result.Timings;
lstTimerValues.Items.Clear();
btnWriteConfig.Enabled = false;
foreach (TimingInfo info in infos)
{
TimingInfo infoTimers = new TimingInfo(info);
infoTimers.ShowTimers = true;
lstTimerValues.Items.Add(infoTimers);
}
}
private void DisplayResults(SortedList<double, ArrayList> timingInfos, double[] filtered)
{
lstResults.Items.Clear();
foreach (double val in filtered)
{
ResultEntry entry = new ResultEntry(val, (TimingInfo[])timingInfos[val].ToArray(typeof(TimingInfo)));
lstResults.Items.Add(entry);
}
}
