private void btnSave_Click(object sender, RoutedEventArgs e)
{
string workerId = txtWorkerId.Text;
DateTime startDate = dpStartDate.SelectedDate.Value;
DateTime endDate = dpEndDate.SelectedDate.Value;
LeaveTypeModel leaveType = cboLeaveType.SelectedItem as LeaveTypeModel;
if (leaveType == null)
{
return;
}
WorkerLeaveModel model = new WorkerLeaveModel
{
WorkerLeaveId = workerLeaveId,
WorkerId = workerId,
StartDate = startDate,
EndDate = endDate,
LeaveType = leaveType.LeaveTypeId,
};
if (String.IsNullOrEmpty(model.WorkerId) == true || model.StartDate.Date > model.EndDate.Date)
{
return;
}
if (threadInsert.IsBusy == false)
{
this.Cursor = Cursors.Wait;
btnSave.IsEnabled = false;
threadInsert.RunWorkerAsync(model);
}
}
private int CalculateNumberOfDayAbsent(int year, int month, List <SourceModel> sourceList, List <WorkerLeaveModel> workerLeaveList, List <HolidayModel> holidayList)
{
int numberOfDayAbsent = 0;
DateTime startDate = new DateTime(year, month, 1);
DateTime endDate = startDate.AddDays(DateTime.DaysInMonth(year, month) - 1);
for (DateTime date = startDate; date <= endDate; date = date.AddDays(1))
{
SourceModel source = sourceList.Where(s => s.Date.Date == date.Date).FirstOrDefault();
if (source == null && date.DayOfWeek != DayOfWeek.Sunday && holidayList.Select(h => h.Date.Date).Contains(date.Date) == false)
{
List <WorkerLeaveModel> workerLeaveList_D1 = workerLeaveList.Where(w => w.StartDate.Date <= date.Date && date.Date <= w.EndDate.Date).ToList();
if (workerLeaveList_D1.Count > 0)
{
WorkerLeaveModel workerLeave = workerLeaveList_D1.OrderBy(w => w.CreatedDate).Last();
LeaveTypeModel leaveType = leaveTypeList.Where(l => l.LeaveTypeId == workerLeave.LeaveType).FirstOrDefault();
if (leaveType != null && leaveType.HaveIncentive == false)
{
numberOfDayAbsent += 1;
}
}
else
{
numberOfDayAbsent += 1;
}
}
}
return(numberOfDayAbsent);
}
public ActionResult Add(LeaveTypeModel leaveTypeModel)
{
leaveTypeModel.AddLeaveType();
TempData["message"] = "Successfully added Branch.";
TempData["alertType"] = "success";
return(RedirectToAction("Index"));
}
public void Hideorshowbutton(LeaveTypeModel obj)
{
if (_OldDisciplinaryData == obj)
{
obj.Isbuttonvisible = !obj.Isbuttonvisible;
UpdateProduct(obj);
}
else
{
if (_OldDisciplinaryData != null)
{
foreach (var items in LeaveTypeList)
{
if (_OldDisciplinaryData.name == items.name)
{
_OldDisciplinaryData.Isbuttonvisible = false;
UpdateProduct(_OldDisciplinaryData);
break;
}
}
}
obj.Isbuttonvisible = true;
UpdateProduct(obj);
}
_OldDisciplinaryData = obj;
}
public void UpdateProduct(LeaveTypeModel obj)
{
var index = LeaveTypeList.IndexOf(obj);
LeaveTypeList.Remove(obj);
LeaveTypeList.Insert(index, obj);
}
public static void Save(LeaveTypeModel _leaveType, out string message)
{
try
{
message = "";
using (var db = new SLVLOnlineEntities())
{
if (_leaveType.ID == null || _leaveType.ID == Guid.Empty)
{
LeaveType newLeaveType = new LeaveType
{
ID = Guid.NewGuid(),
Description = _leaveType.Description,
CreatedBy = UniversalHelpers.CurrentUser.ID,
CreatedDate = DateTime.Now,
DaysBeforeFilling = _leaveType.DaysBeforeFilling,
Type = _leaveType.Type,
LeaveDeduction = _leaveType.LeaveDeduction
};
db.Entry(newLeaveType).State = EntityState.Added;
}
else //Update
{
var leave = db.LeaveType.FirstOrDefault(r => r.ID == _leaveType.ID);
if (leave != null)
{
if (_leaveType.Status == "X")
{
db.Entry(leave).State = EntityState.Deleted;
}
else
{
leave.Description = _leaveType.Description;
leave.CreatedBy = UniversalHelpers.CurrentUser.ID;
leave.CreatedDate = DateTime.Now;
leave.DaysBeforeFilling = _leaveType.DaysBeforeFilling;
leave.Type = _leaveType.Type;
leave.LeaveDeduction = _leaveType.LeaveDeduction;
db.Entry(leave).State = EntityState.Modified;
}
}
}
db.SaveChanges();
}
}
catch (Exception error)
{
message = error.Message;
}
}
public ActionResult Edit(LeaveTypeModel leaveType)
{
try
{
if (!ModelState.IsValid)
{
return(View(leaveType));
}
var leaveTypeEdit = _mapper.Map <LeaveTypeManager>(leaveType);
bool success = _repository.Update(leaveTypeEdit);
if (!success)
{
ModelState.AddModelError("", "Error");
}
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
public ActionResult Create(LeaveTypeModel model)
{
try
{
// TODO: Add insert logic here
if (!ModelState.IsValid)
{
return(View(model));
}
var leaveType = _mapper.Map <LeaveType>(model);
leaveType.DateCreated = DateTime.Now;
var isSuccess = _repo.Create(leaveType);
if (!isSuccess)
{
ModelState.AddModelError("", "Something Went Wrong...");
return(View(model));
}
return(RedirectToAction(nameof(Index)));
}
catch
{
ModelState.AddModelError("", "Something Went Wrong...");
return(View(model));
}
}
public ActionResult SaveLeaveType(LeaveTypeModel leaveType)
{
string serverResponse = "";
LeaveTypeService.Save(leaveType, out serverResponse);
return(Json(serverResponse));
}
/// <summary>
/// Maps the specified original.
/// </summary>
/// <param name="original">The original.</param>
/// <returns>The SelectListItem.</returns>
public static SelectListItem Map(this LeaveTypeModel original)
{
var mappedOutcome = new SelectListItem
{
Text = original.Description,
Value = original.LeaveTypeId.ToString()
};
return(mappedOutcome);
}
/// <summary>
/// Maps the specified original.
/// </summary>
/// <param name="original">The original.</param>
/// <returns></returns>
public static LeaveTypeModel Map(this LeaveType original)
{
var mappedOutcome = new LeaveTypeModel
{
LeaveTypeId = original.LeaveTypeId,
Description = original.Description
};
return(mappedOutcome);
}
public ActionResult Edit(Guid id)
{
var leaveType = new LeaveTypeModel(id);
if (leaveType == null)
{
return(HttpNotFound());
}
return(View(leaveType));
}
public async Task <ActionResult <LeaveTypeDto> > CreateAsync([FromBody] LeaveTypeModel model)
{
var request = new CreateLeaveTypeCommand(_companyId,
_userId,
model.IsHalfDaysActivated,
model.IsHideLeaveTypeName,
model.TypeName,
model.IsApprovalRequired,
model.DefaultDaysPerYear,
model.IsUnlimited,
model.IsReasonRequired,
model.IsAllowNegativeBalance,
model.Color);
return(Single(await CommandAsync(request)));
}
public AttendanceWindow(SectionModel section)
{
this.section = section;
threadLoad = new BackgroundWorker();
threadLoad.WorkerSupportsCancellation = true;
threadLoad.DoWork += new DoWorkEventHandler(threadLoad_DoWork);
threadLoad.RunWorkerCompleted += new RunWorkerCompletedEventHandler(threadLoad_RunWorkerCompleted);
dt = new DataTable();
threadShow = new BackgroundWorker();
threadShow.DoWork += new DoWorkEventHandler(threadShow_DoWork);
threadShow.RunWorkerCompleted += new RunWorkerCompletedEventHandler(threadShow_RunWorkerCompleted);
dtPrint = new AttendanceDataSet().Tables["AttendanceTable"];
leaveTypeList = LeaveTypeModel.Create();
holidayList = new List <HolidayModel>();
InitializeComponent();
}
public JsonResult Save(LeaveTypeModel leaveType, bool isInsert)
{
if (isInsert)
{
leaveType.SetCreateProperties(LoginInformation.UserInformation.Id);
leaveType.Id = _leaveTypeService.Insert(leaveType);
}
else
{
leaveType.SetUpdateProperties(LoginInformation.UserInformation.Id);
_leaveTypeService.Update(leaveType);
}
return(new JsonResult {
Data = leaveType
});
}
public LineIncentiveSummaryWindow(SectionModel section)
{
InitializeComponent();
this.section = section;
threadLoad = new BackgroundWorker();
threadLoad.WorkerSupportsCancellation = true;
threadLoad.RunWorkerCompleted += new RunWorkerCompletedEventHandler(threadLoad_RunWorkerCompleted);
threadLoad.DoWork += new DoWorkEventHandler(threadLoad_DoWork);
lineList = new List <LineModel>();
personalList = new List <PersonalModel>();
threadShow = new BackgroundWorker();
threadShow.RunWorkerCompleted += new RunWorkerCompletedEventHandler(threadShow_RunWorkerCompleted);
threadShow.DoWork += new DoWorkEventHandler(threadShow_DoWork);
leaveTypeList = LeaveTypeModel.Create();
minusIncentiveList = MinusIncentiveModel.Create();
performanceDetailList = new List <LinePerformanceDetailModel>();
}
public LeaveTypeModel InsertLeaveType([FromBody] LeaveTypeModel model)
{
try
{
var leaveTypeId = model.LeaveTypeId;
var leaveTypeModel = _service.InsertLeaveType(model);
// Audit Log
if (leaveTypeId > 0)
{
var audit = new AuditLog
{
UserId = CurrentUser.Id,
EntityId = model.LeaveTypeId.ToString(),
EntityType = AuditLogs.EntityType.LeaveType,
ActionType = AuditLogs.ActionType.UpdatedLeaveType,
PostValue = Serializer.Serialize(model),
DistrictId = CurrentUser.DistrictId,
OrganizationId = CurrentUser.OrganizationId == "-1" ? null : CurrentUser.OrganizationId
};
_audit.InsertAuditLog(audit);
}
else
{
var audit = new AuditLog
{
UserId = CurrentUser.Id,
EntityId = model.LeaveTypeId.ToString(),
EntityType = AuditLogs.EntityType.LeaveType,
ActionType = AuditLogs.ActionType.CreatedLeaveType,
PostValue = Serializer.Serialize(model),
DistrictId = CurrentUser.DistrictId,
OrganizationId = CurrentUser.OrganizationId == "-1" ? null : CurrentUser.OrganizationId
};
_audit.InsertAuditLog(audit);
}
return(leaveTypeModel);
}
catch (Exception ex)
{
}
finally
{
}
return(null);
}
private static LeaveTypeModel PrepareLeaveTypeModel(LeaveType leaveType)
{
LeaveTypeModel leaveTypeTemp = new LeaveTypeModel();
leaveTypeTemp.Id = leaveType.Id;
leaveTypeTemp.Name = leaveType.Name;
leaveTypeTemp.CarryForward = leaveType.CarryForward;
leaveTypeTemp.PayDays = leaveType.PayDays;
leaveTypeTemp.PaymentMode = leaveType.PaymentMode;
leaveTypeTemp.Remarks = leaveType.Remarks;
leaveTypeTemp.ShortName = leaveType.ShortName;
if (leaveType.IsActive != null)
{
leaveTypeTemp.IsActive = leaveType.IsActive.Value;
}
return(leaveTypeTemp);
}
public LeaveTypeModel InsertLeaveType(LeaveTypeModel model)
{
var sql = "[Leaves].[InsertLeaveType]";
var queryParams = new DynamicParameters();
queryParams.Add("@leaveTypeId", model.LeaveTypeId);
queryParams.Add("@Name", model.LeaveTypeName);
queryParams.Add("@StartingBalance", model.StartingBalance);
queryParams.Add("@IsSubtractAllowance", model.IsSubtractAllowance);
queryParams.Add("@IsApprovalRequired", model.IsApprovalRequired);
queryParams.Add("@IsVisible", model.IsVisible);
queryParams.Add("@AllowanceType", model.AllowanceType);
queryParams.Add("@DistrictId", model.DistrictId);
queryParams.Add("@OrganizationId", model.OrganizationId);
queryParams.Add("@CreatedDate", DateTime.Now);
queryParams.Add("@ModifiedDate", DateTime.Now);
model.LeaveTypeId = Db.ExecuteScalar <int>(sql, queryParams, commandType: System.Data.CommandType.StoredProcedure);
return(model);
}
public ActionResult Delete(LeaveTypeModel leaveType)
{
try
{
var leaveTypeDelete = _mapper.Map <LeaveTypeManager>(leaveType);
bool success = _repository.Delete(leaveTypeDelete);
if (!success)
{
ModelState.AddModelError("", "Error");
}
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
public IHttpActionResult UpdateLeaveType(LeaveTypeModel leaveTypeModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var leaveTypeDto = Mapper.Map <LeaveTypeDto>(leaveTypeModel);
_leaveTypeAppService.Update(leaveTypeDto, AuthHelper.GetCurrentUserId());
return(Ok("Leave Type Update"));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public WorkerLeaveWindow()
{
workerLeaveViewList = new ObservableCollection <WorkerLeaveViewModel>();
threadSearch = new BackgroundWorker();
threadSearch.DoWork += new DoWorkEventHandler(threadSearch_DoWork);
threadSearch.RunWorkerCompleted += new RunWorkerCompletedEventHandler(threadSearch_RunWorkerCompleted);
threadInsert = new BackgroundWorker();
threadInsert.DoWork += new DoWorkEventHandler(threadInsert_DoWork);
threadInsert.RunWorkerCompleted += new RunWorkerCompletedEventHandler(threadInsert_RunWorkerCompleted);
threadDelete = new BackgroundWorker();
threadDelete.DoWork += new DoWorkEventHandler(threadDelete_DoWork);
threadDelete.RunWorkerCompleted += new RunWorkerCompletedEventHandler(threadDelete_RunWorkerCompleted);
workerLeaveId = 0;
workerLeaveView = new WorkerLeaveViewModel();
leaveTypeList = LeaveTypeModel.Create();
InitializeComponent();
}
public ActionResult Delete(int id, LeaveTypeModel model)
{
try
{
// TODO: Add delete logic here
var leavetype = _repo.FindById(id);
if (leavetype == null)
{
return(NotFound());
}
var isSuccess = _repo.Delete(leavetype);
if (!isSuccess)
{
return(View(model));
}
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View(model));
}
}
void threadSearch_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
List <WorkerLeaveModel> workerLeaveList = e.Result as List <WorkerLeaveModel>;
foreach (WorkerLeaveModel workerLeave in workerLeaveList)
{
LeaveTypeModel leaveType = leaveTypeList.Where(l => l.LeaveTypeId == workerLeave.LeaveType).FirstOrDefault();
WorkerLeaveViewModel workerLeaveView = new WorkerLeaveViewModel
{
WorkerLeaveId = workerLeave.WorkerLeaveId,
WorkerId = workerLeave.WorkerId,
StartDate = workerLeave.StartDate,
EndDate = workerLeave.EndDate,
LeaveType = leaveType,
};
workerLeaveViewList.Add(workerLeaveView);
}
dgMain.ItemsSource = workerLeaveViewList;
btnSearch.IsEnabled = true;
this.Cursor = null;
}
//
// GET: /Admin/LeaveType/
public ActionResult Index()
{
var leaveType = new LeaveTypeModel().GetAllLeaveTypes().Where(e => e.IsDelete == false);
return(View(leaveType));
}
public async void OnDeleteCommand(LeaveTypeModel obj)
{
web.DeleteLeavetype(obj.leaveTypeId);
Hideorshowbutton(obj);
}
public async void OnTapCommand(LeaveTypeModel obj)
{
Hideorshowbutton(obj);
}
public LeaveTypeModel InsertLeaveType(LeaveTypeModel model)
{
return(_repo.InsertLeaveType(model));
}
void threadShow_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
List <SourceModel> sourceList = e.Result as List <SourceModel>;
DateTime startDate = new DateTime(year, month, 1);
DateTime endDate = startDate.AddDays(DateTime.DaysInMonth(year, month) - 1);
List <PersonalModel> personalList_D1 = personalList.Where(p => p.Department == line).OrderBy(p => p.WorkerId).ToList();
List <DateTime> holidayList_D1 = holidayList.Select(h => h.Date.Date).ToList();
dtPrint.Rows.Clear();
int i = 1;
foreach (PersonalModel personal in personalList_D1)
{
List <SourceModel> sourceList_D1 = sourceList.Where(w => w.CardId == personal.CardId).ToList();
List <WorkerLeaveModel> workerLeaveList_D1 = workerLeaveList.Where(w => w.WorkerId.ToLower() == personal.WorkerId.ToLower()).ToList();
DataRow dr = dt.NewRow();
dr["NumberOf"] = i;
if (personal != null)
{
dr["Name"] = personal.Name;
}
dr["WorkerId"] = personal.WorkerId;
for (DateTime date = startDate; date <= endDate; date = date.AddDays(1))
{
DataRow drPrint = dtPrint.NewRow();
drPrint["NumberOf"] = i;
if (personal != null)
{
drPrint["Name"] = personal.Name;
}
drPrint["WorkerId"] = personal.WorkerId;
drPrint["Day"] = date.Day;
SourceModel source = sourceList_D1.Where(w => w.Date.Date == date.Date).FirstOrDefault();
if (source != null)
{
dr[String.Format("Day_{0}", date.Day)] = "√";
dr[String.Format("Day_{0}_Background", date.Day)] = Brushes.LightGray;
drPrint["Working"] = "√";
drPrint["Background"] = "LightGrey";
}
else
{
dr[String.Format("Day_{0}_Background", date.Day)] = Brushes.Transparent;
drPrint["Background"] = "Transparent";
if (date.DayOfWeek != DayOfWeek.Sunday && holidayList_D1.Contains(date.Date) == false)
{
List <WorkerLeaveModel> workerLeaveList_D2 = workerLeaveList_D1.Where(w => w.StartDate.Date <= date.Date && date.Date <= w.EndDate.Date).ToList();
if (workerLeaveList_D2.Count > 0)
{
WorkerLeaveModel workerLeave = workerLeaveList_D2.OrderBy(w => w.CreatedDate).Last();
LeaveTypeModel leaveType = leaveTypeList.Where(l => l.LeaveTypeId == workerLeave.LeaveType).FirstOrDefault();
if (leaveType != null)
{
dr[String.Format("Day_{0}_Background", date.Day)] = leaveType.BackgroundColor;
drPrint["Background"] = leaveType.ReportBackgroundColor;
}
}
else
{
dr[String.Format("Day_{0}_Background", date.Day)] = Brushes.Red;
drPrint["Background"] = "Red";
}
}
drPrint["Working"] = "";
}
dtPrint.Rows.Add(drPrint);
}
dt.Rows.Add(dr);
i = i + 1;
}
dgMain.ItemsSource = null;
dgMain.ItemsSource = dt.AsDataView();
btnPrint.IsEnabled = true;
btnShow.IsEnabled = true;
this.Cursor = null;
}
public ActionResult Edit(LeaveTypeModel model)
{
model.EditLeaveType();
return(RedirectToAction("Index"));
}
