public ActionResult Create(CreateLeaveRequestVM model)
{
try
{
var leaveTypes = _leaveTypeRepo.FindAll();
var leaveTypesItems = leaveTypes.Select(q => new SelectListItem
{
Text = q.Name,
Value = q.Id.ToString()
});
model.LeaveTypes = leaveTypesItems;
if (!ModelState.IsValid)
{
return(View(model));
}
if (DateTime.Compare(model.StartDate, model.EndDate) > 1)
{
ModelState.AddModelError("", "Start Date cannot be further in the future than the End Date");
return(View(model));
}
var employee = _userManager.GetUserAsync(User).Result; //Obtiene el usuario que ha iniciado sesión actualmente
var allocation = _leaveAllocRepo.GetLeaveAllocationsByEmployeeAndType(employee.Id, model.LeaveTypeId);
int daysRequested = (int)(model.EndDate.Date - model.StartDate.Date).TotalDays;
if (daysRequested > allocation.NumberOfDays)
{
ModelState.AddModelError("", "You Do Not have Sufficient Days For This Request");
return(View(model));
}
var leaveRequestModel = new LeaveRequestVM
{
RequestingEmployeeId = employee.Id,
StartDate = model.StartDate,
EndDate = model.EndDate,
Approved = null,
DateRequested = DateTime.Now,
DateActioned = DateTime.Now,
LeaveTypeId = model.LeaveTypeId
};
var leaveRequest = _mapper.Map <LeaveRequest>(leaveRequestModel);
var isSuccess = _leaveRequestRepo.Create(leaveRequest);
if (!isSuccess)
{
ModelState.AddModelError("", "Something Went Wrong With Submiting Your Record");
return(View(model));
}
return(RedirectToAction(nameof(Index), "Home"));
}
catch (Exception ex)
{
ModelState.AddModelError("", "Something Went Wrong");
return(View(model));
}
}
public ActionResult Create(CreateLeaveRequestVM model)
{
try
{
var startDate = Convert.ToDateTime(model.StartDate);
var endDate = Convert.ToDateTime(model.EndDate);
var leaveTypes = _leaveTypeRepository.FindAll();
var leaveItems = leaveTypes.Select(q => new SelectListItem
{
Text = q.Name,
Value = q.Id.ToString()
});
model.LeaveTypes = leaveItems;
if (!ModelState.IsValid)
{
return(View(model));
}
if (DateTime.Compare(startDate, endDate) > 0)
{
ModelState.AddModelError("", "Start date cannot be farther in the future than end date");
return(View(model));
}
var employee = _userManager.GetUserAsync(User).Result;
var allocation = _leaveAllocationRepository.GetLeaveAllocationsByEmployeeAndType(employee.Id, model.LeaveTypeId);
int daysRequested = (int)(endDate - startDate).TotalDays;
if (daysRequested > allocation.NumberOfDays)
{
ModelState.AddModelError("", "You do not have sufficient days for this request");
return(View(model));
}
var leaveRequestModel = new LeaveRequestVM
{
RequestingEmployeeId = employee.Id,
StartDate = startDate,
EndDate = endDate,
Approved = null,
DateRequested = DateTime.Now,
DateActioned = DateTime.Now,
LeaveTypeId = model.LeaveTypeId,
RequestComments = model.RequestComments
};
var leaveRequest = _mapper.Map <LeaveRequest>(leaveRequestModel);
var isSuccess = _leaveRequestRepository.Create(leaveRequest);
if (!isSuccess)
{
ModelState.AddModelError("", "Something went wrong while creating the leaverequest");
return(View(model));
}
return(RedirectToAction("MyLeave"));
}
catch (Exception ex)
{
ModelState.AddModelError("", "Something went wrong");
return(View(model));
}
}
public ActionResult Create(CreateLeaveRequestVM model)
{
try
{
var leaveTypes = _leaveTypeRepo.FindAll();
var leaveTypeItems = leaveTypes.Select(q => new SelectListItem
{
Text = q.Name,
Value = q.Id.ToString()
});
model.LeaveTypes = leaveTypeItems;
if (!ModelState.IsValid)
{
return(View(model));
}
if (DateTime.Compare(model.StartDate, model.EndDate) > 1)
{
ModelState.AddModelError("", "Start Date cannot be after the end date, pls review!!");
return(View(model));
}
var employee = _userManager.GetUserAsync(User).Result;
var allocation = _leaveAllocRepo.GetLeaveAllocationByEmployeeAndType(employee.Id, model.LeaveTypeId);
int daysRequested = (int)(model.EndDate.Date - model.StartDate.Date).TotalDays;
if (daysRequested > allocation.NumberOfDays)
{
ModelState.AddModelError("", "You Do Not Have Sufficient Days For This Request");
return(View(model));
}
var leaveRequestModel = new LeaveRequestVM
{
RequestingEmployeeId = employee.Id,
StartDate = model.StartDate,
EndDate = model.EndDate,
Approved = null,
DateRequested = DateTime.Now,
DateActioned = DateTime.Now,
LeaveTypeId = model.LeaveTypeId,
RequestComments = model.RequestComments
};
var leaveRequest = _mapper.Map <LeaveRequest>(leaveRequestModel);
var isSuccess = _leaveRequestRepo.Create(leaveRequest);
if (!isSuccess)
{
ModelState.AddModelError("", "Something went wrong with submitting your Request");
return(View(model));
}
return(RedirectToAction("EmployeeLeaveRequests"));
}
catch (Exception ex)
{
ModelState.AddModelError("", "Something Went Wrong");
return(View(model));
}
}
public ActionResult Create(CreateLeaveRequestVM model)
{
var leaveTypes = _leaveTypeRepo.FindAll();
var leaveTypeItems = leaveTypes.Select(q => new SelectListItem
{
Text = q.Name,
Value = q.Id.ToString()
});
try
{
// TODO: Add insert logic here
if (!ModelState.IsValid)
{
return(View(model));
}
if (DateTime.Compare(model.StartDate, model.EndDate) > 1)
{
ModelState.AddModelError("", "Start Date Cannot Be Further In The Future Than The End Date");
return(View(model));
}
var employee = _userManager.GetUserAsync(User).Result;
var allocation = _leaveAlloRepo.GetLeaveAllocationsByEmployeeAndType(employee.Id, model.LeaveTypeId);
int daysRequested = (int)(model.EndDate.Date - model.StartDate.Date).TotalDays;
if (daysRequested > allocation.NumberOfDays)
{
ModelState.AddModelError("", "You Don't Have Enough Days Left");
return(RedirectToAction(nameof(Index), "Home"));
}
var leaveRequestModel = new LeaveRequestVM
{
RequestingEmployeeId = employee.Id,
StartDate = model.StartDate,
EndDate = model.EndDate,
Approved = null,
DateRequested = DateTime.Now,
DateActioned = DateTime.Now,
LeaveTypeId = model.LeaveTypeId,
};
var leaveRequest = _mapper.Map <LeaveRequest>(leaveRequestModel);
var isSuccess = _leaveRequestRepo.Create(leaveRequest);
if (!isSuccess)
{
ModelState.AddModelError(string.Empty, "Errr, Something Went Wrong....");
return(RedirectToAction(nameof(Index), "Home"));
}
return(RedirectToAction(nameof(Index), "Home"));
}
catch (Exception ex)
{
Console.WriteLine(ex);
return(View(model));
}
}
public async Task <ActionResult> Create(CreateLeaveRequestVM model)
{
try
{
var startDate = Convert.ToDateTime(model.StartDate);
var endDate = Convert.ToDateTime(model.EndDate);
var leaveTypes = await _leaveTypeRepo.FindAll();
var leaveTypeItems = leaveTypes.Select(q => new SelectListItem
{
Text = q.Name,
Value = q.Id.ToString()
});
model.LeaveTypes = leaveTypeItems;
if (!ModelState.IsValid)
{
return(View(model));
}
if (DateTime.Compare(startDate, endDate) > 1)
{
ModelState.AddModelError("", "Start date is later than end date.");
return(View(model));
}
var employee = await _userManager.GetUserAsync(User);
var allocation = await _leaveAllocRepo.GetLeaveAllocationsByEmployeeAndType(employee.Id, model.LeaveTypeId);
int daysRequested = (int)(endDate.Date - startDate.Date).TotalDays;
if (daysRequested > allocation.NumberOfDays)
{
ModelState.AddModelError("", "You don't have enough of these leave-type days!");
return(View(model));
}
var leaveRequestModel = new LeaveRequestVM
{
RequestingEmployeeId = employee.Id,
StartDate = startDate,
EndDate = endDate,
Approved = null,
DateRequested = DateTime.Now,
DateActioned = DateTime.Now,
LeaveTypeId = model.LeaveTypeId,
RequestComments = model.RequestComments
};
var leaveRequest = _mapper.Map <LeaveRequest>(leaveRequestModel);
var isSuccess = await _leaveRequestRepo.Create(leaveRequest);
if (!isSuccess)
{
ModelState.AddModelError("", "Something went wrong submitting your request.");
return(View(model));
}
return(RedirectToAction("MyLeave"));
}
catch (Exception)
{
ModelState.AddModelError("", "Something went wrong.");
return(View(model));
}
}
public bool Insert(LeaveRequestVM leaveRequestVM)
{
if (string.IsNullOrWhiteSpace(leaveRequestVM.Requester_Id.ToString()))
{
return(status);
}
else if (string.IsNullOrWhiteSpace(leaveRequestVM.FromDate.ToString()))
{
return(status);
}
else if (string.IsNullOrWhiteSpace(leaveRequestVM.EndDate.ToString()))
{
return(status);
}
else if (string.IsNullOrEmpty(leaveRequestVM.Reason.ToString()))
{
return(status);
}
else if (string.IsNullOrEmpty(leaveRequestVM.Leave_Id.ToString()))
{
return(status);
}
else
{
return(iLeaveRequestRepository.Insert(leaveRequestVM));
}
}
protected override void OnAppearing()
{
Vm = new LeaveRequestVM();
BindingContext = Vm;
applicationno = SecureStorage.GetAsync("applicationNo").GetAwaiter().GetResult();
// Vm.gethosteladmissionid(applicationno);
}
public void Update(LeaveRequestVM leaverequestVM)
{
this.FromDate = leaverequestVM.FromDate;
this.ToDate = leaverequestVM.ToDate;
this.Reason = leaverequestVM.Reason;
this.ApproverComments = leaverequestVM.ApproverComments;
this.Status = leaverequestVM.Status;
this.UpdateDate = DateTimeOffset.Now.LocalDateTime;
}
public ActionResult Create(CreateLeaveRequestVM model)
{
try
{
var leaveTypes = _leaveTypeRepo.FindAll().Select(q => new SelectListItem {
Value = q.Id.ToString(), Text = q.Name
});
model.LeaveTypes = leaveTypes;
if (!ModelState.IsValid)
{
return(View(model));
}
if (DateTime.Compare(model.StartDate, model.EndDate) > 0)
{
ModelState.AddModelError("", "Error");
return(View(model));
}
var employee = _userManager.GetUserAsync(User).Result;
var allocations = _allocationRepo.GetLeaveAllocationsByEmployeeAndType(employee.Id, model.LeaveTypeId);
int daysRequested = (int)(model.EndDate.Date - model.StartDate.Date).TotalDays;
if (daysRequested > allocations.NumberOfDays)
{
ModelState.AddModelError("", "Error to mach days");
return(View(model));
}
var leaveRequestModel = new LeaveRequestVM
{
RequestingEmployeeId = employee.Id,
StartDate = model.StartDate,
EndDate = model.EndDate,
Approved = null,
DateRequested = DateTime.Now,
DateActioned = DateTime.Now,
LeaveTypeId = model.LeaveTypeId
};
var leaveRequest = _mapper.Map <LeaveRequest>(leaveRequestModel);
var isSuccess = _requestRepo.Create(leaveRequest);
if (!isSuccess)
{
ModelState.AddModelError("", "Error create");
return(View(model));
}
return(RedirectToAction(nameof(Index)));
}
catch (Exception ex)
{
ModelState.AddModelError("", "Error");
return(View(model));
}
}
public LeeaveRequest(LeaveRequestVM leaveRequestVM)
{
this.FromDate = leaveRequestVM.FromDate;
this.ToDate = leaveRequestVM.ToDate;
this.Reason = leaveRequestVM.Reason;
this.ApproverComments = leaveRequestVM.ApproverComments;
this.Status = leaveRequestVM.Status;
this.Employees_Id = leaveRequestVM.Employees_Id;
this.CreateDate = DateTimeOffset.Now.LocalDateTime;
}
public bool Insert(LeaveRequestVM leaveRequestVM)
{
var push = new LeeaveRequest(leaveRequestVM);
var getCategory = aplicationContext.LeaveCategories.SingleOrDefault(x => x.IsDelete == false && x.Id == leaveRequestVM.Leave_Categories_Id);
push.LeaveCategory = getCategory;
aplicationContext.LeaveRequest.Add(push);
var result = aplicationContext.SaveChanges();
return(result > 0);
}
private void btn_Save_Click(object sender, RoutedEventArgs e)
{
var result = false;
var LeaveRequestParam = new LeaveRequestVM(Convert.ToInt32(cmb_LeaveType.SelectedValue),
Convert.ToDateTime(date_LeaveStarts.Text),
Convert.ToDateTime(date_LeaveEnds.Text), DateTimeOffset.Now, txt_Reason.Text,
_userId, "lampiran", 5);
result = iLeaveRequestService.Insert(LeaveRequestParam);
MessageBox.Show(result ? "Insert Successfully" : "Insert Failed");
}
public void Update(LeaveRequestVM leaveRequestVM)
{
this.Request_Date = leaveRequestVM.Request_Date;
this.From_Date = leaveRequestVM.From_Date;
this.End_Date = leaveRequestVM.End_Date;
this.Employee_Id = leaveRequestVM.Employee_Id;
this.Attachment = leaveRequestVM.Attachment;
this.Reason = leaveRequestVM.Reason;
this.Manager_Id = leaveRequestVM.Manager_Id;
this.Status = leaveRequestVM.Status;
this.UpdateDate = DateTimeOffset.Now.ToLocalTime();
}
public LeaveRequest(LeaveRequestVM leaveRequestVM)
{
Leave_Id = leaveRequestVM.Leave_Id;
FromDate = leaveRequestVM.FromDate;
EndDate = leaveRequestVM.EndDate;
RequestDate = leaveRequestVM.RequestDate;
Reason = leaveRequestVM.Reason;
Requester_Id = leaveRequestVM.Requester_Id;
// ApprovalManager_Id = leaveRequestVM.ApprovalManager_Id;
// ApprovalHrd_Id = leaveRequestVM.ApprovalManager_Id;
Attachments = leaveRequestVM.Attachments;
Status_Id = leaveRequestVM.Status_Id;
CreateDate = DateTimeOffset.Now.ToLocalTime();
}
public bool Update(int id, LeaveRequestVM leaveRequestVM)
{
var get = Get(id);
var getLeaveType = myContext.LeaveTypes.Find(leaveRequestVM.LeaveType_Id);
get.LeaveType = getLeaveType;
if (get != null)
{
get.Update(leaveRequestVM);
myContext.Entry(get).State = EntityState.Modified;
myContext.SaveChanges();
status = true;
}
return(status);
}
public async Task <ActionResult <LeaveRequest> > PostLeaveRequest(LeaveRequestVM LeaveRequestObj)
{
System.Security.Claims.ClaimsPrincipal currentUser = this.User;
var email = User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Email).Value;
var lstUsers = _context.Employees.Where(e => e.Email == email).ToList();
if (lstUsers.Count > 0)
{
var CurrentEmpUser = lstUsers[0];
if (LeaveRequestObj.EmployeeID == 0)
{
LeaveRequestObj.EmployeeID = CurrentEmpUser.ID;
}
LeaveRequestObj.Date = DateTime.Now;
LeaveRequest lv = new LeaveRequest
{
Date = LeaveRequestObj.Date,
Comment = LeaveRequestObj.Comment,
AlternativeEmpID = LeaveRequestObj.AlternativeEmpID,
EmployeeID = LeaveRequestObj.EmployeeID,
LeaveTypeID = LeaveRequestObj.LeaveTypeID,
AlternativeAddress = LeaveRequestObj.AlternativeAddress,
Start = LeaveRequestObj.Start,
Status = LeaveRequestObj.Status,
Days = LeaveRequestObj.Days
};
_context.LeaveRequests.Add(lv);
await _context.SaveChangesAsync();
if (LeaveRequestObj.LeavesFiles != null)
{
var files = LeaveRequestObj.LeavesFiles.Split(',').ToList();
files.Remove("");
foreach (var item in files)
{
LeaveFiles leaveFiles = new LeaveFiles
{
FileName = item,
LeaveRequestID = lv.ID
};
_context.LeaveFiles.Add(leaveFiles);
}
}
await _context.SaveChangesAsync();
}
return(CreatedAtAction("GetLeaveRequest", new { id = LeaveRequestObj.ID }, LeaveRequestObj));
}
public bool Update(int id, LeaveRequestVM leaveRequestVM)
{
var get = Get(id);
if (get != null)
{
get.Update(leaveRequestVM);
aplicationContext.Entry(get).State = EntityState.Modified;
var result = aplicationContext.SaveChanges();
return(result > 0);
}
else
{
return(false);
}
}
public bool Insert(LeaveRequestVM leaveRequestVM)
{
var push = new LeaveRequest(leaveRequestVM);
var getLeaveType = myContext.LeaveTypes.Find(leaveRequestVM.LeaveType_Id);
push.LeaveType = getLeaveType;
myContext.LeaveRequests.Add(push);
var result = myContext.SaveChanges();
if (result > 0)
{
status = true;
}
return(status);
}
// POST: api/LeaveRequests
public HttpResponseMessage InsertLeaveRequest(LeaveRequestVM leaveRequestVM)
{
try
{
var message = Request.CreateErrorResponse(HttpStatusCode.NotFound, "404 : Data Not Found");
var result = iLeaveRequestService.Insert(leaveRequestVM);
if (result)
{
message = Request.CreateResponse(HttpStatusCode.OK, leaveRequestVM);
}
return(message);
}
catch (Exception e)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "500 : Internal Server Error"));
}
}
public bool Insert(LeaveRequestVM leaveRequestVM)
{
var push = new LeaveRequest(leaveRequestVM);
myContext.leaveRequests.Add(push);
var result = myContext.SaveChanges();
if (result > 0)
{
status = true;
}
else
{
return(status);
}
return(status);
}
public bool Update(int id, LeaveRequestVM leaveRequestVM)
{
if (string.IsNullOrWhiteSpace(leaveRequestVM.Request_Date.ToString()) ||
string.IsNullOrWhiteSpace(leaveRequestVM.From_Date.ToString()) ||
string.IsNullOrWhiteSpace(leaveRequestVM.End_Date.ToString()) ||
string.IsNullOrWhiteSpace(leaveRequestVM.Employee_Id.ToString()) ||
string.IsNullOrWhiteSpace(leaveRequestVM.Reason) ||
string.IsNullOrWhiteSpace(leaveRequestVM.LeaveType_Id.ToString()) ||
string.IsNullOrWhiteSpace(leaveRequestVM.Status) ||
string.IsNullOrWhiteSpace(leaveRequestVM.Manager_Id.ToString()))
{
return(false);
}
else
{
return(iLeaveRequestRepository.Update(id, leaveRequestVM));
}
}
public void InsertOrUpdate(LeaveRequestVM leaveRequestVM)
{
var client = new HttpClient();
client.BaseAddress = new Uri(get.link);
var myContent = JsonConvert.SerializeObject(leaveRequestVM);
var buffer = System.Text.Encoding.UTF8.GetBytes(myContent);
var byteContent = new ByteArrayContent(buffer);
byteContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
if (leaveRequestVM.Id.Equals(0))
{
var result = client.PostAsync("LeaveRequests", byteContent).Result;
}
else
{
var result = client.PutAsync("LeaveRequests/" + leaveRequestVM.Id, byteContent).Result;
}
}
public JsonResult GetById(int id)
{
LeaveRequestVM leaveRequestVM = null;
var client = new HttpClient
{
BaseAddress = new Uri(get.link)
};
var responseTask = client.GetAsync("LeaveRequests/" + id);
responseTask.Wait();
var result = responseTask.Result;
if (result.IsSuccessStatusCode)
{
var readTask = result.Content.ReadAsAsync <LeaveRequestVM>();
responseTask.Wait();
leaveRequestVM = readTask.Result;
}
else
{
}
return(Json(leaveRequestVM, JsonRequestBehavior.AllowGet));
}
public async Task <ActionResult> Create(CreateLeaveRequestVM model)
{
try
{
var startDate = Convert.ToDateTime(model.StartDate);
var endDate = Convert.ToDateTime(model.EndDate);
var leaveTypes = await _unitOfWork.LeaveTypes.FindAll();
var employee = await _userManager.GetUserAsync(User);
var period = DateTime.Now.Year;
var allocation = await _unitOfWork.LeaveAllocations.Find(q => q.EmployeeId == employee.Id &&
q.Period == period &&
q.LeaveTypeId == model.LeaveTypeId);
int daysRequested = (int)(endDate - startDate).TotalDays;
var leaveTypeItems = leaveTypes.Select(q => new SelectListItem
{
Text = q.Name,
Value = q.Id.ToString()
});
model.LeaveTypes = leaveTypeItems;
if (allocation == null)
{
ModelState.AddModelError("", "You Have No Days Left");
}
if (DateTime.Compare(startDate, endDate) > 1)
{
ModelState.AddModelError("", "Start Date cannot be further in the future than the End Date");
}
if (daysRequested > allocation.NumberOfDays)
{
ModelState.AddModelError("", "You Do Not Sufficient Days For This Request");
}
if (!ModelState.IsValid)
{
return(View(model));
}
var leaveRequestModel = new LeaveRequestVM
{
RequestingEmployeeId = employee.Id,
StartDate = startDate,
EndDate = endDate,
Approved = null,
DateRequested = DateTime.Now,
DateActioned = DateTime.Now,
LeaveTypeId = model.LeaveTypeId,
RequestComments = model.RequestComments
};
var leaveRequest = _mapper.Map <LeaveRequest>(leaveRequestModel);
await _unitOfWork.LeaveRequests.Create(leaveRequest);
await _unitOfWork.Save();
// Send Email to supervisor and requesting user
await _emailSender.SendEmailAsync("*****@*****.**", "New Leave Request",
$"Please review this leave request. <a href='UrlOfApp/{leaveRequest.Id}'>Click Here</a>");
return(RedirectToAction("MyLeave"));
}
catch (Exception ex)
{
ModelState.AddModelError("", "Something went wrong");
return(View(model));
}
}
public async Task <ActionResult> Create(CreateLeaveRequestVM model)
{
try
{
var startDate = Convert.ToDateTime(model.StartDate);
var endDate = Convert.ToDateTime(model.EndDate);
var leaveTypes = await _unitOfWork.LeaveTypes.FindAll();
var leaveTypeItems = leaveTypes.Select(_ => new SelectListItem
{
Text = _.Name,
Value = _.Id.ToString()
});
model.LeaveTypes = leaveTypeItems;
if (!ModelState.IsValid)
{
return(View(model));
}
if (DateTime.Compare(startDate, endDate) > 1)
{
ModelState.AddModelError("", "Start Date cannot be further in the future than the End Date.");
return(View(model));
}
var employee = await _userManager.GetUserAsync(User);
var allocation = await _unitOfWork.LeaveAllocations.Find(_ => _.EmployeeId == employee.Id && _.LeaveTypeId == model.LeaveTypeId && _.Period == DateTime.Now.Year);
int daysRequested = (int)(endDate.Date - startDate.Date).TotalDays;
if (daysRequested > allocation.NumberOfDays)
{
ModelState.AddModelError("", "You do not have sufficient days for this request.");
return(View(model));
}
var leaveRequestModel = new LeaveRequestVM
{
RequestingEmloyeeId = employee.Id,
LeaveTypeId = model.LeaveTypeId,
StartDate = startDate,
EndDate = endDate,
Approved = null,
DateRequested = DateTime.Now,
DateActioned = DateTime.Now,
RequestComments = model.RequestComments
};
var leaveRequest = _mapper.Map <LeaveRequest>(leaveRequestModel);
await _unitOfWork.LeaveRequests.Create(leaveRequest);
await _unitOfWork.Save();
return(RedirectToAction(nameof(MyLeave)));
}
catch (Exception ex)
{
ModelState.AddModelError("", "Something went wrong.");
return(View(model));
}
}
public async Task <ActionResult> Create(CreateLeaveRequestVM model)
{
try
{
var StartDate = Convert.ToDateTime(model.StartDate);
var EndDate = Convert.ToDateTime(model.EndDate);
var leaveTypes = _leaveTypeRepo.FindAll();
var leaveTypeItems = (await leaveTypes).Select(q => new SelectListItem
{
Text = q.Name,
Value = q.Id.ToString()
});
model.LeaveTypes = leaveTypeItems;
if (!ModelState.IsValid)
{
return(View(model));
}
if (DateTime.Compare(StartDate, EndDate) > 0)
{
ModelState.AddModelError("", "Ngày kết thúc phải sau ngày bắt đầu.");
return(View(model));
}
if (DateTime.Compare(StartDate, DateTime.Now.Date) < 0)
{
ModelState.AddModelError("", "Ngày bắt đầu và ngày kết thúc phải ở tương lai." + DateTime.Now.Date.ToString());
return(View(model));
}
var employee = await _userManager.GetUserAsync(User);
var allocation = await _leaveAllocationRepo.GetLeaveAllocationsByEmployeeAndType(employee.Id, model.LeaveTypeId);
int daysRequested = (int)(EndDate - StartDate).TotalDays;
if (daysRequested > allocation.NumberOfDays)
{
ModelState.AddModelError("", "Số ngày bạn yêu cầu vượt quá số ngày cho phép");
return(View(model));
}
var previousApprovedLeaveRequests = (await _leaveRequestRepo.FindAll())
.Where(q => q.RequestingEmployeeId == employee.Id);
foreach (var request in previousApprovedLeaveRequests)
{
if (DateTime.Compare(StartDate, request.StartDate) > 0 && DateTime.Compare(StartDate, request.EndDate) < 0 ||
DateTime.Compare(EndDate, request.StartDate) > 0 && DateTime.Compare(EndDate, request.EndDate) < 0 ||
DateTime.Compare(StartDate, request.StartDate) <= 0 && DateTime.Compare(EndDate, request.EndDate) >= 0
)
{
ModelState.AddModelError("", "Khoảng thời gian nghỉ phép mà bạn yêu cầu trùng với khoảng thời gian nghỉ phép đã gửi.");
return(View(model));
}
}
var LichSuChamCongList = await nhatKylamViecRepository.FindByMaNhanVien(employee.Id);
foreach (var item in LichSuChamCongList)
{
if (StartDate.CompareTo(item.ThoiGianBatDau) >= 0 && StartDate.CompareTo(item.ThoiGianKetThuc) < 0
||
EndDate.CompareTo(item.ThoiGianBatDau) > 0 && EndDate.CompareTo(item.ThoiGianKetThuc) <= 0)
{
ModelState.AddModelError("", "Khoảng thời gian được chọn bị trùng với lịch biểu trước đó" +
"\n Khoảng thời gian được chọn: " + StartDate + " => " + EndDate +
"\n Lịch biểu bị trùng: " + item.ThoiGianBatDau + " => " + item.ThoiGianKetThuc);
return(View(model));
}
}
var leaveRequestModel = new LeaveRequestVM
{
RequestingEmployeeId = employee.Id,
StartDate = StartDate,
EndDate = EndDate,
ApprovedById = null,
DateRequested = DateTime.Now,
DateActioned = DateTime.Now,
LeaveTypeId = model.LeaveTypeId
};
var leaveRequest = _mapper.Map <LeaveRequest>(leaveRequestModel);
var isSuccess = await _leaveRequestRepo.Create(leaveRequest);
if (!isSuccess)
{
ModelState.AddModelError("", "Something went wrong with submitting your record");
return(View(model));
}
return(RedirectToAction(nameof(MyLeave)));
}
catch (Exception ex)
{
ModelState.AddModelError("", "Something went wrong");
return(View(model));
}
}
public async Task <ActionResult> Create(CreateLeaveRequestVM model)
{
try
{
var startDate = Convert.ToDateTime(model.StartDate);
var endDate = Convert.ToDateTime(model.EndDate);
var leaveTypes = await _leaveTypeRepo.FindAll();
var employee = await _userManager.GetUserAsync(User);
var allocation = await _leaveAllocRepo.GetLeaveAllocationsByEmployeeAndType(employee.Id, model.LeaveTypeId);
int daysRequested = (int)(endDate - startDate).TotalDays;
var leaveTypeItems = leaveTypes.Select(q => new SelectListItem
{
Text = q.Name,
Value = q.Id.ToString()
});
model.LeaveTypes = leaveTypeItems;
if (allocation == null)
{
ModelState.AddModelError("", "You Have No Days Left");
}
if (DateTime.Compare(startDate, endDate) > 1)
{
ModelState.AddModelError("", "Start Date cannot be further in the future than the End Date");
}
if (daysRequested > allocation.NumberofDays)
{
ModelState.AddModelError("", "You Do Not Sufficient Days For This Request");
}
if (!ModelState.IsValid)
{
return(View(model));
}
var leaveRequestModel = new LeaveRequestVM
{
RequestingEmployeeId = employee.Id,
StartDate = startDate,
EndDate = endDate,
Approved = null,
DateRequested = DateTime.Now,
DateActioned = DateTime.Now,
LeaveTypeId = model.LeaveTypeId,
};
var leaveRequest = _mapper.Map <LeaveRequest>(leaveRequestModel);
var isSuccess = await _leaveRequestRepo.Create(leaveRequest);
if (!isSuccess)
{
ModelState.AddModelError("", "Something went wrong with submitting your record");
return(View(model));
}
return(RedirectToAction("MyLeave"));
}
catch (Exception ex)
{
ModelState.AddModelError("", "Something went wrong");
return(View(model));
}
}
public async Task <ActionResult> Create(CreateLeaveRequestVM model)
{
try
{
var startDate = model.StartDate;
var endDate = model.EndDate;
// var leaveTypes =await _leaveTyperepo.FindAll();
var leaveTypes = await _unitOfWork.LeaveTypes.FindAll();
var leaveTypesItems = leaveTypes.Select(q => new SelectListItem
{
Text = q.Name,
Value = q.Id.ToString()
});
model.LeaveTypes = leaveTypesItems;
if (!ModelState.IsValid)
{
return(View(model));
}
//check startdate is larger than enddate
// if 0 => just one day
// if -1 => not large
//if 1 => large
if (DateTime.Compare(startDate, endDate) > 1)
{
ModelState.AddModelError("", "Start Date cannot be further in the future than the End Date!");
return(View(model));
}
var employee = await _userManager.GetUserAsync(User);
//var allocation =await _leaveAllocationrepo.GetLeaveAllocationsByEmployeeAndType(employee.Id, model.LeaveTypeId);
var period = DateTime.Now.Year;
var allocation = await _unitOfWork.LeaveAllocations.Find(q => q.EmployeeId == employee.Id && q.Period == period && q.LeaveTypeId == model.LeaveTypeId);
int dateRequests = (int)(endDate - startDate).TotalDays;
if (dateRequests > allocation.NumberOfDays)
{
ModelState.AddModelError("", "You have no Sufficient Days for this request!");
return(View(model));
}
var leaveRequestModel = new LeaveRequestVM
{
LeaveTypeId = model.LeaveTypeId,
RequestingEmployeeId = employee.Id,
StartDate = startDate,
EndDate = endDate,
Approved = null,
DateRequested = DateTime.Now,
DateActioned = DateTime.Now,
RequestCommments = model.RequestComments
};
var leaveRequest = _mapper.Map <LeaveRequest>(leaveRequestModel);
//var isSuccess =await _leaveRequestRepo.Create(leaveRequest);
//if (!isSuccess)
//{
// ModelState.AddModelError("", "Something Went Wrong ...");
// return View(model);
//}
await _unitOfWork.LeaveRequests.Create(leaveRequest);
await _unitOfWork.Save();
return(RedirectToAction("MyLeave"));
}
catch
{
return(View(model));
}
}
public ActionResult Create(CreateLeaveRequestVM model)
{
var startDate = Convert.ToDateTime(model.StartDate);
var EndDate = Convert.ToDateTime(model.EndDate);
var leavetypes = _leavTyperepo.FindAll();
var leavetypeviewietms = leavetypes.Select(q => new SelectListItem
{
Text = q.Name,
Value = q.Id.ToString()
});
model.LeaveTypes = leavetypeviewietms;
try
{
if (!ModelState.IsValid)
{
return(View(model));
}
if (DateTime.Compare(startDate, EndDate) > 1)
{
ModelState.AddModelError("", "Start date can not be further in the furture than End Date");
return(View(model));
}
var employee = _userManager.GetUserAsync(User).Result;
var allocations = _leavAllocationrepo.GetLeaveAllocationsByEmployeeandType(employee.Id, model.LeaveTypeId);
int daysRequested = (int)(EndDate - startDate).TotalDays;
if (daysRequested > allocations.NumberOfDays)
{
ModelState.AddModelError("", "You do not have sufficinet days for thsi Request");
return(View(model));
}
var leaveRequetsmodel = new LeaveRequestVM
{
RequestingEmployeeId = employee.Id,
StartDate = startDate,
EndDate = EndDate,
Approved = null,
DateRequested = DateTime.Now,
DateActioned = DateTime.Now,
LeaveTypeId = model.LeaveTypeId,
RequestComments = model.RequestComments
};
var leaverequest = _mapper.Map <LeaveRequest>(leaveRequetsmodel);
var isuccess = _leaveRequestrepo.Create(leaverequest);
if (!isuccess)
{
ModelState.AddModelError("", "Somthing went wrong with somthing with submitting your record");
return(View(model));
}
return(RedirectToAction("MyLeave"));
}
catch (Exception ex)
{
ModelState.AddModelError("", "Somthing went wrong");
return(View(model));
}
}
public async Task <ActionResult> Create(CreateLeaveRequestVM model)
{
var leaveTypes = await _repoleavetype.FindAll();
var leavetypeitems = leaveTypes.Select(x => new SelectListItem
{
Value = x.Id.ToString(),
Text = x.Name
});
model.LeaveTypes = leavetypeitems;
try
{
var StartDate = Convert.ToDateTime(model.StartDate);
var EndDate = Convert.ToDateTime(model.EndDate);
if (!ModelState.IsValid)
{
return(View(model));
}
if (DateTime.Compare(StartDate, EndDate) > 1)
{
ModelState.AddModelError("", "Starting Date cannot be greater then End Date...");
return(View(model));
}
var employee = await _userManager.GetUserAsync(User);
var allocation = await _repoleaveallocation.GetLeaveAllocationsByEmployeeAndType(employee.Id, model.LeaveTypeId);
var daysRequested = (int)(EndDate.Date - StartDate.Date).TotalDays;
if (daysRequested > allocation.NumberOfDays)
{
ModelState.AddModelError("", "You do not sufficient days for this Request...");
return(View(model));
}
var leaveRequestModel = new LeaveRequestVM
{
RequestingEmployeeId = employee.Id,
StartDate = StartDate,
EndDate = EndDate,
Approved = null,
DateRequested = DateTime.Now,
DateActioned = DateTime.Now,
LeaveTypeId = model.LeaveTypeId,
CommentRequest = model.CommentRequest
};
var leaverequest = _mapper.Map <LeaveRequest>(leaveRequestModel);
var isSuccess = await _repoleaverequest.Create(leaverequest);
if (!isSuccess)
{
ModelState.AddModelError("", "Something Went Wrong with submitting your record...");
return(View(model));
}
return(RedirectToAction(nameof(MyLeave)));
}
catch
{
ModelState.AddModelError("", "Something Went Wrong...");
return(View(model));
}
}
