public void PutLeaves()
{
//Admin Login
var login = new EmployeeViewModel()
{
Email = "*****@*****.**", Password = "******"
};
//Team Leader Login
//var login = new EmployeeViewModel() { Email = "*****@*****.**", Password = "******" };
//Employee Login
//var login = new EmployeeViewModel() { Email = "*****@*****.**", Password = "******" };
var loginJson = JsonConvert.SerializeObject(login);
var loginResult = client.PostAsync("Account/Login", new StringContent(loginJson, Encoding.UTF8, "application/json")).Result;
var editedLeave = new LeaveAllowed {
Id = 3, LeaveType = LMS.DomainModel.Models.Type.Casual, AllowedDays = 15
};
var editedLeaveJson = JsonConvert.SerializeObject(editedLeave);
var response = client.PutAsync("api/LeaveAllowed/3", new StringContent(editedLeaveJson, Encoding.UTF8, "application/Json")).Result;
var responseContent = response.Content.ReadAsStringAsync().Result;
var returnedLeave = JsonConvert.DeserializeObject <LeaveAllowed>(responseContent);
Assert.AreEqual(15, returnedLeave.AllowedDays);
}
/// <summary>
/// Method to check leave Balance from slack
/// </summary>
/// <param name="leave">leave slash command</param>
/// <param name="accessToken">User's access token</param>
/// <returns>Reply text to be send</returns>
private async Task <string> SlackLeaveBalanceAsync(SlashCommand leave, string accessToken)
{
var userDetails = await _userManagerRepository.FirstOrDefaultAsync(x => x.SlackUserId == leave.UserId);
// get user details from oAuth server
User user = await _oauthCallsRepository.GetUserByUserIdAsync(userDetails.Id, accessToken);
if (user.Id != null)
{
_logger.Debug("SlackLeaveBalanceAsync user name : " + user.UserName);
// get user leave allowed details from oAuth server
LeaveAllowed allowedLeave = await _oauthCallsRepository.AllowedLeave(user.Id, accessToken);
// method to get user's number of leave taken
LeaveAllowed leaveTaken = _leaveRepository.NumberOfLeaveTaken(user.Id);
double casualLeaveTaken = leaveTaken.CasualLeave;
double sickLeaveTaken = leaveTaken.SickLeave;
double casualLeaveLeft = allowedLeave.CasualLeave - casualLeaveTaken;
double sickLeaveLeft = allowedLeave.SickLeave - sickLeaveTaken;
replyText = string.Format(_stringConstant.ReplyTextForCasualLeaveBalance, casualLeaveTaken,
allowedLeave.CasualLeave, Environment.NewLine, casualLeaveLeft);
replyText += string.Format(_stringConstant.ReplyTextForSickLeaveBalance, sickLeaveTaken,
allowedLeave.SickLeave, Environment.NewLine, sickLeaveLeft);
}
else
{
// if user doesn't exist in Oauth server
replyText = _stringConstant.LeaveNoUserErrorMessage;
}
return(replyText);
}
/// <summary>
/// Method to call an api of oAuth server and get Casual leave allowed to user by user slackName
/// </summary>
/// <param name="userName"></param>
/// <param name="accessToken"></param>
/// <returns>Number of casual leave allowed</returns>
public async Task <LeaveAllowed> CasualLeave(string slackUserName, string accessToken)
{
LeaveAllowed casualLeave = new LeaveAllowed();
var requestUrl = string.Format("{0}{1}", _stringConstant.CasualLeaveUrl, slackUserName);
var response = await _httpClientRepository.GetAsync(_stringConstant.ProjectUserUrl, requestUrl, accessToken);
if (response != null)
{
casualLeave = JsonConvert.DeserializeObject <LeaveAllowed>(response);
}
return(casualLeave);
}
/// <summary>
/// Method to call an api of oAuth server and get Casual leave allowed to user by user slackName. - SS
/// </summary>
/// <param name="userId">userId of user</param>
/// <param name="accessToken">user's access token from Promact OAuth Server</param>
/// <returns>Number of casual leave allowed. Object of LeaveAllowed</returns>
public async Task <LeaveAllowed> AllowedLeave(string userId, string accessToken)
{
LeaveAllowed allowedLeave = new LeaveAllowed();
var requestUrl = string.Format(_stringConstant.FirstAndSecondIndexStringFormat, _stringConstant.CasualLeaveUrl, userId);
var response = await _httpClientService.GetAsync(_stringConstant.ProjectUserUrl, requestUrl, accessToken, _stringConstant.Bearer);
if (response != null)
{
allowedLeave = JsonConvert.DeserializeObject <LeaveAllowed>(response);
}
return(allowedLeave);
}
/// <summary>
/// Method to get the number of casual leave allowed to a user by slack user name -SD
/// </summary>
/// <param name="slackUserId">User's slack userId</param>
/// <returns>number of casual leave</returns>
public async Task <LeaveAllowed> GetUserAllowedLeaveByUserIdAsync(string userId)
{
var user = await _applicationUserDataRepository.FirstOrDefaultAsync(x => x.Id == userId);
if (user != null)
{
LeaveAllowed leaveAllowed = new LeaveAllowed();
leaveAllowed.CasualLeave = user.NumberOfCasualLeave;
leaveAllowed.SickLeave = user.NumberOfSickLeave;
return(leaveAllowed);
}
else
{
throw new SlackUserNotFound();
}
}
/// <summary>
/// This method is used to add new user
/// </summary>
/// <param name="newUser">Passed userAC object</param>
/// <param name="createdBy">Passed id of user who has created this user.</param>
/// <returns>Added user id</returns>
public async Task <string> AddUserAsync(UserAc newUser, string createdBy)
{
LeaveAllowed leaveAllowed = CalculateAllowedLeaves(Convert.ToDateTime(newUser.JoiningDate));
newUser.NumberOfCasualLeave = leaveAllowed.CasualLeave;
newUser.NumberOfSickLeave = leaveAllowed.SickLeave;
var user = _mapperContext.Map <UserAc, ApplicationUser>(newUser);
user.UserName = user.Email;
user.CreatedBy = createdBy;
user.CreatedDateTime = DateTime.UtcNow;
string password = GetRandomString();//get readom password.
await _userManager.CreateAsync(user, password);
await _userManager.AddToRoleAsync(user, newUser.RoleName); //add role of new user.
SendEmail(user.FirstName, user.Email, password); //send mail with generated password of new user.
return(user.Id);
}
/// <summary>
/// Method to get number of leave taken by a user
/// </summary>
/// <param name="employeeId"></param>
/// <returns>number of leave taken</returns>
public LeaveAllowed NumberOfLeaveTaken(string employeeId)
{
double casualLeaveTaken = 0.0;
double sickLeaveTaken = 0.0;
var leaveList = _leaveRequestRepository.Fetch(x => x.EmployeeId == employeeId && x.Status == Condition.Approved);
foreach (var leave in leaveList)
{
var leaveTaken = leave.EndDate.Value.Day - leave.FromDate.Day;
if (leave.Type == LeaveType.cl)
{
casualLeaveTaken += Convert.ToDouble(leaveTaken);
}
else
{
sickLeaveTaken += Convert.ToDouble(leaveTaken);
}
}
LeaveAllowed leaveAllowed = new LeaveAllowed();
leaveAllowed.CasualLeave = casualLeaveTaken;
leaveAllowed.SickLeave = sickLeaveTaken;
return(leaveAllowed);
}
/// <summary>
/// Calculate casual leave and sick leave from the date of joining - RS
/// </summary>
/// <param name="dateTime">passed joining date</param>
/// <returns>LeaveAllowed</returns>
private LeaveAllowed CalculateAllowedLeaves(DateTime dateTime)
{
double casualAllowed;
double sickAllowed;
var month = dateTime.Month;
//if joining year are more then current year or difference of current year and joining year is 1 then calculate casual Allow and sick Allow
//other wise no need to be calculation directly set default value CasualLeave(14) and SickLeave(7).
if (dateTime.Year >= DateTime.Now.Year || (DateTime.Now.Year - dateTime.Year) == 1)
{
double casualAllow = _appSettingUtil.Value.CasualLeave;
double sickAllow = _appSettingUtil.Value.SickLeave;
//If an employee joins between 1st to 15th of month, then he/she will be eligible for that particular month's leaves
//and if he/she joins after 15th of month, he/she will not be eligible for that month's leaves.
//In Our Project we consider Leave renewal on 1st april
if (month >= 4)
{
//if first 15 days of month april to December then substact 4 other wise substact 3 in month
//this setting for the employee eligible for that particular month's leaves or not
if (dateTime.Day <= 15)
{
casualAllowed = (casualAllow / 12) * (12 - (month - 4));
sickAllowed = (sickAllow / 12) * (12 - (month - 4));
}
else
{
casualAllowed = (casualAllow / 12) * (12 - (month - 3));
sickAllowed = (sickAllow / 12) * (12 - (month - 3));
}
}
else //calculate casual allowed and sick allowed for first three month.
{
//if joining year are more then current year then calculate casual allowed and sick allowed
if (dateTime.Year >= DateTime.Now.Year)
{
//if first 15 days of month January to March then add 8 other wise add 9 in month
//this setting for the employee eligible for that particular month's leaves or not
if (dateTime.Day <= 15)
{
casualAllowed = (casualAllow / 12) * (12 - (month + 8));
sickAllowed = (sickAllow / 12) * (12 - (month + 8));
}
else
{
casualAllowed = (casualAllow / 12) * (12 - (month + 9));
sickAllowed = (sickAllow / 12) * (12 - (month + 9));
}
}
else
{
casualAllowed = casualAllow;
sickAllowed = sickAllow;
}
}
var tolerance = 0.0001;
if (Math.Abs(casualAllowed % 1) > tolerance) //check casualAllowed has decimal value
{
double casualAlloweddecimal = casualAllowed - Math.Floor(casualAllowed);
// If calculated casualAllowed decimal value is exact 0.5 then it's considered half day casual leave
if (Math.Abs(casualAlloweddecimal - 0.5) > tolerance)
{
casualAllowed = Convert.ToInt32(casualAllowed);
}
}
if (Math.Abs(sickAllowed % 1) > tolerance)//check sickAllowed has decmial value
{
double sickAlloweddecimal = sickAllowed - Math.Floor(sickAllowed);
// If calculated sickAllowed decimal value is exact 0.5 then it's considered half day sick leave
// If calculated sickAllowed decimal value is more than 0.90 then add one leave in sick leave
if (sickAlloweddecimal > 0.90)
{
sickAllowed = Convert.ToInt32(Math.Ceiling(sickAllowed));
}
else if (Math.Abs(sickAlloweddecimal - 0.5) > tolerance)
{
sickAllowed = Convert.ToInt32(Math.Floor(sickAllowed));
}
}
}
else
{
casualAllowed = _appSettingUtil.Value.CasualLeave;
sickAllowed = _appSettingUtil.Value.SickLeave;
}
LeaveAllowed leaveAllowed = new LeaveAllowed
{
CasualLeave = casualAllowed,
SickLeave = sickAllowed
};
return(leaveAllowed);
}
public IHttpActionResult UpdateLeaveAllowedByLeaveType(LeaveAllowed leaveAllowed)
{
_leaveAllowed.Update(leaveAllowed);
return(Ok(leaveAllowed));
}
public IHttpActionResult AddLeaveAllowedByLeaveType(LeaveAllowed leaveAllowed)
{
_leaveAllowed.Add(leaveAllowed);
return(Ok(leaveAllowed));
}
