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 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 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 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));
}
}
// GET: LeaveRequestController/Create
public async Task <ActionResult> Create()
{
var employee = await _userManager.GetUserAsync(User);
var leaveAllocationsIds = (await _leaveAllocationRepo.FindAll())
.Where(q => q.EmployeeId == employee.Id.ToString())
.Select(q => q.LeaveTypeId);
var leaveTypes = (await _leaveTypeRepo.FindAll())
.Where(q => leaveAllocationsIds.Contains(q.Id));
var leaveTypeItems = leaveTypes.Select(q => new SelectListItem
{
Text = q.Name,
Value = q.Id.ToString()
});
var model = new CreateLeaveRequestVM
{
LeaveTypes = leaveTypeItems
};
return(View(model));
}
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 async Task <IActionResult> Create(CreateLeaveRequestVM leaveRequest)
{
var currentEmployee = await _UnitOfWork.Employees.GetEmployeeAsync(User);
if (currentEmployee == null)
{
ModelState.AddModelError("", _ControllerLocalizer["Your account not belongs to employees"]);
return(Forbid());
}
if (!ModelState.IsValid)
{
return(View(leaveRequest));
}
leaveRequest.LeaveTypes = _Mapper.Map <IEnumerable <SelectListItem> >(await _UnitOfWork.LeaveTypes.WhereAsync(c => c.CompanyId == currentEmployee.CompanyId));
if (DateTime.Compare(leaveRequest.StartDate, leaveRequest.EndDate) > 1)
{
ModelState.AddModelError("Date", _ControllerLocalizer["Start date must be earlier that the end date"]);
return(View(leaveRequest));
}
if (!await ValidateRequestDaysAsync(currentEmployee.Id, (int)leaveRequest.LeaveTypeId, leaveRequest.StartDate, leaveRequest.EndDate))
{
ModelState.AddModelError("", _ControllerLocalizer["You have requested more days that you owned"]);
return(View(leaveRequest));
}
var request = new LeaveRequest()
{
ActionedDateTime = null,
Approuved = null,
ApprouvedBy = null,
ApprouvedById = null,
LeaveTypeId = (int)leaveRequest.LeaveTypeId,
RequestedDate = DateTime.Now,
StartDate = leaveRequest.StartDate,
EndDate = leaveRequest.EndDate,
RequestingEmployeeId = currentEmployee.Id,
RequestComment = leaveRequest.RequestComment,
};
bool result = await _UnitOfWork.LeaveRequest.CreateAsync(request);
result &= await _UnitOfWork.Save();
if (!result)
{
ModelState.AddModelError("", _ControllerLocalizer[
@"Something went wrong when submitting your request. Please wait a moment and retry or contact your system administrator"]);
return(View(leaveRequest));
}
else
{
return(RedirectToAction(nameof(EmployeeRequests)));
}
}
// GET: LeaveRequest/Create
public async Task <ActionResult> Create()
{
var leaveTypes = await _leaveTypeRepo.FindAll();
var leaveTypeItems = leaveTypes.Select(lt => new SelectListItem(lt.Name, lt.Id.ToString()));
var model = new CreateLeaveRequestVM
{
LeaveTypes = leaveTypeItems
};
return(View(model));
}
// GET: LeaveRequest/Create
public ActionResult Create()
{
var leaveTypes = _leaveTypeRepo.FindAll().Select(q => new SelectListItem {
Value = q.Id.ToString(), Text = q.Name
});
var model = new CreateLeaveRequestVM
{
LeaveTypes = leaveTypes
};
return(View(model));
}
// GET: LeaveRequestController/Create
public async Task <IActionResult> Create()
{
var leaveTypes = await unitOfWork.LeaveTypes.FindAll();
var createLeaveRequestVM = new CreateLeaveRequestVM
{
LeaveTypes = leaveTypes.Select(l => new SelectListItem()
{
Value = l.Id.ToString(),
Text = l.Name
})
};
return(View(createLeaveRequestVM));
}
// GET: LeaveRequest/Create
public async Task <ActionResult> Create()
{
var leavetypes = await _leaveTypeRepo.FindAll();
var leaveTypeItem = leavetypes.Select(q => new SelectListItem {
Text = q.Name,
Value = q.Id.ToString()
});
var model = new CreateLeaveRequestVM
{
LeaveTypes = leaveTypeItem,
};
return(View(model));
}
// GET: LeaveRequest/Create
public ActionResult Create()
{
var leavetypes = _leavTyperepo.FindAll();
var leavetypeviewietms = leavetypes.Select(q => new SelectListItem
{
Text = q.Name,
Value = q.Id.ToString()
});
var model = new CreateLeaveRequestVM
{
LeaveTypes = leavetypeviewietms
};
return(View(model));
}
// GET: LeaveRequest/Create
public ActionResult Create()
{
var leaveTypes = _leaveTypeRepo.FindAll();
var leaveTypesItems = leaveTypes.Select(q => new SelectListItem
{ //Se crea un objeto select desde el controlador para mostrarlo en el view
Text = q.Name,
Value = q.Id.ToString()
});
var model = new CreateLeaveRequestVM
{
LeaveTypes = leaveTypesItems
};
return(View(model));
}
// GET: LeaveRequest/Create
public async Task <ActionResult> Create()
{
var leaveTypes = await _repoleavetype.FindAll();
var leavetypeitems = leaveTypes.Select(x => new SelectListItem
{
Value = x.Id.ToString(),
Text = x.Name
});
var model = new CreateLeaveRequestVM
{
LeaveTypes = leavetypeitems,
};
return(View(model));
}
// GET: LeaveRequestController/Create
public async Task <ActionResult> Create()
{
var leaveTypes = await _leaveTypeRepo.FindAll();
var leaveTypeItems = leaveTypes.Select(q => new SelectListItem // To convert it to IEnumerable<SelectListItem> .
{
Text = q.Name,
Value = q.Id.ToString()
});
var model = new CreateLeaveRequestVM
{
LeaveTypes = leaveTypeItems
};
return(View(model));
}
// GET: LeaveRequestController/Create
public async Task <ActionResult> Create()
{
var leaveTypes = await _unitOfWork.LeaveTypes.FindAll();
var leaveTypeItems = leaveTypes.Select(_ => new SelectListItem {
Text = _.Name,
Value = _.Id.ToString()
});
var model = new CreateLeaveRequestVM
{
LeaveTypes = leaveTypeItems
};
return(View(model));
}
// GET: LeaveRequest/Create
public async Task <ActionResult> Create()
{
var leaveTypes = await _leaveTypeRepo.FindAll();
//convert the leaveTypes list into an IEnumerable SelectListItem to match our CreateLeaveRequestVM
var leaveTypeItems = leaveTypes.Select(t => new SelectListItem {
Text = t.Name, //what we see rendered
Value = t.id.ToString() //the actual value (value is string)
});
var model = new CreateLeaveRequestVM
{
LeaveTypes = leaveTypeItems
};
return(View(model));
}
// GET: LeaveRequest/Create
public ActionResult Create()
{
//Retrieving leavetype list from the database
var leaveTypes = _leaveTypeRepo.FindAll();
var leaveTypeItems = leaveTypes.Select(q => new SelectListItem
{
Text = q.Name,
Value = q.Id.ToString()
});
//pass the data into the form
var model = new CreateLeaveRequestVM
{
LeaveTypes = leaveTypeItems
};
return(View(model));
}
// GET: LeaveRequest/Create
public async Task <ActionResult> Create()
{
// This gets the collection of leave types from the DB
var leaveTypes = await _unitOfWork.LeaveTypes.FindAll();
// This converts it to a select list b/c our CreateLeaveRequestVM requires this to be
// an IEnumerable SelectListItem
var leaveTypeItems = leaveTypes.Select(q => new SelectListItem {
Text = q.Name,
Value = q.Id.ToString()
});
var model = new CreateLeaveRequestVM
{
LeaveTypes = leaveTypeItems
};
return(View(model));
}
// GET: LeaveRequest/Create
public async Task <ActionResult> Create()
{
//require selectlistitem of leavetype so we need link here
var leaveTypes = await _leaveTypeRepo.FindAll();
//i want this list and represent the data for ech item
var leaveTypeItems = leaveTypes.Select(q => new SelectListItem
{
Text = q.Name,
Value = q.Id.ToString()
});
var model = new CreateLeaveRequestVM
{
LeaveTypes = leaveTypeItems
};
return(View(model));
}
public async Task <IActionResult> Create()
{
var currentEmployee = await _UnitOfWork.Employees.GetEmployeeAsync(User);
if (currentEmployee == null)
{
ModelState.AddModelError("", _ControllerLocalizer["Your account not belongs to employees"]);
return(Forbid());
}
var createLeaveRequestViewModel = new CreateLeaveRequestVM();
var leaveTypes = await _UnitOfWork.LeaveTypes.WhereAsync(x => x.CompanyId == currentEmployee.CompanyId);
createLeaveRequestViewModel.LeaveTypes = _Mapper.Map <List <SelectListItem> >(leaveTypes);
createLeaveRequestViewModel.StartDate = DateTime.Now.Date;
createLeaveRequestViewModel.EndDate = DateTime.Now.AddDays(7).Date;
var requests = await _UnitOfWork.LeaveRequest.WhereAsync(
filter : x => x.RequestingEmployeeId == currentEmployee.Id,
includes : new System.Linq.Expressions.Expression <Func <LeaveRequest, object> >[] { x => x.RequestingEmployee, x => x.LeaveType, x => x.ApprouvedBy });
ViewBag.LeaveData = await GetLeaveSolds(requests, currentEmployee);
return(View(createLeaveRequestViewModel));
}
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 ActionResult Create(CreateLeaveRequestVM model)
{
try
{
CultureInfo provider = CultureInfo.InvariantCulture;
var format = "MM/dd/yyyy";
var startDate = DateTime.ParseExact(model.StartDate, format, provider);
var endDate = DateTime.ParseExact(model.EndTime, format, provider);
//var startDate = Convert.ToDateTime(model.StartDate, CultureInfo.CurrentCulture);
//var endDate = Convert.ToDateTime(model.EndTime);
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(startDate, 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 allocations = _leaveAllocRepo.GetLeaveAllocationsByEmployeeAndType(employee.Id, model.LeaveTypeId);
int daysRequired = (int)(endDate - startDate).TotalDays;
if (daysRequired > allocations.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
};
var leaveRequest = _mapper.Map <LeaveRequest>(leaveRequestModel);
var isSuccess = _leaveRequestRepo.Create(leaveRequest);
if (!isSuccess)
{
ModelState.AddModelError("", "Something went wrong");
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 = 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)
{
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));
}
}
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)
{
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 = 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 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));
}
}
