public void AssignRecipients(AssignmentResult result)
{
// we can now execute massive amount of inserts ;)
WithConnection(conn =>
{
foreach (var assignment in result.Assignments)
{
conn.Execute($@"INSERT INTO [{nameof(Assignment)}s] (GiverId, RecepientId) VALUES(@GiverId, @RecepientId)",
new { assignment.GiverId, assignment.RecepientId });
}
});
// and save abandoned for future review
WithConnection(conn =>
{
foreach (var abandonedUser in result.Abandoned)
{
conn.Execute($@"INSERT INTO [{nameof(Abandoned)}] (SantaUserId, Reason) VALUES(@SantaUserId, @Reason)",
new { abandonedUser.SantaUserId, abandonedUser.Reason });
}
});
// verify
var assignmentsFromDb =
WithConnection(conn => conn.ExecuteScalar <int>($"SELECT COUNT(*) FROM [{nameof(Assignment)}s]"));
if (assignmentsFromDb != result.Assignments.Count)
{
throw new InvalidOperationException("Inserts were performed, but there is numerical mismatch!");
}
}
public void Assign()
{
var assigner = MockRepository.GenerateMock<IAssign<Rotation>>();
var block = new Block();
var rotations = new List<Rotation>() { new Rotation() };
rotations.ForEach(block.Rotations.Add);
var block2 = new Block();
var rotations2 = new List<Rotation>() { new Rotation(), new Rotation() };
rotations2.ForEach(block2.Rotations.Add);
var residents = new List<Resident> { new Resident() };
var residents2 = new List<Resident> { new Resident(), new Resident() };
var assignmentResult = new AssignmentResult(residents2);
assigner.Stub(a => a.Assign(Arg<IEnumerable<Rotation>>.Matches(l=> rotations.All(l.Contains)), Arg.Is(residents))).Return(assignmentResult);
var residents3 = new List<Resident> { new Resident(), new Resident(), new Resident() };
var assignmentResult2 = new AssignmentResult(residents3);
assigner.Stub(a => a.Assign(Arg<IEnumerable<Rotation>>.Matches(l => rotations2.All(l.Contains)), Arg.Is(residents2))).Return(assignmentResult2);
var result = new BlockAssigner(assigner).Assign(new List<Block> { block, block2 }, residents);
Assert.AreEqual(residents3, result.Residents);
}
public void Verify(AssignmentResult result)
{
Log.Info($"{nameof(AssignmentAlgorithm)}.{nameof(Verify)}: Success={result.Success}, user count={result.UserDisplayById.Count}, assignments={result.Assignments.Count}, abandoned={result.Abandoned.Count} (Loner:{result.Abandoned.Count(a => a.Reason == AbandonmentReason.LoneWontSend)}, Algorithm: {result.Abandoned.Count(a => a.Reason == AbandonmentReason.ComputerSaysNo)})");
// 1. All people either matched or saved as abandoned
if (result.Assignments.Count + result.Abandoned.Count != result.UserDisplayById.Count)
{
throw new InvalidOperationException($"{nameof(AssignmentAlgorithm)}.{nameof(Verify)}: Missing people");
}
// 2. Nobody should be sending to themselves
if (result.Assignments.Any(a => a.RecepientId == a.GiverId))
{
throw new InvalidOperationException($"{nameof(AssignmentAlgorithm)}.{nameof(Verify)}: Sending to yourself");
}
// 3. Nobody should be sending abroad if they did not wish to
foreach (var a in result.Assignments)
{
var giver = result.UserDisplayById[a.GiverId];
var recipient = result.UserDisplayById[a.RecepientId];
if (giver.SendAbroad == SendAbroadOption.WillNot && giver.Country != recipient.Country)
{
throw new InvalidOperationException($"{nameof(AssignmentAlgorithm)}.{nameof(Verify)}: Sending abroad against preferences");
}
}
// 4. Everyone who sends, gets
var givers = new HashSet <long>(result.Assignments.Select(a => a.GiverId));
var recipients = new HashSet <long>(result.Assignments.Select(a => a.RecepientId));
if (!givers.SetEquals(recipients))
{
throw new InvalidOperationException($"{nameof(AssignmentAlgorithm)}.{nameof(Verify)}: Unequal exchange detected");
}
// 5. Duplicates?
if (result.Assignments.Select(a => a.RecepientId).Distinct().Count() !=
result.Assignments.Select(a => a.RecepientId).Count())
{
throw new InvalidOperationException(
$"{nameof(AssignmentAlgorithm)}.{nameof(Verify)}: Duplicates detected");
}
}
public ResultViewModel(ForSchoolsDBContext context, int ClassID, int SubjectID, int SessionTermID)
{
_context = context;
TotalGrade = new List <TotalGrade>();
Exam = _context.Exam.Where(e => e.ClassId == ClassID && e.SubjectId == SubjectID && e.SessionTermId == SessionTermID);
PsycomotResult = _context.PsycomotResult.Where(a => a.ClassId == ClassID && a.SessionTermId == SessionTermID);
CEResult = _context.CeResult.Where(b => b.ClassId == ClassID && b.SubjectId == SubjectID && b.SessionTermId == SessionTermID);
AssignmentResult = _context.AssignmentResult.Where(c => c.ClassId == ClassID && c.SubjectId == SubjectID && c.SessionTermId == SessionTermID);
AffectiveResult = _context.AffectiveResult.Where(d => d.ClassId == ClassID && d.SessionTermId == SessionTermID);
CAResult = _context.CaResult.Where(f => f.ClassId == ClassID && f.SubjectId == SubjectID && f.SessionTermId == SessionTermID);
Students = _context.SCSt.Include(y => y.Student).Where(z => z.ClassId == ClassID && z.SessionTermId == SessionTermID).Select(p => p.Student);
IEnumerable <Grade> grade = _context.Grade.Where(v => v.SchoolId == _context.Class.Find(ClassID).SchoolId);
foreach (var student in Students)
{
TotalGrade tg = new TotalGrade
{
StudentId = student.Id,
Total = (Exam.FirstOrDefault(a => a.StudentId == student.Id).Score +
CAResult.FirstOrDefault(a => a.StudentId == student.Id).FirstCa +
CAResult.FirstOrDefault(a => a.StudentId == student.Id).SecondCa +
CAResult.FirstOrDefault(a => a.StudentId == student.Id).ThirdCa +
CAResult.FirstOrDefault(a => a.StudentId == student.Id).FourthCa +
CAResult.FirstOrDefault(a => a.StudentId == student.Id).FifthCa +
AssignmentResult.FirstOrDefault(a => a.StudentId == student.Id).Assignment1 +
AssignmentResult.FirstOrDefault(a => a.StudentId == student.Id).Assignment2 +
AssignmentResult.FirstOrDefault(a => a.StudentId == student.Id).Assignment3 +
AssignmentResult.FirstOrDefault(a => a.StudentId == student.Id).Assignment4 +
AssignmentResult.FirstOrDefault(a => a.StudentId == student.Id).Assignment5 +
CEResult.FirstOrDefault(a => a.StudentId == student.Id).ClassExercise1 +
CEResult.FirstOrDefault(a => a.StudentId == student.Id).ClassExercise2 +
CEResult.FirstOrDefault(a => a.StudentId == student.Id).ClassExercise3 +
CEResult.FirstOrDefault(a => a.StudentId == student.Id).ClassExercise4 +
CEResult.FirstOrDefault(a => a.StudentId == student.Id).ClassExercise5)
};
tg.Grade = grade.FirstOrDefault(u => u.UpperLimit >= tg.Total && u.LowerLimit <= tg.Total).Name;
TotalGrade.Add(tg);
}
}
/// <summary>
/// Creates an AssignmentDisplayProvider.
/// </summary>
public IAssignmentDisplayProvider CreateDisplayProvider(
AssignmentResult assignmentResult)
{
if (assignmentResult.CombinedSubmissions)
{
return(new CombinedSubmissionsDisplayProvider
(
_timeZoneProvider,
_assignmentUrlProvider,
(CombinedSubmissionsAssignmentResult)assignmentResult
));
}
else
{
return(new SeparateSubmissionsDisplayProvider
(
_timeZoneProvider,
_assignmentUrlProvider,
(SeparateSubmissionsAssignmentResult)assignmentResult
));
}
}
/// <summary>
/// Constructor.
/// </summary>
public AssignmentResultViewModel(
AssignmentResult result,
IAssignmentDisplayProvider displayProvider)
{
var assignmentUrl = displayProvider.GetAssignmentUrl();
AssignmentName = assignmentUrl != null
? GetLink(assignmentUrl, result.AssignmentName, preventWrapping : true)
: GetColoredText("black", result.AssignmentName, bold: false, preventWrapping: true);
DueDate = GetColoredText
(
"black",
displayProvider.GetAssignmentDueDate(),
bold: false,
preventWrapping: true
);
Score = GetColoredText
(
"black",
$"{result.Score} / {result.TotalPoints}",
bold: false,
preventWrapping: true
);
Status = GetColoredText
(
result.Status.GetColor(),
result.Status.GetText(),
result.Status.GetBold(),
preventWrapping: true
);
ChildTableData = displayProvider.GetChildTableData();
}
public async Task GenerateResults(string signature, string schoolId, string assignmentId)
{
var students = this.classesService.GetStudentsFromClass(signature, schoolId);
var firstResults = new List <AssignmentResult>();
foreach (var studentId in students)
{
var result = new AssignmentResult()
{
StudentId = studentId,
AssignmentId = assignmentId,
DueDate = DateTime.UtcNow,
Points = 0,
Content = string.Empty,
Stage = 1
};
firstResults.Add(result);
}
await this.context.AssignmentResults.AddRangeAsync(firstResults);
await this.context.SaveChangesAsync();
}
public ActionResult Assignment()
{
ViewBag.Title = "Rezultatas";
List <List <int> > pyramidNumbers = new List <List <int> >
{
new List <int> {
215
},
new List <int> {
192, 124
},
new List <int> {
117, 269, 442
},
new List <int> {
218, 836, 347, 235
},
new List <int> {
320, 805, 522, 417, 345
},
new List <int> {
229, 601, 728, 835, 133, 124
},
new List <int> {
248, 202, 277, 433, 207, 263, 257
},
new List <int> {
359, 464, 504, 528, 516, 716, 871, 182
},
new List <int> {
461, 441, 426, 656, 863, 560, 380, 171, 923
},
new List <int> {
381, 348, 573, 533, 448, 632, 387, 176, 975, 449
},
new List <int> {
223, 711, 445, 645, 245, 543, 931, 532, 937, 541, 444
},
new List <int> {
330, 131, 333, 928, 376, 733, 017, 778, 839, 168, 197, 197
},
new List <int> {
131, 171, 522, 137, 217, 224, 291, 413, 528, 520, 227, 229, 928
},
new List <int> {
223, 626, 034, 683, 839, 052, 627, 310, 713, 999, 629, 817, 410, 121
},
new List <int> {
924, 622, 911, 233, 325, 139, 721, 218, 253, 223, 107, 233, 230, 124, 233
}
};
bool checkedNumbersResult = CheckPyramidFormation(pyramidNumbers);
AssignmentResult finalResult = new AssignmentResult {
MaximumNumber = 0, NumbersInLine = new List <List <NumberWithIndexes> >(), gottenVariables = pyramidNumbers
};
if (checkedNumbersResult)
{
finalResult.MaximumNumber = pyramidNumbers.First().First();
finalResult.NumbersInLine.Add(new List <NumberWithIndexes>
{
new NumberWithIndexes {
Number = pyramidNumbers.First().First(),
NumberIndex = 0
}
});
AssignmentResult notBranchingResults = new AssignmentResult
{
MaximumNumber = pyramidNumbers.First().First(),
NumbersInLine = new List <List <NumberWithIndexes> >()
};
foreach (var pyramidNumberList in pyramidNumbers.Skip(1))
{
List <List <NumberWithIndexes> > tempNumberList = new List <List <NumberWithIndexes> >();
List <List <NumberWithIndexes> > listsForRemoving = new List <List <NumberWithIndexes> >();
foreach (var lineVarList in finalResult.NumbersInLine)
{
NumberWithIndexes lastNumber = lineVarList.Last();
bool addedNewList = false;
if ((lastNumber.Number % 2 == 0 && pyramidNumberList.Skip(lastNumber.NumberIndex).First() % 2 != 0) ||
(lastNumber.Number % 2 != 0 && pyramidNumberList.Skip(lastNumber.NumberIndex).First() % 2 == 0)
)
{
List <NumberWithIndexes> tempVarlist = lineVarList.ToList();
tempVarlist.Add(new NumberWithIndexes {
Number = pyramidNumberList.Skip(lastNumber.NumberIndex).First(), NumberIndex = lastNumber.NumberIndex
});
tempNumberList.Add(tempVarlist);
addedNewList = true;
}
if ((lastNumber.Number % 2 == 0 && pyramidNumberList.Skip(lastNumber.NumberIndex + 1).First() % 2 != 0) ||
(lastNumber.Number % 2 != 0 && pyramidNumberList.Skip(lastNumber.NumberIndex + 1).First() % 2 == 0)
)
{
List <NumberWithIndexes> tempVarlist2 = lineVarList.ToList();
tempVarlist2.Add(new NumberWithIndexes {
Number = pyramidNumberList.Skip(lastNumber.NumberIndex + 1).First(), NumberIndex = lastNumber.NumberIndex + 1
});
tempNumberList.Add(tempVarlist2);
addedNewList = true;
}
if (!addedNewList)
{
List <NumberWithIndexes> tempVarlistNonBranching = lineVarList;
tempVarlistNonBranching.Add(new NumberWithIndexes {
Number = pyramidNumberList.Skip(lastNumber.NumberIndex).First(), NumberIndex = lastNumber.NumberIndex + 1
});
if (tempVarlistNonBranching.Select(m => m.Number).Sum() > notBranchingResults.MaximumNumber)
{
notBranchingResults.MaximumNumber = tempVarlistNonBranching.Select(m => m.Number).Sum();
notBranchingResults.NumbersInLine = new List <List <NumberWithIndexes> >
{
tempVarlistNonBranching
};
}
else if (tempVarlistNonBranching.Select(m => m.Number).Sum() == notBranchingResults.MaximumNumber)
{
notBranchingResults.NumbersInLine.Add(tempVarlistNonBranching);
}
listsForRemoving.Add(tempVarlistNonBranching);
}
}
if (listsForRemoving.Any())
{
foreach (var badList in listsForRemoving)
{
finalResult.NumbersInLine.Remove(badList);
}
}
if (tempNumberList.Any())
{
finalResult.NumbersInLine = tempNumberList;
finalResult.MaximumNumber = tempNumberList.Max(m => m.Select(n => n.Number).Sum());
}
if (finalResult.MaximumNumber > notBranchingResults.MaximumNumber)
{
notBranchingResults.MaximumNumber = finalResult.MaximumNumber;
notBranchingResults.NumbersInLine = new List <List <NumberWithIndexes> >();
}
}
var maxSumAfterBranching = 0;
try
{
maxSumAfterBranching = finalResult.NumbersInLine.Max(m => m.Select(n => n.Number).Sum());
}
catch
{
}
finalResult.NumbersInLine = finalResult.NumbersInLine.Where(m => m.Select(n => n.Number).Sum() == maxSumAfterBranching).ToList();
}
else
{
ViewBag.Klaida = "Bad variables";
}
return(View(finalResult));
}
public AssignWorkResponseMessage()
{
Result = AssignmentResult.Unknown;
}
public ResultViewModel(ForSchoolsDBContext context, int ClassID, int SessionTermID)
{
_context = context;
TotalGrade = new List <TotalGrade>();
S_C_ST = _context.SCSt.Where(z => z.ClassId == ClassID && z.SessionTermId == SessionTermID);
Students = _context.SCSt.Include(y => y.Student).Where(z => z.ClassId == ClassID && z.SessionTermId == SessionTermID).Select(p => p.Student);
Exam = _context.Exam.Where(e => e.ClassId == ClassID && e.SessionTermId == SessionTermID);
PsycomotResult = _context.PsycomotResult.Where(a => a.ClassId == ClassID && a.SessionTermId == SessionTermID);
CEResult = _context.CeResult.Where(b => b.ClassId == ClassID && b.SessionTermId == SessionTermID);
AssignmentResult = _context.AssignmentResult.Where(c => c.ClassId == ClassID && c.SessionTermId == SessionTermID);
AffectiveResult = _context.AffectiveResult.Where(d => d.ClassId == ClassID && d.SessionTermId == SessionTermID);
CAResult = _context.CaResult.Where(f => f.ClassId == ClassID && f.SessionTermId == SessionTermID);
foreach (var student in Students)
{
TotalGrade tg = new TotalGrade
{
StudentId = student.Id,
NoOfSubjects = _context.Exam.Where(k => k.StudentId == student.Id && k.SessionTermId == SessionTermID && k.Score != null).Count()
};
IEnumerable <Subject> subjects = _context.Exam.Include(q => q.Subject).Where(k => k.StudentId == student.Id && k.SessionTermId == SessionTermID && k.Score != null).Select(g => g.Subject);
Exam = Exam.Where(e => e.StudentId == student.Id);
PsycomotResult = PsycomotResult.Where(a => a.StudentId == student.Id);
CEResult = CEResult.Where(b => b.StudentId == student.Id);
AssignmentResult = AssignmentResult.Where(c => c.StudentId == student.Id);
AffectiveResult = AffectiveResult.Where(d => d.StudentId == student.Id);
CAResult = CAResult.Where(f => f.StudentId == student.Id);
foreach (var subject in subjects)
{
tg.Total = tg.Total + (Exam.FirstOrDefault(a => a.SubjectId == subject.Id).Score +
CAResult.FirstOrDefault(a => a.SubjectId == subject.Id).FirstCa +
CAResult.FirstOrDefault(a => a.SubjectId == subject.Id).SecondCa +
CAResult.FirstOrDefault(a => a.SubjectId == subject.Id).ThirdCa +
CAResult.FirstOrDefault(a => a.SubjectId == subject.Id).FourthCa +
CAResult.FirstOrDefault(a => a.SubjectId == subject.Id).FifthCa +
AssignmentResult.FirstOrDefault(a => a.SubjectId == subject.Id).Assignment1 +
AssignmentResult.FirstOrDefault(a => a.SubjectId == subject.Id).Assignment2 +
AssignmentResult.FirstOrDefault(a => a.SubjectId == subject.Id).Assignment3 +
AssignmentResult.FirstOrDefault(a => a.SubjectId == subject.Id).Assignment4 +
AssignmentResult.FirstOrDefault(a => a.SubjectId == subject.Id).Assignment5 +
CEResult.FirstOrDefault(a => a.SubjectId == subject.Id).ClassExercise1 +
CEResult.FirstOrDefault(a => a.SubjectId == subject.Id).ClassExercise2 +
CEResult.FirstOrDefault(a => a.SubjectId == subject.Id).ClassExercise3 +
CEResult.FirstOrDefault(a => a.SubjectId == subject.Id).ClassExercise4 +
CEResult.FirstOrDefault(a => a.SubjectId == subject.Id).ClassExercise5);
}
if (tg.NoOfSubjects == 0)
{
tg.Average = 0;
}
else
{
tg.Average = tg.Total / tg.NoOfSubjects;
}
Avg = Avg + tg.Average;
TotalGrade.Add(tg);
}
if (Students.Count() == 0)
{
Avg = 0;
}
else
{
Avg = Avg / Students.Count();
}
}
public void SaveAssignments(AssignmentResult result) => _userRepository.AssignRecipients(result);
public async Task <ActionResult <ImportExcelDTO> > Import(ImportExcelDTO payload)
{
foreach (var(studentId, studentResult) in payload.StudentResults)
{
var student = new Student
{
Id = studentId,
FullName = studentResult.Name
};
var courseResult = new CourseResult
{
CourseId = payload.CourseId,
StudentId = studentId,
};
foreach (var(assignmentId, assignmentTaskResults) in studentResult.AssignmentTaskResults)
{
var assignmentResult = new AssignmentResult
{
AssignmentId = assignmentId,
};
foreach (var(assignmentTaskId, grade) in assignmentTaskResults)
{
var assignmentTaskResult = new AssignmentTaskResult
{
AssignmentTaskId = assignmentTaskId,
Grade = grade
};
assignmentResult.AssignmentTaskResults.Add(assignmentTaskResult);
}
courseResult.AssignmentResults.Add(assignmentResult);
}
var existingStudent = await _context.Students.FindAsync(student.Id);
if (existingStudent == null)
{
_context.Students.Add(student);
}
else
{
_context.Entry(existingStudent).CurrentValues.SetValues(student);
}
var existingCourseResult = await _context.CourseResults.FindAsync(courseResult.Id);
if (existingCourseResult == null)
{
_context.CourseResults.Add(courseResult);
}
else
{
_context.Entry(existingCourseResult).CurrentValues.SetValues(courseResult);
}
}
await _context.SaveChangesAsync();
return(NoContent());
}
