/// <summary>
/// Adds a assignment to the test.
/// </summary>
public void AddAssignment(Assignment assignment)
{
if (assignment == null)
{
throw new ArgumentNullException(nameof(assignment));
}
Assignments.Add(assignment);
}
public void InsertAssignment(int index, Assignment assignment)
{
Assignments.Insert(index, assignment);
assignment.EmployeeSchedule = this;
AdjustTime();
RaiseAssignmentsChanged();
}
public ASTFor(Token token, IEnumerable <ASTAssign> assignments, ASTNode condition, List <ASTNode> continueStatements, ASTNode body)
{
Token = token;
Assignments.AddRange(assignments);
Condition = condition;
ContinueStatements.AddRange(continueStatements);
Body = body;
}
public BuildClassInfo Merge(BuildClassInfo c)
{
Debug.Assert(Class == c.Class);
Debug.Assert(Assignments.Select(a => a.Parameter).Intersect(c.Assignments.Select(a => a.Parameter)).Any() == false);
var assignments = Assignments.Concat(c.Assignments).ToList();
return(new BuildClassInfo(Class, assignments));
}
public override void Cleanup()
{
Classes.Clear();
Assignments.Clear();
Grades.Clear();
ProfessorsHours.Clear();
base.Cleanup();
}
internal override void VerifyPartners(Assignments assignments,
Nanobot botP)
{
(Nanobot botS, Command cmdS) = assignments.FirstOrDefault(
bot_cmd => bot_cmd.Item1.Pos == botP.Pos + mNd);
Verify(botS != null, $"No bot exists at {botP.Pos + mNd}.");
Verify(cmdS is FusionSCommand, $"{botS} is not performing FusionS.");
}
public ActionResult DeleteConfirmed(Assignments assignments)
{
Assignments deleteAssigments = db.Assignments.Where(r => r.CourseId == assignments.CourseId).Where(r => r.ApplicationUserId.Contains(assignments.ApplicationUserId)).FirstOrDefault();
db.Assignments.Remove(deleteAssigments);
db.SaveChanges();
return(RedirectToAction("Index", "Account", new { userRoleId = "Student" }));
}
public void IsAppointment()
{
var patientId = 11;
var doctorId = 3;
var entity = new Assignments(DateTime.Now.AddDays(1), patientId, doctorId);
Assert.AreNotEqual(null, entity);
}
public void AddAssignments(string title, string desc, DateTime sub_date)
{
int current_id = Assignments.Count + 1;
var assignment = new Assignment(current_id, title, desc, sub_date);
Assignments.Add(assignment);
PrivateSchool.OutputAssignments(assignment);
}
public IList <Assignment> AssignmentsByTag(string tag)
{
return(Assignments
.Include(a => a.AssignmentTags)
.ThenInclude(ast => ast.Tag)
.Where(asn => asn.AssignmentTags.Any(atag => atag.Tag.Name == tag))
.ToList());
}
public ActionResult DeleteConfirmed(int id)
{
Assignments assignments = db.Assignments.Find(id);
db.Assignments.Remove(assignments);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public bool createAppointment(DateTime assingmentDate, int patientId, int doctorId)
{
var entity = new Assignments(assingmentDate, patientId, doctorId);
assingmentRepository.add(entity);
return(assingmentRepository.SaveChange());
}
public IActionResult Done(long Id)
{
Assignments assignment = db.Assignments.Find(Id);
db.Remove(assignment);
db.SaveChanges();
return(RedirectToAction("List"));
}
/// <summary>
/// Helper for configuring a database with no assignment categories
/// </summary>
/// <returns></returns>
private Team55LMSContext MakeDatabaseWithOneAssignment()
{
var optionsBuilder = new DbContextOptionsBuilder <Team55LMSContext>();
optionsBuilder.UseInMemoryDatabase("one_assignment").UseApplicationServiceProvider(NewServiceProvider());
Team55LMSContext db = new Team55LMSContext(optionsBuilder.Options);
Courses course = new Courses
{
CourseId = 5,
CourseNumber = 2210,
Name = "Calculus III",
SubjectAbbr = "MATH"
};
Classes calculusIII = new Classes
{
CourseId = 2,
Location = "TBA",
Semester = "Summer 2020",
Professor = "u0000010",
Start = TimeSpan.Parse("12:25:00"),
End = TimeSpan.Parse("13:10:00"),
};
Enrolled enr = new Enrolled
{
ClassId = calculusIII.ClassId,
Grade = "--",
UId = "u0000002",
};
AssignmentCategories category = new AssignmentCategories
{
ClassId = calculusIII.ClassId,
Name = "Assignments",
Weight = 50,
};
Assignments assignment = new Assignments
{
AssignCatId = category.AssignCatId,
Contents = "Just compute the indefinite integral on problem 2, page 303 :)",
MaxPoints = 10,
Name = "One Problem",
DueDate = DateTime.Parse("12/01/2020 11:59:59"),
};
db.Courses.Add(course);
db.Classes.Add(calculusIII);
db.Enrolled.Add(enr);
db.AssignmentCategories.Add(category);
db.Assignments.Add(assignment);
db.SaveChanges();
return(db);
}
/// <summary>
/// Creates a new assignment for the given class and category.
/// </summary>
/// <param name="subject">The course subject abbreviation</param>
/// <param name="num">The course number</param>
/// <param name="season">The season part of the semester for the class the assignment belongs to</param>
/// <param name="year">The year part of the semester for the class the assignment belongs to</param>
/// <param name="category">The name of the assignment category in the class</param>
/// <param name="asgname">The new assignment name</param>
/// <param name="asgpoints">The max point value for the new assignment</param>
/// <param name="asgdue">The due DateTime for the new assignment</param>
/// <param name="asgcontents">The contents of the new assignment</param>
/// <returns>A JSON object containing success = true/false,
/// false if an assignment with the same name already exists in the same assignment category.</returns>
public IActionResult CreateAssignment(string subject, int num, string season, int year, string category, string asgname, int asgpoints, DateTime asgdue, string asgcontents)
{
try
{
int catId = 0;
int classId = 0;
var query1 =
from clas in db.Class
join course in db.Course
on clas.CourseId equals course.CourseId
where course.CNumber == num
where clas.SemesterSeason == season
where clas.SemesterYear == year
select new
{
clID = clas.ClassId
};
foreach (var q in query1)
{
classId = (int)q.clID;
}
var query2 =
from cat in db.AssignmentCat
where cat.CatName == category
where cat.ClassId == classId
select new
{
c = cat.AcId
};
foreach (var q in query2)
{
catId = (int)q.c;
}
Assignments a = new Assignments();
a.AName = asgname;
a.Instructions = asgcontents;
a.DueDate = asgdue;
a.PointValue = (uint)asgpoints;
a.AcId = (uint)catId;
db.Assignments.Add(a);
db.SaveChanges();
return(Json(new { success = true }));
}
catch (Exception e)
{
return(Json(new { success = false }));
}
}
public Teacher()
{
Assignments.CollectionChanged += AssignmentsChanged;
ErrorContainer no_periods = new ErrorContainer((e) => MaxPeriodsPerCycle == 0, (e) => "Teacher has no free periods.",
ErrorType.Warning);
no_periods.BindProperty(this, nameof(MaxPeriodsPerCycle));
ErrorList.Add(no_periods);
ErrorContainer insuf_periods = new ErrorContainer((e) =>
{
int assigned = Assignments.Sum(a => a.TotalPeriods);
e.Data = assigned;
return(MaxPeriodsPerCycle < assigned);
},
(e) => $"Teacher has fewer free periods ({MaxPeriodsPerCycle}) than assigned periods ({e.Data}).",
ErrorType.Error);
insuf_periods.BindCollection(UnavailablePeriods);
insuf_periods.BindCollection(Assignments);
ErrorList.Add(insuf_periods);
ErrorContainer lesson_missing = new ErrorContainer((e) =>
{
IEnumerable <Assignment> assignmentMismatches = Assignments.Where(a => !Subjects.Contains(a.Lesson.Subject));
e.Data = assignmentMismatches;
return(assignmentMismatches.Any());
},
(e) =>
{
IEnumerable <Assignment> data = (IEnumerable <Assignment>)e.Data;
return($"The following Assignments have a subject that the teacher does not have: {string.Join(", ", data.Select(a => a.TeacherString))}.");
},
ErrorType.Warning);
lesson_missing.BindCollection(Assignments);
lesson_missing.BindCollection(Subjects);
ErrorList.Add(lesson_missing);
ErrorContainer insuf_lesson_slots = new ErrorContainer((e) =>
{
IEnumerable <Lesson> errors = Assignments.Where(a => a.Lesson.LessonsPerCycle <
a.Lesson.Assignments.Where(a2 => (a2.Teacher ?? this) != this).Sum(a2 => a2.LessonCount) + a.LessonCount
).Select(a => a.Lesson);
e.Data = errors;
return(errors.Any());
},
(e) =>
{
IEnumerable <Lesson> errors = (IEnumerable <Lesson>)e.Data;
return($"The following lessons happen more frequently per cycle than has been assigned: {GenericHelpers.FormatEnumerable(errors)}.");
},
ErrorType.Warning);
insuf_lesson_slots.BindCollection(Assignments);
ErrorList.Add(lesson_missing);
BindToErrors();
}
public DateTime GetAvailableDateTime(Resource resource)
{
var assigment = Assignments
.Where(x => x.ResourceId == resource.Id)
.OrderBy(x => x.End)
.LastOrDefault();
return(assigment?.End ?? DateTime.Now);
}
/// <summary>
/// Creates a new assignment for the given class and category.
/// </summary>
/// <param name="subject">The course subject abbreviation</param>
/// <param name="num">The course number</param>
/// <param name="season">The season part of the semester for the class the assignment belongs to</param>
/// <param name="year">The year part of the semester for the class the assignment belongs to</param>
/// <param name="category">The name of the assignment category in the class</param>
/// <param name="asgname">The new assignment name</param>
/// <param name="asgpoints">The max point value for the new assignment</param>
/// <param name="asgdue">The due DateTime for the new assignment</param>
/// <param name="asgcontents">The contents of the new assignment</param>
/// <returns>A JSON object containing success = true/false</returns>
public IActionResult CreateAssignment(string subject, int num, string season, int year, string category, string asgname, int asgpoints, DateTime asgdue, string asgcontents)
{
try
{
uint catid = 0;
int classid = 0;
var query =
from c in db.Classes
join co in db.Courses
on c.CatalogId equals co.CatalogId
where co.DepartmentNavigation.Subject == subject
where co.Num == num
where c.Semester == season + " " + year
select new
{
cid = c.ClassId
};
foreach (var q in query)
{
classid = (int)q.cid;
}
var query2 =
from ac in db.AssignmentCategories
where ac.Name == category
where ac.ClassId == classid
select new
{
cd = ac.CatId
};
foreach (var q in query2)
{
catid = q.cd;
}
Assignments a = new Assignments();
a.Name = asgname;
a.Contents = asgcontents;
a.Due = asgdue;
a.Points = (uint?)asgpoints;
a.CatId = catid;
db.Assignments.Add(a);
db.SaveChanges();
//update all students grade in class
UpdateClassGrades(classid);
return(Json(new { success = true }));
}
catch (Exception e)
{
return(Json(new { success = false }));
}
}
public void CorrectDurationForAppointment()
{
var patientId = 11;
var doctorId = 3;
var entity = new Assignments(DateTime.Now.AddDays(1), patientId, doctorId);
Assert.AreEqual(true, (entity.AssignmentFinalDate > entity.AssignmentInitialDate &&
entity.AssignmentFinalDate.Subtract(entity.AssignmentInitialDate).TotalMinutes == 10));
}
void RegisterEmployee(EmployeeComponent employee)
{
this.Log($"Assignment registering {employee}");
if (!Assignments.ContainsKey(employee))
{
Assignments.Add(employee, null);
}
}
public IActionResult Edit(long Id, string Note)
{
Assignments assignment = db.Assignments.Find(Id);
assignment.Notes = Note;
db.SaveChanges();
return(RedirectToAction("List"));
}
internal static AssigmentListStudentsDTO ToAssigmentWihtListStudents(Assignments assigment, IQueryable <StudenAssigments> studenAssigments)
{
var studentListAssigmentsDTO = new AssigmentListStudentsDTO();
studentListAssigmentsDTO.AssigmentName = assigment.Name;
studentListAssigmentsDTO.ListStudents = ToListStudents(studenAssigments);
return(studentListAssigmentsDTO);
}
/// <summary>
/// Finishing an assignment by setting its completion date to todays date
/// </summary>
/// <param name="id">The id of the assignment to finish</param>
/// <returns>An integer value representing the number of rows affected in the database, either 1 for success or 0 for fail.</returns>
public async Task <int> FinishAssignmentAsync(int id)
{
var assignment = await GetAssignmentById(id);
assignment.DateCompleted = DateTime.Now;
Assignments.Update(assignment);
return(await SaveChangesAsync());
}
/// <summary>
/// Получить задание на подготовку проекта резолюции.
/// </summary>
/// <param name="startDate">Дата начала текущей итерации рассмотрения.</param>
/// <returns>Задание на подготовку проекта резолюции.</returns>
private IAssignment GetPreparingDraftResolutionAssignment(DateTime startDate)
{
return(Assignments.GetAll()
.Where(a => Equals(a.Task, _obj))
.Where(a => a.Created >= startDate)
.Where(a => PreparingDraftResolutionAssignments.Is(a))
.OrderByDescending(a => a.Created)
.FirstOrDefault());
}
/// <summary>
/// Creates a new assignment for the given class and category.
/// </summary>
/// <param name="subject">The course subject abbreviation</param>
/// <param name="num">The course number</param>
/// <param name="season">The season part of the semester for the class the assignment belongs to</param>
/// <param name="year">The year part of the semester for the class the assignment belongs to</param>
/// <param name="category">The name of the assignment category in the class</param>
/// <param name="asgname">The new assignment name</param>
/// <param name="asgpoints">The max point value for the new assignment</param>
/// <param name="asgdue">The due DateTime for the new assignment</param>
/// <param name="asgcontents">The contents of the new assignment</param>
/// <returns>A JSON object containing success = true/false</returns>
public IActionResult CreateAssignment(string subject, int num, string season, int year, string category, string asgname, int asgpoints, DateTime asgdue, string asgcontents)
{
var createAssign = from assignCat in db.AssignmentCategories
join classes in db.Classes on assignCat.ClassId equals classes.ClassId
join course in db.Courses on classes.CId equals course.CId
where course.Listing == subject &&
course.Number == num &&
classes.Semester.Equals(season + year) &&
assignCat.Name == category
select new
{
assignCat.AcId,
classes.ClassId
};
uint assignmentCatID = createAssign.First().AcId;
uint classesID = createAssign.First().ClassId;
Assignments newAssignment = new Assignments
{
AcId = assignmentCatID,
Name = asgname,
Contents = asgcontents,
Due = asgdue,
Points = (uint)asgpoints
};
db.Assignments.Add(newAssignment);
db.SaveChanges();
//Change all student scores
//Get all Students in that class
var getAllStudents = (from student in db.Students
join enroll in db.Enrolled on student.UId equals enroll.UId
join classes in db.Classes on enroll.ClassId equals classes.ClassId
where classes.ClassId == classesID
select student).ToList();
//For each student and knowing which class they are in
foreach (Students s in getAllStudents)
{
//Get their assignmentCategories and compute
string letterGrade = getStudentScore(s.UId, classesID);
var changeGrade = from enroll in db.Enrolled
where enroll.ClassId == classesID &&
s.UId == enroll.UId
select enroll;
Enrolled grade = changeGrade.SingleOrDefault();
if (grade != null)
{
grade.Grade = letterGrade;
}
db.SaveChanges();
}
return(Json(new { success = true }));
}
public void CreateRandomAssignment(List <string> assignmentDescriptions, Random random)
{
var assignmentTitle = $"Assignment{Assignments.Count + 1}";
var assignmentDescription = assignmentDescriptions[random.Next(assignmentDescriptions.Count)];
var assignmentSubmissionDateAndTime = Randomizer.GenerateDateExcludingWeekends(StartDate, (EndDate - StartDate).Days, random);
var courseAssignment = new Assignment(assignmentTitle, assignmentDescription, assignmentSubmissionDateAndTime, this);
Assignments.Add(courseAssignment);
CreatePersonalAssignmentsForAllStudentsAppliedToCourse(courseAssignment);
}
public Operand With(OperandKind kind, OperandType type = OperandType.None, ulong value = 0)
{
Kind = kind;
Type = type;
Value = value;
Assignments.Clear();
Uses.Clear();
return this;
}
public ActionResult Edit([Bind(Include = "AssignmentID,Title,PointsAvailable")] Assignments assignments)
{
if (ModelState.IsValid)
{
db.Entry(assignments).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(assignments));
}
private void BindAutoData()
{
Evaluation.EvaluationList evals =
new Assignments(Globals.CurrentIdentity).GetAutoEvals(GetAsstID());
lstTests.DataSource = evals;
lstTests.DataTextField = Evaluation.NAME_FIELD;
lstTests.DataValueField = Evaluation.ID_FIELD;
lstTests.DataBind();
}
// This method is populating the ListView with WeightedItem objects
// that have been entered by the user
private void PopulateAssignments(WeightedItem item)
{
RetrieveAssignments();
if (item != null)
{
Assignments.Add(item);
}
AssignmentsList.DataSource = Assignments;
AssignmentsList.DataBind();
}
internal int addAssignmentTypes(Assignments model)
{
string sql = "insert into ASSIGNMENT (TYPE) values (:s)";
var data = db.Database.ExecuteSqlCommand(sql,
new OracleParameter(":s", model.Type)
);
return data;
}
internal void updateAssignmentType(Assignments assignmentType)
{
String sql = "update ASSIGNMENT set type=:x where id=:y";
using (MedMidsContext db = new MedMidsContext())
{
db.Database.ExecuteSqlCommand(sql, new OracleParameter(":x", assignmentType.Type),
new OracleParameter(":y", assignmentType.Id));
}
}
public static Assignments CreateAssignments(int assID, string assName, global::System.DateTime deadline, string quesFileUrl)
{
Assignments assignments = new Assignments();
assignments.AssID = assID;
assignments.AssName = assName;
assignments.Deadline = deadline;
assignments.QuesFileUrl = quesFileUrl;
return assignments;
}
public void AddToAssignments(Assignments assignments)
{
base.AddObject("Assignments", assignments);
}
