public EmployeeAttendance VHasUniqueAttendanceDate(EmployeeAttendance employeeAttendance, IEmployeeAttendanceService _employeeAttendanceService)
{
var list = _employeeAttendanceService.GetQueryable().Where(x => x.EmployeeId == employeeAttendance.EmployeeId && x.AttendanceDate == employeeAttendance.AttendanceDate && x.Id != employeeAttendance.Id && !x.IsDeleted);
if (list.Any())
{
employeeAttendance.Errors.Add("Generic", "AttendanceDate (" + employeeAttendance.AttendanceDate.ToShortDateString() + ") Sudah ada");
}
return(employeeAttendance);
}
public EmployeeAttendance VHasEmployee(EmployeeAttendance employeeAttendance, IEmployeeService _employeeService)
{
Employee employee = _employeeService.GetObjectById(employeeAttendance.EmployeeId);
if (employee == null)
{
employeeAttendance.Errors.Add("Employee", "Tidak ada");
}
return(employeeAttendance);
}
public bool UpdateEmployeeAttendance(EmployeeAttendance employeeAttendance)
{
var emp = _context.EmployeeAttendance.Single(c => c.Id == employeeAttendance.Id);
emp.CheckIn = employeeAttendance.CheckIn;
emp.CheckOut = employeeAttendance.CheckOut;
emp.Duration = employeeAttendance.Duration;
_context.SaveChanges();
return(true);
}
public async Task <IActionResult> EditEmployeeAttendance(EmployeeAttendance item)
{
var model = await _context.EmployeeAttendances.SingleOrDefaultAsync(b => b.Id == item.Id);
await TryUpdateModelAsync(model);
await _context.SaveChangesAsync();
return(RedirectToAction("AttendanceDetails", new { id = model.AttendanceId }));
}
public async Task <IHttpActionResult> GetEmployeeAttendance(int id)
{
EmployeeAttendance employeeAttendance = await db.EmployeeAttendances.FindAsync(id);
if (employeeAttendance == null)
{
return(NotFound());
}
return(Ok(employeeAttendance));
}
// POST: odata/EmployeeAttendances
public async Task <IHttpActionResult> Post(EmployeeAttendance employeeAttendance)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.EmployeeAttendances.Add(employeeAttendance);
await db.SaveChangesAsync();
return(Created(employeeAttendance));
}
public async Task <IHttpActionResult> PostEmployeeAttendance(EmployeeAttendance employeeAttendance)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.EmployeeAttendances.Add(employeeAttendance);
await db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = employeeAttendance.Id }, employeeAttendance));
}
public EmployeeAttendance GetEmployeeAttendanceData(int id)
{
try
{
EmployeeAttendance EmployeeAttendance = _appContext.employeeAttendances.Find(id);
return(EmployeeAttendance);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <(bool IsTrue, string ResponseMSG)> ClockInNow(EmployeeAttendance model)
{
try
{
_context.EmployeeAttendances.Add(model);
return(await _context.SaveChangesAsync() > 0, "Success");
}
catch (Exception exc)
{
return(false, Error.GetDetail(exc));
}
}
public dynamic Insert(EmployeeAttendance model, Nullable <DateTime> AttendanceDateEnd)
{
try
{
DateTime date = model.AttendanceDate;
if (AttendanceDateEnd != null)
{
if (AttendanceDateEnd.GetValueOrDefault() < date)
{
Dictionary <string, string> Errors = new Dictionary <string, string>();
Errors.Add("AttendanceDateEnd", "Harus lebih besar atau sama dengan Attendance Date");
return(Json(new
{
Errors
}, JsonRequestBehavior.AllowGet));
}
else if (AttendanceDateEnd.GetValueOrDefault().Subtract(date).TotalDays > 366)
{
Dictionary <string, string> Errors = new Dictionary <string, string>();
Errors.Add("AttendanceDateEnd", "Tidak boleh berjarak lebih dari setahun dari Attendance Date");
return(Json(new
{
Errors
}, JsonRequestBehavior.AllowGet));
}
}
do
{
model.AttendanceDate = date;
model = _employeeAttendanceService.CreateObject(model, _employeeService);
date = date.AddDays(1);
} while (AttendanceDateEnd != null && date <= AttendanceDateEnd.GetValueOrDefault());
}
catch (Exception ex)
{
LOG.Error("Insert Failed", ex);
Dictionary <string, string> Errors = new Dictionary <string, string>();
Errors.Add("Generic", "Error " + ex);
return(Json(new
{
Errors
}, JsonRequestBehavior.AllowGet));
}
return(Json(new
{
// model.Errors
}));
}
public EmployeeAttendance VHasCheckOutTime(EmployeeAttendance employeeAttendance)
{
if (employeeAttendance.CheckOut == null || employeeAttendance.CheckOut.Equals(DateTime.FromBinary(0)))
{
employeeAttendance.Errors.Add("CheckOut", "Tidak valid");
}
else if (employeeAttendance.CheckOut < employeeAttendance.CheckIn)
{
employeeAttendance.Errors.Add("CheckOut", "Harus lebih besar atau sama dengan CheckIn");
}
return(employeeAttendance);
}
public async Task <(bool IsTrue, string ResponseMSG)> ClockOutNow(EmployeeAttendance model)
{
try
{
_context.Entry(model).State = EntityState.Modified;
return(await _context.SaveChangesAsync() > 0, "Success");
}
catch (Exception exc)
{
return(false, Error.GetDetail(exc));
}
}
public int AddEmployeeAttendance(EmployeeAttendance EmployeeAttendance)
{
try
{
_appContext.employeeAttendances.Add(EmployeeAttendance);
_appContext.SaveChanges();
return(1);
}
catch (Exception ex)
{
throw ex;
}
}
public string PrintError(EmployeeAttendance obj)
{
string erroroutput = "";
KeyValuePair <string, string> first = obj.Errors.ElementAt(0);
erroroutput += first.Key + "," + first.Value;
foreach (KeyValuePair <string, string> pair in obj.Errors.Skip(1))
{
erroroutput += Environment.NewLine;
erroroutput += pair.Key + "," + pair.Value;
}
return(erroroutput);
}
public int UpdateEmployeeAttendance(EmployeeAttendance EmployeeAttendance)
{
try
{
_appContext.Entry(EmployeeAttendance).State = EntityState.Modified;
_appContext.SaveChanges();
return(1);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <IHttpActionResult> DeleteEmployeeAttendance(int id)
{
EmployeeAttendance employeeAttendance = await db.EmployeeAttendances.FindAsync(id);
if (employeeAttendance == null)
{
return(NotFound());
}
db.EmployeeAttendances.Remove(employeeAttendance);
await db.SaveChangesAsync();
return(Ok(employeeAttendance));
}
public int DeleteEmployeeAttendance(int id)
{
try
{
EmployeeAttendance EmployeeAttendance = _appContext.employeeAttendances.Find(id);
_appContext.employeeAttendances.Remove(EmployeeAttendance);
_appContext.SaveChanges();
return(1);
}
catch (Exception ex)
{
throw ex;
}
}
// DELETE: odata/EmployeeAttendances(5)
public async Task <IHttpActionResult> Delete([FromODataUri] int key)
{
EmployeeAttendance employeeAttendance = await db.EmployeeAttendances.FindAsync(key);
if (employeeAttendance == null)
{
return(NotFound());
}
db.EmployeeAttendances.Remove(employeeAttendance);
await db.SaveChangesAsync();
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <JsonResult> ClockOut(EmployeeAttendance model)
{
model.ClockOut = DateTimeHelper.Now();
model.ModifiedDate = DateTimeHelper.Now();
model.Status = "P";
var(IsTrue, ResponseMSG) = await _employeeAttendanceService.ClockOutNow(model);
JsonResult jsonResult = new JsonResult
{
Data = new { IsSuccess = IsTrue, msg = ResponseMSG }
};
return(jsonResult);
}
public async Task <ApiResponse> Handle(DeleteHolidayDetailCommand request, CancellationToken cancellationToken)
{
ApiResponse response = new ApiResponse();
try
{
var existrecord = await _dbContext.HolidayDetails.FirstOrDefaultAsync(x => x.HolidayId == request.HolidayId);
if (existrecord != null)
{
existrecord.IsDeleted = true;
existrecord.ModifiedById = request.ModifiedById;
existrecord.ModifiedDate = request.ModifiedDate;
_dbContext.HolidayDetails.Update(existrecord);
await _dbContext.SaveChangesAsync();
var existempattendance = await _dbContext.EmployeeAttendance.Where(x => x.HolidayId == request.HolidayId).ToListAsync();
if (existempattendance.Count > 0)
{
List <EmployeeAttendance> empattendancelist = new List <EmployeeAttendance>();
foreach (var list in existempattendance)
{
EmployeeAttendance empattendance = new EmployeeAttendance();
empattendance.EmployeeId = list.EmployeeId;
empattendance.AttendanceId = list.AttendanceId;
empattendance.IsDeleted = false;
empattendance.ModifiedById = request.ModifiedById;
empattendance.ModifiedDate = request.ModifiedDate;
empattendancelist.Add(empattendance);
}
_dbContext.EmployeeAttendance.UpdateRange(empattendancelist);
await _dbContext.SaveChangesAsync();
}
response.StatusCode = StaticResource.successStatusCode;
response.Message = "Success";
}
}
catch (Exception ex)
{
response.StatusCode = StaticResource.failStatusCode;
response.Message = ex.Message;
}
return(response);
}
/// <summary>
/// Inserts the current day fields in the attendance collection for marking.
/// </summary>
/// <param name="colLink">The link to attendance collection</param>
/// <returns></returns>
public async Task <bool> AddTodayAttendanceFieldsAsync(string colLink)
{
bool fieldsAdded = false;
List <Document> docList = GetDocumentsInACollection(colLink);
foreach (var doc in docList)
{
if (doc != null)
{
// Fetch object from the document.
Attendance attendance = JsonConvert.DeserializeObject <Attendance>(doc.ToString());
List <EmployeeAttendance> attendanceList = attendance.EmpAttendance;
bool fieldsExist = false;
// Mark Sttatus
foreach (var currentDayAttendance in attendanceList)
{
if (currentDayAttendance.Date == DateTime.Now.ToShortDateString())
{
fieldsExist = true;
}
}
if (fieldsExist == false)
{
// Create the attendance object
EmployeeAttendance employeeAttendance = new EmployeeAttendance
{
Date = DateTime.Now.ToShortDateString(),
};
attendanceList.Insert(0, employeeAttendance);
}
// Replace the existing document with the updated one.
try
{
await currentClient.ReplaceDocumentAsync(doc.SelfLink, attendance);
fieldsAdded = true;
}
catch (Exception e)
{
Console.WriteLine(e.Message);
fieldsAdded = false;
}
}
}
return(fieldsAdded);
}
public bool UpdateEmployeeAttendance(EmployeeAttendance employeeAttendance)
{
bool isSuccess = true;
try
{
employeeAttendanceRepository.Update(employeeAttendance);
this.SaveRecord();
ServiceUtil <EmployeeAttendance> .WriteActionLog(employeeAttendance.Id, ENUMOperation.UPDATE, employeeAttendance);
}
catch (Exception ex)
{
isSuccess = false;
logger.Error("Error in updating EmployeeAttendance", ex);
}
return(isSuccess);
}
public async Task <EmployeeAttendanceQueryModel> EmployeeWorkingDays(int employeeId, DateTime startTime, DateTime endTime)
{
var duration = await EmployeeAttendance.GetEmployeeAttendanceForDuration(employeeId, startTime, endTime);
var workingFullDays = duration.Where(d => d.Duration >= 480).Count();
var workingHalfDays = duration.Where(d => d.Duration <= 480 && d.Duration >= 240).Count();
var totalWorkingDays = workingFullDays + (workingHalfDays / 2);
var employeeAttendanceDUration = new EmployeeAttendanceQueryModel()
{
EmployeeId = employeeId,
QueryEndTime = endTime,
QueryStartTime = startTime,
TotalWorkingDays = totalWorkingDays
};
return(employeeAttendanceDUration);
}
private bool CreateAttendanceSummary(EmployeeAttendance employeeAttendance)
{
// for IN
if (employeeAttendance.Type == 1)
{
int empId = employeeAttendance.EmployeeId;
string flag = "H";
if (employeeAttendance.RemarkId == 1)
{
flag = "P";
}
else if (employeeAttendance.RemarkId == 2)
{
flag = "A";
}
else if (employeeAttendance.RemarkId == 3)
{
flag = "LP";
}
else if (employeeAttendance.RemarkId == 4)
{
flag = "LA";
}
else if (employeeAttendance.RemarkId == 5)
{
flag = "D";
}
else if (employeeAttendance.RemarkId == 6)
{
flag = "HD";
}
else if (employeeAttendance.RemarkId == 7)
{
flag = "EO";
}
else if (employeeAttendance.RemarkId == 8)
{
flag = "ELP";
}
return(employeeAttendanceSummaryService.InsertEmployeeAttendanceSummary(empId, employeeAttendance.Date, employeeAttendance.Date, flag));
}
return(true);
}
public dynamic Update(EmployeeAttendance model, bool IsDateRange, Nullable <DateTime> AttendanceDateEnd)
{
try
{
if (!AuthenticationModel.IsAllowed("Edit", Core.Constants.Constant.MenuName.ManualAttendance, Core.Constants.Constant.MenuGroupName.Setting))
{
Dictionary <string, string> Errors = new Dictionary <string, string>();
Errors.Add("Generic", "You are Not Allowed to Edit record");
return(Json(new
{
Errors
}, JsonRequestBehavior.AllowGet));
}
var data = _employeeAttendanceService.GetObjectById(model.Id);
data.EmployeeId = model.EmployeeId;
data.AttendanceDate = model.AttendanceDate;
data.Shift = model.Shift;
data.Status = model.Status;
data.CheckIn = model.CheckIn;
data.CheckOut = model.CheckOut;
//data.BreakOut = model.BreakOut;
//data.BreakIn = model.BreakIn;
data.Remark = model.Remark;
model = _employeeAttendanceService.UpdateObject(data, _employeeService);
}
catch (Exception ex)
{
LOG.Error("Update Failed", ex);
Dictionary <string, string> Errors = new Dictionary <string, string>();
Errors.Add("Generic", "Error " + ex);
return(Json(new
{
Errors
}, JsonRequestBehavior.AllowGet));
}
return(Json(new
{
model.Errors
}));
}
private EmployeeAttendanceModel PrepareEmployeeAttendanceModel(EmployeeAttendance employeeAttendance)
{
EmployeeAttendanceModel employeeAttendanceTemp = new EmployeeAttendanceModel();
employeeAttendanceTemp.Id = employeeAttendance.Id;
employeeAttendanceTemp.Date = employeeAttendance.Date.AddMinutes(timeZoneOffset).ToString("dd MMM yyyy");
employeeAttendanceTemp.EmployeeId = employeeAttendance.EmployeeId;
if (employeeAttendanceTemp.EmployeeId > 0)
{
employeeAttendanceTemp.EmployeeName = employeeAttendance.Employee.FullName;
}
employeeAttendanceTemp.Note = employeeAttendance.Note;
employeeAttendanceTemp.RemarkId = employeeAttendance.RemarkId;
if (employeeAttendanceTemp.RemarkId > 0)
{
employeeAttendanceTemp.AttendanceRemarkName = employeeAttendance.AttendanceRemark.Name;
}
employeeAttendanceTemp.Time = employeeAttendance.Time;
employeeAttendanceTemp.Type = employeeAttendance.Type;
employeeAttendanceTemp.SchoolId = employeeAttendance.SchoolId;
if (employeeAttendanceTemp.SchoolId > 0)
{
employeeAttendanceTemp.SchoolName = employeeAttendance.School.Name;
employeeAttendanceTemp.UpazilaId = employeeAttendance.School.UpazilaId;
if (employeeAttendanceTemp.UpazilaId > 0)
{
//employeeAttendanceTemp.UpazilaName = employeeAttendance.School.Upazila.Name;
employeeAttendanceTemp.DistrictId = employeeAttendance.School.Upazila.DistrictId;
if (employeeAttendanceTemp.DistrictId > 0)
{
//employeeAttendanceTemp.DistrictName = employeeAttendance.School.Upazila.District.Name;
employeeAttendanceTemp.DivisionId = employeeAttendance.School.Upazila.District.DivisionId;
if (employeeAttendanceTemp.DivisionId > 0)
{
//employeeAttendanceTemp.DivisionName = employeeAttendance.School.Upazila.District.Division.Name;
employeeAttendanceTemp.GeoName = employeeAttendance.School.Upazila.District.Division.Name + " - " + employeeAttendance.School.Upazila.District.Name + " - " + employeeAttendance.School.Upazila.Name;
}
}
}
}
return(employeeAttendanceTemp);
}
private List <EmployeeAttendance> selectEmployeeAttendances(SqlCommand cmd)
{
cmd.CommandType = CommandType.StoredProcedure;
SqlConnection con = cmd.Connection;
List <EmployeeAttendance> listAttendance = new List <EmployeeAttendance>();
con.Open();
using (con)
{
SqlDataReader dr = cmd.ExecuteReader();
if (dr.HasRows)
{
listAttendance = new List <EmployeeAttendance>();
while (dr.Read())
{
EmployeeRole role = new EmployeeRole();
role.ID = Convert.ToInt32(dr[3]);
role.Description = Convert.ToString(dr[4]);
Employee currEmployee = new Employee();
currEmployee.ID = Convert.ToString(dr[1]);
currEmployee.Name = Convert.ToString(dr[2]);
AttendanceStatus currAttendanceStatus = new AttendanceStatus()
{
ID = Convert.ToInt32(dr[5]),
Description = Convert.ToString(dr[6])
};
EmployeeAttendance attendance = new EmployeeAttendance
{
AttendanceDateTime = Convert.ToDateTime(dr[0]),
Emp = currEmployee,
Status = currAttendanceStatus
};
listAttendance.Add(attendance);
}
}
}
return(listAttendance);
}
public int AddLeavingStatus(EmployeeAttendance employeeAttendance)
{
try
{
const string query = @"UPDATE employee_attendance_info SET leaving_time = @leavingTime WHERE user_id = @userId AND local_date = @localDate";
Connection.Open();
Command.CommandText = query;
Command.Parameters.Clear();
Command.Parameters.AddWithValue("@userId", employeeAttendance.UserId);
Command.Parameters.AddWithValue("@leavingTime", employeeAttendance.LeavingTime);
Command.Parameters.AddWithValue("@localDate", employeeAttendance.LocalDate);
int count = Command.ExecuteNonQuery();
return(count);
}
finally
{
Connection.Close();
}
}
public async Task <ActionResult <AttendenceVMEmp> > PutEmployeeAttendance(int id)
{
var emp = _context.Employees.FirstOrDefault(x => x.EmployeeId == id);
if (emp == null)
{
return(NotFound());
}
var att = _context.EmployeeAttendances.FirstOrDefault(x => x.EmployeeId == emp.EmployeeId && x.InTime.Date == DateTime.Now.Date);
if (att == null)
{
att = new EmployeeAttendance {
EmployeeId = emp.EmployeeId, InTime = DateTime.Now
};
_context.EmployeeAttendances.Add(att);
}
else
{
att.InTime = DateTime.Now;
}
try
{
await _context.SaveChangesAsync();
return(new AttendenceVMEmp {
EmployeeId = att.EmployeeId, EmployeeName = emp.EmployeeName, Time = att.InTime
});
}
catch (DbUpdateConcurrencyException)
{
if (!EmployeeAttendanceExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
}
public ActionResult Edit(List <TempEmployeeAttendance> employeeAttendanceList)
{
Session["err"] = "Error, Please Check Input Fields";
Session["msg"] = "";
try
{
foreach (TempEmployeeAttendance t in employeeAttendanceList.ToList())
{
EmployeeAttendance employeeattendance = db.EmployeeAttendances.Find(t.id);
employeeattendance.AttendanceTypeID = t.attendancetypeid;
db.Entry(employeeattendance).State = EntityState.Modified;
db.SaveChanges();
Session["err"] = "";
Session["msg"] = "Modified Successfully";
}
}
catch { }
return(Json(Session["err"], JsonRequestBehavior.AllowGet));
}
