public HttpResponseMessage Get(string EID, DateTime startDate, DateTime endDate)
{
try
{
using (ebuilderEntities entities = new ebuilderEntities())
{
var allLeaves = entities.leavs.Where(l => l.EID == EID && (DateTime.Compare(startDate, l.date) < 0 && DateTime.Compare(l.date, endDate) < 0)).ToList();
var entity = new List <leavWithStatusAndName>();
foreach (leav l in allLeaves)
{
foreach (approval app in entities.approvals.Where(a => a.LID == l.LID).ToList())
{
if (app.status == "accepted")
{
var levStatusName = new leavWithStatusAndName(l);
entity.Add(levStatusName); //select only the accepted leaves
}
}
}
return(Request.CreateResponse(HttpStatusCode.OK, entity));
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
public HttpResponseMessage GetManaged(string ManagerID, DateTime startDate, DateTime endDate)
{
try
{
using (ebuilderEntities entities = new ebuilderEntities())
{
var manager = entities.employees.FirstOrDefault(e => e.EID == ManagerID);
if (manager == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "No manager exists with the given EID"));
}
entities.Entry(manager).Collection("employee1").Load();
var entity = new List <attendanceWithWorkingHours>();
foreach (var emp in manager.employee1)
{
var attList = entities.attendances.Where(a => a.EID == emp.EID && (DateTime.Compare(startDate, a.date) < 0 && DateTime.Compare(a.date, endDate) <= 0)).ToList();
foreach (var a in attList)
{
var attWithWH = new attendanceWithWorkingHours(a);
entity.Add(attWithWH);
}
}
return(Request.CreateResponse(HttpStatusCode.OK, entity));
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
public HttpResponseMessage Post([FromBody] Login login)
{
using (ebuilderEntities entities = new ebuilderEntities())
{
var emp = entities.employees.Where(e => e.email == login.email).FirstOrDefault();
if (emp != null)
{
if (string.Compare(Crypto.Hash(login.password), emp.password) == 0)
{
entities.Entry(emp).Collection("employees").Load();
var employeeData = new AccessView(emp);
var response = Request.CreateResponse(HttpStatusCode.OK, employeeData);
response.Headers.Location = new Uri("http://localhost:61355/api/Employees/" + emp.EID);
return(response);
}
else
{
var response = Request.CreateResponse(HttpStatusCode.NotFound, new AccessView(new employee()));
return(response);
}
}
else
{
return(Request.CreateResponse(HttpStatusCode.NotFound, new AccessView(new employee())));
}
}
}
/// <summary>
/// Add an approval
/// </summary>
/// <param name="appr"></param>
/// <returns></returns>
public HttpResponseMessage Post([FromBody] approval appr)
{
try
{
using (ebuilderEntities entities = new ebuilderEntities())
{
var entity = entities.approvals.FirstOrDefault(a => a.ManagerID == appr.ManagerID && a.LID == appr.LID);
if (entity != null)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Approval already available with given datails"));
}
appr.status = "pending";
entities.approvals.Add(appr);
entities.SaveChanges();
var message = Request.CreateResponse(HttpStatusCode.OK, appr);
message.Headers.Location = new Uri(Request.RequestUri + appr.APID.ToString());
return(message);
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
/// <summary>
/// Update the status of an approval
/// </summary>
/// <param name="id"></param>
/// <param name="appr"></param>
/// <returns></returns>
public HttpResponseMessage Put(int id, [FromBody] approval appr)
{
try
{
using (ebuilderEntities entities = new ebuilderEntities())
{
var entity = entities.approvals.FirstOrDefault(a => a.APID == id);
if (entity == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Approval with APID " + id.ToString() + " not found"));
}
else
{
entity.status = appr.status.ToLower();
entities.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.OK, entity));
}
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
/// <summary>
/// Update time, date, activity or status of an existing task
/// </summary>
/// <param name="id"></param>
/// <param name="t"></param>
/// <returns></returns>
public HttpResponseMessage Put(int id, [FromBody] task t)
{
try
{
using (ebuilderEntities entities = new ebuilderEntities())
{
var entity = entities.tasks.FirstOrDefault(tsk => tsk.TID == id);
if (entity == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Task with TID " + id.ToString() + " not found"));
}
else
{
entity.time = t.time;
entity.date = t.date;
entity.activity = t.activity;
entity.status = t.status;
entities.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.OK, entity));
}
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
/// <summary>
/// Update the maxAllowed number of leaves for a leave type
/// </summary>
/// <param name="jobCategory"></param>
/// <param name="leaveCategory"></param>
/// <param name="leaveType"></param>
/// <returns></returns>
public HttpResponseMessage Put(string jobCategory, string leaveCategory, [FromBody] leave_type leaveType)
{
try
{
using (ebuilderEntities entities = new ebuilderEntities())
{
var entity = entities.leave_type.FirstOrDefault(lt => lt.jobCategory == jobCategory && lt.leaveCategory == leaveCategory);
if (entity == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Leave type " + leaveCategory + "for" + jobCategory + " not found"));
}
else
{
entity.maxAllowed = leaveType.maxAllowed;
entities.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.OK, entity));
}
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
public leavWithStatusAndName(leav leave)
{
using (ebuilderEntities entities = new ebuilderEntities())
{
this.LID = leave.LID;
this.EID = leave.EID;
this.date = leave.date.Date;
this.reason = leave.reason;
this.jobCategory = leave.jobCategory;
this.leaveCategory = leave.leaveCategory;
var entity = entities.approvals.Where(a => a.LID == this.LID).Select(ap => ap.status).ToList();
if (entity.Any(e => e == "rejected"))
{
this.status = "rejected";
}
else if (entity.Any(e => e == "pending"))
{
this.status = "pending";
}
if (entity.All(e => e == "accepted"))
{
this.status = "accepted";
}
var emp = entities.employees.FirstOrDefault(e => e.EID == this.EID);
this.fName = emp.fName;
this.lName = emp.lName;
}
}
/// <summary>
/// Update appointmnet time, date and end time of a dutyleave by providing DLID
/// </summary>
/// <param name="id"></param>
/// <param name="dutyLeave"></param>
/// <returns></returns>
public HttpResponseMessage Put(int id, [FromBody] duty_leave dutyLeave)
{
try
{
using (ebuilderEntities entities = new ebuilderEntities())
{
var entity = entities.duty_leave.FirstOrDefault(dl => dl.DLID == id);
if (entity == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Duty Leave with DLID " + id.ToString() + " not found"));
}
else
{
entity.date = dutyLeave.date;
entity.appointmentTime = dutyLeave.appointmentTime;
entity.endTime = dutyLeave.endTime;
entities.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.OK, entity));
}
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
/// <summary>
/// Update the date, leaveCategory and reason by providing LID
/// </summary>
/// <param name="id"></param>
/// <param name="leave"></param>
/// <returns></returns>
public HttpResponseMessage Put(int id, [FromBody] leav leave)
{
try
{
using (ebuilderEntities entities = new ebuilderEntities())
{
var entity = entities.leavs.FirstOrDefault(l => l.LID == id);
if (entity == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Leave with LID " + id.ToString() + " not found"));
}
else
{
entity.date = leave.date;
entity.leaveCategory = leave.leaveCategory;
entity.reason = leave.reason;
entities.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.OK, entity));
}
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
/// <summary>
/// Update the details of employee
/// </summary>
/// <param name="id"></param>
/// <param name="emp"></param>
/// <returns></returns>
public HttpResponseMessage Put(string id, [FromBody] employee emp)
{
try
{
using (ebuilderEntities entities = new ebuilderEntities())
{
var entity = entities.employees.FirstOrDefault(e => e.EID == id);
if (entity == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Employee with EID " + id + " not found"));
}
else
{
entity.fName = emp.fName;
entity.lName = emp.lName;
entity.street = emp.street;
entity.homeNo = emp.homeNo;
entity.city = emp.city;
entity.gender = emp.gender;
entity.jobCategory = emp.jobCategory;
entities.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.OK, entity));
}
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
/// <summary>
/// Add an dutyleave. One dutyleave is allowed for one employee in a single day
/// </summary>
/// <param name="dutyLeave"></param>
/// <returns></returns>
public HttpResponseMessage Post([FromBody] duty_leave dutyLeave)
{
try
{
using (ebuilderEntities entities = new ebuilderEntities())
{
if (dutyLeave.EID == null || dutyLeave.location == null || dutyLeave.date == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Some fieds are empty"));
}
if (DateTime.Compare(dutyLeave.date, DateTime.Today) < 0 || TimeSpan.Compare(dutyLeave.appointmentTime, dutyLeave.endTime) >= 0)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Invalid date or time"));
}
var entity = entities.duty_leave.FirstOrDefault(dl => dl.EID == dutyLeave.EID && dl.date == dutyLeave.date);
if (entity != null)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Duty leave for given EID and date alredy exists"));
}
entities.duty_leave.Add(dutyLeave);
entities.SaveChanges();
var message = Request.CreateResponse(HttpStatusCode.OK, dutyLeave);
message.Headers.Location = new Uri(Request.RequestUri + dutyLeave.DLID.ToString());
return(message);
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
public HttpResponseMessage PutPassword(changePasswordCredential credential)
{
try
{
using (ebuilderEntities entities = new ebuilderEntities())
{
var entity = entities.employees.FirstOrDefault(e => e.EID == credential.EID);
if (entity == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "No employee exists with the given EID"));
}
if (string.Compare(entity.password, Crypto.Hash(credential.oldPassword)) == 0)
{
entity.password = Crypto.Hash(credential.newPassword);
entities.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.OK, "Change Success"));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Wrong Password"));
}
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
/// <summary>
/// Add an attendance to the database
/// </summary>
/// <param name="att"></param>
/// <returns></returns>
public HttpResponseMessage Post([FromBody] attendance att)
{
try
{
using (ebuilderEntities entities = new ebuilderEntities())
{
if (DateTime.Compare(DateTime.Today, att.date.Date) < 0)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Attendance for future dates are not allowed"));
}
if (att.EID == null || att.checkIn == null || att.checkOut == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Some fields are empty"));
}
var entity = entities.attendances.FirstOrDefault(a => a.EID == att.EID && a.date == att.date);
if (entity != null)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Attendance the given EID and date already exists."));
}
entities.attendances.Add(att);
entities.SaveChanges();
var message = Request.CreateResponse(HttpStatusCode.OK, att);
message.Headers.Location = new Uri(Request.RequestUri + att.AID.ToString());
return(message);
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, att.ToString(), ex));
}
}
/// <summary>
/// Add an employee
/// </summary>
/// <param name="emp"></param>
/// <returns></returns>
public HttpResponseMessage Post([FromBody] employee emp)
{
try
{
if (emp.EID == null || emp.email == null || emp.fName == null || emp.lName == null || emp.jobCategory == null || emp.gender == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Some fields are empty"));
}
using (ebuilderEntities entities = new ebuilderEntities())
{
var entity = entities.employees.FirstOrDefault(e => e.EID == emp.EID || e.email == emp.email);
if (entity != null)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Employee with the given details already exists"));
}
emp.password = Crypto.Hash(emp.password);
entities.employees.Add(emp);
entities.SaveChanges();
var message = Request.CreateResponse(HttpStatusCode.Created, emp);
message.Headers.Location = new Uri(Request.RequestUri + emp.EID);
return(message);
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
public HttpResponseMessage ResetPassword(forgotPasswordCredential credential)
{
try
{
using (ebuilderEntities entities = new ebuilderEntities())
{
var entity = entities.employees.FirstOrDefault(e => e.email == credential.email);
if (entity == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Bad Credentials"));
}
if (entity.activationCode == credential.verificationCode)
{
entity.password = Crypto.Hash(credential.newPassword);
entities.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.OK, "Reset Success"));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Bad Crededntials"));
}
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
/// <summary>
/// Get the duty leave by providing DLID
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public HttpResponseMessage Get(int id)
{
using (ebuilderEntities entities = new ebuilderEntities())
{
var entity = entities.duty_leave.FirstOrDefault(dl => dl.DLID == id);
if (entity != null)
{
dutyLeaveWithName dlName = new dutyLeaveWithName();
dlName.DLID = entity.DLID;
dlName.EID = entity.EID;
dlName.date = entity.date;
dlName.appointmentTime = entity.appointmentTime;
dlName.endTime = entity.endTime;
dlName.location = entity.location;
dlName.purpose = entity.purpose;
employee emp = entities.employees.FirstOrDefault(e => e.EID == entity.EID);
dlName.fName = emp.fName;
dlName.lName = emp.lName;
return(Request.CreateResponse(HttpStatusCode.OK, dlName));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "DutyLeave with the DLID " + id.ToString() + " not Found"));
}
}
}
/// <summary>
/// Delete a leave by giving the LID
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public HttpResponseMessage Delete(int id)
{
try
{
using (ebuilderEntities entities = new ebuilderEntities())
{
var entity = entities.leavs.FirstOrDefault(l => l.LID == id);
if (entity != null)
{
var approvals = entities.approvals.Where(a => a.LID == id).ToList();
approvals.ForEach(a => entities.approvals.Remove(a));
entities.leavs.Remove(entity);
entities.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.OK, new { Message = "Deleted" }));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "No Leave with the LID " + id.ToString() + " to delete"));
}
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
public HttpResponseMessage GetManaged(string ManagerID)
{
try
{
using (ebuilderEntities entities = new ebuilderEntities())
{
var manager = entities.employees.FirstOrDefault(e => e.EID == ManagerID);
if (manager == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "No Manager exists for the given EID"));
}
entities.Entry(manager).Collection("employee1").Load();
var entity = new List <leavWithStatusAndName>();
foreach (var emp in manager.employee1)
{
var empLeaves = entities.leavs.Where(e => e.EID == emp.EID).ToList();
foreach (leav l in empLeaves)
{
var leavNameStatus = new leavWithStatusAndName(l);
entity.Add(leavNameStatus);
}
}
return(Request.CreateResponse(HttpStatusCode.OK, entity));
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
/// <summary>
/// Add a tracking by providing EID and location details
/// </summary>
/// <param name="trackWithEID"></param>
/// <returns></returns>
public HttpResponseMessage Post([FromBody] trackingWithEID trackWithEID)
{
try
{
using (ebuilderEntities entities = new ebuilderEntities())
{
var DLID = entities.duty_leave.FirstOrDefault(dl => dl.EID == trackWithEID.EID && dl.date.Year == DateTime.Now.Year &&
dl.date.Month == DateTime.Now.Month && dl.date.Day == DateTime.Now.Day).DLID;
tracking newTracking = new tracking();
newTracking.DLID = DLID;
newTracking.latitude = trackWithEID.latitude;
newTracking.longitude = trackWithEID.longitude;
newTracking.time = new TimeSpan(DateTime.Now.Hour + 5, DateTime.Now.Minute + 30, DateTime.Now.Second);
entities.trackings.Add(newTracking);
entities.SaveChanges();
var message = Request.CreateResponse(HttpStatusCode.OK, newTracking);
message.Headers.Location = new Uri(Request.RequestUri + trackWithEID.TRID.ToString());
return(message);
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
/// <summary>
/// Get the approvals by ManagerID or LID or status. All parameters are optional
/// </summary>
/// <param name="LID"></param>
/// <param name="ManagerID"></param>
/// <param name="status"></param>
/// <returns></returns>
public HttpResponseMessage Get(int LID = 0, string ManagerID = "all", string status = "all")
{
try
{
using (ebuilderEntities entities = new ebuilderEntities())
{
string parameters = "";
parameters += LID == 0 ? "0" : "1";
parameters += ManagerID == "all" ? "0" : "1";
parameters += status == "all" ? "0" : "1";
var entity = new List <approval>();
switch (parameters)
{
case "000":
entity = entities.approvals.ToList();
break;
case "001":
entity = entities.approvals.Where(a => a.status == status).ToList();
break;
case "010":
entity = entities.approvals.Where(a => a.ManagerID == ManagerID).ToList();
break;
case "011":
entity = entities.approvals.Where(a => a.ManagerID == ManagerID && a.status == status).ToList();
break;
case "100":
entity = entities.approvals.Where(a => a.LID == LID).ToList();
break;
case "101":
entity = entities.approvals.Where(a => a.LID == LID && a.status == status).ToList();
break;
case "110":
entity = entities.approvals.Where(a => a.LID == LID && a.ManagerID == ManagerID).ToList();
break;
case "111":
entity = entities.approvals.Where(a => a.LID == LID && a.ManagerID == ManagerID && a.status == status).ToList();
break;
}
var approvalsViewList = new List <approvalView>();
entity.ForEach(e => approvalsViewList.Add(new approvalView(e)));
return(Request.CreateResponse(HttpStatusCode.OK, approvalsViewList));
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
public HttpResponseMessage GetWeekly()
{
try
{
using (ebuilderEntities entities = new ebuilderEntities())
{
var allDutyLeaves = entities.duty_leave.Where(l => l.date.Year == DateTime.Now.Year).ToList();
var dutyLeavePercentageByWeeklyDay = new appliedLeavesPercentView();
for (int dayOfWeek = 1; dayOfWeek <= 7; dayOfWeek++)
{
switch (dayOfWeek)
{
case 1:
int leaveCountMonday = allDutyLeaves.Where(l => l.date.DayOfWeek == DayOfWeek.Monday).ToList().Count;
dutyLeavePercentageByWeeklyDay.Monday = Math.Round((((double)leaveCountMonday) / allDutyLeaves.Count * 100), 2);
break;
case 2:
int leaveCountTuesday = allDutyLeaves.Where(l => l.date.DayOfWeek == DayOfWeek.Tuesday).ToList().Count;
dutyLeavePercentageByWeeklyDay.Tuesday = Math.Round((((double)leaveCountTuesday) / allDutyLeaves.Count * 100), 2);
break;
case 3:
int leaveCountWednesday = allDutyLeaves.Where(l => l.date.DayOfWeek == DayOfWeek.Wednesday).ToList().Count;
dutyLeavePercentageByWeeklyDay.Wednesday = Math.Round((((double)leaveCountWednesday) / allDutyLeaves.Count * 100), 2);
break;
case 4:
int leaveCountThursday = allDutyLeaves.Where(l => l.date.DayOfWeek == DayOfWeek.Thursday).ToList().Count;
dutyLeavePercentageByWeeklyDay.Thursday = Math.Round((((double)leaveCountThursday) / allDutyLeaves.Count * 100), 2);
break;
case 5:
int leaveCountFriday = allDutyLeaves.Where(l => l.date.DayOfWeek == DayOfWeek.Friday).ToList().Count;
dutyLeavePercentageByWeeklyDay.Friday = Math.Round((((double)leaveCountFriday) / allDutyLeaves.Count * 100), 2);
break;
case 6:
int leaveCountSaturday = allDutyLeaves.Where(l => l.date.DayOfWeek == DayOfWeek.Saturday).ToList().Count;
dutyLeavePercentageByWeeklyDay.Saturday = Math.Round((((double)leaveCountSaturday) / allDutyLeaves.Count * 100), 2);
break;
case 7:
int leaveCountSunday = allDutyLeaves.Where(l => l.date.DayOfWeek == DayOfWeek.Sunday).ToList().Count;
dutyLeavePercentageByWeeklyDay.Sunday = Math.Round((((double)leaveCountSunday) / allDutyLeaves.Count * 100), 2);
break;
}
}
return(Request.CreateResponse(HttpStatusCode.OK, dutyLeavePercentageByWeeklyDay));
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
public HttpResponseMessage GetLeaves(string EID)
{
try
{
using (ebuilderEntities entities = new ebuilderEntities())
{
var jCategory = entities.employees.FirstOrDefault(e => e.EID == EID).jobCategory;
var allLeavesTypes = entities.leave_type.Where(lt => lt.jobCategory == jCategory).ToList();
List <leav> leavesApplied;
int leaveTakenCount = 0;
foreach (var lt in allLeavesTypes)
{
switch (lt.leaveCategory)
{
case "casual":
case "medical":
leavesApplied = entities.leavs.Where(l => l.EID == EID && l.leaveCategory == lt.leaveCategory && l.date.Year == DateTime.Now.Year).ToList();
foreach (var l in leavesApplied)
{
if (entities.approvals.Where(a => a.LID == l.LID).All(a => a.status == "accepted"))
{
leaveTakenCount++;
}
}
lt.maxAllowed = lt.maxAllowed - leaveTakenCount;
leaveTakenCount = 0;
break;
case "short leave":
case "half day":
leavesApplied = entities.leavs.Where(l => l.EID == EID && l.leaveCategory == lt.leaveCategory && l.date.Month == DateTime.Now.Month).ToList();
foreach (var l in leavesApplied)
{
if (entities.approvals.Where(a => a.LID == l.LID).All(a => a.status == "accepted"))
{
leaveTakenCount++;
}
}
lt.maxAllowed = lt.maxAllowed - leaveTakenCount;
leaveTakenCount = 0;
break;
}
}
return(Request.CreateResponse(HttpStatusCode.OK, allLeavesTypes));
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
/// <summary>
/// Get the approval by APID
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public HttpResponseMessage Get(int id)
{
using (ebuilderEntities entities = new ebuilderEntities())
{
var entity = entities.approvals.FirstOrDefault(a => a.APID == id);
if (entity != null)
{
return(Request.CreateResponse(HttpStatusCode.OK, entity));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Approal with the APID " + id.ToString() + " not Found"));
}
}
}
/// <summary>
/// Get the list of contacts by EID
/// </summary>
/// <param name="EID"></param>
/// <returns></returns>
public HttpResponseMessage Get(string EID)
{
try
{
using (ebuilderEntities entities = new ebuilderEntities())
{
var entity = entities.contacts.Where(c => c.EID == EID).ToList();
return(Request.CreateResponse(HttpStatusCode.Accepted, entity));
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
/// <summary>
/// Get an employee's details by giving EID
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public HttpResponseMessage Get(string id)
{
using (ebuilderEntities entities = new ebuilderEntities())
{
var entity = entities.employees.FirstOrDefault(e => e.EID == id);
if (entity != null)
{
return(Request.CreateResponse(HttpStatusCode.OK, entity));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Employee with the EID " + id + " not Found"));
}
}
}
/// <summary>
/// Add an contact
/// </summary>
/// <param name="con"></param>
/// <returns></returns>
public HttpResponseMessage Post(contact con)
{
try
{
using (ebuilderEntities entities = new ebuilderEntities())
{
entities.contacts.Add(con);
entities.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.Created, con));
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
public HttpResponseMessage PostEx([FromBody] leav leave)
{
try
{
using (ebuilderEntities entities = new ebuilderEntities())
{
if (DateTime.Compare(leave.date, DateTime.Today.AddDays(-30)) < 0)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "The date should be within last 30 days."));
}
//Check whether the a leave eixsts for the fiven date
var entity = entities.leavs.FirstOrDefault(l => l.EID == leave.EID && l.date == leave.date);
if (entity != null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Leave Already exists"));
}
//get the jobCategory for the leave
leave.jobCategory = entities.employees.FirstOrDefault(e => e.EID == leave.EID).jobCategory;
//Check whether the leaveCategory exists
var maxLeaves = entities.leave_type.FirstOrDefault(lt => lt.leaveCategory == leave.leaveCategory && lt.jobCategory == leave.jobCategory).maxAllowed;
if (maxLeaves == 0)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Incompatible leave type"));
}
//check whether the maximum allowed leaves for the period has been taken
var leavesTaken = entities.leavs.Where(l => l.EID == leave.EID && l.leaveCategory == leave.leaveCategory && l.date.Year == leave.date.Year).Count();
if (leavesTaken >= maxLeaves)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "No leaves available"));
}
entities.leavs.Add(leave);
entities.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.Created, leave));
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
/// <summary>
/// Get Attendance by AID
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public HttpResponseMessage Get(int id)
{
using (ebuilderEntities entities = new ebuilderEntities())
{
var entity = entities.attendances.FirstOrDefault(a => a.AID == id);
if (entity != null)
{
attendanceWithWorkingHours att = new attendanceWithWorkingHours(entity);
return(Request.CreateResponse(HttpStatusCode.OK, att));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Attendance with AID " + id.ToString() + " not found"));
}
}
}
/// <summary>
/// Get the attendance by date or EID, all parameters are optional
/// </summary>
/// <param name="date"></param>
/// <param name="EID"></param>
/// <returns></returns>
public HttpResponseMessage Get(DateTime?date = null, string EID = "all")
{
try
{
using (ebuilderEntities entities = new ebuilderEntities())
{
string parameters = "";
parameters += date == null ? "0" : "1";
parameters += EID == "all" ? "0" : "1";
var entity = new List <attendance>();
switch (parameters)
{
case "00":
entity = entities.attendances.ToList();
break;
case "01":
entity = entities.attendances.Where(a => a.EID == EID).ToList();
break;
case "10":
entity = entities.attendances.Where(a => a.date == date).ToList();
break;
case "11":
entity = entities.attendances.Where(a => a.date == date && a.EID == EID).ToList();
break;
}
List <attendanceWithWorkingHours> attList = new List <attendanceWithWorkingHours>();
foreach (var a in entity)
{
attendanceWithWorkingHours att = new attendanceWithWorkingHours(a);
attList.Add(att);
}
return(Request.CreateResponse(HttpStatusCode.OK, attList));
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
