public int AddCurriculum(Curriculum curriculum)
{
var db = this.GetDbContext();
curriculum.IsDeleted = false;
curriculum.IsValid = true;
db.Curriculums.InsertOnSubmit(curriculum);
db.SubmitChanges();
// add corresponding curriculum chapters
var chapters = this.GetChapters(curriculum.DisciplineRef);
foreach (var chapter in chapters)
{
var curriculumChapter = new CurriculumChapter
{
ChapterRef = chapter.Id,
CurriculumRef = curriculum.Id
};
this.AddCurriculumChapter(curriculumChapter);
}
return(curriculum.Id);
}
public ActionResult Index(int curriculumAssignmentId)
{
try
{
CurriculumAssignment curriculumAssignment = Storage.GetCurriculumAssignment(curriculumAssignmentId);
Curriculum curriculum = Storage.GetCurriculum(curriculumAssignment.CurriculumRef);
Group group = Storage.GetGroup(curriculumAssignment.UserGroupRef);
var timelines = Storage.GetStageTimelinesByCurriculumAssignmentId(curriculumAssignmentId)
.Select(item => new ViewStageTimelineModel
{
Id = item.Id,
StartDate = item.StartDate,
EndDate = item.EndDate,
StageName = Storage.GetStage((int)item.StageRef).Name
});
ViewData["Group"] = group;
ViewData["Curriculum"] = curriculum;
return(View(timelines));
}
catch (Exception e)
{
throw e;
}
}
static void Main(string[] args)
{
Student s01 = new Student("002");
Student s02 = new Student("001", "Rungrat", "Sriwirun");
s01.setFirstname("Anocha");
s01.setLastname("Prungtaeng");
Console.WriteLine(s01.ToString());
Console.WriteLine(s02.ToString());
Console.WriteLine((new Student("018", "Rene", "Smith")).ToString());
room r433 = new room("433", "433", 8, 8, "Computer");
Console.WriteLine(r433.ToString());
Console.WriteLine("_____________________________________________________________");
Building s05 = new Building("04", "Faculty of Computer Science and Information Technology", "13.7442", "100.4608");
Console.WriteLine(s05.ToString());
Console.WriteLine("_____________________________________________________________");
Subject s06 = new Subject("9022081", "Web Programming", 3, 2, 2);
Console.WriteLine(s06.ToString());
Console.WriteLine("_____________________________________________________________");
Lecturer s03 = new Lecturer("Nitat", "Ninchawee", "Master of Sience (Electronic Transactions)");
Console.WriteLine(s03.ToString());
Console.WriteLine("_____________________________________________________________");
Curriculum s04 = new Curriculum("Information Technology", "Bachelor");
Console.WriteLine(s04.ToString());
Console.WriteLine("_____________________________________________________________");
}
public JsonResult Create( CreateCurriculumModel model ) {
try {
var curriculum = new Curriculum();
curriculum.UpdateFromModel(model);
AddValidationErrorsToModelState(Validator.ValidateCurriculum(curriculum).Errors);
if (ModelState.IsValid) {
var id = Storage.AddCurriculum(curriculum);
var createdCurriculum = Storage.GetCurriculum(id);
return Json(new {
success = true,
curriculumRow = PartialViewAsString("CurriculumRow", new ViewCurriculumModel {
Id = createdCurriculum.Id,
GroupName = Storage.GetGroup(createdCurriculum.UserGroupRef) != null ? Storage.GetGroup(createdCurriculum.UserGroupRef).Name : string.Empty,
DisciplineName = Storage.GetDiscipline(createdCurriculum.DisciplineRef).Name,
StartDate = Converter.ToString(createdCurriculum.StartDate),
EndDate = Converter.ToString(createdCurriculum.EndDate),
IsValid = createdCurriculum.IsValid
})
});
}
model = curriculum.ToCreateCurriculumModel(Storage, true);
return Json(new {
success = false,
html = PartialViewAsString("Create", model)
});
} catch (Exception ex) {
return Json(new {success = false, html = ex.Message});
}
}
public ActionResult Create(int disciplineId, CreateCurriculumModel createAssignmentModel)
{
try
{
Curriculum curriculum = new Curriculum();
curriculum.UserGroupRef = createAssignmentModel.GroupId;
curriculum.DisciplineRef = disciplineId;
AddValidationErrorsToModelState(Validator.ValidateCurriculum(curriculum).Errors);
if (ModelState.IsValid)
{
Storage.AddCurriculum(curriculum);
return RedirectToAction("Index");
}
else
{
SaveValidationErrors();
return RedirectToAction("Create");
}
}
catch (Exception e)
{
throw e;
}
}
public ActionResult Create([Bind(Include = "ProfissionalID,Escolaridade,Foto1,Texto1")] Curriculum curriculum, HttpPostedFileBase foto)
{
ViewBag.FotoMensagem = "";
try
{
if (ModelState.IsValid)
{
string fileName = "";
string contentType = "";
string path = "";
if (foto != null && foto.ContentLength > 0)
{
fileName = System.IO.Path.GetFileName(foto.FileName);
contentType = foto.ContentType;
path = System.Configuration.ConfigurationManager.AppSettings["PathFiles"] + "\\Curriculum\\" + fileName;
foto.SaveAs(path);
curriculum.Foto1 = fileName;
}
db.Curriculum.Add(curriculum);
db.SaveChanges();
return(RedirectToAction("Index"));
}
}
catch (Exception ex)
{
ViewBag.FotoMensagem = "Não foi possível salvar a foto";
}
return(View(curriculum));
}
private void Save()
{
Boolean ret;
string message = String.Empty;
Curriculum c = new Curriculum();
if (chkCurrent.ToggleState == Telerik.WinControls.Enumerations.ToggleState.On)
{
c.CurrentCurr = true;
}
c.CurriculumCode = txtCurrCode.Text;
c.CurriculumSubjects = currSub1.ToArray();
c.Description = txtDescription.Text;
if (Op.Equals("edit"))
{
ret = cs.UpdateCurriculum(ref c, ref message);
}
else
{
ret = cs.CreateCurriculum(ref c, ref message);
}
if (ret)
{
MessageBox.Show(this, message, "Add Successful");
}
else
{
MessageBox.Show(this, message, "Add Failed");
}
}
public static void AreEqual(Curriculum actual, Curriculum expected)
{
Assert.AreEqual(expected.UserGroupRef, actual.UserGroupRef);
Assert.AreEqual(expected.Id, actual.Id);
Assert.AreEqual(expected.IsDeleted, actual.IsDeleted);
Assert.AreEqual(expected.DisciplineRef, actual.DisciplineRef);
}
private async Task <UniversityDbContext> PrepareDiplomas()
{
var diploma1 = new Diploma {
Id = DiplomaValidId, StudentId = StudentValidId, CurriculumId = CurriculumValidId
};
var diploma2 = new Diploma {
Id = DiplomaValidId2, StudentId = "2", CurriculumId = 2
};
var curriculum1 = new Curriculum {
Id = CurriculumValidId
};
var curriculum2 = new Curriculum {
Id = CurriculumInvalidId
};
var user1 = new User {
Id = StudentValidId
};
var user2 = new User {
Id = StudentInvalidId
};
var db = Tests.InitializeDatabase();
await db.Curriculums.AddRangeAsync(curriculum1, curriculum2);
await db.Diplomas.AddRangeAsync(diploma1, diploma2);
await db.Users.AddRangeAsync(user1, user2);
await db.SaveChangesAsync();
return(db);
}
public JsonResult Get(int page, int pageSize)
{
JsonResult result = new JsonResult();
Curriculum bll = new Curriculum();
var t = bll.FindByPage(page, pageSize);
return Json(t, JsonRequestBehavior.AllowGet);
}
public async Task <ActionResult> Save(Curriculum curriculum)
{
var userManager = new ApplicationUserManager(new UserStore <ApplicationUser>(new ApplicationDbContext()));
var user = await userManager.FindByNameAsync(User.Identity.Name);
var deptHead = user == null ? null : _context.Instructors.Include(i => i.Department).Single(i => i.AccountId == user.Id);
if (curriculum.Id == 0)
{
curriculum.DepartmentId = deptHead.DepartmentId;
_context.Curriculums.Add(curriculum);
}
else
{
var curriculumInDb = _context.Curriculums.SingleOrDefault(c => c.Id == curriculum.Id);
curriculumInDb.AdmissionClassification = curriculum.AdmissionClassification;
curriculumInDb.DepartmentId = curriculum.DepartmentId;
curriculumInDb.FieldOfStudy = curriculum.FieldOfStudy;
curriculumInDb.MinimumCredit = curriculum.MinimumCredit;
curriculumInDb.Program = curriculum.Program;
curriculumInDb.StaySemester = curriculum.StaySemester;
curriculumInDb.StayYear = curriculum.StayYear;
curriculumInDb.Nomenclature = curriculum.Nomenclature;
curriculumInDb.DepartmentId = deptHead.DepartmentId;
}
_context.SaveChanges();
return(RedirectToAction("Index", "Curriculums"));
}
public bool CreateCurriculum(ref Curriculum curriculum, ref string message)
{
CurriculumBDO cbdo = new CurriculumBDO();
TranslateCurriculumToCurriculumBDO(curriculum, cbdo);
return(clogic.CreateCurriculum(ref cbdo, ref message));
}
/// <summary>
/// Validates the curriculum.
/// </summary>
/// <param name="curriculum">The curriculum.</param>
/// <returns></returns>
public ValidationStatus ValidateCurriculum(Curriculum curriculum)
{
var validationStatus = new ValidationStatus();
var currentGroupId = -1;
// If update old curriculum
if (curriculum.Id > 0)
{
var oldCurriculum = this.Storage.GetCurriculum(curriculum.Id);
currentGroupId = oldCurriculum.UserGroupRef;
curriculum.DisciplineRef = oldCurriculum.DisciplineRef;
}
if (curriculum.UserGroupRef > 0 && curriculum.DisciplineRef > 0)
{
var curriculums = this.Storage.GetCurriculums(c => c.DisciplineRef == curriculum.DisciplineRef).ToList();
if (curriculums.Exists(item => item.UserGroupRef == curriculum.UserGroupRef) && curriculum.UserGroupRef != currentGroupId)
{
validationStatus.AddLocalizedError("ChooseAnotherGroupForThisCurriculum");
}
}
if (curriculum.UserGroupRef <= 0)
{
validationStatus.AddLocalizedError("ChooseGroup");
}
if (curriculum.DisciplineRef <= 0)
{
validationStatus.AddLocalizedError("ChooseDiscipline");
}
ValidateDate(curriculum.StartDate, curriculum.EndDate, validationStatus);
return(validationStatus);
}
private void TranslateCurriculumBDOToCurriculum(CurriculumBDO curriculum, Curriculum cbdo)
{
cbdo.CurrentCurr = curriculum.CurrentCurr;
cbdo.CurriculumCode = curriculum.CurriculumCode;
cbdo.Description = curriculum.Description;
cbdo.CurriculumSubjects = ToCurriculumSubjectList(curriculum.CurriculumSubjects);
}
private void TranslateCurriculumToCurriculumBDO(Curriculum curriculum, CurriculumBDO cbdo)
{
cbdo.CurrentCurr = curriculum.CurrentCurr;
cbdo.CurriculumCode = curriculum.CurriculumCode;
cbdo.Description = curriculum.Description;
cbdo.CurriculumSubjects = ToCurriculumSubjectBDOList(curriculum.CurriculumSubjects.ToList <CurriculumSubject>());
}
public bool UpdateCurriculum(ref Curriculum curriculum, ref string message)
{
CurriculumBDO cb = new CurriculumBDO();
TranslateCurriculumToCurriculumBDO(curriculum, cb);
return(clogic.UpdateCurriculum(ref cb, ref message));
}
public void DeleteCurriculum(int id)
{
Curriculum curriculum = GetCurriculum(id);
db.Curriculums.DeleteOnSubmit(curriculum);
db.SubmitChanges();
}
public int AddCurriculum(Curriculum curriculum)
{
var id = this.storage.AddCurriculum(curriculum);
this.cacheProvider.Invalidate("curriculums", "curriculum-" + id);
return(id);
}
/// <summary>
/// создать новый учебный план по подобию
/// </summary>
/// <param name="ind"> индекс по которому создается</param>
/// <param name="numberOfPairs"> сколько пар будет</param>
/// <returns></returns>
public Curriculum NewCurriculum(int ind, int numberOfPairs)
{
Curriculum newcul = Curricula[ind].Clone() as Curriculum;
newcul.Number = numberOfPairs;
return(newcul);
}
public ActionResult DeleteConfirmed(int id)
{
Curriculum curriculum = db.Curricula.Find(id);
db.Curricula.Remove(curriculum);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void ToggleVisibility(string sectionIsVisible, int curriculumId)
{
Curriculum curriculum = _context.Curriculum.FirstOrDefault(c => c.CurriculumId == curriculumId);
var propertyInfo = curriculum.GetType().GetProperty(sectionIsVisible);
propertyInfo.SetValue(curriculum, !(bool)propertyInfo.GetValue(curriculum));
_context.SaveChanges();
}
public static void AreEqual(Curriculum expected, Curriculum actual)
{
Assert.AreEqual(expected.Name, actual.Name);
Assert.AreEqual(expected.IsDeleted, actual.IsDeleted);
Assert.AreEqual(expected.Id, actual.Id);
Assert.AreEqual(expected.Created.ToString(), actual.Created.ToString());
Assert.AreEqual(expected.Updated.ToString(), actual.Updated.ToString());
}
public static Curriculum MapToEntity(this CurriculumDto dto)
{
var result = new Curriculum(dto.Code, dto.Course, dto.Class, dto.Discipline);
result.AddIdentity(dto.Id);
return(result);
}
// Currículo já cadastrado:
public async Task <bool> HasName(Curriculum obj, int userId)
{
if (await _context.Curriculums.Where(c => c.UserId == userId).AnyAsync(x => x.Name.ToUpper() == obj.Name.ToUpper()))
{
return(true);
}
return(false);
}
public void DelTest()
{
Archivio test = new Archivio();
Curriculum c = new Curriculum("Florin", "Gheliuc", 22, "Aaha11", "ddd", "Torino", "ddd");
c.IDCV = 4;
test.Del(c);
}
public static bool Delete(Curriculum curriculum)
{
using (_d = new DataRepository <Curriculum>())
{
_d.Delete(curriculum);
_d.SaveChanges();
}
return(true);
}
public CurriculaWithAmountPair(Curriculum curriculum)
{
Curricula = new Curriculum[] { curriculum };
NumberOfPair = curriculum.Number;
if (NumberOfPair > 0)
{
MaybeAdd = true;
}
}
public static CurriculumDto MapToDto(this Curriculum entity, int peopleId)
=> new CurriculumDto()
{
PeopleId = peopleId,
Class = entity.Class,
Code = entity.Code,
Course = entity.Course,
Discipline = entity.Discipline
};
public void ModificaTest()
{
Archivio test = new Archivio();
Curriculum c = new Curriculum("Florin", "Gheliuc", 22, "Aaha11", "ddd", "Torino", "ddd");
Curriculum s = new Curriculum("Fede", "Marracash", 22, "Aaha11", "ddd", "Torino", "ddd");
s.IDCV = 5;
test.Modifica(s, c);
}
public CurriculumDto CurriculumToDto(Curriculum curriculum)
{
UserDto userdto = UserMapper.UserToDto(curriculum.User);
CurriculumDto dto = new CurriculumDto {
Id = curriculum.Id, Experiencia = curriculum.Experiencia, Formacion = curriculum.Formacion, InfoAdicional = curriculum.InfoAdicional, UserDto = userdto
};
return(dto);
}
public static CreatedCurriculumCommandRequest MapToCommand(this CriarGradeModel model)
{
var entity = new Curriculum(model.CodGrade, model.Curso, model.Turma, model.Disciplina);
entity.AddEmployee(new Employee(model.CodFuncionario));
var result = new CreatedCurriculumCommandRequest(entity);
return(result);
}
public ActionResult Add()
{
var t = Request.QueryString["id"];
if (t != null)
{
ViewData["curriculum"] = new Curriculum().Find(int.Parse(t.ToString()));
}
return View();
}
public void SetSpLesson(string year, string lesson)
{
var challenge = Curriculum.GetChallengesForYear(year).FirstOrDefault(c => c.Lesson == lesson);
if (challenge != null)
{
GameObject.Find("LevelColliders/SpawnedObjects").GetComponent <CollectibleGeneration>().Setup(0, challenge);
}
}
public void UpdateCurriculum(Curriculum curriculum)
{
var oldCurriculum = GetCurriculum(curriculum.Id);
oldCurriculum.Name = curriculum.Name;
oldCurriculum.Updated = DateTime.Now;
_Db.SubmitChanges();
}
/// <summary>
/// Validates the curriculum.
/// </summary>
/// <param name="curriculum">The curriculum.</param>
/// <returns></returns>
public ValidationStatus ValidateCurriculum(Curriculum curriculum)
{
ValidationStatus validationStatus = new ValidationStatus();
if (curriculum.UserGroupRef <= 0)
{
validationStatus.AddLocalizedError("ChooseGroup");
}
ValidateDate(curriculum.StartDate, curriculum.EndDate, validationStatus);
return validationStatus;
}
public ActionResult GetModel()
{
if (Request["id"] != null)
{
ViewData["curriculum"] = new Curriculum().Find(int.Parse(Request["id"].ToString()));
}
else
{
ViewData["curriculum"] = null;
}
return View();
}
public ActionResult Detail()
{
var id = Request.QueryString["id"];
int pid = 0;
var i = int.TryParse(id, out pid);
if (!string.IsNullOrEmpty(id) && i)
{
var model = new Curriculum().Find(pid);
ViewBag.curriculumDetail = model;
//ViewData["vedioDetail"] = model;
}
return View();
}
private void gvCurriculum_SelectionChanged(object sender, EventArgs e)
{
int selectedIndex = gvCurriculum.CurrentRow.Index;
if (selectedIndex >= 0)
{
string cID = gvCurriculum.Rows[selectedIndex].Cells["CurriculumCode"].Value.ToString();
List<Curriculum> item = new List<Curriculum>();
item = currList.FindAll(x => x.CurriculumCode.ToString() == cID);
currSelected = new Curriculum();
currSelected = (Curriculum)item[0];
}
}
public ActionResult Create(CreateCurriculumModel model)
{
var curriculum = new Curriculum();
curriculum.UpdateFromModel(model);
AddValidationErrorsToModelState(Validator.ValidateCurriculum(curriculum).Errors);
if (ModelState.IsValid)
{
Storage.AddCurriculum(curriculum);
return RedirectToAction("Index");
}
model = curriculum.ToCreateCurriculumModel(Storage, true);
return View(model);
}
public ActionResult Create(Curriculum curriculum)
{
try
{
if (ModelState.IsValid)
{
Storage.AddCurriculum(curriculum);
return RedirectToAction("Index");
}
else
{
return View(curriculum);
}
}
catch (Exception e)
{
throw e;
}
}
private void Save()
{
Boolean ret;
string message = String.Empty;
Curriculum c = new Curriculum();
if (chkCurrent.ToggleState == Telerik.WinControls.Enumerations.ToggleState.On)
{
c.CurrentCurr = true;
}
c.CurriculumCode = txtCurrCode.Text;
c.CurriculumSubjects = currSub1.ToArray();
c.Description = txtDescription.Text;
if (Op.Equals("edit"))
ret = cs.UpdateCurriculum(ref c, ref message);
else
ret = cs.CreateCurriculum(ref c, ref message);
if (ret)
MessageBox.Show(this, message, "Add Successful");
else
MessageBox.Show(this, message, "Add Failed");
}
public ActionResult Create(int disciplineId, CreateCurriculumModel model)
{
var curriculum = new Curriculum()
{
UserGroupRef = model.GroupId,
DisciplineRef = disciplineId,
StartDate = model.SetDate ? model.StartDate : (DateTime?)null,
EndDate = model.SetDate ? model.EndDate : (DateTime?)null
};
AddValidationErrorsToModelState(Validator.ValidateCurriculum(curriculum).Errors);
if (ModelState.IsValid)
{
Storage.AddCurriculum(curriculum);
return RedirectToAction("Index");
}
else
{
SaveValidationErrors();
return RedirectToAction("Create");
}
}
public GradeSchool(SchoolClassDB schoolClassDB) : base(schoolClassDB){
curriculum = new Curriculum(this.GetType());
}
public int AddCurriculum(Curriculum curriculum)
{
var db = GetDbContext();
curriculum.IsDeleted = false;
curriculum.IsValid = true;
db.Curriculums.InsertOnSubmit(curriculum);
db.SubmitChanges();
//add corresponding TopicAssignments
var topicsInCurrentDiscipline = GetTopicsByDisciplineId(curriculum.DisciplineRef)
.Where(item => item.TopicTypeRef == (int)Enums.TopicType.Test ||
item.TopicTypeRef == (int)Enums.TopicType.TestWithoutCourse);
foreach (var topic in topicsInCurrentDiscipline)
{
TopicAssignment newTopicAssingment = new TopicAssignment()
{
CurriculumRef = curriculum.Id,
TopicRef = topic.Id,
MaxScore = Constants.DefaultTopicMaxScore
};
AddTopicAssignment(newTopicAssingment);
}
return curriculum.Id;
}
public void UpdateCurriculum(Curriculum curriculum)
{
var db = GetDbContext();
var oldCurriculum = GetCurriculum(db, curriculum.Id);
oldCurriculum.UserGroupRef = curriculum.UserGroupRef;
oldCurriculum.IsValid = true;
db.SubmitChanges();
}
public ActionResult Edit(int curriculumId, Curriculum curriculum)
{
try
{
curriculum.Id = curriculumId;
Storage.UpdateCurriculum(curriculum);
return RedirectToAction("Index");
}
catch (Exception e)
{
throw e;
}
}
public int AddCurriculum(Curriculum curriculum)
{
curriculum.Created = DateTime.Now;
curriculum.Updated = DateTime.Now;
curriculum.IsDeleted = false;
curriculum.IsValid = true;
curriculum.Owner = GetCurrentUser().Username;
_Db.Curriculums.InsertOnSubmit(curriculum);
_Db.SubmitChanges();
return curriculum.Id;
}
public void UpdateCurriculum(Curriculum curriculum)
{
var db = this.GetDbContext();
var oldCurriculum = GetCurriculum(db, curriculum.Id);
oldCurriculum.UserGroupRef = curriculum.UserGroupRef;
oldCurriculum.StartDate = curriculum.StartDate;
oldCurriculum.EndDate = curriculum.EndDate;
db.SubmitChanges();
oldCurriculum.IsValid = this.IsCurriculumValid(curriculum);
db.SubmitChanges();
}
public ActionResult Create()
{
var model = new Curriculum().ToCreateCurriculumModel(Storage, true);
return View(model);
}
public int AddCurriculum(Curriculum curriculum)
{
var db = this.GetDbContext();
curriculum.IsDeleted = false;
curriculum.IsValid = true;
db.Curriculums.InsertOnSubmit(curriculum);
db.SubmitChanges();
// add corresponding curriculum chapters
var chapters = this.GetChapters(curriculum.DisciplineRef);
foreach (var chapter in chapters)
{
var curriculumChapter = new CurriculumChapter
{
ChapterRef = chapter.Id,
CurriculumRef = curriculum.Id
};
this.AddCurriculumChapter(curriculumChapter);
}
return curriculum.Id;
}
private bool IsCurriculumValid(Curriculum curriculum)
{
if (this.GetGroup(curriculum.UserGroupRef) == null)
{
return false;
}
if (!this.GetDiscipline(curriculum.DisciplineRef).IsValid)
{
return false;
}
var curriculumChapters = this.GetCurriculumChapters(item => item.CurriculumRef == curriculum.Id);
foreach (var curriculumChapter in curriculumChapters)
{
if (curriculumChapter.StartDate < curriculum.StartDate || curriculumChapter.EndDate > curriculum.EndDate)
{
return false;
}
var curriculumChapterTopics = this.GetCurriculumChapterTopics(item => item.CurriculumChapterRef == curriculumChapter.Id);
foreach (var curriculumChapterTopic in curriculumChapterTopics)
{
if (curriculumChapter.StartDate > curriculumChapterTopic.TestStartDate
|| curriculumChapter.StartDate > curriculumChapterTopic.TheoryStartDate
|| curriculumChapter.EndDate < curriculumChapterTopic.TheoryEndDate
|| curriculumChapter.EndDate < curriculumChapterTopic.TestEndDate)
{
return false;
}
}
foreach (var curriculumChapterTopic in curriculumChapterTopics)
{
if (curriculum.StartDate > curriculumChapterTopic.TestStartDate
|| curriculum.StartDate > curriculumChapterTopic.TheoryStartDate
|| curriculum.EndDate < curriculumChapterTopic.TheoryEndDate
|| curriculum.EndDate < curriculumChapterTopic.TestEndDate)
{
return false;
}
}
}
return true;
}
public void UpdateCurriculum(Curriculum curriculum)
{
var oldCurriculum = GetCurriculum(curriculum.Id);
oldCurriculum.Name = curriculum.Name;
oldCurriculum.Updated = DateTime.Now;
_Db.SubmitChanges();
}
private void MakeSearch(SearchModel model)
{
string query = model.SearchText + "~";
DateTime datastart = DateTime.Now;
Directory directory = FSDirectory.Open(new System.IO.DirectoryInfo(Server.MapPath("~/Data/Index")));
IndexSearcher searcher = new IndexSearcher(directory, true);
Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_29);
List<string> strings = new List<string>();
foreach (var checkBox in model.CheckBoxes)
{
if (checkBox.IsChecked)
{
if (checkBox.SearchType == SearchType.Courses)
{
//make filtration here...
strings.Add("Name");
strings.Add("Content");
}
if (checkBox.SearchType == SearchType.Themes)
{
//make filtration here...
strings.Add("Theme");
}
if (checkBox.SearchType == SearchType.Users)
{
//make filtration here...
strings.Add("User");
}
if (checkBox.SearchType == SearchType.Curriculums)
{
//make filtration here...
strings.Add("Curriculum");
}
//make filtration here...
}
}
MultiFieldQueryParser queryParser = new MultiFieldQueryParser(
Version.LUCENE_29,
strings.ToArray(),
//new String[] { "Name", "Content", "Curriculum", "User", "Group", "Theme" },
analyzer
);
ScoreDoc[] scoreDocs = searcher.Search(queryParser.Parse(query), 100).scoreDocs;
Hits hit = searcher.Search(queryParser.Parse(query));
int total = hit.Length();
List<Curriculum> curriculums123 = _CurriculmService.GetCurriculums(_UserService.GetCurrentUser()).ToList();
List<Course> courses123 = _CourseService.GetCourses(_UserService.GetCurrentUser()).ToList();
List<ThemeDescription> themes123 = _CurriculmService.GetThemesAvailableForUser(_UserService.GetCurrentUser()).ToList();
//List<Curriculum> themes123 = _CurriculmService.GetCurriculumsWithThemesOwnedByUser(_UserService.GetCurrentUser()).ToList();
//foreach(Curriculum curr in curriculums123){
// themes123.InsertRange(themes123.Count - 1, _CurriculmService.GetThemesByCurriculumId(curr.Id));
//}
List<ISearchResult> results = new List<ISearchResult>();
Stopwatch sw = new Stopwatch();
sw.Start();
foreach (ScoreDoc doc in scoreDocs)
{
ISearchResult result;
Document document = searcher.Doc(doc.doc);
String type = document.Get("Type").ToLower();
switch (type)
{
case "node":
Node node = new Node();
node.Id = Convert.ToInt32(document.Get("NodeID"));
node.Name = document.Get("Name");
node.CourseId = Convert.ToInt32(document.Get("NodeCourseID"));
node.IsFolder = Convert.ToBoolean(document.Get("isFolder"));
result = new NodeResult(node, _CourseService.GetCourse(node.CourseId).Name, document.Get("Content"), _CourseService.GetCourse(node.CourseId).Updated.ToString());
results.Add(result);
break;
case "course":
Course course = new Course();
course.Id = Convert.ToInt32(document.Get("CourseID"));
course.Name = document.Get("Name");
foreach (Course cour in courses123)
{
if (cour.Id == course.Id)
{
result = new CourseResult(course, _CourseService.GetCourse(course.Id).Updated.ToString(), _CourseService.GetCourse(course.Id).Owner);
results.Add(result);
break;
}
}
break;
case "curriculum":
Curriculum curriculum = new Curriculum();
curriculum.Id = Convert.ToInt32(document.Get("CurriculumID"));
curriculum.Name = document.Get("Curriculum");
curriculum.Owner = document.Get("Owner");
string str = _CurriculmService.GetCurriculum(curriculum.Id).Owner;
foreach (Curriculum curr in curriculums123)
{
if (curr.Owner.Equals(curriculum.Owner))
{
result = new CurriculumResult(curriculum, _CurriculmService.GetCurriculum(curriculum.Id).Updated.ToString());
results.Add(result);
break;
}
}
break;
case "user":
User user = new User();
user.Id = Guid.Parse(document.Get("UserID"));
user.Name = document.Get("User");
//user.Roles
/*user.RoleId = Convert.ToInt32(document.Get("RoleId"));*/
result = new UserResult(user);
results.Add(result);
break;
case "group":
Group group = new Group();
group.Id = int.Parse(document.Get("GroupID"));
group.Name = document.Get("Group");
result = new GroupResult(group);
results.Add(result);
break;
case "theme":
Theme theme = new Theme();
theme.Id = Convert.ToInt32(document.Get("ThemeID"));
theme.Name = document.Get("Theme");
if (document.Get("CourseRef") == "null")
{
theme.CourseRef = null;
}
else
{
theme.CourseRef = Convert.ToInt32(document.Get("CourseRef"));
}
foreach (ThemeDescription themdesc in themes123)
{
if (themdesc.Theme.Id == theme.Id)
{
result = new ThemeResult(theme, _CourseService.GetCourse(theme.CourseRef.Value).Name);
results.Add(result);
break;
}
}
break;
default:
throw new Exception("Unknown result type");
}
}
sw.Stop();
DateTime dataend = DateTime.Now;
analyzer.Close();
searcher.Close();
directory.Close();
//ViewData["SearchString"] = query;
//ViewData["score"] = Math.Abs(dataend.Millisecond - datastart.Millisecond); //sw.ElapsedMilliseconds.ToString();
//ViewData["total"] = total;
model.SearchResult = results;
model.Total = total;
model.Score = Math.Abs(dataend.Millisecond - datastart.Millisecond);
}
public int AddCurriculum(Curriculum curriculum)
{
var db = GetDbContext();
curriculum.Created = DateTime.Now;
curriculum.Updated = DateTime.Now;
curriculum.IsDeleted = false;
curriculum.IsValid = true;
curriculum.Owner = GetCurrentUser().Username;
db.Curriculums.InsertOnSubmit(curriculum);
db.SubmitChanges();
_LmsService.Inform(CurriculumNotifications.CurriculumCreate, curriculum);
return curriculum.Id;
}
public ActionResult Index()
{
var list = new Curriculum().FindByPage(1, 20);
ViewBag.curriculumlist = list;
return View();
}
public ActionResult UpdateList(string models)
{
sd_curriculum model = new sd_curriculum();
List<sd_curriculum> list = new List<sd_curriculum>();
if (models != null)
{
try
{
list = JsonConvert.DeserializeObject<List<sd_curriculum>>(models);
foreach (sd_curriculum item in list)
{
var t = new Curriculum().Update(item);
}
return Json(true);
}
catch (Exception ex)
{
return Json(false);
}
}
return Json(list);
}
public ActionResult Update(string models)
{
sd_curriculum model = new sd_curriculum();
List<sd_curriculum> list = new List<sd_curriculum>();
if (models != null)
{
model = JsonConvert.DeserializeObject<sd_curriculum>(models);
var t = new Curriculum().Update(model);
}
return Json(list);
}
public void UpdateCurriculum(Curriculum curriculum)
{
var db = GetDbContext();
var oldCurriculum = GetCurriculum(db, curriculum.Id);
oldCurriculum.Name = curriculum.Name;
oldCurriculum.Updated = DateTime.Now;
db.SubmitChanges();
}
public ActionResult Edit(int curriculumId, CreateCurriculumModel editAssignmentModel)
{
try
{
Curriculum curriculum = new Curriculum();
curriculum.UserGroupRef = editAssignmentModel.GroupId;
curriculum.Id = curriculumId;
AddValidationErrorsToModelState(Validator.ValidateCurriculum(curriculum).Errors);
if (ModelState.IsValid)
{
Storage.UpdateCurriculum(curriculum);
return RedirectToRoute("Curriculums", new { action = "Index", DisciplineId = Session["DisciplineId"] });
}
else
{
SaveValidationErrors();
return RedirectToAction("Create");
}
}
catch (Exception e)
{
throw e;
}
}
public void UpdateCurriculum(Curriculum curriculum)
{
var db = GetDbContext();
var oldCurriculum = GetCurriculum(db, curriculum.Id);
var newCurriculum = GetCurriculum(db, curriculum.Id);
newCurriculum.Name = curriculum.Name;
newCurriculum.Updated = DateTime.Now;
db.SubmitChanges();
object[] data = new object[2];
data[0] = oldCurriculum;
data[1] = newCurriculum;
_LmsService.Inform(CurriculumNotifications.CurriculumEdit, data);
}
