public IActionResult Create(DesignationViewModel designationViewModel)
{
var designation = _mapper.Map <Designation>(designationViewModel);
if (ModelState.IsValid)
{
try
{
if (_designationRepository.Add(designation))
{
ViewBag.Message = "Designation Saved Successfully";
ModelState.Clear();
}
else
{
ViewBag.Message = "Designation Save Failled";
}
}
catch (Exception e)
{
ViewBag.DesignationMessage = e.Message;
}
}
return(View());
}
//[AuthorizeUser(RoleModule.Designation, Function.Edit)]
public JsonResult Update(DesignationViewModel dViewModel)
{
Set_Date_Session(dViewModel.DesignationInfo);
using (TransactionScope tran = new TransactionScope())
{
try
{
_designationManager.Update_Designation(dViewModel.DesignationInfo);
dViewModel.FriendlyMessage.Add(MessageStore.Get("DESIGNATION02"));
tran.Complete();
Logger.Debug("Designation Controller Update");
}
catch (Exception ex)
{
tran.Dispose();
dViewModel.FriendlyMessage.Add(MessageStore.Get("SYS01"));
Logger.Error("Designation Controller - Update " + ex.Message);
}
}
return(Json(dViewModel));
}
public JsonResult GetDesignations(DesignationViewModel dViewModel)
{
PaginationInfo pager = new PaginationInfo();
pager = dViewModel.Pager;
PaginationViewModel pViewModel = new PaginationViewModel();
try
{
pViewModel.dt = _dRepo.GetDesignations(dViewModel.Designation.DesignationName, ref pager);
pViewModel.Pager = pager;
Logger.Debug("Designation Controller GetDesignations");
}
catch (Exception ex)
{
dViewModel.FriendlyMessage.Add(MessageStore.Get("SYS01"));
Logger.Error("Designation Controller - GetDesignations" + ex.ToString());
}
return(Json(JsonConvert.SerializeObject(pViewModel), JsonRequestBehavior.AllowGet));
}
public ActionResult Create([Bind(Include = "Id,Title")] DesignationViewModel designationViewModel)
{
try
{
if (ModelState.IsValid)
{
Designation designation = Mapper.Map <Designation>(designationViewModel);
var title = designation.Title.Trim();
if (_designationManager.GetAll().Count(o => o.Title == title) > 0)
{
ViewBag.Message = "Designation title already exist.";
}
if (ViewBag.Message == null)
{
_designationManager.Add(designation);
TempData["msg"] = "Information has been saved successfully";
return(RedirectToAction("Index"));
}
}
return(View(designationViewModel));
}
catch (Exception ex)
{
ExceptionMessage(ex);
return(View("Error", new HandleErrorInfo(ex, "Designations", "Create")));
}
}
public ActionResult <DesignationViewModel> Get(string name)
{
_designationService.GetDesignation(name);
DesignationModel designation = _designationService.GetDesignation(name);
DesignationViewModel designationData = _mapper.Map <DesignationModel, DesignationViewModel>(designation);
return(designationData);
}
public virtual ActionResult EditDesignation(int id)
{
var designation = db.Designations.Find(id);
var model = new DesignationViewModel();
model.DesignationName = designation.DesignationName;
model.Id = designation.Id;
return(PartialView(model));
}
public ActionResult Create()
{
DesignationViewModel designationVM = new DesignationViewModel();
var departments = _departmenManager.GetAll();
designationVM.Departments = departments;
return(View(designationVM));
}
public IActionResult AddDesigantion([FromBody] DesignationViewModel designationModel)
{
var result = _designationHandler.AddDesignation(designationModel);
if (result)
{
return(Json(new { Msg = "Designation Added" }));
}
return(Json(new { Msg = "Designation/Abbr Already Exist" }));
}
public IActionResult UpdateDesignation([FromBody] DesignationViewModel designationModel)
{
var result = _designationHandler.UpdateDesignation(designationModel);
if (result)
{
return(Json(new { Msg = "Record Updated" }));
}
return(Json(new { Msg = "Designation/Abbr Already Exist" }));
}
public bool AddDesignation(DesignationViewModel designationViewModel)
{
DesignationModel designationModel = new DesignationModel
{
Designation = designationViewModel.Designation,
Abbrivation = designationViewModel.Abbrivation
};
return(_userProcessor.AddDesignation(designationModel));
}
public async Task <ActionResult> MemberDesignations()
{
IEnumerable <Designation> designations = await db.Designations.ToListAsync();
var viewModel = new DesignationViewModel()
{
Designations = designations
};
return(View(viewModel));
}
public bool UpdateDesignation(DesignationViewModel designationViewModel)
{
DesignationModel designationModel = new DesignationModel
{
DesignationId = designationViewModel.DesignationId,
Designation = designationViewModel.Designation,
Abbrivation = designationViewModel.Abbrivation
};
return(_userProcessor.UpdateDesignation(designationModel));
}
//public int GetLatestDesignationId()
//{
// return designationRepository.GetLatestDesignationId();
//}
public void AddDesignation(DesignationViewModel obj)
{
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <DesignationViewModel, Designation>();
cfg.IgnoreUnmapped();
});
IMapper mapper = config.CreateMapper();
Designation designation = mapper.Map <DesignationViewModel, Designation>(obj);
designationRepository.AddDesignation(designation);
}
public ActionResult AddDesignation(DesignationViewModel designation)
{
if (ModelState.IsValid)
{
designationService.AddDesignation(designation);
return(RedirectToAction("AddDesignation"));
}
else
{
ModelState.AddModelError("x", "Insertion failed");
return(View(designation));
}
}
public ActionResult Update(DesignationViewModel designationVm)
{
ApiResult <Designation> apiResult;
if (ModelState.IsValid)
{
if (designationVm.Id > 0)
{
apiResult = TryExecute(() =>
{
var designation = new Designation
{
Title = designationVm.Title,
DepartmentId = designationVm.DepartmentId,
Band = designationVm.Band,
Description = designationVm.Description,
MailAlias = designationVm.MailAlias,
Id = designationVm.Id
};
_designationRepository.Update(designation);
_unitOfWork.Commit();
return(designation);
}, "Designation updated sucessfully");
}
else
{
apiResult = TryExecute(() =>
{
var designation = new Designation
{
Title = designationVm.Title,
DepartmentId = designationVm.DepartmentId,
Band = designationVm.Band,
Description = designationVm.Description,
MailAlias = designationVm.MailAlias,
Id = designationVm.Id
};
_designationRepository.Create(designation);
_unitOfWork.Commit();
return(designation);
}, "Designation created sucessfully");
}
}
else
{
apiResult = ApiResultFromModelErrors <Designation>();
}
return(Json(apiResult, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// Map Designations
/// </summary>
/// <param name="designationList"></param>
/// <returns></returns>
public static BaseResult <List <DesignationViewModel> > MapDesignations(BaseResult <List <Designation> > designationList)
{
BaseResult <List <DesignationViewModel> > designationListResult = new BaseResult <List <DesignationViewModel> >();
List <DesignationViewModel> modelList = new List <DesignationViewModel>();
DesignationViewModel model = new DesignationViewModel();
foreach (var item in designationList.Result)
{
//Map
model = AutoMapper.Mapper.Map <Designation, DesignationViewModel>(item);
modelList.Add(model);
}
designationListResult.Result = modelList;
return(designationListResult);
}
public ActionResult AddDesignations(DesignationViewModel designationViewModel)
{
Designations designations = new Designations();
if (ModelState.IsValid)
{
designations.DesignationName = designationViewModel.DesignationName;
designationBL.AddDesignation(designations);
return(RedirectToAction("DisplayDesignations"));
}
else
{
return(View());
}
}
public ActionResult Create(DesignationViewModel designationVM)
{
try
{
Designation designation = new Designation();
designation.Name = designationVM.Name;
designation.OrganaizationId = designationVM.OrganaizationId;
_designationManager.Add(designation);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public DesignationViewModel GetDesignationByDesignationID(int DesignationID)
{
Designation designation = designationRepository.GetDesignationByDesignationID(DesignationID);
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <Designation, DesignationViewModel>();
cfg.IgnoreUnmapped();
});
IMapper mapper = config.CreateMapper();
DesignationViewModel designationViewModel = mapper.Map <Designation, DesignationViewModel>(designation);
return(designationViewModel);
}
// GET: Designation/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(HttpNotFound());
}
Designation designation = _designationManager.GetById((int)id);
DesignationViewModel designationVM = new DesignationViewModel();
designationVM.Id = designation.Id;
designationVM.Name = designation.Name;
designationVM.OrganaizationId = designation.OrganaizationId;
ViewBag.OrganaizationId = new SelectList(_organaizationManager.GetAll(), "Id", "Name", designation.OrganaizationId);
return(View(designationVM));
}
public PartialViewResult CreateDesignation(int id = 0)
{
var model = new DesignationViewModel();
if (id > 0)
{
model = AutomapperConfig.Mapper.Map <DesignationViewModel>(db.DesignationRepo.GetById(id));
}
if (model == null)
{
Response.StatusCode = (int)HttpStatusCode.OK;
return(PartialView(BadRequestView));
}
return(PartialView(model));
}
public virtual JsonResult CreateDesignation(DesignationViewModel model)
{
try
{
Designation entity = new Designation();
entity.DesignationName = model.DesignationName;
var result = db.Designations.Add(entity);
db.SaveChanges();
return(Json(new { success = true, message = "success" }, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
return(Json(new { success = false, message = ex.Message }, JsonRequestBehavior.AllowGet));
}
}
public ActionResult Index()
{
var departments = _departmenManager.GetAll();
var designation = _designationManager.GetAll();
List <DesignationViewModel> designationList = new List <DesignationViewModel>();
foreach (var designation1 in designation)
{
var designationVM = new DesignationViewModel();
designationVM.Id = designation1.Id;
designationVM.Name = designation1.Name;
designationVM.Department = departments.Where(x => x.Id == designation1.DepartmentId).FirstOrDefault();
designationList.Add(designationVM);
}
return(View(designationList));
}
public JsonResult CreateDesignation(DesignationViewModel model)
{
List <string> errors = new List <string>();
try
{
if (DuplicateDesignation(model.Id, model.Name) != null)
{
ModelState.AddModelError("Name", $"Item Group {model.Name} already exists.");
}
if (ModelState.IsValid)
{
if (model.Id == 0)
{
var itemD = db.DesignationRepo.Table();
var order = itemD.Any() ? itemD.Max(x => x.DisplayOrder) : 0;
model.DisplayOrder = order + 1;
model.Id = db.DesignationRepo.Create(AutomapperConfig.Mapper.Map <Designation>(model));
}
else
{
var oldmodel = db.DesignationRepo.GetById(model.Id);
if (oldmodel == null)
{
Response.StatusCode = (int)HttpStatusCode.OK;
return(Json(new { redirecturl = "/error/badrequest" }));
}
oldmodel.Name = model.Name;
}
db.SaveChanges();
Response.StatusCode = (int)HttpStatusCode.OK;
return(Json(new { message = "Designation successfully created" }));
}
foreach (var item in ModelState.Where(x => x.Value.Errors.Any()))
{
errors.Add(item.Value.Errors.FirstOrDefault().ErrorMessage);
}
}
catch (Exception ex)
{
errors.Add(ex.GetExceptionMessages());
}
Response.StatusCode = (int)HttpStatusCode.SeeOther;
return(Json(new { error = errors }));
}
public ActionResult LeaveDetail(int Id) //show each emp leave details for admin
{
RequestVacationViewModel requestVacation = leaveRequestService.GetLeaveRequestByRequestID(Id);
AdminProfileViewModel employee = employeeService.GetEmployeeByID(requestVacation.CreatedBy);
requestVacation.RequesterName = employee.FirstName + " " + employee.MiddleName + " " + employee.LastName;
DesignationViewModel designation = designationService.GetDesignationByDesignationID(employee.DesignationID);
requestVacation.RequesterDesignation = designation.DesignationName;
VacationTypeViewModel vacationType = vacationTypeService.GetVacationTypeByVacationId(requestVacation.VacationTypeID);
requestVacation.VacationName = vacationType.VacationName;
return(View(requestVacation));
}
public List <DesignationViewModel> GetDesignationList()
{
DataTable dt = _userProcessor.GetDesignationList();
List <DesignationViewModel> designationList = new List <DesignationViewModel>();
for (int i = 0; i < dt.Rows.Count; i++)
{
DesignationViewModel designation = new DesignationViewModel
{
DesignationId = Convert.ToInt32(dt.Rows[i]["DesignationId"]),
Designation = Convert.ToString(dt.Rows[i]["Designation"]),
Abbrivation = Convert.ToString(dt.Rows[i]["Abbr"]),
};
designationList.Add(designation);
}
return(designationList);
}
// GET: Designation/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var departments = _departmenManager.GetAll();
Designation designation = _designationManager.GetById((int)id);
DesignationViewModel designationVM = new DesignationViewModel()
{
Id = designation.Id,
Name = designation.Name,
Department = departments.Where(x => x.Id == designation.DepartmentId).FirstOrDefault()
};
return(View(designationVM));
}
public JsonResult CheckDesignationNameExist(string designationName)
{
bool check = false;
DesignationViewModel dViewModel = new DesignationViewModel();
try
{
check = _dRepo.CheckDesignationNameExist(designationName);
Logger.Debug("Designation Controller CheckDesignationNameExist");
}
catch (Exception ex)
{
Logger.Error("Designation Controller - CheckDesignationNameExist" + ex.Message);
}
return(Json(check, JsonRequestBehavior.AllowGet));
}
public ActionResult Create(DesignationViewModel designationVM)
{
try
{
Designation designation = new Designation();
designation.Name = designationVM.Name;
designation.DepartmentId = designationVM.DepartmentId;
bool isSaved = _designationManager.Add(designation);
if (isSaved)
{
TempData["msg"] = "Designation Save Successfully";
}
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public virtual JsonResult EditDesignation(DesignationViewModel model)
{
try
{
var entity = db.Designations.Find(model.Id);
if (entity == null)
{
return(Json(new { success = false, message = "Not found" }, JsonRequestBehavior.AllowGet));
}
entity.DesignationName = model.DesignationName;
db.Entry(entity).State = EntityState.Modified;
db.SaveChanges();
return(Json(new { success = true, message = "Success" }, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
return(Json(new { success = false, message = ex.Message }, JsonRequestBehavior.AllowGet));
}
}
