private void addLP_Click(object sender, EventArgs e)
{
var startingYear = 0;
try
{
startingYear = int.Parse(lpStartingYear.Text);
}
catch {}
var newLearningPlan = new LearningPlan()
{
name = lpName.Text,
speciality_code = lpSpecialityCode.Text,
speciality_name = lpSpecialityName.Text,
profile = lpProfile.Text,
starting_year = startingYear,
education_standard = lpEducationStandard.Text,
faculty_id = (int)lpFaculty.SelectedValue
};
lpRepo.add(newLearningPlan);
RefreshLearningPlanList();
}
public double Evaluate(LearningPlan learningPlan, Requisition requisition, Schedule schedule, Meeting meetingToAdd)
{
var badMeetings = GetCollidedMeetings(schedule, meetingToAdd);
var totalPenalty = UnitPenalty * badMeetings.Count;
return(totalPenalty);
}
public double Evaluate(LearningPlan learningPlan, Requisition requisition, Schedule schedule, Meeting meetingToAdd)
{
var totalPenalty = 0d;
foreach (var rule in rules)
{
totalPenalty += rule.Evaluate(learningPlan, requisition, schedule, meetingToAdd);
}
return(totalPenalty);
}
public double Evaluate(LearningPlan learningPlan, Requisition requisition, Schedule schedule, Meeting meetingToAdd)
{
var classesInARowDifference = FindClassesInARowDifference(schedule, meetingToAdd);
if (classesInARowDifference < 0)
{
return(0);
}
var totalPenalty = UnitPenalty * classesInARowDifference;
return(totalPenalty);
}
private void PlansGrid_CellClick(object sender, DataGridViewCellEventArgs e)
{
var studentPlanPeriod = ((List <StudentLearningPlanWithPeriodsView>)PlansGrid.DataSource)[e.RowIndex];
currentLearningPlan = lpRepo.get(studentPlanPeriod.learning_plan_id);
currentLearningPlanDisciplines = lpdRepo.learningPlanAll(currentLearningPlan.id);
var discIdDict = currentLearningPlanDisciplines.ToDictionary(d => d.id, d => d.name);
currentLearningPlanDisciplineSemesters = lpdsRepo.learningPlanAll(studentPlanPeriod.learning_plan_id);
var semesters = currentLearningPlanDisciplineSemesters
.Select(lpds => lpds.semester)
.OrderBy(sn => sn)
.Distinct()
.ToList();
var semesterSpans = semesters.ToDictionary(s => s, s => new Tuple <DateTime, DateTime>(
new DateTime(currentLearningPlan.starting_year + ((s % 2 == 0) ? 1 : 0) + (int)Math.Floor((double)(s - 1) / 2), (s % 2 == 0) ? 2 : 9, 1),
new DateTime(currentLearningPlan.starting_year + 1 + (int)Math.Floor((double)(s - 1) / 2), (s % 2 == 0) ? 8 : 1, 31)
));
var studentSemestersWithYear = new List <Tuple <int, int> >();
var studentSemesters = new List <int>();
for (int i = 0; i < semesters.Count; i++)
{
var semester = semesters[i];
if (studentPlanPeriod.from <= semesterSpans[semester].Item2 &&
semesterSpans[semester].Item1 <= studentPlanPeriod.to)
{
studentSemesters.Add(semester);
studentSemestersWithYear.Add(
new Tuple <int, int>(currentLearningPlan.starting_year + (int)Math.Floor((double)(semester - 1) / 2),
(semester % 2 == 1) ? 1 : 2));
}
}
var studentDisciplineSemesters = currentLearningPlanDisciplineSemesters
.Where(sm => studentSemesters.Contains(sm.semester))
.ToList();
dsViews = DisciplineSemesterView.FromLpdsList(studentDisciplineSemesters, discIdDict);
var semesterIntList = dsViews
.Select(dsv => dsv.semester)
.Distinct()
.OrderBy(s => s)
.ToList();
var semesterViews = IntegerView.FromIntegerList(semesterIntList);
SemestersGrid.DataSource = semesterViews;
SemestersGrid.Columns["value"].HeaderText = "Семестр";
SemestersGrid.Columns["value"].Width = SemestersGrid.Width - 20;
}
public void EvaluateWhenNoPracticesInPlan()
{
var learningPlanItems = new[] { new LearningPlanItem("FT-202", new Discipline("OOP"), MeetingType.Lecture, GroupSize.HalfGroup, 2) };
var learningPlan = new LearningPlan(learningPlanItems);
var testSchedule = new Schedule(new Meeting[] { });
var meetingToAdd = MeetingCreator.CreateMeeting("OOP 514 Eg 0 2 0 1 FT-202#1");
var lecturerHasPracticeWithSameFlowRule = new LecturerHasPracticeWithSameFlow();
var actualPenalty = lecturerHasPracticeWithSameFlowRule.Evaluate(learningPlan, standardRequisition, testSchedule, meetingToAdd);
Assert.AreEqual(0, actualPenalty);
}
public static (List <RequisitionItem>, LearningPlan) ConvertToRequisitions(GSRepository repo, string requisitionSheetName, string learningPlanSheetName)
{
var PlanData = SheetTableReader.ReadRowsFromSheet(repo, learningPlanSheetName, (1, 0), 6);
var(planItemsAndLocations, allGroups) = ParseLearningPlanItems(PlanData);
var learningPlanItems = planItemsAndLocations.Select(x => x.Item1).ToArray();
var learningPlan = new LearningPlan(learningPlanItems);
var RequestionData = SheetTableReader.ReadRowsFromSheet(repo, requisitionSheetName, (1, 0), 7);
var requisitions = ParseRequisitions(RequestionData, planItemsAndLocations, allGroups);
return(requisitions, learningPlan);
}
public IActionResult Put(string id, [FromBody] LearningPlan learningPlan)
{
try
{
// save
context.PutNote(id, learningPlan);
return(Ok());
}
catch (Exception ex)
{
// return error message if there was an exception
return(BadRequest(new { message = ex.Message }));
}
}
public string update(LearningPlan LearningPlan, int id)
{
var response =
ApiHelper.Post(ApiEndpoint + "/learningPlan/" + id.ToString(),
new Dictionary <string, string>
{
{ "name", LearningPlan.name },
{ "speciality_code", LearningPlan.speciality_code },
{ "speciality_name", LearningPlan.speciality_name },
{ "profile", LearningPlan.profile },
{ "starting_year", LearningPlan.starting_year.ToString() },
{ "education_standard", LearningPlan.education_standard },
{ "faculty_id", LearningPlan.faculty_id.ToString() }
});
return(response);
}
public Schedule MakeSchedule(LearningPlan learningPlan, MeetingEvaluator evaluator, Requisition requisition)
{
var meetingsToFill = requisition.Items.Select(
Conversions.RequisitionToMeetingConverter.ConvertRequisitionToMeetingWithoutTime).SelectMany(x => x).ToArray();
var bestSchedule = new Schedule(new Meeting[0]);
var bestPenalty = double.PositiveInfinity;
for (var i = 0; i < 100; ++i)
{
var shuffledMeetingsToFill = meetingsToFill.Shuffled();
var tryingResult = TryMakeSchedule(learningPlan, evaluator, shuffledMeetingsToFill, requisition);
if (bestPenalty > tryingResult.Item2)
{
bestPenalty = tryingResult.Item2;
bestSchedule = tryingResult.Item1;
}
}
return(bestSchedule);
}
public void Test()
{
var learningPlanItem =
new LearningPlanItem("A", new Discipline("X"), MeetingType.Lecture, GroupSize.FullGroup, 1);
var learningPlan = new LearningPlan(new LearningPlanItem[] { learningPlanItem });
var groupsChoices = new GroupsChoice[]
{ new GroupsChoice(new MeetingGroup[] { new MeetingGroup("A", GroupPart.FullGroup) }) };
var groupRequisition = new GroupRequisition[] { new GroupRequisition(groupsChoices) };
var meetingTimeRequisitions = new MeetingTimeRequisition[]
{ new MeetingTimeRequisition(new MeetingTime[] { new MeetingTime(DayOfWeek.Friday, 5) }) };
var requisition = new Requisition(new RequisitionItem[]
{
new RequisitionItem(learningPlanItem, groupRequisition, "", 1, meetingTimeRequisitions, new Teacher("1"), WeekType.Any)
});
var generator = new GreedyScheduleGenerator();
var evaluator = new MeetingEvaluator(new IRule[0]);
var schedule = generator.MakeSchedule(learningPlan, evaluator, requisition);
Assert.True(schedule.Meetings.Length == 1);
var actualMeeting = schedule.Meetings[0];
var expectedMeeting = new Meeting(new Discipline("X"), MeetingType.Lecture,
new MeetingGroup[] { new MeetingGroup("A", GroupPart.FullGroup) })
{
MeetingTime = new MeetingTime(DayOfWeek.Friday, 5),
Teacher = new Teacher("1"),
Location = "",
WeekType = WeekType.Any,
};
Assert.AreEqual(expectedMeeting.MeetingTime, actualMeeting.MeetingTime);
Assert.AreEqual(expectedMeeting.Discipline, actualMeeting.Discipline);
Assert.AreEqual(expectedMeeting.Groups, actualMeeting.Groups);
Assert.AreEqual(expectedMeeting.Location, actualMeeting.Location);
Assert.AreEqual(expectedMeeting.MeetingType, actualMeeting.MeetingType);
Assert.AreEqual(expectedMeeting.Teacher, actualMeeting.Teacher);
Assert.AreEqual(expectedMeeting.WeekType, actualMeeting.WeekType);
}
private (Schedule, double) TryMakeSchedule(LearningPlan learningPlan, MeetingEvaluator evaluator, Meeting[] meetingsToFill, Requisition requisition)
{
var penalty = 0d;
List <Meeting> currentMeetings = new List <Meeting>();
foreach (var meeting in meetingsToFill)
{
var requisitionItem = GetCorrespondingRequisitionItem(meeting, requisition);
var bestPenalty = double.PositiveInfinity;
var bestMeeting = default(Meeting);
foreach (var groupPriority in requisitionItem.GroupPriorities)
{
foreach (var groupsChoice in groupPriority.GroupsChoices)
{
foreach (var meetingTimePriority in requisitionItem.MeetingTimePriorities)
{
foreach (var meetingTimeChoice in meetingTimePriority.MeetingTimeChoices)
{
meeting.MeetingTime = meetingTimeChoice;
meeting.Groups = groupsChoice.Groups;
var currentPenalty = evaluator.Evaluate(learningPlan, requisition, new Schedule(currentMeetings.ToArray()), meeting);
if (bestPenalty > currentPenalty)
{
bestPenalty = currentPenalty;
bestMeeting = meeting.Copy();
}
}
}
}
}
currentMeetings.Add(bestMeeting);
}
return(new Schedule(currentMeetings.ToArray()), penalty);
}
public IActionResult LPPost([FromBody] LearningPlan newLP)
{
try
{
// save
client.client.Cypher
.Merge("(LP:LearningPlan { LearningPlanId: {id} })")
.OnCreate()
.Set("LP = {newLP}")
.WithParams(new
{
id = newLP.LearningPlanId,
newLP
})
.ExecuteWithoutResults();
return(Ok());
}
catch (Exception ex)
{
// return error message if there was an exception
return(BadRequest(new { message = ex.Message }));
}
//newUser =new List<User>();
}
public ActionResult InsertSyll(Syll data)
{
List <Syllab> kita = new List <Syllab>();
Syllab res = new Syllab();
Syllab syllabus = new Syllab();
syllabus.User_ID = logID;
syllabus.Course_ID = 1;
//IList<Syllab> syllablist = new List<Syllab>();
db.Syllabs.Add(syllabus);
kita = db.Syllabs.ToList();
foreach (var sud in kita)
{
if (sud.Course_ID == syllabus.Course_ID)
{
res = sud;
break;
}
}
foreach (PEO p in data.Lpeo)
{
if (p.Peo_CODE != null && p.Peo_CVA != null && p.Peo_DESC != null)
{
PEO peo = new PEO();
peo.Peo_CODE = p.Peo_CODE;
peo.Peo_DESC = p.Peo_DESC;
peo.Peo_CVA = p.Peo_CVA;
peo.Syllabus_ID = res.Syllabus_ID;
db.PEOs.Add(peo);
db.SaveChanges();
}
}
foreach (ClassroomAndLabPolicy p in data.Lclp)
{
if (p.CLP_desc != null)
{
ClassroomAndLabPolicy classroomAndLabPolicies = new ClassroomAndLabPolicy();
classroomAndLabPolicies.CLP_desc = p.CLP_desc;
classroomAndLabPolicies.Syllabus_ID = res.Syllabus_ID;
db.ClassroomAndLabPolicies.Add(classroomAndLabPolicies);
db.SaveChanges();
}
}
foreach (CourseDeliverableOutputsAndRequirement p in data.Lcodor)
{
if (p.OutputReq != null && p.OutputReqDesc != null && p.ToA != null && p.Cilo_Add != null)
{
CourseDeliverableOutputsAndRequirement courseDeliverableOutputsAndRequirements = new CourseDeliverableOutputsAndRequirement();
courseDeliverableOutputsAndRequirements.OutputReq = p.OutputReq;
courseDeliverableOutputsAndRequirements.OutputReqDesc = p.OutputReqDesc;
courseDeliverableOutputsAndRequirements.Cilo_Add = p.Cilo_Add;
courseDeliverableOutputsAndRequirements.ToA = p.ToA;
courseDeliverableOutputsAndRequirements.Syllabus_ID = res.Syllabus_ID;
db.CourseDeliverableOutputsAndRequirements.Add(courseDeliverableOutputsAndRequirements);
db.SaveChanges();
}
}
foreach (CourseOutcome p in data.Lco)
{
if (p.CO_Code != null && p.CO_CVA != null && p.CO_DESC != null && p.CO_DOLLevel != null & p.CO_POactivated != null)
{
CourseOutcome courseOutcomes = new CourseOutcome();
courseOutcomes.CO_Code = p.CO_Code;
courseOutcomes.CO_DESC = p.CO_DESC;
courseOutcomes.CO_CVA = p.CO_CVA;
courseOutcomes.CO_POactivated = p.CO_POactivated;
courseOutcomes.CO_DOLLevel = p.CO_DOLLevel;
courseOutcomes.Syllabus_ID = res.Syllabus_ID;
db.CourseOutcomes.Add(courseOutcomes);
db.SaveChanges();
}
}
foreach (GradingSystem p in data.Lgs)
{
if (p.GRD_outputs != null && p.GRD_type != null && p.GRD_weight != null)
{
GradingSystem gradingSystem = new GradingSystem();
gradingSystem.GRD_outputs = p.GRD_outputs;
gradingSystem.GRD_type = p.GRD_type;
gradingSystem.GRD_weight = p.GRD_weight;
gradingSystem.Syllabus_ID = res.Syllabus_ID;
db.GradingSystems.Add(gradingSystem);
db.SaveChanges();
}
}
foreach (LearningPlan p in data.Llplan)
{
if (p.activityL != null && p.activityT != null & p.LPlan_Asses != null && p.LPlan_No_hours != 0 && p.LPlan_Outcome != null && p.LPlan_Topics != null)
{
LearningPlan learningPlan = new LearningPlan();
learningPlan.LPlan_Outcome = p.LPlan_Outcome;
learningPlan.LPlan_No_hours = p.LPlan_No_hours;
learningPlan.LPlan_Topics = p.LPlan_Topics;
learningPlan.LPlan_Asses = p.LPlan_Asses;
learningPlan.activityL = p.activityL;
learningPlan.activityT = p.activityT;
learningPlan.Syllabus_ID = res.Syllabus_ID;
db.LearningPlans.Add(learningPlan);
db.SaveChanges();
}
}
foreach (ProgramOutcome p in data.Lpo)
{
if (p.PO_Code != null && p.PO_attr != null & p.PO_CVA != null && p.PO_Desc != null)
{
ProgramOutcome programOutcome = new ProgramOutcome();
programOutcome.PO_Code = p.PO_Code;
programOutcome.PO_attr = p.PO_attr;
programOutcome.PO_Desc = p.PO_Desc;
programOutcome.PO_CVA = p.PO_CVA;
programOutcome.Syllabus_ID = res.Syllabus_ID;
db.ProgramOutcomes.Add(programOutcome);
db.SaveChanges();
}
}
foreach (Rubric p in data.Lr)
{
if (p.marginal != null && p.notAcceptable != null & p.outstanding != null && p.competent != null && p.criteria != null)
{
Rubric rubric = new Rubric();
rubric.competent = p.competent;
rubric.criteria = p.criteria;
rubric.marginal = p.marginal;
rubric.notAcceptable = p.notAcceptable;
rubric.outstanding = p.outstanding;
rubric.Syllabus_ID = res.Syllabus_ID;
db.Rubrics.Add(rubric);
db.SaveChanges();
}
}
return(View());
}
public double Evaluate(LearningPlan learningPlan, Requisition requisition, Schedule schedule, Meeting meetingToAdd)
{
var hasPracticeWithSameFlow = CheckTeacherHasPracticeWithSameFlow(schedule, meetingToAdd, learningPlan);
return(hasPracticeWithSameFlow ? 0 : UnitPenalty);
}
public LearningPlanView(LearningPlan lp)
{
id = lp.id;
summary = lp.speciality_code + " " + lp.speciality_name + " (" + lp.starting_year + ")";
}
public static bool CheckTeacherHasPracticeWithSameFlow(Schedule schedule, Meeting meetingToAdd, LearningPlan learningPlan)
{
var planItemsWithSameDiscipline = learningPlan.Items.Where(m => m.Discipline.Equals(meetingToAdd.Discipline)).ToList();
var planedLectures = planItemsWithSameDiscipline.Where(m => m.MeetingType == MeetingType.Lecture);
var planedPractices = planItemsWithSameDiscipline
.Where(m => m.MeetingType == MeetingType.ComputerLab || m.MeetingType == MeetingType.Seminar);
if (!planedLectures.Any() || !planedPractices.Any())
{
return(true);
}
var meetingsWithSameDiscipline = schedule.Meetings.Where(m => m.Discipline.Equals(meetingToAdd.Discipline));
var meetingsWithSameTeacherAndDiscipline = meetingsWithSameDiscipline.Where(m => m.Teacher.Equals(meetingToAdd.Teacher));
var lectures = meetingsWithSameTeacherAndDiscipline
.Where(m => m.MeetingType == MeetingType.Lecture)
.ToHashSet();
var practices = meetingsWithSameTeacherAndDiscipline
.Where(m => m.MeetingType == MeetingType.ComputerLab || m.MeetingType == MeetingType.Seminar)
.ToHashSet();
if (meetingToAdd.MeetingType == MeetingType.Lecture)
{
if (practices.Count == 0)
{
return(true);
}
lectures.Add(meetingToAdd);
}
else
{
if (lectures.Count == 0)
{
return(true);
}
practices.Add(meetingToAdd);
}
var lectureGroups = new HashSet <string>();
var practiceGroups = new HashSet <string>();
foreach (var lecture in lectures)
{
// Should be exactly one group specified by meeting
foreach (var meetingGroup in lecture.Groups)
{
lectureGroups.Add(meetingGroup.GroupName);
}
}
foreach (var practice in practices)
{
// Should be exactly one group specified by meeting
foreach (var meetingGroup in practice.Groups)
{
practiceGroups.Add(meetingGroup.GroupName);
}
}
var intersection = lectureGroups.Intersect(practiceGroups);
var hasPracticeWithSameFlow = intersection.Any();
return(hasPracticeWithSameFlow);
}
private void PlansGridView_CellClick(object sender, DataGridViewCellEventArgs e)
{
var studentPlanPeriod = ((List <StudentLearningPlanWithPeriodsView>)PlansGridView.DataSource)[e.RowIndex];
currentLearningPlan = lpRepo.get(studentPlanPeriod.learning_plan_id);
currentLearningPlanDisciplines = lpdRepo.learningPlanAll(currentLearningPlan.id);
var discIdDict = currentLearningPlanDisciplines.ToDictionary(d => d.id, d => d.name);
currentLearningPlanDisciplineSemesters = lpdsRepo.learningPlanAll(studentPlanPeriod.learning_plan_id);
var semesters = currentLearningPlanDisciplineSemesters
.Select(lpds => lpds.semester)
.OrderBy(sn => sn)
.Distinct()
.ToList();
var semesterSpans = semesters.ToDictionary(s => s, s => new Tuple <DateTime, DateTime>(
new DateTime(currentLearningPlan.starting_year + ((s % 2 == 0) ? 1 : 0) + (int)Math.Floor((double)(s - 1) / 2), (s % 2 == 0) ? 2 : 9, 1),
new DateTime(currentLearningPlan.starting_year + 1 + (int)Math.Floor((double)(s - 1) / 2), (s % 2 == 0) ? 8 : 1, 31)
));
var studentSemestersWithYear = new List <Tuple <int, int> >();
var studentSemesters = new List <int>();
for (int i = 0; i < semesters.Count; i++)
{
var semester = semesters[i];
if (studentPlanPeriod.from <= semesterSpans[semester].Item2 &&
semesterSpans[semester].Item1 <= studentPlanPeriod.to)
{
studentSemesters.Add(semester);
studentSemestersWithYear.Add(
new Tuple <int, int>(currentLearningPlan.starting_year + (int)Math.Floor((double)(semester - 1) / 2),
(semester % 2 == 1) ? 1 : 2));
}
}
var studentDisciplineSemesters = currentLearningPlanDisciplineSemesters
.Where(sm => studentSemesters.Contains(sm.semester))
.OrderBy(s => s.semester)
.ThenBy(s => discIdDict[s.learning_plan_discipline_id])
.ToList();
var dsViews = DisciplineSemesterView.FromLpdsList(studentDisciplineSemesters, discIdDict);
PlanGridView.DataSource = dsViews;
FormatSemesterView();
var studentCardItems = new List <TeacherCardAndItem>();
for (int i = 0; i < studentSemestersWithYear.Count; i++)
{
var semesterStudentCardItems = tciRepo.yearSemesterStudentIdAll(
studentSemestersWithYear[i].Item1,
studentSemestersWithYear[i].Item2,
studentPlanPeriod.student_id);
studentCardItems.AddRange(semesterStudentCardItems);
}
var teachersDict = tRepo.all().ToDictionary(t => t.id, t => t);
for (int i = 0; i < studentCardItems.Count; i++)
{
studentCardItems[i].semester = studentCardItems[i].semester + (studentCardItems[i].starting_year - currentLearningPlan.starting_year) * 2;
if (teachersDict.ContainsKey(studentCardItems[i].teacher_id))
{
var teacher = teachersDict[studentCardItems[i].teacher_id];
studentCardItems[i].teacher_fio = teacher.f + " " + teacher.i + " " + teacher.o;
}
if (teachersDict.ContainsKey(studentCardItems[i].real_teacher_id))
{
var realTeacher = teachersDict[studentCardItems[i].real_teacher_id];
studentCardItems[i].real_teacher_fio = realTeacher.f + " " + realTeacher.i + " " + realTeacher.o;
}
}
studentCardItems = studentCardItems
.OrderBy(i => i.semester)
.ThenBy(i => i.discipline_name)
.ToList();
CardsGridView.DataSource = studentCardItems;
FormatCardsView();
var eprst = 999;
}
