public void Save(DegreeViewModel vm)
{
var entity = new DegreeEntity(0);
vm.Bind(entity);
DegreeService.Save(entity);
}
public async Task <DegreeViewModel> AddNewDegree(DegreeViewModel model)
{
var mapped = _mapper.Map <Degree>(model);
await _degreeRepository.Add(mapped);
return(model);
}
public DegreeModel MapDoctorDegree(DegreeViewModel dModel)
{
return(new DegreeModel()
{
Id = dModel.Id,
DegreeName = dModel.DegreeName,
TenantID = dModel.TanentId
});
}
public ActionResult DegreeDetail(int?id)
{
DegreeViewModel model = new DegreeViewModel();
if (id.HasValue)
{
model = new DegreeRepository().GetByID((int)id);
}
return(PartialView("_Degree", model));
}
public async Task <IActionResult> Index()
{
var degree = await _degreeService.GetAllAsync();
var viewModel = new DegreeViewModel
{
Degrees = degree
};
return(View(viewModel));
}
public IHttpActionResult SaveDegree(RequestCarrier requestCarrier)
{
ResponseCarrier response;
if (requestCarrier != null && requestCarrier.TanentId != 0 && requestCarrier.From != string.Empty && requestCarrier.UserId.HasValue)
{
DegreeViewModel dViewModel = WebCommon.Instance.GetObject <DegreeViewModel>(requestCarrier.PayLoad);
string validationResponse = this._doctorMapper.ValidateDegree(dViewModel);
if (string.IsNullOrEmpty(validationResponse))
{
dViewModel.TanentId = requestCarrier.TanentId;
var degreeModel = this._doctorMapper.MapDoctorDegree(dViewModel);
degreeModel.CreatedBy = (int)requestCarrier.UserId.Value;
degreeModel.CreatedByEntity = Convert.ToInt32(requestCarrier.From);
degreeModel.ModifiedBy = (int)requestCarrier.UserId.Value;
degreeModel.ModifiedByEntity = Convert.ToInt32(requestCarrier.From);
var userResponse = _staticDataServices.SaveDegree(degreeModel);
if (userResponse.Success)
{
degreeModel.LongId = userResponse.LongId;
response = new ResponseCarrier()
{
Status = true, PayLoad = degreeModel, TanentId = requestCarrier.TanentId
};
}
else
{
response = new ResponseCarrier()
{
Status = false, TanentId = requestCarrier.TanentId, ErrorMessage = userResponse.ErrorMessage
};
}
}
else
{
response = new ResponseCarrier()
{
Status = false, TanentId = requestCarrier.TanentId, ErrorMessage = validationResponse
};
}
}
else
{
response = new ResponseCarrier()
{
Status = false, PayLoad = null, ErrorMessage = "TanentId or RequestFrom or UserId not provided.", TanentId = requestCarrier.TanentId
};
}
return(Json(response));
}
public JsonResult SaveDegree(DegreeViewModel model)
{
ResponseData result = new Models.ResponseData();
if (model.DegID != 0)
{
result = new DegreeRepository().UpdateByEntity(model);
}
else
{
result = new DegreeRepository().AddByEntity(model);
}
return(Json(result, JsonRequestBehavior.AllowGet));
}
/*
* Combined the Undergrad and Graduate calls to the API to display all
* information onto one page
*/
public async Task <IActionResult> Degree()
{
var getUnder = new GetUnderGraduate();
var under = await getUnder.GetAllUnderGrads();
var getGrad = new GetGraduate();
var grad = await getGrad.GetAllGrads();
var degreeViewModel = new DegreeViewModel()
{
UnderGrads = under.ToList(),
Grad = grad.ToList(),
Title = "A Look At Our Programs"
};
return(View(degreeViewModel));
}
public ResponseData UpdateByEntity(DegreeViewModel newdata)
{
using (SATEntities db = new SATEntities())
{
ResponseData result = new Models.ResponseData();
try
{
var data = db.tb_Degree.Single(x => x.DegID == newdata.DegID);
data.DegName = newdata.DegName;
data.DegStatus = (newdata.Status == "1") ? true : false;
data.ModifyBy = UtilityService.User.UserID;
data.ModifyDate = DateTime.Now;
db.SaveChanges();
}
catch (Exception)
{
}
return(result);
}
}
//-------------------------------------------------------------------------------//
// ~/Grade/Degree
public IActionResult Degree()
{
var userId = userManager.GetUserId(HttpContext.User);
var student = context.Students.Include(s => s.ApplicationUser).FirstOrDefault(u => u.UserId == userId);
string degreecond = "Όχι";
if (DegreeCondition(student.Id))
{
degreecond = "Ναι";
}
DegreeViewModel degreeViewModel = new DegreeViewModel()
{
Student = student,
PassedDirectionCourses = PassedDirectionCourses(student.Id),
PassedNonDirectionCourses = PassedNonDirectionCourses(student.Id),
Degree = degreecond
};
return(View(degreeViewModel));
}
public async Task <IActionResult> Degrees()
{
var singleFooter = new GetFooter();
var footer = await singleFooter.GetSimpleFooter();
var getUnder = new GetUndergraduate();
var under = await getUnder.GetUnderGradDegrees();
var getGrad = new GetGraduate();
var grad = await getGrad.GetAllGraduate();
var degreeViewModel = new DegreeViewModel()
{
FooterInfo = footer,
UnderGrads = under,
Graduates = grad,
Title = "Degree Programs"
};
return(View(degreeViewModel));
}
public async Task <IActionResult> AddNewDegree(DegreeViewModel model)
{
try
{
degreeList = await _degreePageServices.getDegrees();
foreach (var item in degreeList)
{
if (item.degree_name == model.degree_name)
{
ViewData["msg"] = model.degree_name;
return(View());
}
}
await _degreePageServices.AddNewDegree(model);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return(RedirectToAction("Index", "Qualification"));
}
public async Task <IActionResult> AddNewDept(DepartmentViewModel model)
{
try
{
DegreeViewModel degrees = await _degreePageServices.GetDegreeWithDepartmentById(model.DegreeId);
foreach (var item in degrees.Departments)
{
if (item.dept_name == model.dept_name)
{
TempData["msg"] = model.dept_name;
return(RedirectToAction("Index", "Qualification", new { s = TempData["msg"] }));
}
}
await _departmentPageservices.AddNewDepartment(model);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return(RedirectToAction("Index", "Qualification"));
}
public ResponseData AddByEntity(DegreeViewModel data)
{
using (SATEntities db = new SATEntities())
{
ResponseData result = new Models.ResponseData();
try
{
tb_Degree model = new tb_Degree();
model.DegID = data.DegID;
model.DegName = data.DegName;
model.DegStatus = (data.Status == "1") ? true : false;
model.CreateBy = UtilityService.User.UserID;
model.CreateDate = DateTime.Now;
model.ModifyBy = UtilityService.User.UserID;
model.ModifyDate = DateTime.Now;
db.tb_Degree.Add(model);
db.SaveChanges();
}
catch (Exception)
{
}
return(result);
}
}
public async Task <IActionResult> Index(CandidateViewModel model)
{
//checking if already applied for same job
candidateList = await _candidatePageServices.getCandidates();
try
{
List <CandidateViewModel> list = new List <CandidateViewModel>();
list = candidateList.ToList();
foreach (var item in list)
{
var job_ID = _dbContext.JobPostCandidate.AsNoTracking().FirstOrDefault(x => x.candidate_Id == item.ID).job_Id;
if (item.email == model.email && model.jobpostID == job_ID)
{
TempData["msg1"] = model.email;
return(RedirectToAction("Index", "Home", new { s = TempData["msg1"] }));
}
}
//------------------------------------------------------------------------------------
//receiving dropdown value of degree
if (model.degree == "Select Degree")
{
ModelState.AddModelError("", "Select Degree");
}
//getting data from database
List <Degree> DegreeList = new List <Degree>();
DegreeList = (from element in _dbContext.Degree select element).ToList();
//inserting into dropdown list
DegreeList.Insert(0, new Degree {
ID = 0, degree_name = "Select Degree"
});
//assigning degreelist to viewbag.listofdegree
ViewBag.ListOfDegree = DegreeList;
//------------------------------------------------------------------------------------
//getting selected value for degree
DegreeViewModel selectedDegree = await _degreePageServices.getDegreeById(model.selectedDegree);
string degreename = selectedDegree.degree_name;
DepartmentViewModel selectedDept = await _departmentPageservices.getDepartmentById(model.selectDept);
string deptename = selectedDept.dept_name;
model.degree = degreename + "(" + deptename + ")";
//Resume details fetching
//create a place in wwwroot for storing uploaded images
var uploads = Path.Combine(_environment.WebRootPath, "Resume");
if (model.File != null)
{
using (var fileStream = new FileStream(Path.Combine(uploads, model.File.FileName), FileMode.Create))
{
await model.File.CopyToAsync(fileStream);
}
model.resume = model.File.FileName;
}
model.emailConfirmed = false;
var latestRecord = await _candidatePageServices.AddNewCandidate(model);
//add to jobpostcandidate
JobPostCandidateViewModel newModel = new JobPostCandidateViewModel()
{
job_Id = model.jobpostID,
candidate_Id = latestRecord.ID
};
await _jobPostCandidatePage.AddNewJobPostCandidate(newModel);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return(RedirectToAction("SendOTPToMail", model));
}
public async Task <IActionResult> UpdateDegree(DegreeViewModel model)
{
await _degreePageServices.UpdateDegree(model);
return(RedirectToAction("Index", "Qualification"));
}
public ActionResult Post([FromBody] DegreeViewModel vm)
{
ViewModelService.Save(vm);
return(Ok());
}
internal string ValidateDegree(DegreeViewModel dViewMOdel)
{
return(string.Empty);
}
public async Task UpdateDegree(DegreeViewModel model)
{
var mapped = _mapper.Map <Degree>(model);
await _degreeRepository.Update(mapped);
}
