// test
public async Task <OperationDetailDTO <List <SubjectDTO> > > GetRepositoryListFilters()
{
var detail = new OperationDetailDTO <List <SubjectDTO> >();
var resultSubjectDTOList = new List <SubjectDTO>();
var currentUserEntity = await GetUserFromClaimsAsync();
var teacherEntity = await _context.Teachers
.Where(t => t.UserId == currentUserEntity.Id)
.FirstOrDefaultAsync();
IQueryable <RepositoryModel> repositories = from r in _context.RepositoryModels
.Include(r => r.Teacher)
.Include(r => r.Subject)
.Where(r => r.TeacherId == teacherEntity.Id)
select r;
foreach (var repo in repositories)
{
SubjectDTO subjectDTO;
if ((subjectDTO = resultSubjectDTOList.FirstOrDefault(s => s.Id == repo.SubjectId)) != null)
{
}
else
{
subjectDTO = SubjectDTO.Map(repo.Subject);
resultSubjectDTOList.Add(subjectDTO);
}
}
detail.Data = resultSubjectDTOList;
detail.Succeeded = true;
return(detail);
}
public SubjectDTO EditSubject(SubjectDTO subjectDto)
{
if (subjectDto == null)
{
return new SubjectDTO
{
Successed = false,
ErrorMessage = "Subject not be null"
}
}
;
var subjectTask = Task.Factory.StartNew(() => this.database.Subjects.Get(subjectDto.Id));
var subject = subjectTask.Result;
if (this.ValidateSubject(subjectDto, subject))
{
subject.Name = subjectDto.Name;
this.database.Subjects.Update(subject);
this.EventChanges = new EditOperation(EventChanges);
this.EventChanges.AddOperation(subject.Id);
Save();
subjectDto.Successed = true;
return(subjectDto);
}
return(new SubjectDTO
{
Successed = false,
ErrorMessage = "validation error"
});
}
public void Cleanup()
{
GivenIAmAnAuthorizedUser();
if (_subjects != null)
{
foreach (Subject s in _subjects)
{
var deleteSubject = "http://localhost:8080/subjects/" + s.id;
_client.DeleteAsync(deleteSubject);
}
}
if (_teachers != null)
{
foreach (Teacher t in _teachers)
{
var deleteTeacher = "http://localhost:8080/teachers/" + t.id;
_client.DeleteAsync(deleteTeacher);
}
}
_subject = null;
_subjectId = 0;
_subjects = null;
_teacher = null;
_teacherId = 0;
_teachers = null;
}
public string SetSubjectName(int idEducation)
{
Education education = Database.EducationsRepository.FindById(idEducation);
SubjectDTO subjectDTO = GetStudentSubject(education.Id);
return(subjectDTO.Name);
}
public void UpdateSubject(Subject subject, SubjectDTO subjectDTO)
{
Domain.Subject updateSubject = _context.Subjects.FirstOrDefault(s => s.Id == subject.Id);
updateSubject.Name = subjectDTO.Name;
_context.SaveChanges();
}
public async Task <ActionResult> DeleteSubject(int id)
{
string currentUserId = System.Web.HttpContext.Current.User.Identity.GetUserId();
if (currentUserId == null)
{
return(new HttpUnauthorizedResult());
}
SubjectDTO subjectDTO = await SubjectService.GetAsync(id);
if (subjectDTO != null)
{
OperationDetails operationDetails = await SubjectService.DeleteAsync(id, 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/DeleteSubject.cshtml", id));
}
public void AddSubject(SubjectDTO subjectDTO)
{
var mapper = new MapperConfiguration(cfg => cfg.CreateMap <SubjectDTO, Subject>()).CreateMapper();
Database.SubjectsRepository.Create(mapper.Map <SubjectDTO, Subject>(subjectDTO));
Database.SaveChanges();
}
public IHttpActionResult UpdateSubject(int id, SubjectDTO subjectDTO)
{
subjectsService = new SubjectsService();
subjectToExposeService = new SubjectToExposeService();
if (id == 0)
{
return(NotFound());
}
if (subjectDTO == null)
{
return(BadRequest());
}
Subject subject = Mapper.Map <SubjectDTO, Subject>(subjectDTO);
Subject theSubject = new Subject();
theSubject = subjectsService.UpdateSubject(id, subject);
if (theSubject == null)
{
return(BadRequest());
}
//SubjectToExpose subjectToExpose = subjectToExposeService.TrimSubject(subject);
SubjectDTO theSubjectDTO = Mapper.Map <Subject, SubjectDTO>(theSubject);
return(Ok(theSubjectDTO));
}
public async Task <IActionResult> AddSubject([FromBody] SubjectDTO subject)
{
if (!ModelState.IsValid)
{
return(BadRequest("Invalid input"));
}
Subject newSubject = new Subject
{
name = subject.name,
ECTSpoints = subject.ECTSpoints,
teacher = subject.teacher
};
if (_subjectRepository.CheckIfExists(newSubject))
{
return(Conflict("Subject already exists"));
}
bool created = await _subjectRepository.Add(newSubject);
if (created)
{
return(Created("", newSubject));
}
return(Conflict());
}
public async Task <IActionResult> PostSubject([FromBody] SubjectDTO subjectDto)
{
var subject = new Subject()
{
Name = subjectDto.Name
};
_context.Subjects.Add(subject);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (SubjectExists(subjectDto.ID))
{
return(new StatusCodeResult(StatusCodes.Status409Conflict));
}
else
{
throw;
}
}
return(Ok());
}
public async Task <IActionResult> PutSubject([FromRoute] int id, [FromBody] SubjectDTO subjectDto)
{
if (id != subjectDto.ID)
{
return(BadRequest());
}
var subject = await _context.Subjects.FirstOrDefaultAsync(s => s.ID == subjectDto.ID);
subject.Name = subjectDto.Name;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SubjectExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(Ok());
}
public List <SubjectDTO> GetSubjects()
{
List <SubjectDTO> oSubjectList = new List <SubjectDTO>();
try
{
sb.Clear();
sb.Append("SELECT SubjectId, SubjectName");
sb.Append(" FROM [Subject]");
using (CloudConnection connection = new CloudConnection(DMSSWE.Common.ConnectionString))
{
connection.CommandText = sb.ToString();
connection.Parameters.Clear();
using (IDataReader dr = connection.ExecuteReader())
{
while (dr.Read())
{
SubjectDTO oSubject = new SubjectDTO();
oSubject.SubjectId = dr["SubjectId"].ToString();
oSubject.SubjectName = dr["SubjectName"].ToString();
oSubjectList.Add(oSubject);
}
}
}
}
catch (Exception ex)
{
throw ex;
}
return(oSubjectList);
}
public bool AddSubject(SubjectDTO subjectDTO)
{
using (db = new storesEntities())
{
subjectDTO.DatetimeOfWriting = DateTime.Now;
try
{
db.Subjects.Add(subjectDTO.FromDTO());
db.SaveChanges();
return(true);
}
catch (DbEntityValidationException e)
{
foreach (var eve in e.EntityValidationErrors)
{
Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
eve.Entry.Entity.GetType().Name, eve.Entry.State);
foreach (var ve in eve.ValidationErrors)
{
Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
ve.PropertyName, ve.ErrorMessage);
}
}
throw;
}
}
}
private void btnAdd_Click(object sender, EventArgs e)
{
try
{
if (tbxID.Text != "" && tbxName.Text != "" && tbxSession.Text != "" && cbDepartment.Text != "")
{
SubjectDTO subject = new SubjectDTO();
subject.Subjectid = tbxID.Text;
subject.Name = tbxName.Text;
subject.Session = int.Parse(tbxSession.Value.ToString());
subject.Deparmentid = int.Parse(cbDepartment.SelectedValue.ToString());
if (SubjectDAO.Instance.CheckSubjectID(subject.Subjectid) == 0)
{
if (SubjectDAO.Instance.Insert(subject) > 0)
{
MessageBox.Show("OK!");
btnRefesh_Click(sender, e);
}
}
else
{
MessageBox.Show("Mã môn học bị trùng !");
}
}
else
{
MessageBox.Show("Điền đầy đủ thông tin");
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Lỗi", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
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 <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 void Create(SubjectDTO subjecteDto)
{
var subject = _mapper.Map <Subject>(subjecteDto);
_database.SubjectRepository.Create(subject);
_database.Save();
}
// Subject specialities list.
public async Task <ActionResult> SubjectSpecialities(int?id)
{
// Check id.
if (!int.TryParse(id.ToString(), out int intId))
{
return(RedirectToAction("Index"));
}
// Get SubjectDTO.
SubjectDTO subjectDTO = await SubjectService.GetAsync(intId);
if (subjectDTO == null)
{
return(RedirectToAction("Index"));
}
// Set ViewBag properties.
ViewBag.ParentId = intId;
ViewBag.SubjectName = subjectDTO.SubjectName;
// AutoMapper Setup.
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <SpecialityDTO, SpecialityViewModel>()
.ForMember("Id", opt => opt.MapFrom(obj => obj.SpecialityId))
.ForMember("Name", opt => opt.MapFrom(obj => obj.SpecialityName));
});
IMapper iMapper = config.CreateMapper();
List <SpecialityDTO> source = SpecialityService.Find(dto => dto.SubjectId == intId).OrderBy(o => o.SpecialityName).OrderBy(o => o.IsApproved).ToList();
IEnumerable <SpecialityViewModel> specialityOrderedList = iMapper.Map <IEnumerable <SpecialityDTO>, IEnumerable <SpecialityViewModel> >(source);
return(View(specialityOrderedList));
}
public void EditSubject(SubjectDTO subjectDto)
{
var subject = _mapper.Map <Subject>(subjectDto);
_database.SubjectRepository.Update(subject);
_database.Save();
}
public async Task <SubjectDTO> CreateSubject(SubjectDTO subjectDTO, string token)
{
try
{
var repo = _unitOfWork.GetRepository <Subject>();
var newvalue = Mapper.Map <Subject>(subjectDTO);
newvalue.CreationDate = DateTime.Now;
newvalue.SubjectGUID = Guid.NewGuid();
if (newvalue.SubjectCode == null)
{
newvalue.SubjectCode = newvalue.SubjectId;
}
newvalue.CreatedBy = _appUserService.GetUserId(token);
repo.Add(newvalue);
repo.SaveChanges();
var result = await _schoolDBContext.Database.ExecuteSqlCommandAsync("exec SPCheckSubjects");
var newSubject = _masterService.GetOne <Subject>
(x => x.SubjectId == newvalue.SubjectId);
return(Mapper.Map <SubjectDTO>(newSubject));
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task <IActionResult> Edit(int id, [Bind("Name,Id")] SubjectDTO subject)
{
if (id != subject.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
await _service.UpdateAsync(subject);
}
catch (DbUpdateConcurrencyException)
{
if (!_service.SubjectExists(subject.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(subject));
}
public async Task <MessageResult> Save(SubjectDTO request)
{
var result = new MessageResult();
try
{
var ctx = new DatabaseContext();
var subject = ctx.Subjects.SingleOrDefault(s => s.SubjectID == request.SubjectID);
if (subject != null)
{
subject.SubjectName = request.SubjectName;
}
else
{
ctx.Subjects.Add(new Subject()
{
SubjectName = request.SubjectName
});
}
await ctx.SaveChangesAsync();
result.IsSuccess = true;
}
catch (Exception ex)
{
result.IsSuccess = false;
result.ErrorMessage = ex.Message;
}
return(result);
}
public void AddSubject(SubjectDTO subjectDTO)
{
try
{
var subject = new Subject()
{
Name = subjectDTO.Name,
};
context.Subjects.Add(subject);
SaveChanges();
foreach (var teacherId in subjectDTO.SelectedTeachers)
{
/*Mapper.Map<Subject>(subjectDTO);*/
//var teacher = Mapper.Map<Teacher>(teacherId);
var subjectTeacher = new Linq_Subject_Teacher()
{
SubjectID = subject.Id,
TeacherID = teacherId
};
context.Subject_Teachers.Add(subjectTeacher);
}
SaveChanges();
}
catch (Exception)
{
throw;
}
}
private void updateSubject()
{
try
{
if (!txtSubjectId.Text.Trim().Equals(string.Empty))
{
SubjectDTO oSubjectDTO = new SubjectDTO();
oSubjectDTO.SubjectId = txtSubjectId.Text.Trim();
oSubjectDTO.SubjectName = txtSubjectName.Text.Trim();
oSubjectDTO.ModifiedBy = "Kaveen";
oSubjectDTO.ModifiedDateTime = DateTime.Now;
if (oSubjectBL.UpdateSubject(oSubjectDTO))
{
ClearControls();
LoadSubjects();
MessageBox.Show("Record updated successfully.!");
}
}
else
{
txtSubjectId.Focus();
}
}
catch (Exception ex)
{
throw ex;
}
}
public void UpdateSubject(SubjectDTO subjectDTO)
{
try
{
var subject = context.Subjects.Where(x => x.Id == subjectDTO.Id).FirstOrDefault();
subject.SubjectTeachers.Clear();
if (subjectDTO.SelectedTeachers != null)
{
foreach (var teacherId in subjectDTO.SelectedTeachers)
{
/*Mapper.Map<Subject>(subjectDTO);*/
//var teacher = Mapper.Map<Teacher>(teacherId);
var subjectTeacher = new Linq_Subject_Teacher()
{
SubjectID = subject.Id,
TeacherID = teacherId
};
context.Subject_Teachers.Add(subjectTeacher);
}
}
SaveChanges();
}
catch (Exception e)
{
throw;
}
}
public ActionResult AddSubject(EducationProcessViewModel educationVM)
{
if (ModelState.IsValid)
{
Validate validate = new Validate();
if (!(validate.ValidationSubjectRes(educationVM.SubjectResult)))
{
ViewBag.message = "Введіть оцінку ще раз";
return(View("Report"));
}
int idSubject = subjectService.Get().Where(s => s.Name == educationVM.SubjectName).FirstOrDefault().Id;
educationVM.IdSubject = idSubject;
EducationProcessDTO educationDTO1 = educationService.Get().Where(s => s.IdStudent == educationVM.IdStudent).Where(s => s.IdSubject == educationVM.IdSubject).FirstOrDefault();
if (educationDTO1 != null)
{
ViewBag.message = "Студент вже має такий предмет";
return(View("Report"));
}
var mapper = new MapperConfiguration(cfg => cfg.CreateMap <EducationProcessViewModel, EducationProcessDTO>()).CreateMapper();
EducationProcessDTO educationDTO = mapper.Map <EducationProcessViewModel, EducationProcessDTO>(educationVM);
educationService.AddSubject(educationDTO);
StudentDTO studentDTO = studentService.GetStudent(educationDTO.IdStudent);
studentDTO.StudentAvg = studentService.GetStudentAvg(studentDTO.Id);
SubjectDTO subjectDTO = subjectService.GetSubject(educationDTO.IdSubject);
subjectDTO.SubjectAvg = subjectService.GetSubjectAvg(subjectDTO.Id);
ViewBag.message = "Предмет додано до даних студента";
return(View("Report"));
}
return(View(educationVM));
}
//Update Subject (async)
public async Task <SubjectDTO> UpdateSubjectAsync(SubjectDTO modelDTO)
{
try
{
using (var unitOfWork = unitOfWorkFactory.Create())
{
SubjectModel model = _Mapper_ToModel.Map <SubjectDTO, SubjectModel>(modelDTO);
bool result = unitOfWork.SubjectRepository.Update(model);
SubjectDTO modelRTN = null;
if (result)
{
await unitOfWork.SaveChangesAsync();
modelRTN = _Mapper_ToDTO.Map <SubjectModel, SubjectDTO>(model);
}
return(modelRTN);
}
}
catch (Exception ex)
{
LogException(ex);
throw ex;
}
}
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 async Task UpdateAsync(SubjectDTO subjectEntity)
{
var subject = _mapper.Map <Subject>(subjectEntity);
_unitOfWork.Subjects.Update(subject);
await _unitOfWork.SaveAsync();
}
