public async Task <ActionResult> EditSubject(SubjectViewModel subject)
{
string currentUserId = System.Web.HttpContext.Current.User.Identity.GetUserId();
if (currentUserId == null)
{
return(new HttpUnauthorizedResult());
}
if (ModelState.IsValid)
{
SubjectDTO subjectDTO = new SubjectDTO
{
SubjectId = subject.Id,
SubjectName = subject.Name,
Description = subject.Description,
IsApproved = subject.IsApproved
};
OperationDetails operationDetails = await SubjectService.UpdateAsync(subjectDTO, currentUserId);
if (operationDetails.Succedeed)
{
return(PartialView("Report", operationDetails));
}
else
{
ModelState.AddModelError(operationDetails.Property, operationDetails.Message);
return(PartialView("Report", operationDetails));
}
}
ViewBag.Message = "Non valid";
return(PartialView("~/Views/Admin/Subject/EditSubject.cshtml", subject));
}
public async Task <ActionResult <SubjectViewModel> > Create(SubjectViewModel subjectView)
{
try
{
if (ModelState.IsValid)
{
//var subject = _mapper.Map<Subject>(subjectView);
var subject = _mapper.Map <SubjectViewModel, Subject>(subjectView);
var result = await _context.Subjects.AddAsync(subject);
var save = await _context.SaveChangesAsync();
// var subject = _mapper.Map<SubjectViewModel, Subject>(subjectView);
//var save = _manager.Create(subject);
return(RedirectToAction("Index"));
//if (save != null)
//{
// return RedirectToAction("Index");
//}
}
return(View());
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public SubjectView()
{
InitializeComponent();
var vm = new SubjectViewModel();
this.DataContext = vm;
}
public async Task <IActionResult> EditSubject(SubjectViewModel model)
{
if (ModelState.IsValid)
{
var subj = await db.Subjects.FirstOrDefaultAsync(s => s.SubjectId != model.Id && s.SubjectName == model.Name && s.NeedVisits == model.NeedVisits);
if (subj == null)
{
Subject subject = await db.Subjects.FirstOrDefaultAsync(s => s.SubjectId == model.Id);
if (subject != null)
{
subject.SubjectName = model.Name;
subject.NeedVisits = model.NeedVisits;
db.Subjects.Update(subject);
await db.SaveChangesAsync();
return(RedirectToAction("Subjects"));
}
ModelState.AddModelError("", "Предмета не существует");
}
else
{
ModelState.AddModelError("", "Такая дисциплина уже есть");
}
}
return(View("Edit/Subject", model));
}
private void AddNew(object sender, EventArgs e)
{
if (Pivot.SelectedItem == TermsTab)
{
var term = new TermViewModel();
set.Terms.Add(term);
Dispatcher.BeginInvoke(delegate {
Debug.Assert(TermList.ItemContainerGenerator != null, "TermList.ItemContainerGenerator != null");
var container = TermList.ItemContainerGenerator.ContainerFromItem(term) as FrameworkElement;
FocusTextBox(container);
});
}
else if (Pivot.SelectedItem == SubjectsTab)
{
var subject = new SubjectViewModel();
set.Subjects.Insert(0, subject);
Dispatcher.BeginInvoke(delegate {
Debug.Assert(SubjectList.ItemContainerGenerator != null, "SubjectList.ItemContainerGenerator != null");
var container = SubjectList.ItemContainerGenerator.ContainerFromItem(subject) as FrameworkElement;
FocusTextBox(container);
});
}
}
public void EditSubject(int?Id, [FromBody] SubjectViewModel subject)
{
if ((Id != null) & (subject != null))
{
subjectService.UpdateSubject(Map(subject));
}
}
public async Task <IActionResult> CreateSubject(SubjectViewModel model)
{
if (ModelState.IsValid)
{
//Есть ли уже такой предмет
var subj = await db.Subjects.FirstOrDefaultAsync(s => s.SubjectName == model.Name && s.NeedVisits == model.NeedVisits);
if (subj == null)
{
Subject subject = new Subject
{
SubjectId = db.NextSequence("SEQ_Subjects"),
SubjectName = model.Name,
NeedVisits = model.NeedVisits
};
db.Subjects.Add(subject);
await db.SaveChangesAsync();
return(RedirectToAction("Subjects"));
}
else
{
ModelState.AddModelError("", "Такая дисциплина уже есть");
}
}
return(View("Create/Subject", model));
}
public ActionResult Subject(int?id)
{
if (!id.HasValue)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var subject = this.context.Subjects.Find(id.Value);
if (subject == null)
{
return(this.HttpNotFound());
}
var @class = subject.Class;
var classType = @class?.ClassType;
var students = @class?.Students?.ToList() ?? new List <Student>();
var viewModel = new SubjectViewModel()
{
SubjectId = subject.Id,
SubjectTypeId = subject.SubjectType.Id,
SubjectName = subject.Name,
ClassName = classType?.Name ?? "None",
Hours = subject.SchedulePositions != null && subject.SchedulePositions.Any() ? subject.SchedulePositions.Select(x => $"{x.Time} ({x.Duration}min)") : new[] { "None" },
Students = students.ToList().Select(x => new StudentListItemViewModel(x)).OrderBy(x => x.Name)
};
return(this.View(viewModel));
}
public async Task <ActionResult> Create(SubjectViewModel subject, string StudyPCodeStr)
{
if (!ModelState.IsValid)
{
return(new HttpStatusCodeResult(System.Net.HttpStatusCode.BadRequest, "FullError"));
}
//Valid Subjec's code
bool exitCode = this._serviceSubject.ExitCode(subject.Code);
if (exitCode)
{
return(new HttpStatusCodeResult(System.Net.HttpStatusCode.BadRequest, "CodeExit"));
}
//Create Subject
var subjectToSave = subject.GenericConvert <domain.Subject>();
subjectToSave.StudyPlanFK = StudyPCodeStr;
subjectToSave.Created = DateTime.Now;
subjectToSave.Status = Helpers.Status.Active;
_serviceSubject.Add(subjectToSave);
var listOfSubjects = await _serviceSubject.GetAllSubjectByStudyPlanAsync(StudyPCodeStr);
Message msg = new Message()
{
Code = 1,
Messages = "Ok",
list = listOfSubjects.GenericConvertList <vm.SubjectViewModel>()
};
return(Json(ToJSON <Message>(msg), JsonRequestBehavior.AllowGet));
}
public static void Save(SubjectViewModel subject)
{
using (SqlConnection connection = new SqlConnection(Settings.Default.SQLConnection))
{
connection.Open();
string query = "";
if (subject.Id == 0)
{
query = "INSERT INTO [Subject]([Year], [Order], Name, Coefficient, [Option], ParentSubjectId)"
+ $" VALUES({subject.Year}, {subject.Order}, '{subject.Name}', {subject.Coefficient.ToString().Replace(',', '.')},"
+ $" {(subject.Option ? 1 : 0)}, {(subject.ParentSubject != null ? subject.ParentSubject.Id.ToString() : "NULL")})";
}
else
{
query = $"UPDATE [Subject] SET Name = '{subject.Name}', [Order] = {subject.Order}, Coefficient = {subject.Coefficient.ToString().Replace(',', '.')},"
+ $" [Option] = {(subject.Option ? 1 : 0)}, ParentSubjectId = {(subject.ParentSubject != null ? subject.ParentSubject.Id.ToString() : "NULL")}"
+ $" WHERE [Subject].Id = {subject.Id} AND [Subject].[Year] = {subject.Year}";
}
using (SqlCommand command = new SqlCommand(query, connection))
{
command.ExecuteNonQuery();
}
}
}
public static IEnumerable <SubjectViewModel> ReadChildren(int year, IEnumerable <SubjectViewModel> parentsSubjects)
{
List <SubjectViewModel> subjects = new List <SubjectViewModel>(parentsSubjects);
using (SqlConnection connection = new SqlConnection(Settings.Default.SQLConnection))
{
connection.Open();
using (SqlCommand command = new SqlCommand($"SELECT * FROM [Subject] WHERE Year = {year} AND ParentSubjectId IS NOT NULL ORDER BY [Order] DESC", connection))
{
using (SqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
SubjectViewModel parentSubject = parentsSubjects.FirstOrDefault(s => s.Id == (int)reader["ParentSubjectId"]);
SubjectViewModel subject = new SubjectViewModel()
{
Year = (int)reader["Year"],
Id = (int)reader["Id"],
Order = (int)reader["Order"],
Name = (string)reader["Name"],
Coefficient = (double)(decimal)reader["Coefficient"],
Option = (bool)reader["Option"],
ParentSubject = parentSubject,
};
subjects.Insert(subjects.IndexOf(parentSubject) + 1, subject);
parentSubject.ChildrenSubjects.Add(subject);
}
}
}
}
return(subjects);
}
public async Task <JsonResult> AddSubjectJSON(SubjectViewModel subject)
{
try
{
var subjectDto = new SubjectDTO
{
Id = subject.Id,
Name = subject.Name,
};
if (subject.Id > 0)
{
await subjectService.EditSubjectTask(subjectDto);
}
else
{
await subjectService.AddSubjectTask(subjectDto);
}
return(Json(new { success = true, data = subject }, JsonRequestBehavior.AllowGet));
}
catch (ValidationException ex)
{
ModelState.AddModelError(ex.Property, ex.Message);
return(Json(new { success = false, errorstring = ex.Message }, JsonRequestBehavior.AllowGet));
}
}
// Delete a subject.
public async Task <ActionResult> DeleteSubject(int?id)
{
// Check id.
if (!int.TryParse(id.ToString(), out int intId))
{
return(RedirectToAction("Index"));
}
// Get SubjectDTO.
SubjectDTO source = await SubjectService.GetAsync(intId);
if (source == null)
{
return(RedirectToAction("Index"));
}
// AutoMapper Setup.
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <SubjectDTO, SubjectViewModel>()
.ForMember("Id", opt => opt.MapFrom(obj => obj.SubjectId))
.ForMember("Name", opt => opt.MapFrom(obj => obj.SubjectName));
});
IMapper iMapper = config.CreateMapper();
SubjectViewModel subject = iMapper.Map <SubjectDTO, SubjectViewModel>(source);
return(PartialView("~/Views/Admin/Subject/DeleteSubject.cshtml", subject));
}
public async Task <IActionResult> Delete(int id, bool?saveChangesError = false)
{
var subject = await this.subjectService.Delete(id);
var teacher = await this.userService.GetUserById(subject.TeacherId);
if (subject == null)
{
return(NotFound());
}
var subjectToDelete = new SubjectViewModel()
{
Id = subject.Id,
Name = subject.Name,
//TeacherFullName = $"{teacher.Title} {teacher.FirstName} {teacher.LastName}",
};
if (saveChangesError.GetValueOrDefault())
{
ViewData["ErrorMessage"] =
"Delete failed. Try again, and if the problem persists " +
"see your system administrator.";
}
return(View(subjectToDelete));
}
private void ReloadSubjects()
{
this.homeworkFilter = this.NoFilterSubject;
List<SubjectViewModel> subjects = timetable.Subjects.Select(p => new SubjectViewModel(p)).ToList();
subjects.Insert(0, NoFilterSubject);
this.Subjects = new ReadOnlyCollection<SubjectViewModel>(subjects);
}
public Result <bool> InsertSubject(SubjectViewModel model)
{
var result = new Result <bool>();
try
{
var SubjectCheck = (from s in _context.Subjects where s.Name == model.SubjectName select s).ToList();
if (SubjectCheck.Count == 0)
{
Subject Sub = new Subject();
Sub.Name = model.SubjectName;
Sub.Status = true;
_context.Subjects.Add(Sub);
_context.SaveChanges();
result.Message = "Subject Added Succcessfully";
result.Data = true;
result.ResultType = ResultType.Success;
}
else
{
result.Message = "Subject name already exist";
result.Data = false;
result.ResultType = ResultType.Duplicate;
}
}
catch (Exception e)
{
result.Data = false;
result.ResultType = ResultType.Exception;
result.Exception = e;
result.Message = e.Message;
}
return(result);
}
public static void ReadSubjectTeachers(ObservableCollection <SubjectViewModel> subjects, ObservableCollection <TeacherViewModel> teachers, int year)
{
using (SqlConnection connection = new SqlConnection(Settings.Default.SQLConnection))
{
connection.Open();
using (SqlCommand command = new SqlCommand($"SELECT * FROM [SubjectTeacher] WHERE Year = {year}", connection))
{
using (SqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
int idSubject = (int)reader["IdSubject"];
SubjectViewModel subject = subjects.FirstOrDefault(s => s.Id == idSubject);
if (subject != null)
{
int idTeacher = (int)reader["IdTeacher"];
TeacherViewModel teacher = teachers.FirstOrDefault(t => t.Id == idTeacher);
if (teacher != null)
{
subject.Teachers.Add(teacher);
teacher.Subjects.Add(subject);
}
}
}
}
}
}
}
public IHttpActionResult Create(SubjectViewModel subject)
{
if (Framework.SubjectManager.SubjectIsAlreadyExist(subject.ShortName, subject.LongName))
{
return(BadRequest());
}
if (!User.IsInRole("Filler"))
{
return(BadRequest());
}
var group = Framework.GroupManager.GetById(subject.GroupId);
var result = group.Subjects.Any(s => (s.ShortName == subject.ShortName) || (s.LongName == subject.LongName));
if (result)
{
return(BadRequest());
}
Subject model = Mapper.Map <Subject>(subject);
model.Id = Guid.NewGuid().ToString();
model.FacultyId = user.User.FacultyId;
Framework.SubjectManager.Create(model);
return(Ok(model));
}
public ActionResult InactiveSubject(SubjectViewModel ViewModel, int id)
{
checkLogin();
ViewModel.TermList = CP.termSelectList;
ViewModel.SubjectList = Session["subjectSelectList"] != null?
(SelectList)Session["subjectSelectList"]:
SubjectService.GetSelectList(ViewModel.SelectedTerm);
if (id > 0)
{
ViewModel.InactiveSubjectsList.Add(id);
}
ViewModel.SubjectAndSSubjects.Remove(ViewModel.SubjectAndSSubjects.Where(s => s.MainSubject.ID == id).FirstOrDefault());
ViewModel.SubjectList = SubjectService.GetSelectList(ViewModel.SubjectAndSSubjects);
Session["subjectSelectList"] = ViewModel.SubjectList;
if (ViewModel.SelectedSubject == id)
{
ViewModel.SelectedSubject = 0;
}
ModelState.Clear();
TempData["showForm"] = true;
return(View("Subject", ViewModel));
}
public ActionResult InactiveSSubject(SubjectViewModel ViewModel, int id)
{
checkLogin();
ViewModel.TermList = CP.termSelectList;
ViewModel.SubjectList = Session["subjectSelectList"] != null ?
(SelectList)Session["subjectSelectList"] :
SubjectService.GetSelectList(ViewModel.SelectedTerm);
//deduct marks of the delete sub-subject from its main subject
ViewModel.SubjectAndSSubjects.Where(s => s.SSubjects.Exists(ss => ss.ID == id)).First().MainSubject.FULL_MARK -= ViewModel.SubjectAndSSubjects.Where(s => s.SSubjects.Exists(ss => ss.ID == id)).First().SSubjects.Where(ssb => ssb.ID == id).First().FULL_MARK;
if (id > 0)
{
ViewModel.InactiveSSubjectsList.Add(id);
}
ViewModel.SubjectAndSSubjects.ForEach(s => s.SSubjects.RemoveAll(ss => ss.ID == id));
//int totalMark = 0;
//int target_main_subject_id = ViewModel.SubjectAndSSubjects.Where(s => s.SSubjects.Exists(ss => ss.ID == id)).FirstOrDefault().MainSubject.ID;
//ViewModel.SubjectAndSSubjects.FindAll(s => s.MainSubject.ID == target_main_subject_id).FirstOrDefault().SSubjects.ForEach(s => totalMark += s.FULL_MARK);
//ViewModel.SubjectAndSSubjects.FindAll(s => s.MainSubject.ID == target_main_subject_id).FirstOrDefault().MainSubject.FULL_MARK = totalMark;
ModelState.Clear();
TempData["showForm"] = true;
return(View("Subject", ViewModel));
}
public IHttpActionResult UpdateTeacherSubject([FromBody] SubjectViewModel vm)
{
var subject = _unitOfWork.Subjects.UpdateSubjectTeachers(vm.SubjectId, vm.TeacherId);
_unitOfWork.Complete();
return(Ok(subject));
}
public ActionResult SaveSubject(SubjectViewModel subject)
{
try
{
if (subject.SubjectId > 0)
{
var s = _unitOfWork.SubjectRepository.GetByID(subject.SubjectId);
s.Name = subject.SubjectName;
}
else
{
string userId = _accountService.GetCurrentUserId();
_unitOfWork.SubjectRepository.Insert(new Subject
{
ID = -1,
Name = subject.SubjectName,
Teacher_ID = userId
});
}
_unitOfWork.Save();
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
catch (SqlException)
{
return(new HttpStatusCodeResult(HttpStatusCode.NotFound));
}
}
public async Task <IActionResult> Subject(int page = 1, SortState sortOrder = SortState.NameAsc)
{
int pageSize = 10;
ViewData["Message"] = "Subjects";
ViewData["NameSort"] = sortOrder == SortState.NameAsc ? SortState.NameDesc : SortState.NameAsc;
ViewData["TeacherSort"] = sortOrder == SortState.TeacherAsc ? SortState.TeacherDesc : SortState.TeacherAsc;
ViewData["DescriptionSort"] = sortOrder == SortState.DescriptionAsc ? SortState.DescriptionDesc : SortState.DescriptionAsc;
var Subjects = _service.GetSubjects(sortOrder);
var count = await Subjects.CountAsync();
var items = await Subjects.Skip((page - 1) *pageSize).Take(pageSize).ToListAsync();
PageViewModel pageViewModel = new PageViewModel(count, page, pageSize);
SubjectViewModel viewModel = new SubjectViewModel
{
PageViewModel = pageViewModel,
subjects = items
};
return(View(viewModel));
}
public void SubjectViewModel_SerialiseAndDeserialise()
{
var original = new SubjectViewModel(
Guid.NewGuid(),
"Name",
"Content",
new TimePeriodLabels
{
From = "2020",
To = "2022"
},
new List <string>
{
"level1"
},
new FileInfo {
Created = DateTime.Now,
Id = Guid.NewGuid(),
Name = "Name",
Size = "1234",
Summary = "Summary",
Type = FileType.Ancillary,
FileName = "Filename",
UserName = "******"
});
var converted = DeserializeObject <SubjectViewModel>(SerializeObject(original));
converted.AssertDeepEqualTo(original);
}
public ActionResult CreateSubject(SubjectViewModel subjectVM)
{
if (ModelState.IsValid)
{
Validate validate = new Validate();
if (!(validate.ValidationSubjectName(subjectVM.Name)))
{
ViewBag.message = "Неправильна назва предмету";
return(View("Report"));
}
SubjectDTO subjectDTO1 = subjectService.Get().Where(s => s.Name == subjectVM.Name).FirstOrDefault();
if (subjectDTO1 != null)
{
ViewBag.message = "Предмет з такою назвою вже існує";
return(View("Report"));
}
var mapper = new MapperConfiguration(cfg => cfg.CreateMap <SubjectViewModel, SubjectDTO>()).CreateMapper();
SubjectDTO subjectDTO = mapper.Map <SubjectViewModel, SubjectDTO>(subjectVM);
subjectService.AddSubject(subjectDTO);
ViewBag.message = "Предмет додано";
return(View("Report"));
}
return(View(subjectVM));
}
public ActionResult Create(SubjectViewModel model)
{
try
{
if (ModelState.IsValid)
{
Business.SubjectBusiness subject = new Business.SubjectBusiness();
Domain.Subject newSubject = new Domain.Subject
{
Name = model.Name,
year = model.Year,
};
subject.Save(newSubject);
}
else
{
foreach (var item in ModelState.AsQueryable().ToList())
{
if (item.Value.Errors.Count > 0)
{
ModelState.AddModelError("Error", item.Value.Errors.First().ErrorMessage + string.Empty);
}
}
}
return(RedirectToAction("Index", model));
}
catch (Exception ex)
{
//Code to save the customer data here
ViewData["error"] = ex.Message;
return(RedirectToAction("Index", model));
}
}
public Result <bool> UpdateSubject(SubjectViewModel model)
{
var result = new Result <bool>();
try
{
var SubjectCheck = (from s in _context.Subjects where s.Name == model.SubjectName select s).ToList();
if (SubjectCheck.Count == 0)
{
var obj = (from s in _context.Subjects where s.Id == model.SubjectId select s).FirstOrDefault();
obj.Name = model.SubjectName;
_context.SaveChanges();
result.Message = "Record updated Succcessfully";
result.Data = true;
result.ResultType = ResultType.Success;
}
else
{
result.Message = "Subject name already exist";
result.Data = false;
result.ResultType = ResultType.Duplicate;
}
}
catch (Exception e)
{
result.Data = false;
result.ResultType = ResultType.Exception;
result.Exception = e;
result.Message = "Record not update";
}
return(result);
}
public static void ReadLevelSubjects(ObservableCollection <LevelViewModel> levels, ObservableCollection <SubjectViewModel> subjects, int year)
{
using (SqlConnection connection = new SqlConnection(Settings.Default.SQLConnection))
{
connection.Open();
using (SqlCommand command = new SqlCommand($"SELECT * FROM [LevelSubject] WHERE Year = {year}", connection))
{
using (SqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
int idLevel = (int)reader["IdLevel"];
LevelViewModel level = levels.FirstOrDefault(l => l.Id == idLevel);
if (level != null)
{
int idSubject = (int)reader["IdSubject"];
SubjectViewModel subject = subjects.FirstOrDefault(s => s.Id == idSubject);
if (subject != null)
{
level.Subjects.Add(subject);
subject.Levels.Add(level);
}
}
}
}
}
}
}
public ActionResult SubjectsGridViewPartialUpdate(SubjectViewModel item)
{
if (ModelState.IsValid)
{
try
{
subjectRepository.UpdateSubject(item.SubjectId, item.SubjectName, item.SubjectYear, item.Observations);
}
catch (Exception e)
{
ViewData["EditError"] = e.Message;
}
}
else
{
ViewData["EditError"] = "Please, correct all errors.";
}
var model = subjectRepository.GetAllSubjects().Select(z => new SubjectViewModel()
{
SubjectYear = z.SubjectYear,
SubjectName = z.SubjectName,
SubjectId = z.SubjectId,
Observations = z.Observations
}).ToList();
return(PartialView("~/Views/Subject/_SubjectsGridViewPartial.cshtml", model));
}
//view Subjects
public ActionResult ViewSubject(int gradeID)
{
using (CyberSchoolEntities context = new CyberSchoolEntities())
{
IQueryable <GradeVsSubject> gradeVsSubjectList = context.GradeVsSubject.Where(o => o.GradeId == gradeID);
List <GradeVsSubject> objgradeVsSubjectListt = gradeVsSubjectList.ToList();
List <SubjectViewModel> subjectVMList = new List <SubjectViewModel>();
foreach (GradeVsSubject item in objgradeVsSubjectListt)
{
Subject objSubject = context.Subject.Where(o => o.Id == item.SubjectId && o.IsActive == 1 && o.IsDeleted == 0).FirstOrDefault();
SubjectViewModel objSubjectVM = new SubjectViewModel();
objSubjectVM.Id = objSubject.Id;
objSubjectVM.SubjectCode = objSubject.SubjectCode;
objSubjectVM.SubjectDescription = objSubject.SubjectDescription;
objSubjectVM.SubjectName = objSubject.SubjectName;
objSubjectVM.gradeId = gradeID;
subjectVMList.Add(objSubjectVM);
}
Grade objGrade = context.Grade.Where(o => o.Id == gradeID).FirstOrDefault();
Session["Grade"] = objGrade.Grade1;
return(View(subjectVMList));
}
}
public ActionResult Edit(Guid id, SubjectViewModel viewModel)
{
var knowledgeAreaRepository = new KnowledgeAreaRepository(_context);
var subjectRepository = new SubjectRepository(_context);
if (ModelState.IsValid)
{
try
{
var knowledgeArea = knowledgeAreaRepository.GetById(id);
subjectRepository.Update(SubjectViewModel.ToEntity(viewModel, knowledgeArea));
_context.Save(_loggedUser);
TempData["MessageType"] = "success";
TempData["MessageTitle"] = Resource.ContentManagementToastrTitle;
TempData["Message"] = "Subject updated";
return(Redirect(TempData["BackURL"].ToString()));
}
catch (Exception ex)
{
TempData["MessageType"] = "error";
TempData["MessageTitle"] = Resource.ContentManagementToastrTitle;
TempData["Message"] = ex.Message;
}
}
var knowledgeAreas = knowledgeAreaRepository.ListActiveKnowledgeAreas();
ViewBag.KnowledgeAreas = new SelectList(knowledgeAreas, "Id", "Name");
return(View(viewModel));
}
public void AddSubject(SubjectViewModel subject)
{
if(!_groupLookup.ContainsKey(subject.GroupId.ToLower()))
_groupLookup[subject.GroupId.ToLower()] = ComputeGroup.GroupNone;
foreach (var graph in subject.Graphs)
{
if (!_dataTypeLookup.ContainsKey(graph.Key))
_dataTypeLookup[graph.Key] = false;
}
_all.Add(subject);
}
public override void Execute(object parameter)
{
var subject = parameter as SubjectViewModel;
if (subject == null)
subject = new SubjectViewModel(App.Timetable.AddSubject(App.Timetable.GetSubjectName(Strings.SubjectNewFormat)));
int index = subject.GetIndex(App.Timetable.Subjects);
if (index != -1)
{
this.NavigationFrame.Navigate(typeof(EditSubjectPage), index);
}
else if (System.Diagnostics.Debugger.IsAttached)
System.Diagnostics.Debugger.Break();
}
public async Task LoadSubjectData(SubjectViewModel subject, int vertexLimit)
{
if (_adjBySubjectId.ContainsKey(subject.SubjectId))
{
var adjs = _adjBySubjectId[subject.SubjectId];
foreach(var adj in adjs)
{
// Read in all the lines
var lines = await Windows.Storage.FileIO.ReadLinesAsync(adj.File);
//subjectGraph.AddGraphLines(lines);
for (int lineIdx = 0; lineIdx < lines.Count; lineIdx++)
{
var line = lines[lineIdx];
var columns = line.TrimEnd().Split('\t');
for (int colIdx = 0; colIdx < columns.Length; colIdx++)
{
if (lineIdx < vertexLimit && colIdx < vertexLimit)
{
var val = Double.Parse(columns[colIdx]);
if (DoWeCare(lineIdx, colIdx) && (adj.DataType == "fMRI-mo") && (colIdx > lineIdx))
{
var str = string.Format("{0}, {1:00}{2:00}, {3}", subject.SubjectId, lineIdx, colIdx, val);
Debug.WriteLine(str);
}
// Only load the upper triangle
if (colIdx > lineIdx)
adj.Graph.AddEdge(lineIdx, colIdx, Math.Abs(val));
}
}
}
subject.AddGraph(adj.DataType, adj.Graph);
}
}
}
public static async Task<List<SubjectViewModel>> LoadSubjectFile(StorageFile file)
{
// Read in all the lines
var lines = await Windows.Storage.FileIO.ReadLinesAsync(file);
if (lines.Count == 0)
throw new Exception("Subject file empty");
// Pull out the headers
char[] splitChars = new char[] { '\t' };
var headers = lines[0].Split(splitChars);
// TODO: Make error msg for missing cols
// Find our subject id col
var subIdIdx = -1;
for (var i = 0; i < headers.Length; i++)
{
if (headers[i] == "subjectId")
subIdIdx = i;
}
// This will be our lookup by subject id
var subjects = new Dictionary<string, SubjectViewModel>();
// Loop through lines of subject file
foreach (var line in lines.Skip(1))
{
// Load up the properties
var fields = line.Split(splitChars);
// Pull out the subject id
var subId = fields[subIdIdx];
// Create subject if they do not exist
if (!subjects.ContainsKey(subId))
subjects[subId] = new SubjectViewModel(subId);
// Get the subject
var subject = subjects[subId];
// Loop through fields for this subject
for (int i = 0; i < fields.Length; i++)
{
var propName = headers[i];
var propVal = fields[i];
switch (propName)
{
case "groupId":
subject.GroupId = propVal.ToUpper();
break;
case "sex":
subject.Sex = propVal;
break;
case "age":
subject.Age = propVal;
break;
case "eventId":
subject.AddEventId(propVal);
break;
default:
{
double value;
bool isNumber = Double.TryParse(fields[i], out value);
if(isNumber)
subject.AddAttribute(headers[i], value);
}
break;
}
}
}
return subjects.Values.ToList();
}
