public Lesson UpdateLessonGrade(int lessonId, double grade)
{
var lessonRepo = new LessonRepository();
var lesson = lessonRepo.GetLesson(lessonId);
lesson.Grade = grade;
if (!lesson.IsPassed)
{
var moduleRepository = new ModuleRepository();
var module = moduleRepository.GetModule(lessonId);
if (grade >= module.MinimumPassingGrade)
{
lesson.IsPassed = true;
}
else
{
lesson.IsPassed = false;
}
}
return(lesson);
}
public CreateUserViewModel()
{
CreateCommand = new RelayCommand(() =>
{
if (Username == null)
return;
if(Username.Trim().Length<3)
{
Notifier.ShowMessage("Please enter at least 3 character for a user name!");
return;
}
if(StudentRepository.GetStudents().Select(s=>s.Username).Contains(Username))
{
Notifier.ShowMessage($"{Username} already exist. Please specify a different one.");
return;
}
Student student = new Student()
{
Username = Username
};
StudentRepository.Add(student);
StudentRepository.Logged = StudentRepository.GetStudents().Where(s => s.Username == student.Username).First();
PerfomanceMonitor.PopulateLetters();
LessonRepository.PopulateUserLessons();
Notifier.ShowMessage($"{Username} created successfully");
DialogService.HideDialog(GetType());
DialogService.ShowDialog(typeof(MainVM));
DialogService.CloseDialog(GetType());
});
CancelCommand = new RelayCommand(() => DialogService.CloseDialog(GetType()));
}
public void UpdateLessonGrade(int lessonId, double grade)
{
var lessonRepo = new LessonRepository();
var lesson = lessonRepo.GetLesson(lessonId);
lesson.Grade = grade;
// For consistency, we need to set the lesson's pass status
// each time the grade changes
//if (!lesson.IsPassed)
//{
var moduleRepository = new ModuleRepository();
var module = moduleRepository.GetModule(lessonId);
if (grade >= module.MinimumPassingGrade)
{
lesson.IsPassed = true;
}
else
{
lesson.IsPassed = false;
}
//}
}
public static void Save(string path, Schedule[] schedules, ClassRepository classRepository, LessonRepository lessonRepository)
{
IWorkbook workbook = null;
var directoryInfo = new DirectoryInfo(path);
if (!directoryInfo.Parent.Exists)
{
Directory.CreateDirectory(directoryInfo.Parent.FullName);
}
var fs = File.OpenWrite(path);
if (path.IndexOf(".xlsx") > 0) // 2007版本
{
workbook = new XSSFWorkbook();
}
else if (path.IndexOf(".xls") > 0) // 2003版本
{
workbook = new HSSFWorkbook();
}
var lessons = lessonRepository.Get();
var classes = classRepository.Get();
if (schedules.Length > 0)
{
var classSchedules = new Dictionary <Class, List <Schedule> >();
foreach (var schedule in schedules)
{
var @class = classes.Where(_class => _class.ID == schedule.ClassID).First();
if (!classSchedules.ContainsKey(@class))
{
var _schedules = new List <Schedule>()
{
schedule
};
classSchedules.Add(@class, _schedules);
}
else
{
classSchedules[@class].Add(schedule);
}
}
var classSchedulesList = classSchedules.ToList();
classSchedulesList.Sort((x, y) =>
{
return(x.Key.ID.CompareTo(y.Key.ID));
});
foreach (var keyValue in classSchedulesList)
{
var _class = keyValue.Key;
var _schedules = keyValue.Value;
ISheet sheet = workbook.CreateSheet(_class.Name);
int rowIndex = 0;
int colIndex = 0;
IRow row = null;
row = sheet.CreateRow(rowIndex++);
row.CreateCell(colIndex++).SetCellValue("一");
row.CreateCell(colIndex++).SetCellValue("二");
row.CreateCell(colIndex++).SetCellValue("三");
row.CreateCell(colIndex++).SetCellValue("四");
row.CreateCell(colIndex++).SetCellValue("五");
rowIndex = 0;
colIndex = 0;
foreach (var schedule in _schedules)
{
var lesson = lessons.Where(_lesson => _lesson.ID == schedule.LessonID).First();
rowIndex = lesson.No;
colIndex = lesson.WeekDay - 1;
var course = _class.Courses.Where(_course => _course.CourseType == schedule.CourseType).First();
row = sheet.GetRow(rowIndex);
if (row == null)
{
row = sheet.CreateRow(rowIndex);
}
row.CreateCell(colIndex).SetCellValue(course.Name);
}
}
}
workbook.Write(fs);
fs.Close();
}
public LessonService()
{
lessonRepository = new LessonRepository();
}
// ReSharper disable once UnusedMember.Global
public LessonResponse Post(LessonUpsertRequest request)
{
Guard.AgainstEmpty(request.Provider);
Guard.AgainstEmpty(request.ProviderId);
var existingUser = UserHelpers.GetExistingUser(request, UserRepository);
Guard.IsTrue(eu => eu.IsNew == false, existingUser);
Guard.IsTrue(eu => eu.IsTeacher, existingUser);
var lesson = new Lesson
{
Id = request.Id,
BookTitle = request.BookTitle,
BookAmazonUrl = request.BookAmazonUrl,
TheHookYouTubeVideo = request.TheHookYouTubeVideo,
TheTwoVocabularyWordsYouTubeVideo = request.TheTwoVocabularyWordsYouTubeVideo,
EnunciationVideo1 = request.EnunciationVideo1,
EnunciationVideo2 = request.EnunciationVideo2,
MainIdea = request.MainIdea,
SupportingIdea = request.SupportingIdea,
StoryDetails = request.StoryDetails,
StoryQuestions = request.StoryQuestions,
ImportantSentencesForWordScramble = request.ImportantSentencesForWordScramble,
Provider = request.Provider,
ProviderId = request.ProviderId
};
if (lesson.IsNew)
{
LessonRepository.Add(lesson);
}
else
{
if (request.Provider != lesson.Provider || request.ProviderId != lesson.ProviderId)
{
throw new HttpError(HttpStatusCode.Unauthorized, "Unauthorized");
}
if (lesson.IsDeleted)
{
throw new HttpError(HttpStatusCode.NotFound, "NotFound");
}
lesson.UpdateDateUtc = DateTime.UtcNow;
LessonRepository.Update(lesson);
}
// TODO: Use Automapper
return(new LessonResponse
{
Id = lesson.Id,
BookTitle = lesson.BookTitle,
BookAmazonUrl = lesson.BookAmazonUrl,
TheHookYouTubeVideo = lesson.TheHookYouTubeVideo,
TheTwoVocabularyWordsYouTubeVideo = lesson.TheTwoVocabularyWordsYouTubeVideo,
EnunciationVideo1 = lesson.EnunciationVideo1,
EnunciationVideo2 = lesson.EnunciationVideo2,
MainIdea = lesson.MainIdea,
SupportingIdea = lesson.SupportingIdea,
StoryDetails = lesson.StoryDetails,
StoryQuestions = lesson.StoryQuestions,
ImportantSentencesForWordScramble = lesson.ImportantSentencesForWordScramble,
LessonAuthor = existingUser
});
}
public LessonService(DefaultContext context)
{
this.repository = new LessonRepository(context);
}
public Schedule[] Do(ClassRepository classRepository, ScheduleRepository scheduleRepository, LessonRepository lessonRepository)
{
Schedule[] result = null;
var lessons = new List <Lesson>(lessonRepository.Get());
var classes = classRepository.Get();
var classesCount = classes.Count();
List <Schedule> schedules = new List <Schedule>();
List <Class> isScheduleClasses = new List <Class>();
int days = 0;
int period = 0;
foreach (var lesson in lessons)
{
days = Math.Max(lesson.WeekDay, days);
period = Math.Max(lesson.No, period);
}
while (true)
{
foreach (var @class in classes)
{
if (isScheduleClasses.Contains(@class))
{
continue;
}
@class.ResetCourse();
bool flag1 = false;
List <Schedule> _schedules = new List <Schedule>();
var keyValuePairs = @class.GetLessonCourses(lessons, days, period);
foreach (var keyValuePair in keyValuePairs)
{
var lesson = keyValuePair.Key;
var course = keyValuePair.Value;
var teacherID = course.TeacherID;
var lessonID = lesson.ID;
if (!scheduleRepository.IsTeacherAvaliable(teacherID, lessonID))
{
flag1 = true;
break;
}
else
{
if (teacherID > 0)
{
var temp = new List <Schedule>();
temp.AddRange(schedules);
temp.AddRange(_schedules);
var _schedulesResult = temp.Where(schedule => schedule.TeacherID > 0 && schedule.TeacherID == teacherID && schedule.LessonID == lessonID);
if (_schedulesResult.Count() > 0)
{
flag1 = true;
break;
}
}
flag1 = false;
course.ScheduleLesson();
_schedules.Add(new Schedule(ScheduleType.Schedule, @class.ID, lessonID, teacherID, course.CourseType));
continue;
}
}
if (flag1)
{
continue;
}
else
{
isScheduleClasses.Add(@class);
schedules.AddRange(_schedules);
}
}
if (isScheduleClasses.Count == classesCount)
{
// 筛选结果
foreach (var lesson in lessons)
{
var id = lesson.ID;
var _schedules = schedules.Where(schedule => schedule.LessonID == id && schedule.TeacherID > 0);
var distinct = _schedules.Distinct(m => m.TeacherID);
if (distinct.Count() < _schedules.Count())
{
isScheduleClasses.Clear();
schedules.Clear();
}
}
if (schedules.Count > 0)
{
// 保存结果
result = new Schedule[schedules.Count];
schedules.CopyTo(result);
break;
}
else
{
continue;
}
}
}
return(result);
}
// ReSharper disable once UnusedMember.Global
public IEnumerable <GroupedStudentLessonAnswerResponse> Post(StudentLessonAnswerGetAllRequest request)
{
Guard.AgainstEmpty(request.Provider);
Guard.AgainstEmpty(request.ProviderId);
var existingUser = UserHelpers.GetExistingUser(request, UserRepository);
Guard.IsTrue(eu => eu.IsNew == false, existingUser);
Guard.GreaterThan(0, request.LessonId, "LessonId");
Guard.IsTrue(eu => eu.IsTeacher, existingUser);
var lesson = LessonRepository.Find(request.LessonId);
if (request.Provider != lesson.Provider || request.ProviderId != lesson.ProviderId)
{
throw new HttpError(HttpStatusCode.Unauthorized, "Unauthorized");
}
var studentLessonAnswers = StudentLessonAnswerRepository.GetAllByLessonId(request.LessonId);
var groupedStudentLessonAnswers = studentLessonAnswers.GroupBy(g => new { g.Provider, g.ProviderId }).ToList();
var allStudents = groupedStudentLessonAnswers.Select(g => UserRepository.GetUserByProviderAndProviderId(g.Key.Provider, g.Key.ProviderId)).ToList();
var response = new List <GroupedStudentLessonAnswerResponse>();
foreach (var grouping in groupedStudentLessonAnswers)
{
var student = allStudents.SingleOrDefault(a => a.Provider == grouping.Key.Provider && a.ProviderId == grouping.Key.ProviderId);
if (student == null || student.IsStudent == false)
{
ErrorLogRepository.Add(new ErrorLog
{
Application = "MetacognitiveTutor.Api",
Message = $"No student found for Provider '{grouping.Key.Provider}', ProviderId '{grouping.Key.ProviderId}'; LessonId: '{request.LessonId}'.",
Provider = request.Provider,
ProviderId = request.ProviderId,
});
continue;
}
var grade = GradeRepository.GetGrade(request.LessonId, student.Provider, student.ProviderId);
response.Add(new GroupedStudentLessonAnswerResponse
{
LessonId = request.LessonId,
BookTitle = lesson.BookTitle,
Name = student.Name,
Provider = student.Provider,
ProviderId = student.ProviderId,
ProviderPic = student.ProviderPic,
StudentLessonAnswers = grouping.Select(g => new StudentLessonAnswerResponse
{
Id = g.Id,
LessonId = g.LessonId,
QuestionType = g.QuestionType,
QuestionId = g.QuestionId,
Question = g.Question,
Answer = g.Answer
}).OrderByDescending(sla => sla.QuestionType.Equals("card_pyramid", StringComparison.OrdinalIgnoreCase)).ThenByDescending(sla => sla.QuestionType.Equals("word_scramble", StringComparison.OrdinalIgnoreCase)),
GradeResponse = grade == null ? new GradeResponse {
IsGraded = false
} : new GradeResponse {
IsGraded = true, Comments = grade.Comments, Grade = grade.Grade
}
});
}
return(response);
}
public LessonService()
{
_lessonRepository = new LessonRepository();
_lessonsSetupRepository = new LessonsSetupRepository();
_exerciseService = new ExerciseService();
}
// GET: api/Lesson
public async Task <IEnumerable <Lesson> > Get()
{
LessonRepository repository = new LessonRepository();
return(await repository.Get());
}
///<summary>
/// Constructor for initialize
///</summary>
public LessonCoreModel()
{
_repository = new LessonRepository <object>();
}
public void Setup()
{
// Let's make sure every test starts with a clean slate
_lessonRepo = new LessonRepository();
}
public LessonsController(LessonRepository lessonRepository, SessionRepository sessionRepository)
{
_lessonRepository = lessonRepository;
_sessionRepository = sessionRepository;
}
