public async Task <IActionResult> Create(TeachersViewModel model)
{
using (var context = new SchoolDbContext())
{
var teacherId = context.Users
.Where(u => u.Login == User.Identity.Name)
.Select(u => u.TeacherId)
.FirstOrDefault();
var principalId = context.Users
.Where(u => u.Login == User.Identity.Name)
.Select(u => u.PrincipalId)
.FirstOrDefault();
if (teacherId == null && principalId == null)
{
TempData["message"] = "Brak wymaganych uprawnien.";
return(RedirectToAction("Index", "Home"));
}
if (ModelState.IsValid)
{
var logins = context.Users.Select(u => u.Login).ToList();
if (logins.Contains(model.User.Login))
{
return(NotFound("login already exists"));
}
context.Addresses.Add(model.Address);
await context.SaveChangesAsync();
var pdata = model.PersonalData;
pdata.Address = model.Address;
context.PersonalDatas.Add(pdata);
await context.SaveChangesAsync();
var teacher = model.Teacher;
teacher.PersonalData = pdata;
context.Teachers.Add(teacher);
await context.SaveChangesAsync();
var user = new Users
{
Login = model.User.Login,
Password = model.User.Password,
TeacherId = teacher.TeacherId
};
var result = await _userManager.CreateAsync(user, user.Password);
await context.SaveChangesAsync();
return(RedirectToAction("Get"));
}
return(View());
}
}
public TeachersViewModel AllPerGroup(int groupId, int page, int teachersPerPage = 3)
{
var teachers = this.teachersRepository.AllAsNoTracking()
.Where(x => x.NurseryGroupId == groupId)
.Skip((page - 1) * teachersPerPage)
.Take(teachersPerPage)
.Select(x => new SingleTeacherViewModel
{
Id = x.Id,
FullName = x.FirstName + " " + x.LastName,
NurseryGroupId = x.NurseryGroupId,
NurserySchool = x.NurseryGroup.NurserySchool.Name,
NurseryGroup = x.NurseryGroup.Name,
//ProfilePic = x.Url,
//PersonalMessage = x.PersonalMessage,
})
.ToList();
var teachersViewModel = new TeachersViewModel
{
Teachers = teachers,
};
return(teachersViewModel);
}
// GET: Teachers
public IActionResult Index(int page = 1)
{
PageViewModel pageViewModel = new PageViewModel(teacherDAO.Count(), page, 10);
TeachersViewModel model = new TeachersViewModel(teacherDAO.GetList(page), pageViewModel);
return(View(model));
}
public IActionResult Index(TeachersViewModel teachersView)
{
PageViewModel pageViewModel = new PageViewModel(1, 1, 1);
TeachersViewModel model = new TeachersViewModel(
teacherDAO.Search(teachersView.MinExp, teachersView.MaxExp, teachersView.SubjectTitle), pageViewModel);
return(View(model));
}
public ActionResult Edit(TeachersViewModel model)
{
if (ModelState.IsValid)
{
var teachers = mapper.Map <tblTeachers>(model);
teachersService.Update(teachers);
return(RedirectToAction("Index"));
}
return(Edit(model.Id));
}
public ActionResult EditTeacher(int TeacherId)
{
var model = _db.Teachers.Include("Courses")
.ToList()
.Find(x => x.TeacherId == TeacherId);
TeachersViewModel teacher = new TeachersViewModel(model);
return(View(teacher));
}
public ActionResult Create(TeachersViewModel model, HttpPostedFileBase imageFile)
{
if (ModelState.IsValid)
{
var teachers = mapper.Map <tblTeachers>(model);
teachers.ImageLink = SaveImage(imageFile);
teachersService.AddTeachers(teachers);
return(RedirectToAction("Index"));
}
return(Create());
}
public ActionResult AddTeacher(TeachersViewModel vm)
{
try
{
TeachersRepository.AddTeacher(vm.TeacherToAdd);
TempData["userAdded"] = "1";
}
catch (Exception ex)
{
TempData["userAdded"] = "0";
}
return(RedirectToAction("Show"));
}
// GET: Index
public ActionResult Show()
{
var classes = DB.GetClasses();
var teachers = TeachersRepository.GetTeachers();
TeachersViewModel vm = new TeachersViewModel()
{
AllTeachers = teachers,
AllClasses = classes
};
return(View(vm));
}
public ActionResult SaveTeachersChanges(TeachersViewModel vm)
{
try
{
TeachersRepository.UpdateTeachers(vm.AllTeachers);
TempData["success"] = "1";
}
catch (Exception ex)
{
TempData["success"] = "0";
}
return(RedirectToAction("Show"));
}
public async Task <IActionResult> Teachers()
{
{
var accessToken = await GetAccessTokenFromContext();
List <Teacher> teachersList = await GetDataFromApi <List <Teacher> >(ApiTypes.Teacher, "teachers/secured", accessToken);
if (teachersList == null)
{
return(RedirectToAction(nameof(AccessDenied)));
}
var model = new TeachersViewModel();
foreach (var teacher in teachersList)
{
model.Teachers.Add(new TeachersViewModel.Teacher
{
Id = teacher.Id,
Forename = teacher.Forename,
Surname = teacher.Surname,
Students = await GetStudents(teacher.Students, accessToken)
});
}
return(View(model));
}
async Task <List <string> > GetStudents(List <Guid> ids, string accessToken)
{
var students = new List <string>();
if (ids.Any() == false)
{
return(students);
}
foreach (var id in ids)
{
var student = await GetDataFromApi <Student>(ApiTypes.Student, $"students/{id}", accessToken);
students.Add($"{student.Forename} {student.Surname}");
}
return(students);
}
}
public ActionResult Delete(TeachersViewModel TeacherVM)
{
TeachersBLL TeacherBLL = new TeachersBLL()
{
TeacherID = TeacherVM.TeacherID,
LoginIdentity = UserIdentity
};
Result result = TeacherBLL.Remove();
if ((System.Type)result.EnumType == typeof(TeachersValidationEnum))
{
// if (result.EnumMember == LendersValidationEnum.RejectedBecauseOfActivePreviousLender.ToString())
//{
// throw new CustomException(Resources.Globalization.MustEndPreviousLenderText + "NewLine" + "تاريخ اخر تكليف : " + assgining.LenderStartDate.ToShortDateString());
//}
}
return(View());
}
public IActionResult teachersApi()
{
List <Teacher> teachers = dbContext.teachers.Include(t => t.Department).ToList();
TeachersViewModel viewModel = new TeachersViewModel()
{
Teachers = teachers,
AddNewTeacherViewModel = new AddNewTeacherViewModel()
{
departments = dbContext.departments.Select(d => new SelectListItem
{
Value = d.Id.ToString(),
Text = d.Name
}).ToList()
}
};
return(Ok(viewModel));
}
public void Update(TeachersViewModel model)
{
var entity = new Teachers();
entity.MemberID = model.MemberID;
entity.TaxNumber = model.TaxNumber;
entity.FullName = model.FullName;
entity.Country = model.Country;
entity.School = model.School;
entity.SchoolAddress = model.SchoolAddress;
entity.Phone = model.Phone;
entity.Email = model.Email;
entity.SocialMedia = model.SocialMedia;
entity.LoginName = model.LoginName;
entities.Teachers.Attach(entity);
entities.Entry(entity).State = EntityState.Modified;
entities.SaveChanges();
}
public void Create(TeachersViewModel model)
{
Teachers entity = new Teachers()
{
MemberID = model.MemberID,
TaxNumber = model.TaxNumber,
FullName = model.FullName,
Country = model.Country,
School = model.School,
SchoolAddress = model.SchoolAddress,
Phone = model.Phone,
Email = model.Email,
SocialMedia = model.SocialMedia,
LoginName = model.LoginName
};
entities.Teachers.Add(entity);
entities.SaveChanges();
}
private TeachersViewModel GetTeacherByTeacherID(int id)
{
TeachersBLL TeacherBLL = new TeachersBLL().GetByTeacherID(id);
TeachersViewModel TeacherVM = new TeachersViewModel();
if (TeacherBLL != null)
{
TeacherVM.TeacherID = TeacherBLL.TeacherID;
TeacherVM.StartDate = TeacherBLL.StartDate;
TeacherVM.EndDate = TeacherBLL.EndDate;
TeacherVM.Employee = new EmployeesViewModel()
{
EmployeeCodeID = TeacherBLL.EmployeeCareerHistory.EmployeeCode.EmployeeCodeID,
EmployeeCodeNo = TeacherBLL.EmployeeCareerHistory.EmployeeCode.EmployeeCodeNo,
EmployeeNameAr = TeacherBLL.EmployeeCareerHistory.EmployeeCode.Employee.EmployeeNameAr
};
}
return(TeacherVM);
}
public IActionResult Index()
{
var teachers = this.teachersRepository.AllAsNoTrackingWithDeleted()
.Select(x => new SingleTeacherViewModel
{
Id = x.Id,
FirstName = x.FirstName,
LastName = x.LastName,
CreatedOn = x.CreatedOn,
ModifiedOn = (System.DateTime)x.ModifiedOn,
IsDeleted = x.IsDeleted,
DeletedOn = (System.DateTime)x.DeletedOn,
})
.ToList();
var viewModel = new TeachersViewModel
{
Teachers = teachers,
};
return(this.View(viewModel));
}
public async Task <IActionResult> teachers()
{
if (!authorize.AuthorizeUser("admin"))
{
//return RedirectToAction("login", "user");
}
using (client)
{
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("multipart/form-data"));
//HTTP Get
HttpResponseMessage response = await client.GetAsync("api/admin/teachersApi");
if (response.IsSuccessStatusCode == true)
{
TeachersViewModel viewModel = response.Content.ReadAsAsync <TeachersViewModel>().Result;
return(View(viewModel));
}
return(Content("Some Internal Error Occur"));
}
}
public ActionResult EditTeachers(TeachersViewModel TeacherVM)
{
TeachersBLL TeacherBLL = new TeachersBLL()
{
TeacherID = TeacherVM.TeacherID,
StartDate = TeacherVM.StartDate,
EndDate = TeacherVM.EndDate,
EmployeeCareerHistory = new EmployeesCareersHistoryBLL().GetEmployeeCurrentJob(TeacherVM.EmployeeCodeID.Value),
LoginIdentity = new EmployeesCodesBLL()
{
EmployeeCodeID = UserIdentity.EmployeeCodeID
},
};
Result result = TeacherBLL.Update();
if ((System.Type)result.EnumType == typeof(NoConflictWithOtherProcessValidationEnum))
{
Classes.Helpers.CommonHelper.ConflictValidationMessage(result);
}
if ((System.Type)result.EnumType == typeof(TeachersValidationEnum))
{
if (result.EnumMember == TeachersValidationEnum.Done.ToString())
{
TeacherVM.TeacherID = ((TeachersBLL)result.Entity).TeacherID;
}
else if (result.EnumMember == TeachersValidationEnum.RejectedBecauseOfEndDateShouldNotBeLessThanStartDate.ToString())
{
throw new CustomException(Resources.Globalization.ValidationEndDateShouldBeMoreThanStartDateText);
}
else if (result.EnumMember == TeachersValidationEnum.RejectedBecauseOfBeforeHiringDate.ToString())
{
throw new CustomException(Resources.Globalization.ValidationBeforeHiringText);
}
}
return(View(this.GetTeacherByTeacherID(TeacherVM.TeacherID)));
//return View(LenderVM);
}
public TeachersView()
{
InitializeComponent();
DataContext = new TeachersViewModel();
}
public ActionResult Edit(int id)
{
TeachersViewModel TeacherVM = GetTeacherByTeacherID(id);
return(View(TeacherVM));
}
public TeachersPage()
{
InitializeComponent();
BindingContext = _viewModel = new TeachersViewModel();
}
public TeachersUserControl(bool isToEdit)
{
ViewModel = new TeachersViewModel(isToEdit);
InitializeComponent();
}
