public async Task <IHttpActionResult> PutLeaveType(int id, LeaveType leaveType)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != leaveType.LeaveTypeID)
{
return(BadRequest());
}
db.Entry(leaveType).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!LeaveTypeExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IHttpActionResult> PutUserLogin(int id, UserLogin userLogin)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != userLogin.UserLoginID)
{
return(BadRequest());
}
db.Entry(userLogin).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserLoginExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IHttpActionResult> PutDepartment(int id, Department department)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != department.DepartmentID)
{
return(BadRequest());
}
db.Entry(department).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DepartmentExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IActionResult> Create([Bind("Dean_id,MobileNo,FirstName,LastName,Deparment,FreeLeave")] Dean dean)
{
if (ModelState.IsValid)
{
_context.Add(dean);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(dean));
}
public async Task <IActionResult> Create([Bind("id,Email,MobileNo,MobileNo2,Name,LastName,MiddleName,Deparment,Role,Addreaddress,City,PaidLeave")] AllUser allUser)
{
if (ModelState.IsValid)
{
_context.Add(allUser);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(allUser));
}
public async Task <IActionResult> Create([Bind("leave_id,LeaveStatus,HODApproveStatus,DeanApproveStatus,RegistrarApproveStatus,NoOfDay,LeaveReason,StartFrome,EndTill,id")] LeaveHistory leaveHistory)
{
if (ModelState.IsValid)
{
_context.Add(leaveHistory);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["id"] = new SelectList(_context.AllUser, "id", "id", leaveHistory.id);
return(View(leaveHistory));
}
public async Task <IActionResult> LeaveRequest(LeaveRequest leaveRequest, IFormFile file)
{
ViewBag.leavetype = new SelectList(_context.leaveType.Where(x => x.itispersonal == true && x.allcatoToAll == true), "leaveTypeID", "LeaveType");
if (ModelState.IsValid)
{
string uniqueFileName = null;
if (file != null)
{
string uploadsFolder = Path.Combine(webHostEnvironment.WebRootPath, "file");
uniqueFileName = Guid.NewGuid().ToString() + "_" + file.FileName;
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
using (var fileStream = new FileStream(filePath, FileMode.Create))
{
file.CopyTo(fileStream);
}
}
string username = User.Identity.Name;
var singleUser = _context.AllUser.Where(x => x.Email == username).FirstOrDefault();
var leaveHistory = new LeaveHistory
{
StartFrome = leaveRequest.LeaveStartFrome,
EndTill = leaveRequest.LeaveEndTill,
LeaveReason = leaveRequest.LeaveReason,
NoOfDay = (int)((leaveRequest.LeaveEndTill - leaveRequest.LeaveStartFrome).TotalDays),
DeanApproveStatus = "Pending",
HODApproveStatus = "Pending",
RegistrarApproveStatus = "Pending",
LeaveStatus = "Pending",
id = singleUser.id,
leaveTypeID = Convert.ToInt32(leaveRequest.LeaveType),
Attachment = uniqueFileName
};
var leaevupdate = _context.leaveAllocation.Where(x => x.id == singleUser.id && x.leaveTypeID == Convert.ToInt32(leaveRequest.LeaveType)).FirstOrDefault();
var totaledayinpending = _context.LeaveHistory.Where(x => x.id == singleUser.id && x.StartFrome > DateTime.Now && x.LeaveStatus == "Pending").Select(x => x.NoOfDay).ToList().Sum();
if ((int)((leaveRequest.LeaveEndTill - leaveRequest.LeaveStartFrome).TotalDays) > (leaevupdate.NoOfLeave - totaledayinpending))
{
ModelState.AddModelError(string.Empty, "You can not request More than " + (leaevupdate.NoOfLeave - totaledayinpending));
return(View());
}
_context.LeaveHistory.Add(leaveHistory);
await _context.SaveChangesAsync();
return(RedirectToAction("MyLeave", "Registrar"));
}
return(View(leaveRequest));
}
public async Task <AddUserListToLeavePlanDto> Handle(AddUserListToLeavePlanCommand request, CancellationToken cancellationToken)
{
var leavePlanEntity = await context
//.AsNoTracking()
.LeavePlans.SingleOrDefaultAsync(lt => lt.Id.Equals(request.LeavePlanId));
if (leavePlanEntity == null)
{
throw new EntityNotFoundException(nameof(LeavePlan), request.LeavePlanId);
}
var resourceLeaveEntity = await context
//.AsNoTracking()
.ResourceLeaves.SingleOrDefaultAsync(lt => lt.ResourceId.Equals(request.ResourceId));
if (resourceLeaveEntity == null)
{
throw new EntityNotFoundException(nameof(ResourceLeave), request.ResourceId);
}
leavePlanEntity.ResourceLeaves.Add(resourceLeaveEntity);
context.LeavePlans.Update(leavePlanEntity);
await context.SaveChangesAsync(cancellationToken);
return(new AddUserListToLeavePlanDto
{
});
}
public async Task <IActionResult> ListOfAllUser(int?x)
{
try
{
string UserId = HttpContext.Request.Query["UserId"];
string RoleId = HttpContext.Request.Query["RoleId"];
string deparment_name = HttpContext.Request.Query["Deparment"];
if (RoleId == null && deparment_name == null)
{
return(RedirectToAction("ListOfAllUser", "Role"));
}
IdentityUser user = await userManager.FindByIdAsync(UserId);;
if (RoleId != null)
{
var new_role = (await roleManager.FindByIdAsync(RoleId)).Name;
var user_role = (await userManager.GetRolesAsync(user)).FirstOrDefault();
var user_change = _context.AllUser.Where(x => x.Email == user.Email).FirstOrDefault();
user_change.Role = new_role;
_context.AllUser.Update(user_change);
await _context.SaveChangesAsync();
await userManager.RemoveFromRoleAsync(user, user_role);
await userManager.AddToRoleAsync(user, new_role);
}
if (deparment_name != null)
{
var user_change = _context.AllUser.Where(x => x.Email == user.Email).FirstOrDefault();
user_change.Deparment = deparment_name;
_context.AllUser.Update(user_change);
await _context.SaveChangesAsync();
}
//System.Console.WriteLine("svuhfodsifhadhfidfhh");
//return View();
}
catch (Exception)
{
}
return(RedirectToAction("ListOfAllUser", "Role"));
}
public async Task <IActionResult> OwnProfile(OwnProfile ownProfile)
{
//var userLoginDetail = userManager.Users.Where(x => x.Email == User.Identity.Name).FirstOrDefault();
//var userdetail = _context.AllUser.Where(x => x.Email == userLoginDetail.Email).FirstOrDefault();
if (ModelState.IsValid)
{
string uniqueFileName = ProcessUploadedFile(ownProfile);
AllUser allUser = new AllUser
{
id = ownProfile.id,
LastName = ownProfile.LastName,
Addreaddress = ownProfile.Addreaddress,
Email = User.Identity.Name,
City = ownProfile.City,
MiddleName = ownProfile.MiddleName,
MobileNo = ownProfile.MobileNo.ToString(),
MobileNo2 = ownProfile.MobileNo2.ToString(),
Name = ownProfile.Name,
PaidLeave = ownProfile_transfer.PaidLeave,
Deparment = ownProfile_transfer.Department,
Role = ownProfile_transfer.Role,
UserImage = uniqueFileName
};
try
{
_context.Update(allUser);
await _context.SaveChangesAsync();
return(RedirectToAction(controllerName: "common", actionName: "OwnProfile"));
}
catch (DbUpdateConcurrencyException)
{
return(View(ownProfile));
}
}
return(View(ownProfile));
}
public async Task <IActionResult> Register(RegisterViewModel registerViewModel)
{
if (ModelState.IsValid)
{
var user = new IdentityUser
{
Email = registerViewModel.Email,
UserName = registerViewModel.Email
};
var result = await userManager.CreateAsync(user, registerViewModel.Password);
if (result.Succeeded)
{
AllUser allUser = new AllUser();
allUser.Role = "Pending";
allUser.Email = registerViewModel.Email;
allUser.PaidLeave = 20;
allUser.Deparment = "Pending";
_context.Add(allUser);
await _context.SaveChangesAsync();
var s = userManager.Users.Where(a => a.Email == registerViewModel.Email).FirstOrDefault();
IdentityResult identityResult = await userManager.AddToRoleAsync(s, "Pending");
//IdentityResult identityResult = await userManager.AddToRoleAsync(s, "Admin");
await leaveallocationToALL(s.Email);
if (identityResult.Succeeded)
{
return(RedirectToAction("index", "home"));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
return(View(registerViewModel));
}
public async Task <JsonResult> AjaxMethod(string name, string leave_id)
{
var currentuser = User.Identity.Name;
var currentuserId = _context.AllUser.Where(x => x.Email == currentuser).FirstOrDefault().id;
int leave_id_int = int.Parse(leave_id);
var leave = _context.LeaveHistory.Include(x => x.AllUser).Include(x => x.leaveType).Where(x => x.leave_id == leave_id_int).FirstOrDefault();
leave.DeanApproveStatus = name;
leave.LeaveStatus = name;
leave.approved_id = currentuserId;
UserEmail userEmail = new UserEmail
{
ToEmail = leave.AllUser.Email,
};
var arr = new List <KeyValuePair <string, string> >();
var leavereason = new KeyValuePair <string, string>("{{leavereason}}", leave.LeaveReason);
var leavestart = new KeyValuePair <string, string>("{{leavestart}}", leave.StartFrome.ToString());
var leaveend = new KeyValuePair <string, string>("{{leaveend}}", leave.EndTill.ToString());
var leavetype = new KeyValuePair <string, string>("{{leavetype}}", leave.leaveType.LeaveType);
var leavestatus = new KeyValuePair <string, string>("{{leavestatus}}", leave.LeaveStatus);
//temp.Key = "username";
//temp.Value = "*****@*****.**";
arr.Add(leavereason);
arr.Add(leavestart);
arr.Add(leaveend);
arr.Add(leavetype);
arr.Add(leavestatus);
userEmail.PlaceHolder = arr;
await emailService.LeaveStatusChangeEmail(userEmail);
if (name == "Accepted")
{
var allocation = _context.leaveAllocation.Where(x => x.id == leave.id && x.leaveTypeID == leave.leaveTypeID).FirstOrDefault();
allocation.NoOfLeave -= leave.NoOfDay;
_context.Update(allocation);
_context.SaveChanges();
}
//try
//{
_context.Update(leave);
await _context.SaveChangesAsync();
//}
//catch (Exception e)
//{
// throw;
//}
return(Json(leave));
}
public async Task <CreatedDto> Handle(CreateResourceLeaveCommand request, CancellationToken cancellationToken)
{
var resourceLeaveEntity = await context
//.AsNoTracking()
.ResourceLeaves.SingleOrDefaultAsync(lt => lt.Id.Equals(request.ResourceId));
if (resourceLeaveEntity != null)
{
throw new EntityAlreadyExistException(nameof(ResourceLeave), request.ResourceId);
}
var leavePlansEntity = await context
//.AsNoTracking()
.LeavePlans
.Include(l => l.LeavePlanAssignments)
.SingleOrDefaultAsync(lt => lt.Id.Equals(request.LeavePlanId));
if (leavePlansEntity == null)
{
throw new EntityNotFoundException(nameof(LeavePlan), request.LeavePlanId);
}
var entity = new ResourceLeave()
{
ResourceId = request.ResourceId,
LeavePlan = leavePlansEntity,
};
var resourceLeaveAssignmentList = leavePlansEntity.LeavePlanAssignments
.Select(lpa => new ResourceLeaveAssignment
{
Amount = lpa.Amount,
LeavePlanAssignment = lpa,
ResourceLeave = entity,
LeaveTypeId = lpa.LeaveTypeId
})
.ToList();
entity.ResourceLeaveAssignments = resourceLeaveAssignmentList;
context.ResourceLeaves.Add(entity);
await context.SaveChangesAsync(cancellationToken);
return(new CreatedDto
{
Id = entity.Id
});
}
public async Task <CreatedDto> Handle(CreateLeavePlanCommand request, CancellationToken cancellationToken)
{
var entity = new LeavePlan()
{
Name = request.Name
};
var leaveTypeEntityList = await context
//.AsNoTracking()
.LeaveTypes
.ToListAsync();
var leavePlanAssignmentList = request.Leaves.Select(l =>
{
var leaveType = leaveTypeEntityList.SingleOrDefault(lt => lt.Id.Equals(l.Key));
if (leaveType == null)
{
throw new EntityNotFoundException(nameof(LeaveType), l.Key);
}
return(new LeavePlanAssignment
{
LeaveType = leaveType,
Amount = l.Value,
LeavePlan = entity,
});
});
context.LeavePlanAssignments.AddRange(leavePlanAssignmentList);
await context.SaveChangesAsync(cancellationToken);
return(new CreatedDto
{
Id = entity.Id
});
}
public async Task <ApplyLeaveDto> Handle(ApplyLeaveCommand request, CancellationToken cancellationToken)
{
var resourceLeaveEntity = await context
//.AsNoTracking()
.ResourceLeaves
.Include(r => r.ResourceLeaveAssignments)
.Include(r => r.LeavePlan)
.ThenInclude(l => l.LeavePlanAssignments)
.SingleOrDefaultAsync(lt => lt.ResourceId.Equals(request.ResourceId));
if (resourceLeaveEntity == null)
{
throw new EntityNotFoundException(nameof(ResourceLeave), request.ResourceId);
}
var leavePlanAssignment = resourceLeaveEntity.LeavePlan
.LeavePlanAssignments
.SingleOrDefault(l => l.LeaveTypeId.Equals(request.LeaveTypeId));
if (leavePlanAssignment == null)
{
throw new EntityNotAssignedException(nameof(LeaveType), request.LeaveTypeId, nameof(LeavePlanAssignment));
}
var resourceLeaveAssignment = resourceLeaveEntity.ResourceLeaveAssignments
.SingleOrDefault(rla => rla.LeavePlanAssignmentId.Equals(leavePlanAssignment.Id));
if (resourceLeaveAssignment == null)
{
throw new EntityNotAssignedException(nameof(leavePlanAssignment), leavePlanAssignment.Id, nameof(ResourceLeaveAssignment));
}
var remainingLeave = leavePlanAssignment.Amount - resourceLeaveAssignment.Amount;
if (remainingLeave < 0)
{
throw new LeaveNotEnoughException(request.TotalApplied, remainingLeave);
}
else
{
resourceLeaveAssignment.Amount = remainingLeave;
}
var entity = new Leave
{
Description = request.Description,
StartDate = request.StartDate,
EndDate = request.EndDate,
ResourceId = request.ResourceId,
Status = LeaveStatus.Pending,
Emergency = request.Emergency,
LeaveTypeId = leavePlanAssignment.LeaveTypeId,
};
await context.Leaves.AddAsync(entity, cancellationToken);
await context.SaveChangesAsync(cancellationToken);
return(new ApplyLeaveDto
{
Id = entity.Id,
RemainingLeaveCount = resourceLeaveAssignment.Amount
});
}
