Example #1
0
 public static LeaveType GetLeaveTypeByID(int id)
 {
     LeaveType leaveType = new LeaveType();
     SqlLeaveTypeProvider sqlLeaveTypeProvider = new SqlLeaveTypeProvider();
     leaveType = sqlLeaveTypeProvider.GetLeaveTypeByID(id);
     return leaveType;
 }
    private void showLeaveTypeData()
    {
        LeaveType leaveType = new LeaveType();
        leaveType = LeaveTypeManager.GetLeaveTypeByID(Int32.Parse(Request.QueryString["leaveTypeID"]));

        txtLeaveName.Text = leaveType.LeaveName;
    }
    protected void btnAdd_Click(object sender, EventArgs e)
    {
        LeaveType leaveType = new LeaveType();

        leaveType.LeaveName = txtLeaveName.Text;
        int resutl = LeaveTypeManager.InsertLeaveType(leaveType);
        Response.Redirect("AdminLeaveTypeDisplay.aspx");
    }
    protected void btnUpdate_Click(object sender, EventArgs e)
    {
        LeaveType leaveType = new LeaveType();
        leaveType = LeaveTypeManager.GetLeaveTypeByID(Int32.Parse(Request.QueryString["leaveTypeID"]));
        LeaveType tempLeaveType = new LeaveType();
        tempLeaveType.LeaveTypeID = leaveType.LeaveTypeID;

        tempLeaveType.LeaveName = txtLeaveName.Text;
        bool result = LeaveTypeManager.UpdateLeaveType(tempLeaveType);
        Response.Redirect("AdminLeaveTypeDisplay.aspx");
    }
Example #5
0
 public LeaveType GetLeaveTypeFromReader(IDataReader reader)
 {
     try
     {
         LeaveType leaveType = new LeaveType
             (
                 (int)reader["LeaveTypeID"],
                 reader["LeaveName"].ToString()
             );
          return leaveType;
     }
     catch(Exception ex)
     {
         return null;
     }
 }
 public static LeaveType[] GetAll()
 {
     DataTable dt = Database.ExecuteQuery("SELECT * FROM Leave_Type");
     if (dt != null && dt.Rows.Count >= 1)
     {
         LeaveType[] lt = new LeaveType[dt.Rows.Count];
         for (int i = 0; i < lt.Length; i++)
         {
             lt[i] = new LeaveType();
             lt[i].Id = int.Parse(dt.Rows[i][0].ToString());
             lt[i].Name = dt.Rows[i][1].ToString();
             lt[i].MaxLeavesMonth = int.Parse(dt.Rows[i][2].ToString());
             lt[i].MaxLeavesYear = int.Parse(dt.Rows[i][3].ToString());
         }
         return lt;
     }
     return null;
 }
Example #7
0
        public void AddNewLeave(DateTime startingDate, int duration, LeaveType vacation)
        {
            if (duration > availableDaysOff)
            {
                throw new NegativeLeaveDays();//lansare exceptie manuala
            }
            try
            {
                Leave newleave = new Leave(startingDate, duration, vacation);
                newleave.employee = this.lastName + " " + this.firstName;

                SubstractDays(duration);
                listLeave.Add(newleave);//adaugare concedii in lista de concedii
            }
            catch (NegativeLeaveDays)
            {
                Console.WriteLine("Numarul de zile ramase nu poate fi mai mare decat durata concediului!");
            }
        }
Example #8
0
 public bool Create(LeaveType entity)
 {
     _db.LeaveTypes.Add(entity);
     return(Save());
 }
Example #9
0
        private static LeaveEntitlement GetLeaveEntitlement(User user, List<Leave> leaves, LeaveType leaveType, double taken)
        {
            var accepted = leaves.Where(l => l.LeaveType == leaveType.LeaveCodeName && !l.IsApproved.HasValue || l.IsApproved.Value).ToList();

            return new LeaveEntitlement
            {
                Name = leaveType.Name,
                Type = leaveType.LeaveCodeName,
                Accepted = leaves.Where(l => l.LeaveType == leaveType.LeaveCodeName && (!l.IsApproved.HasValue || l.IsApproved.Value)).Sum(l => l.Hours) / 8.0,
                Pending = leaves.Where(l => l.LeaveType == leaveType.LeaveCodeName && l.IsApproved.HasValue && !l.IsApproved.Value && l.Date > DateTime.Now).Sum(l => l.Hours) / 8.0,
                Left = leaveType.Value - taken
            };
        }
Example #10
0
    public int InsertLeaveType(LeaveType leaveType)
    {
        using (SqlConnection connection = new SqlConnection(this.ConnectionString))
        {
            SqlCommand cmd = new SqlCommand("CUC_InsertLeaveType", connection);
            cmd.CommandType = CommandType.StoredProcedure;
            cmd.Parameters.Add("@LeaveTypeID", SqlDbType.Int).Direction = ParameterDirection.Output;
            cmd.Parameters.Add("@LeaveName", SqlDbType.NVarChar).Value = leaveType.LeaveName;
            connection.Open();

            int result = cmd.ExecuteNonQuery();
            return (int)cmd.Parameters["@LeaveTypeID"].Value;
        }
    }
Example #11
0
    public bool UpdateLeaveType(LeaveType leaveType)
    {
        using (SqlConnection connection = new SqlConnection(this.ConnectionString))
        {
            SqlCommand cmd = new SqlCommand("CUC_UpdateLeaveType", connection);
            cmd.CommandType = CommandType.StoredProcedure;
            cmd.Parameters.Add("@LeaveTypeID", SqlDbType.Int).Value = leaveType.LeaveTypeID;
            cmd.Parameters.Add("@LeaveName", SqlDbType.NVarChar).Value = leaveType.LeaveName;
            connection.Open();

            int result = cmd.ExecuteNonQuery();
            return result == 1;
        }
    }
Example #12
0
 public bool Delete(LeaveType entity)
 {
     _db.LeaveTypes.Remove(entity);
     return(Save());
 }
 public static LeaveType GetById(string Id)
 {
     DataTable dt = Database.ExecuteQuery("SELECT * FROM Leave_Type WHERE Id = " + Id);
     if (dt != null && dt.Rows.Count == 1)
     {
         LeaveType lt = new LeaveType();
         lt.Id = int.Parse(dt.Rows[0][0].ToString());
         lt.Name = dt.Rows[0][1].ToString();
         lt.MaxLeavesMonth = int.Parse(dt.Rows[0][2].ToString());
         lt.MaxLeavesYear = int.Parse(dt.Rows[0][3].ToString());
         return lt;
     }
     return null;
 }
Example #14
0
 public static bool UpdateLeaveType(LeaveType leaveType)
 {
     SqlLeaveTypeProvider sqlLeaveTypeProvider = new SqlLeaveTypeProvider();
     return sqlLeaveTypeProvider.UpdateLeaveType(leaveType);
 }
        public float CalculateNoOfDays(LeaveApplication lvapplication, LeaveType lvType, LeavePolicy lvPolicy)
        {
            List <Holiday> holidays = new List <Holiday>();

            holidays = DDService.GetHolidays();
            float val = 0;

            if (lvapplication.IsHalf == true)
            {
                val = (float)0.5;
            }
            else
            {
                val = (lvapplication.ToDate - lvapplication.FromDate).Days + 1;
                Expression <Func <Employee, bool> > SpecificEntries = aa => aa.PEmployeeID == lvapplication.EmpID;
                Employee emp   = EmployeeRepo.FindBy(SpecificEntries).First();
                Shift    shift = emp.Shift;
                Expression <Func <VAT_RosterDetail, bool> > SpecificEntries2 = aa => aa.CriteriaData == emp.CrewID && aa.RosterDate >= lvapplication.FromDate && aa.RosterDate <= lvapplication.ToDate;
                List <VAT_RosterDetail> rosterDetails = RosterDetailRepo.FindBy(SpecificEntries2);
                if ((lvPolicy.CountRestDays != true || lvPolicy.CountGZDays != true) && lvPolicy.PLeavePolicyID != 0)
                {
                    DateTime dts = lvapplication.FromDate;
                    while (dts <= lvapplication.ToDate)
                    {
                        if (rosterDetails.Where(aa => aa.RosterDate == dts).Count() > 0)
                        {
                            VAT_RosterDetail rd = rosterDetails.First(aa => aa.RosterDate == dts);

                            if (holidays.Where(aa => aa.HolidayDate == dts).Count() > 0 && shift.GZDays == true)
                            {
                                if (lvPolicy.CountGZDays == false)
                                {
                                    val = val - 1;
                                }
                            }
                            else
                            {
                                if (rd.WorkMin == 0)
                                {
                                    val = val - 1;
                                }
                            }
                        }
                        else
                        {
                            if (holidays.Where(aa => aa.HolidayDate == dts).Count() > 0 && shift.GZDays == true)
                            {
                                if (lvPolicy.CountGZDays == false)
                                {
                                    val = val - 1;
                                }
                            }
                            else
                            {
                                if (CurrentDayNotRest(shift, dts))
                                {
                                    val = val - 1;
                                }
                            }
                        }
                        dts = dts.AddDays(1);
                    }
                }
            }
            return(val);
        }
Example #16
0
 public bool Update(LeaveType entity)
 {
     throw new System.NotImplementedException();
 }
Example #17
0
 static LeaveTypeB()
 {
     _leaveTypeRep = new LeaveType();
 }
        public async Task <bool> Delete(LeaveType entity)
        {
            _db.LeaveTypes.Remove(entity);

            return(await Save());
        }
        public async Task <bool> Create(LeaveType entity)
        {
            await _db.LeaveTypes.AddAsync(entity);

            return(await Save());
        }
Example #20
0
 public bool Update(LeaveType entity)
 {
     _db.LeaveTypes.Update(entity);
     return(Save());
 }
Example #21
0
 public static int InsertLeaveType(LeaveType leaveType)
 {
     SqlLeaveTypeProvider sqlLeaveTypeProvider = new SqlLeaveTypeProvider();
     return sqlLeaveTypeProvider.InsertLeaveType(leaveType);
 }
Example #22
0
    public LeaveType[] getWalk()
    {
        LeaveType[] b = new LeaveType[4];

        if (n != null)
        {
            if (n.canMove())
            {
                b[0] = n.getLeaveObj().type;
            }
            else
            {
                b [0] = LeaveType.Block;
            }
        }
        else
        {
            b [0] = LeaveType.Empty;
        }
        if (e != null)
        {
            if (e.canMove())
            {
                b[1] = e.getLeaveObj().type;
            }
            else
            {
                b [1] = LeaveType.Block;
            }
        }
        else
        {
            b [1] = LeaveType.Empty;
        }
        if (s != null)
        {
            if (s.canMove())
            {
                b[2] = s.getLeaveObj().type;
            }
            else
            {
                b [2] = LeaveType.Block;
            }
        }
        else
        {
            b [2] = LeaveType.Empty;
        }
        if (w != null)
        {
            if (w.canMove())
            {
                b[3] = w.getLeaveObj().type;
            }
            else
            {
                b [3] = LeaveType.Block;
            }
        }
        else
        {
            b [3] = LeaveType.Empty;
        }
        return(b);
    }
 public void ChangeLeaveType(int leaveId, LeaveType leaveType)
 {
     var leave = this.leaveRepository.FindById(leaveId);
     var escalationList = this.GetApprovers(leave.EmployeeId, leaveType);
     leave.Approvers.Clear();
     leave.Approvers.AddRange(escalationList);
     leave.CurrentApprover = leave.Approvers.First();
     leave.LeaveType = leaveType;
     this.leaveRepository.Update(leave);
 }
        public bool BalanceLeaves(LeaveApplication lvappl, LeaveType LeaveType, int PayrollPeriodID)
        {
            bool isAccLeave = false;
            List <LeaveQuotaYear> _lvConsumedYear = new List <LeaveQuotaYear>();
            Expression <Func <LeaveQuotaYear, bool> > SpecificEntries = aa => aa.EmployeeID == lvappl.EmpID && aa.FinancialYearID == lvappl.FinancialYearID && aa.LeaveTypeID == lvappl.LeaveTypeID;

            _lvConsumedYear = LeaveQuotaYearRepo.FindBy(SpecificEntries);
            float _NoOfDays = lvappl.NoOfDays;

            if (_lvConsumedYear.Count > 0)
            {
                // For Yearly Leave Quota
                if (lvappl.LeaveTypeID == 1) // AL
                {
                    if (lvappl.IsAccum == true)
                    {
                        _lvConsumedYear.FirstOrDefault().CFRemaining    = (float)(_lvConsumedYear.FirstOrDefault().CFRemaining - _NoOfDays);
                        _lvConsumedYear.FirstOrDefault().GrandRemaining = (float)(_lvConsumedYear.FirstOrDefault().GrandRemaining - _NoOfDays);
                        if (_lvConsumedYear.FirstOrDefault().CFRemaining < 0)
                        {
                            _lvConsumedYear.FirstOrDefault().YearlyRemaining = (float)(_lvConsumedYear.FirstOrDefault().YearlyRemaining + _lvConsumedYear.FirstOrDefault().CFRemaining);
                            //_lvConsumedYear.FirstOrDefault().GrandRemaining = (float)(_lvConsumedYear.FirstOrDefault().GrandRemaining + _lvConsumedYear.FirstOrDefault().CFRemaining);
                            _lvConsumedYear.FirstOrDefault().CFRemaining = 0;
                        }
                    }
                    else
                    {
                        if (_lvConsumedYear.FirstOrDefault().YearlyRemaining > 0)
                        {
                            _lvConsumedYear.FirstOrDefault().YearlyRemaining = (float)(_lvConsumedYear.FirstOrDefault().YearlyRemaining - _NoOfDays);
                        }
                        _lvConsumedYear.FirstOrDefault().GrandRemaining = (float)(_lvConsumedYear.FirstOrDefault().GrandRemaining - _NoOfDays);
                    }
                }
                else if (lvappl.LeaveTypeID == 4) //CPL
                {
                    if (_lvConsumedYear.FirstOrDefault().YearlyRemaining > 0)
                    {
                        _lvConsumedYear.FirstOrDefault().YearlyRemaining = (float)(_lvConsumedYear.FirstOrDefault().YearlyRemaining - _NoOfDays);
                    }
                    _lvConsumedYear.FirstOrDefault().GrandRemaining = (float)(_lvConsumedYear.FirstOrDefault().GrandRemaining - _NoOfDays);
                    // Subtract leave from LeaveCPLBalance
                    Expression <Func <LeaveCPLEmpBalance, bool> > SpecificEntrie3 = aa => aa.EmployeeID == lvappl.EmpID && aa.IsExpire == false && aa.RemainingDays > 0;
                    List <LeaveCPLEmpBalance> dbLeaveCPLBalances = LeaveCPLEmpBalanceRepo.FindBy(SpecificEntrie3).OrderBy(aa => aa.PLeaveCPLEmpBalanceID).ToList();
                    if (dbLeaveCPLBalances.Count == 1)
                    {
                        LeaveCPLEmpBalance dbLeaveCPLBalance = dbLeaveCPLBalances.First();
                        dbLeaveCPLBalance.Used          = (float)(dbLeaveCPLBalance.Used + _NoOfDays);
                        dbLeaveCPLBalance.RemainingDays = (float)(dbLeaveCPLBalance.RemainingDays - _NoOfDays);
                        LeaveCPLEmpBalanceRepo.Edit(dbLeaveCPLBalance);
                        LeaveCPLEmpBalanceRepo.Save();
                    }
                    else if (dbLeaveCPLBalances.Count > 1)
                    {
                        double?NoOfdays = _NoOfDays;
                        foreach (var dbLeaveCPLBalance in dbLeaveCPLBalances)
                        {
                            if (dbLeaveCPLBalance.RemainingDays > 0 && NoOfdays > 0)
                            {
                                dbLeaveCPLBalance.Used          = (float)(dbLeaveCPLBalance.Used + NoOfdays);
                                dbLeaveCPLBalance.RemainingDays = (float)(dbLeaveCPLBalance.RemainingDays - NoOfdays);
                                if (dbLeaveCPLBalance.RemainingDays < 0)
                                {
                                    NoOfdays = -1.0 * dbLeaveCPLBalance.RemainingDays;
                                    dbLeaveCPLBalance.Used          = (float)(dbLeaveCPLBalance.Used - NoOfdays);
                                    dbLeaveCPLBalance.RemainingDays = 0;
                                }
                                else
                                {
                                    NoOfdays = 0;
                                }
                                LeaveCPLEmpBalanceRepo.Edit(dbLeaveCPLBalance);
                                LeaveCPLEmpBalanceRepo.Save();
                            }
                        }
                    }
                }
                else // All others
                {
                    if (_lvConsumedYear.FirstOrDefault().YearlyRemaining > 0)
                    {
                        _lvConsumedYear.FirstOrDefault().YearlyRemaining = (float)(_lvConsumedYear.FirstOrDefault().YearlyRemaining - _NoOfDays);
                    }
                    _lvConsumedYear.FirstOrDefault().GrandRemaining = (float)(_lvConsumedYear.FirstOrDefault().GrandRemaining - _NoOfDays);
                }
                LeaveQuotaYearRepo.Edit(_lvConsumedYear.First());
                LeaveQuotaYearRepo.Save();

                LeaveQuotaPeriod atLQp = new LeaveQuotaPeriod();
                Expression <Func <LeaveQuotaPeriod, bool> > SpecificEntrie2 = aa => aa.EmployeeID == lvappl.EmpID && aa.PayrollPeriodID == PayrollPeriodID && aa.LeaveTypeID == lvappl.LeaveTypeID;

                if (LeaveQuotaPeriodRepo.FindBy(SpecificEntrie2).Count() > 0)
                {
                    atLQp = LeaveQuotaPeriodRepo.FindBy(SpecificEntrie2).First();
                }
                else
                {
                    atLQp.EmployeeID      = lvappl.EmpID;
                    atLQp.LeaveTypeID     = lvappl.LeaveTypeID;
                    atLQp.PayrollPeriodID = PayrollPeriodID;
                    atLQp.ConsumedDays    = 0;
                    atLQp.StartNoOfDays   = _lvConsumedYear.FirstOrDefault().GrandRemaining + _NoOfDays;
                    LeaveQuotaPeriodRepo.Add(atLQp);
                    LeaveQuotaPeriodRepo.Save();
                }
                atLQp = AssistantLeave.AddBalancceMonthQuota(_lvConsumedYear, lvappl, atLQp);
                LeaveQuotaPeriodRepo.Edit(atLQp);
                // Check for Post edit
                LeaveQuotaPeriodRepo.Save();
            }
            return(isAccLeave);
        }
 private IEnumerable<Employee> GetApprovers(int employeeId, LeaveType leaveType)
 {
     switch(leaveType)
     {
         case LeaveType.Annual: //(Team Lead -> Account Manager -> SignOff)
             throw new NotImplementedException();
         case LeaveType.Study: //(Account Manager -> SignOff)
             throw new NotImplementedException();
         default:
             throw new ArgumentOutOfRangeException("leaveType");
     }
 }
Example #26
0
 public async Task <bool> Update(LeaveType entity)
 {
     _db.LeaveTypes.Update(entity);
     return(await Save());
 }