public void TestCourse()
{
Models.Course cs = new Models.Course {
Title = "IELTS Focus", Cost = 100
};
Assert.AreSame("IELTS Focus", cs.Title);
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
Course = await _context.Course.FirstOrDefaultAsync(m => m.ID == id);
if (Course == null)
{
return(NotFound());
}
//Get userId of logged in user
var userId = HttpContext.Session.GetInt32(SD.UserSessionId);
if (userId == null)
{
userId = 0;
}
//Check if user is an instructor
var isInstructor = await _context.User.Where(x => x.ID == userId).Where(x => x.UserType == 'I').AnyAsync();
//Makes sure user is logged in, is an instructor and is the instructor who created the course
if (userId == 0 || !isInstructor || (userId != Course.InstructorID))
{
return(Unauthorized());
}
return(Page());
}
public async Task <IActionResult> Create(Models.Course course)
{
_context.Courses.Add(course);
await _context.SaveChangesAsync();
return(Ok(course.Id));
}
public IActionResult EditCourses([FromBody] CoursesActionModel model)
{
try
{
var coure = new Models.Course
{
Id = model.Id,
Name = model.NameCourses,
Price = model.Price,
Description = model.Description,
NumberCredits = model.NumberCredits,
Donors = model.Donors,
UrlImage = model.UrlImage,
DateStart = model.DateStart,
DateEnd = model.DateEnd,
AccountId = model.idTeacher,
CategoryId = model.idCategory,
CetificateId = model.idCetificate
};
bool result = _courses.Edit(coure);
return(new ObjectResult(result));
}
catch
{
return(new ObjectResult(false));
}
}
public ActionResult Create(CourseDetailsViewModel viewModel)
{
ActionResult result = null;
try
{
if (ModelState.IsValid && ValidateCourseForCreate(viewModel, ModelState) && !CheckCourseTitleAlreadyExists(viewModel.Title))
{
Course newCourse = new Models.Course(viewModel.Title, viewModel.Description, viewModel.From.Value, viewModel.To.Value);
unitOfWork.CoursesRepository.CreateCourse(newCourse, User.Identity.GetUserId());
unitOfWork.Complete();
Course course = unitOfWork.CoursesRepository.GetCourseById(newCourse.Id);
unitOfWork.CoursesAntenna.OnCourseCreated(course);
result = RedirectToAction("Index");
}
else
{
result = View(viewModel);
}
}
catch
{
result = View(viewModel);
}
return(result);
}
private void AddData(HttpContext context)
{
var courModel = new Models.Course();
SetModelValue(courModel, context);
courModel.CreatTime = DateTime.Now;
courModel.LastModifyTime = DateTime.Now;
var courBll = new BLL.Course();
var result = false;
var msg = "";
try
{
result = courBll.Add(courModel);
if (!result)
{
msg = "保存失败！";
}
}
catch (Exception ex)
{
LogHelper.WriteLogofExceptioin(ex);
result = false;
msg = ex.Message;
}
// var str = JsonConvert.SerializeObject(new { success = result, errorMsg = msg});
context.Response.Write(msg);
}
public List <Models.Group> GetGroupListFull(Dal.AD ad, Dal.SQL sql)
{
List <Models.Group> groups = sql.GetGroupList(false);
for (int i = 0; i < groups.Count; i++)
{
groups[i].Members = sql.GetMemberList(groups[i].Id);
for (int j = 0; j < groups[i].Members.Count; j++)
{
Models.Person person = new Models.Person();
Models.Course personCourse = sql.GetPersonsCourse(groups[i].Members[j].UNI);
if (personCourse.StartCourse < DateTime.Now && personCourse.EndCourse > DateTime.Now)
{
person.OnCourse = true;
}
else
{
person.OnCourse = false;
}
person.Name = ad.GetUserInfo(groups[i].Members[j].UNI).Name;
groups[i].Members[j] = person;
}
}
return(groups);
}
public List <Models.Course> GetAllCourses()
{
Qurey = "SELECT * FROM course";
Command = new SqlCommand(Qurey, Connection);
List <Models.Course> courses = new List <Models.Course>();
Connection.Open();
Reader = Command.ExecuteReader();
while (Reader.Read())
{
Models.Course course = new Models.Course();
course.Id = Convert.ToInt32(Reader["id"]);
course.Code = Reader["courseCode"].ToString();
course.Name = Reader["courseName"].ToString();
course.Credit = Convert.ToDouble(Reader["credit"]);
course.DepartmentId = Convert.ToInt32(Reader["departmentId"]);
course.Description = Reader["description"].ToString();
course.SemesterId = Convert.ToInt32(Reader["semesterId"]);
courses.Add(course);
}
Reader.Close();
Connection.Close();
return(courses);
}
public async Task <IActionResult> OnGetAsync(int?id)
{
int userId = (int)HttpContext.Session.GetInt32(SD.UserSessionId);
if (id == null)
{
return(NotFound());
}
Course = await _context.Course.FirstOrDefaultAsync(m => m.ID == id);
courseHelper = new CourseHelper();
if (Course == null)
{
return(NotFound());
}
else
{
string startEndTime = courseHelper.ConcatenateStartAndEndTime(Course);
string fullSchedule = courseHelper.ConcatenateDaysAndTimes(Course, startEndTime);
Course.StartTime = fullSchedule;
}
if (id > 0)
{
User = _context.User.Where(x => x.ID == userId).FirstOrDefault();
}
return(Page());
}
public Models.Course CreateCourseSubject(Guid programId, Guid subjectId, string name, string shortName, int totalSections, int sectionPerWeek, bool isTeachingByHomeroomTeacher, bool isActive)
{
if (String.IsNullOrEmpty(name))
{
throw new ArgumentNullException("name");
}
if (programId == null || programId == System.Guid.Empty)
{
throw new ArgumentNullException("programId");
}
Models.Course course = new Models.Course()
{
Id = Guid.NewGuid(),
TrainingProgramId = programId,
SubjectId = subjectId,
TotalSection = totalSections,
SectionPerWeek = sectionPerWeek,
IsTeachingByHomeroomTeacher = isTeachingByHomeroomTeacher,
IsActive = isActive,
IsDeleted = false
};
this.DataContext.Insert <Models.Course>(course);
return(course);
}
public string SaveCourse(Models.Course course)
{
if (courseGateway.SaveCourse(course) > 0)
{
return("Course Saved Successfully.");
}
return("Course Saving Failed");
}
public async Task <IActionResult> Update([Bind("ID, Name, Level, Category")] Models.Course course)
{
_context.Courses.Update(course);
await _context.SaveChangesAsync();
return(RedirectToAction("Index", "Home"));
}
//添加课程
public void AddCourse()
{
using (db_context)
{
var course = new Models.Course();
db_context.Courses.Add(course);
db_context.SaveChanges();
}
}
public IActionResult Index(Models.Course model)
{
if (ModelState.IsValid)
{
courseRepository.AddCourse(model);
return(RedirectToAction("index"));
}
return(View());
}
public async Task <IActionResult> Update(int?id)
{
if (id.HasValue)
{
Models.Course course = await _context.Courses.FirstOrDefaultAsync(a => a.ID == id);
return(View(course));
}
return(RedirectToAction("Index", "Home"));
}
internal static Models.Course mapCourse(Data.Course ent, Models.Course mdl = null)
{
if (ent == null) return mdl;
if (mdl == null) mdl = new Models.Course();
mdl.ID = new Models.CourseID(ent.CourseID);
mdl.Code = ent.Code;
mdl.Name = ent.Name;
return mdl;
}
public void Create_Course_NotNull()
{
var course = new Models.Course()
{
Capacity = 2,
Name = "TestC1",
};
var addedCourse = _courseRepository.GenericsDbContext.Add(course);
_courseRepository.GenericsDbContext.SaveChanges();
Assert.NotEqual(0, addedCourse.Id);
}
/// <summary>
/// 得到一个对象实体
/// </summary>
public Models.Course DataRowToModel(DataRow row)
{
Models.Course model=new Models.Course();
if (row != null)
{
if(row["CourseId"]!=null && row["CourseId"].ToString()!="")
{
model.CourseId= new Guid(row["CourseId"].ToString());
}
if(row["CourseName"]!=null)
{
model.CourseName=row["CourseName"].ToString();
}
if(row["TeacherId"]!=null && row["TeacherId"].ToString()!="")
{
model.TeacherId= new Guid(row["TeacherId"].ToString());
}
if(row["TeacherName"]!=null)
{
model.TeacherName=row["TeacherName"].ToString();
}
if(row["TeachTime"]!=null)
{
model.TeachTime=row["TeachTime"].ToString();
}
if(row["TeachPlace"]!=null)
{
model.TeachPlace=row["TeachPlace"].ToString();
}
if(row["CreatTime"]!=null && row["CreatTime"].ToString()!="")
{
model.CreatTime=DateTime.Parse(row["CreatTime"].ToString());
}
if(row["LastModifyTime"]!=null && row["LastModifyTime"].ToString()!="")
{
model.LastModifyTime=DateTime.Parse(row["LastModifyTime"].ToString());
}
if (row["Type"] != null)
{
model.Type = int.Parse(row["Type"].ToString());
}
if (row["Status"] != null && row["Status"].ToString() != "")
{
model.Status = int.Parse(row["Status"].ToString());
}
if (row["Description"] != null && row["Description"].ToString() != "")
{
model.Description = row["Description"].ToString();
}
}
return model;
}
public async Task <IActionResult> Create([FromBody] Models.CourseCreate Course)
{
Models.Course newCourse = new Models.Course()
{
description = Course.description,
name = Course.name
};
context.Courses.Add(newCourse);
await context.SaveChangesAsync();
return(Ok(Course));
}
private Models.Course AddNewCourse()
{
var course = new Models.Course()
{
Capacity = 1,
Name = "TestCourse",
};
var addedCourse = _courseRepository.GenericsDbContext.Add(course);
_courseRepository.GenericsDbContext.SaveChanges();
return(addedCourse);
}
public async Task <IActionResult> Update(int id, [FromBody] Models.Course Course)
{
if (id != Course.id)
{
return(BadRequest());
}
context.Entry(Course).State = EntityState.Modified;
await context.SaveChangesAsync();
return(Ok(Course));
}
//POST: api/Course
public JsonResult AddCourse(Models.Course course)
{
string status = "adding course failed in controller";
try
{
status = _repository.addCourse(course.CourseName, course.CourseDescription, course.CourseLink, course.Semester);
}
catch (Exception ex)
{
status = ex.Message;
}
return(new JsonResult(status));
}
//adds a event/holiday to the db
public void AddEvent(Models.Course course)
{
if (course.Type == "VE")
{
sql.AddEvent(course.Title, course.Desc, course.StartCourse.ToString("yyyy-MM-dd") + course.StartTime.ToString(" HH:mm:ss"), course.EndCourse.ToString("yyyy-MM-dd") + course.EndTime.ToString(" HH:mm:ss"), true, false);
}
else if (course.Type == "F")
{
sql.AddEvent(course.Title, course.Desc, course.StartCourse.ToString("yyyy-MM-dd"), course.EndCourse.ToString("yyyy-MM-dd") + " 23:59:59", false, true);
}
else
{
sql.AddEvent(course.Title, course.Desc, course.StartCourse.ToString("yyyy-MM-dd") + course.StartTime.ToString(" HH:mm:ss"), course.EndCourse.ToString("yyyy-MM-dd") + course.EndTime.ToString(" HH:mm:ss"), false, false);
}
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
Course = await _context.Courses.FirstOrDefaultAsync(m => m.CourseID == id);
if (Course == null)
{
return(NotFound());
}
return(Page());
}
public static DAL.Models.Course Consumme_To_Dal(this Models.Course course)
{
return(new DAL.Models.Course
{
ID_Course = course.ID_Course,
Hippodrome = course.Hippodrome,
Jockey = course.Jockey,
Corde = course.Corde,
Discipline = course.Discipline,
Terrain = course.Terrain,
Avis = course.Avis,
Poids_De_Course = course.Poids_De_Course,
Date_Course = course.Date_Course
});
}
private GetCourseStudentSummaryModel GetCourses(Models.Course c)
{
var courseStudentsExist = c.CourseStudents != null && c.CourseStudents.Any();
var studentsAges = courseStudentsExist ? c.CourseStudents.Select(s => s.Student.Age) : null;
return(new GetCourseStudentSummaryModel()
{
CourseID = c.Id,
CourseName = c.Name,
AssignedStudentsCount = courseStudentsExist ? c.CourseStudents.Count() : 0,
StudentMaxAge = courseStudentsExist ? studentsAges.Max() : 0,
StudentMinAge = courseStudentsExist ? studentsAges.Min() : 0,
TotalCapacity = c.Capacity
});
}
public ActionResult AddCourse(int Id)
{
Student student = context.Students.FirstOrDefault(x => x.StudentId == Id);
if (student != null)
{
Course course = new Models.Course();
course.Students = new List <Student>();
course.Students.Add(student);
return(View(course));
}
else
{
return(RedirectToAction("Create"));
}
}
public void ExplicitCastTest()
{
// Arrange
Models.Course course = CreateNewModelCourseWithOneCourseImplementation("ENDEVN", 1,
new DateTime[] { new DateTime(2017, 2, 14), new DateTime(2017, 2, 15), new DateTime(2017, 2, 16) });
// Act
var result = (Generator.Course)course;
// Assert
Assert.AreEqual("ENDEVN", result.Code);
Assert.AreEqual(1, result.Priority);
Assert.AreEqual(new DateTime(2017, 2, 14), result.CourseImplementations.First().Days.ElementAt(0));
Assert.AreEqual(new DateTime(2017, 2, 15), result.CourseImplementations.First().Days.ElementAt(1));
Assert.AreEqual(new DateTime(2017, 2, 16), result.CourseImplementations.First().Days.ElementAt(2));
}
public ActionResult CreateCourese()
{
int schoolid = User.GetSchoolID();
BLL.ACBaseExecService.ExecSQL("Delete Courses Where SchoolID={0}", schoolid);
string s = Request.Form["data"];
BLLCousrse bc = new BLLCousrse();
foreach (var c in s.Split('\n'))
{
Models.Course mc = new Models.Course();
mc.CourseName = c;
mc.SchoolID = schoolid;
bc.Add(mc, false);
}
bc.Save();
return Content("T");
}
public async Task <IActionResult> Update(int id, Models.Course courseDb)
{
var course = await _context.Courses.Where(d => d.Id == id).FirstOrDefaultAsync();
if (course == null)
{
return(NotFound());
}
else
{
course.Id = courseDb.Id;
course.Name = courseDb.Name;
await _context.SaveChangesAsync();
return(Ok(course.Id));
}
}
public int SaveCourse(Models.Course course)
{
Qurey =
"INSERT INTO course VALUES(@courseCode, @courseName, @credit, @description, @departmentId, @semesterId)";
Command = new SqlCommand(Qurey, Connection);
Command.Parameters.AddWithValue("@courseCode", course.Code);
Command.Parameters.AddWithValue("@courseName", course.Name);
Command.Parameters.AddWithValue("@credit", course.Credit);
Command.Parameters.AddWithValue("@description", course.Description);
Command.Parameters.AddWithValue("@departmentId", course.DepartmentId);
Command.Parameters.AddWithValue("@semesterId", course.SemesterId);
Connection.Open();
RowAffected = Command.ExecuteNonQuery();
Connection.Close();
return(RowAffected);
}
public async Task <IActionResult> OnPostAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
Course = await _context.Courses.FindAsync(id);
if (Course != null)
{
_context.Courses.Remove(Course);
await _context.SaveChangesAsync();
}
return(RedirectToPage("./Index"));
}
public Models.Course UpdateCourseSubject(Guid id, Guid subjectId, string name, string shortName, int totalSections, int sectionPerWeek, bool isTeachingByHomeroomTeacher, bool isActive)
{
Models.Course course = this.GetById(id);
if (course == null)
{
throw new InvalidOperationException($"Course Subject ({id}) does not exist.");
}
course.SubjectId = subjectId;
course.TotalSection = totalSections;
course.SectionPerWeek = sectionPerWeek;
course.IsTeachingByHomeroomTeacher = isTeachingByHomeroomTeacher;
course.IsActive = isActive;
this.DataContext.Update <Models.Course, Guid>(course, x => x.TotalSection, x => x.SectionPerWeek, x => x.IsTeachingByHomeroomTeacher, x => x.IsActive);
return(course);
}
public ActionResult Create(CourseViewModel viewModel)
{
if (!ModelState.IsValid)
{
viewModel.Categories = _dbContext.Category.ToList();
return(View("Create", viewModel));
}
var course = new Models.Course
{
LecturerId = User.Identity.GetUserId(),
DateTime = viewModel.GetDateTime(),
CategoryId = viewModel.Category,
Place = viewModel.Place
};
_dbContext.Courses.Add(course);
_dbContext.SaveChanges();
return(RedirectToAction("Index", "Home"));
}
public void CreateDelete_Course()
{
// Arrange
CourseService service = new CourseService();
// Act
var course = new Models.Course();
course.Id = 5;
course.Number = "TEST1234";
course.Name = "Test Class!!!";
course.Active = true;
int id = service.Create(course);
var newcourse = service.Find(id);
// Assert
Assert.IsNotNull(newcourse);
// Assert
Assert.AreEqual(course, newcourse);
service.Remove(id);
var newcourse2 = service.Find(id);
// Assert
Assert.IsNull(newcourse2);
}
/// <summary>
/// 得到一个对象实体
/// </summary>
public Models.Course GetModel(Guid CourseId)
{
StringBuilder strSql=new StringBuilder();
strSql.Append("select top 1 CourseId,CourseName,TeacherId,TeacherName,TeachTime,TeachPlace,CreatTime,LastModifyTime, Type, Status, Description from Course ");
strSql.Append(" where CourseId=@CourseId ");
SqlParameter[] parameters = {
new SqlParameter("@CourseId", SqlDbType.UniqueIdentifier,16) };
parameters[0].Value = CourseId;
Models.Course model = new Models.Course();
DataSet ds=DbHelperSQL.Query(strSql.ToString(),parameters);
if(ds.Tables[0].Rows.Count>0)
{
return DataRowToModel(ds.Tables[0].Rows[0]);
}
else
{
return null;
}
}
public ActionResult Upload(HttpPostedFileBase file)
{
try
{
// Verify that the user selected a file
if (file != null && file.ContentLength > 0)
{
var serializer = new System.Xml.Serialization.XmlSerializer(typeof(DataModels.Course));
var data = serializer.Deserialize(file.InputStream) as DataModels.Course;
var course = new Models.Course();
course.ID = Guid.NewGuid();
course.Title = data.Title;
course.Description = data.Description;
course.Problems = new List<Models.Problem>();
foreach (var p in data.Problems)
{
var problem = new Models.Problem();
problem.ID = Guid.NewGuid();
problem.Identity = p.Identity;
problem.Description = p.Description;
problem.Choices = new List<Models.Choice>();
foreach (var c in p.Choices)
{
problem.Choices.Add(new Models.Choice()
{
ID = Guid.NewGuid(),
Identity = c.Identity,
Description = c.Description,
IsAnswer = c.IsAnswer
});
}
course.Problems.Add(problem);
}
this.Context.Courses.Add(course);
this.Context.SaveChanges();
}
return RedirectToAction("Index");
}
catch (System.Data.Entity.Validation.DbEntityValidationException dbEx)
{
return View();
}
catch (Exception ex)
{
this.ModelState.AddModelError(string.Empty, ex);
return View();
}
}
