1421 lines
53 KiB
C#
1421 lines
53 KiB
C#
using System;
|
|
using System.Linq;
|
|
using System.Data;
|
|
using System.Collections.Generic;
|
|
using Ease.Core.Model;
|
|
using System.IO;
|
|
using Ease.Core.Utility;
|
|
using System.Text.RegularExpressions;
|
|
|
|
namespace HRM.BO
|
|
{
|
|
|
|
public class DefaultConfigurationValue
|
|
{
|
|
|
|
public DefaultConfigurationValue()
|
|
{
|
|
|
|
}
|
|
public DefaultConfigurationValue(int _roundDigit, string _dayFractionType, bool _isMidPointRound)
|
|
{
|
|
roundOfDigit = _roundDigit;
|
|
DayFactionType = _dayFractionType;
|
|
IsMidPointRound = _isMidPointRound;
|
|
|
|
}
|
|
public int roundOfDigit { get; }
|
|
|
|
public string DayFactionType { get; }
|
|
public bool IsMidPointRound { get; }
|
|
|
|
}
|
|
|
|
|
|
public class GlobalFunctions
|
|
{
|
|
private static DefaultConfigurationValue _defaultConfigVal;
|
|
public static bool bDataFound = false;
|
|
public static DefaultConfigurationValue defaultConfigVal
|
|
{
|
|
get
|
|
{
|
|
if (_defaultConfigVal == null)
|
|
{
|
|
_defaultConfigVal = GlobalFunctions.Service.RefreshServerValue();
|
|
}
|
|
return _defaultConfigVal;
|
|
}
|
|
|
|
set
|
|
{
|
|
_defaultConfigVal = value;
|
|
}
|
|
}
|
|
|
|
#region Service Factory IGlobalFunctionService : IGlobalFunctionService
|
|
|
|
internal static IGlobalFunctionService Service
|
|
{
|
|
get { return Services.Factory.CreateService<IGlobalFunctionService>(typeof(IGlobalFunctionService)); }
|
|
}
|
|
|
|
public static int MONTH_START_DATE { get; set; }
|
|
|
|
#endregion
|
|
|
|
|
|
public static string GetApiDefaultData(string str)
|
|
{
|
|
str = (str == "" || str == "null" || str == "undefined") ? string.Empty : str;
|
|
return str;
|
|
}
|
|
|
|
public static int? GetApiDefaultIntData(string str)
|
|
{
|
|
int? intData = null; ;
|
|
if (str != null && str != "" && str.ToLower() != "null" && str.ToLower() != "undefined")
|
|
{
|
|
intData = Convert.ToInt32(str);
|
|
}
|
|
return intData;
|
|
}
|
|
|
|
|
|
public static DateTime GetApiDefaultDateData(string str)
|
|
{
|
|
DateTime dateData = DateTime.MinValue;
|
|
if (str != null && str != "" && str.ToLower() != "null" && str.ToLower() != "undefined")
|
|
{
|
|
dateData = Convert.ToDateTime(str);
|
|
}
|
|
return dateData;
|
|
}
|
|
|
|
public static string AgeCalculate(DateTime Bday, DateTime Cday)
|
|
{
|
|
int Years = 0;
|
|
int Months = 0;
|
|
int Days = 0;
|
|
|
|
if ((Cday.Year - Bday.Year) > 0 ||
|
|
(((Cday.Year - Bday.Year) == 0) && ((Bday.Month < Cday.Month) ||
|
|
((Bday.Month == Cday.Month) && (Bday.Day <= Cday.Day)))))
|
|
{
|
|
int DaysInBdayMonth = DateTime.DaysInMonth(Bday.Year, Bday.Month);
|
|
int DaysRemain = Cday.Day + (DaysInBdayMonth - Bday.Day);
|
|
|
|
if (Cday.Month > Bday.Month)
|
|
{
|
|
Years = Cday.Year - Bday.Year;
|
|
Months = Cday.Month - (Bday.Month + 1) + Math.Abs(DaysRemain / DaysInBdayMonth);
|
|
Days = (DaysRemain % DaysInBdayMonth + DaysInBdayMonth) % DaysInBdayMonth;
|
|
}
|
|
else if (Cday.Month == Bday.Month)
|
|
{
|
|
if (Cday.Day >= Bday.Day)
|
|
{
|
|
Years = Cday.Year - Bday.Year;
|
|
Months = 0;
|
|
Days = Cday.Day - Bday.Day;
|
|
}
|
|
else
|
|
{
|
|
Years = (Cday.Year - 1) - Bday.Year;
|
|
Months = 11;
|
|
Days = DateTime.DaysInMonth(Bday.Year, Bday.Month) - (Bday.Day - Cday.Day);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Years = (Cday.Year - 1) - Bday.Year;
|
|
Months = Cday.Month + (11 - Bday.Month) + Math.Abs(DaysRemain / DaysInBdayMonth);
|
|
Days = (DaysRemain % DaysInBdayMonth + DaysInBdayMonth) % DaysInBdayMonth;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw new ArgumentException("Birthday date must be earlier than current date");
|
|
}
|
|
|
|
return Years + " Years, " + Months + " Months, " + Days + " Days";
|
|
}
|
|
|
|
//public static DateTime GetOperationDate()
|
|
//{
|
|
// try
|
|
// {
|
|
// return Service.GetOperationDate();
|
|
// }
|
|
// catch (ServiceException e)
|
|
// {
|
|
// throw new Exception(e.Message, e);
|
|
// }
|
|
//}
|
|
public static string GetShortAttnType(EnumAttendanceType atype, EnumWorkPlanDayType daytype, double latehour)
|
|
{
|
|
string type = string.Empty;
|
|
switch (atype)
|
|
{
|
|
case EnumAttendanceType.Absent:
|
|
type = "AB";
|
|
break;
|
|
|
|
case EnumAttendanceType.Delay:
|
|
type = "LP";
|
|
break;
|
|
|
|
case EnumAttendanceType.Holiday:
|
|
type = "H";
|
|
break;
|
|
|
|
case EnumAttendanceType.Late:
|
|
type = "LP";
|
|
break;
|
|
|
|
case EnumAttendanceType.Leave:
|
|
type = "Lv";
|
|
break;
|
|
|
|
case EnumAttendanceType.Present:
|
|
type = "PR";
|
|
|
|
if (daytype == EnumWorkPlanDayType.WorkingDay &&
|
|
latehour > 0)
|
|
{
|
|
type = "L-PR";
|
|
}
|
|
else if (daytype == EnumWorkPlanDayType.WeeklyHoliday
|
|
&& latehour > 0)
|
|
{
|
|
type = "WD-L-PR";
|
|
|
|
}
|
|
else if (daytype == EnumWorkPlanDayType.WeeklyHoliday &&
|
|
latehour <= 0)
|
|
{
|
|
type = "WD-PR";
|
|
}
|
|
else if (daytype == EnumWorkPlanDayType.NationalHoliday &&
|
|
latehour > 0)
|
|
{
|
|
type = "H-L-PR";
|
|
|
|
}
|
|
else if (daytype == EnumWorkPlanDayType.NationalHoliday &&
|
|
latehour <= 0)
|
|
{
|
|
type = "H-PR";
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
case EnumAttendanceType.OutSideDuty:
|
|
type = "OD";
|
|
break;
|
|
|
|
case EnumAttendanceType.Early:
|
|
type = "E";
|
|
break;
|
|
|
|
case EnumAttendanceType.WeeklyHoliday:
|
|
type = "WD";
|
|
break;
|
|
}
|
|
return type;
|
|
}
|
|
|
|
public static double GetHourtoMinutes(double hours)
|
|
{
|
|
return Math.Floor(hours) * ((hours - Math.Floor(hours))/100);
|
|
}
|
|
|
|
public static double GetOTDailyRate(double nBasic, DateTime dMonthDate)
|
|
{
|
|
double amount = 0;
|
|
amount = nBasic / Convert.ToDouble(DateTime.DaysInMonth(dMonthDate.Year, dMonthDate.Month));
|
|
return amount;
|
|
}
|
|
|
|
public static double GetOTHourlyRate(double nBasic, DateTime dMonthDate)
|
|
{
|
|
double amount = 0;
|
|
int hours = 0;//ConfigurationManager.GetIntValue("overtime", "hoursonmonth", EnumConfigurationType.Logic);
|
|
if (hours <= 0) hours = 208;
|
|
double doubleHOur = Convert.ToDouble(hours);
|
|
amount = nBasic / doubleHOur;
|
|
return amount;
|
|
|
|
}
|
|
public static double ConvertToDailyRate(double nBasic, DateTime dMonthDate)
|
|
{
|
|
enumfractionCalculatinType ntype = getFractionateCalType();
|
|
double amount = 0;
|
|
|
|
switch (ntype)
|
|
{
|
|
case enumfractionCalculatinType.Monthly:
|
|
amount = nBasic / Convert.ToDouble(DateTime.DaysInMonth(dMonthDate.Year, dMonthDate.Month));
|
|
break;
|
|
case enumfractionCalculatinType.Yearly:
|
|
amount = (nBasic * 12) / 365;
|
|
break;
|
|
case enumfractionCalculatinType.ThirtyDaysMonth:
|
|
case enumfractionCalculatinType.ThirtyDaysMonthActual:
|
|
amount = nBasic / 30;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return amount;
|
|
}
|
|
|
|
public static int GetDaysInMonth(DateTime dMonthDate)
|
|
{
|
|
enumfractionCalculatinType ntype = getFractionateCalType();
|
|
int amount = 0;
|
|
|
|
switch (ntype)
|
|
{
|
|
case enumfractionCalculatinType.Monthly:
|
|
amount = DateTime.DaysInMonth(dMonthDate.Year, dMonthDate.Month);
|
|
break;
|
|
case enumfractionCalculatinType.ThirtyDaysMonthActual:
|
|
case enumfractionCalculatinType.ThirtyDaysMonth:
|
|
amount = 30;
|
|
break;
|
|
default:
|
|
amount = 30;
|
|
break;
|
|
}
|
|
return amount;
|
|
}
|
|
|
|
public static string ConvertDoubleHourToHourMinute(double totalHour)
|
|
{
|
|
string[] strParts = totalHour.ToString("0.000000").Split('.');
|
|
strParts[1] = "." + strParts[1];
|
|
|
|
string hourPart = Convert.ToInt32(strParts[0]).ToString("00");
|
|
string minutepart = Math.Round(Convert.ToDecimal(strParts[1]) * 60, 0, MidpointRounding.AwayFromZero).ToString("00");
|
|
|
|
return string.Format("{0}:{1}", hourPart, minutepart);
|
|
}
|
|
public static string GetShortAttnType(EnumAttendanceType attnType)
|
|
{
|
|
string type = string.Empty;
|
|
switch (attnType)
|
|
{
|
|
case EnumAttendanceType.Absent:
|
|
type = "A";
|
|
break;
|
|
|
|
case EnumAttendanceType.Delay:
|
|
type = "L";
|
|
break;
|
|
|
|
case EnumAttendanceType.Holiday:
|
|
type = "H";
|
|
break;
|
|
|
|
case EnumAttendanceType.Late:
|
|
type = "L";
|
|
break;
|
|
|
|
case EnumAttendanceType.Leave:
|
|
type = "Lv";
|
|
break;
|
|
|
|
case EnumAttendanceType.Present:
|
|
type = "P";
|
|
break;
|
|
|
|
|
|
case EnumAttendanceType.OutSideDuty:
|
|
type = "OD";
|
|
break;
|
|
|
|
case EnumAttendanceType.Early:
|
|
type = "E";
|
|
break;
|
|
|
|
case EnumAttendanceType.WeeklyHoliday:
|
|
type = "W";
|
|
break;
|
|
}
|
|
return type;
|
|
}
|
|
|
|
public static string BloodGroupToBangla(EnumBloodGroup eBloodGrp)
|
|
{
|
|
string str = string.Empty;
|
|
switch (eBloodGrp)
|
|
{
|
|
case EnumBloodGroup.None:
|
|
break;
|
|
case EnumBloodGroup.APos:
|
|
str = "G cwRwUf";
|
|
break;
|
|
case EnumBloodGroup.ANeg:
|
|
str = "G ‡b‡MwUf";
|
|
break;
|
|
case EnumBloodGroup.BPos:
|
|
str = "we cwRwUf";
|
|
break;
|
|
case EnumBloodGroup.BNeg:
|
|
str = "we ‡b‡MwUf";
|
|
break;
|
|
case EnumBloodGroup.OPos:
|
|
str = "I cwRwUf";
|
|
break;
|
|
case EnumBloodGroup.ONeg:
|
|
str = "I ‡b‡MwUf";
|
|
break;
|
|
case EnumBloodGroup.ABPos:
|
|
str = "Gwe cwRwUf";
|
|
break;
|
|
case EnumBloodGroup.ABNeg:
|
|
str = "Gwe ‡b‡MwUf";
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return str;
|
|
}
|
|
|
|
public static string GetFullAttnType(EnumAttendanceType attnType)
|
|
{
|
|
Regex r = new Regex(@"(?<=[A-Z])(?=[A-Z][a-z])|(?<=[^A-Z])(?=[A-Z])|(?<=[A-Za-z])(?=[^A-Za-z])");
|
|
return r.Replace(attnType.ToString(), " ");
|
|
}
|
|
|
|
//public static DateTime AttendanceMonthStart(DateTime date)
|
|
//{
|
|
// if (date.Day > 20)
|
|
// return new DateTime(date.Year, date.Month, 21);
|
|
// else if (date.Month == 1)
|
|
// return new DateTime(date.Year - 1, 12, 21);
|
|
// else return new DateTime(date.Year, date.AddMonths(-1).Month, 21);
|
|
//}
|
|
//public static DateTime AttendanceMonthEnd(DateTime date)
|
|
//{
|
|
// if (date.Day < 20)
|
|
// return new DateTime(date.Year, date.Month, 20);
|
|
// else
|
|
// if (date.Month == 12)
|
|
// return new DateTime(date.Year + 1, 1, 20);
|
|
// else return new DateTime(date.Year, date.AddMonths(1).Month, 20);
|
|
//}
|
|
|
|
//public static DateTime GetServerDate()
|
|
//{
|
|
// object serverDate = null;
|
|
// try
|
|
// {
|
|
// serverDate = Service.GetServerDate();
|
|
// }
|
|
// catch (ServiceException e)
|
|
// {
|
|
// throw new ServiceException(e.Message, e);
|
|
// }
|
|
// return Convert.ToDateTime(serverDate);
|
|
//}
|
|
//public static DataTable AvailableUserObject()
|
|
//{
|
|
// DataTable dataTable = new DataTable();
|
|
// try
|
|
// {
|
|
// dataTable = Service.AvailableUserObject();
|
|
// }
|
|
// catch (ServiceException e)
|
|
// {
|
|
// throw new ServiceException(e.Message, e);
|
|
// }
|
|
// return dataTable;
|
|
//}
|
|
|
|
public static string TagSQL(string sPrevious, string sNew)
|
|
{
|
|
string sSearch = string.Empty;
|
|
if (sPrevious == string.Empty)
|
|
{
|
|
return sSearch = " Where " + sNew;
|
|
}
|
|
else
|
|
{
|
|
return sSearch = sPrevious + " And " + sNew;
|
|
}
|
|
|
|
}
|
|
|
|
public static void ExportToExcel(StreamWriter wr, DataTable dt)
|
|
{
|
|
try
|
|
{
|
|
for (int i = 0; i < dt.Columns.Count; i++)
|
|
{
|
|
wr.Write(dt.Columns[i].ToString().ToUpper() + "\t");
|
|
}
|
|
|
|
wr.WriteLine();
|
|
|
|
//write rows to excel file
|
|
for (int i = 0; i < (dt.Rows.Count); i++)
|
|
{
|
|
for (int j = 0; j < dt.Columns.Count; j++)
|
|
{
|
|
if (dt.Rows[i][j] != null)
|
|
{
|
|
wr.Write(Convert.ToString(dt.Rows[i][j]) + "\t");
|
|
}
|
|
else
|
|
{
|
|
wr.Write("\t");
|
|
}
|
|
}
|
|
//go to next line
|
|
wr.WriteLine();
|
|
}
|
|
//close file
|
|
wr.Close();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw ex;
|
|
}
|
|
}
|
|
public static int GetDayofWeek(DateTime FromDate, DateTime ToDate, int day)
|
|
{
|
|
int i;
|
|
DateTime dateTemp;
|
|
i = 0;
|
|
|
|
dateTemp = FromDate;
|
|
|
|
|
|
while (dateTemp <= ToDate)
|
|
{
|
|
if (((int)dateTemp.DayOfWeek == day)) i = i + 1;
|
|
dateTemp = dateTemp.AddDays(1);
|
|
}
|
|
|
|
return i;
|
|
}
|
|
public static DateTime GetAttandaceSalaryMonth(DateTime dDate)
|
|
{
|
|
return GetAttandaceSalaryMonth(dDate, -1);
|
|
|
|
}
|
|
public static DateTime GetAttandaceSalaryMonth(DateTime dDate, int MonthStartDate)
|
|
{
|
|
if (MonthStartDate == 1) // Fisrt date of Current Month
|
|
{
|
|
return Global.DateFunctions.LastDateOfMonth(dDate);
|
|
}
|
|
else if (MonthStartDate == -1) // Fisrt date of Current Month
|
|
{
|
|
dDate = dDate.AddMonths(-1);
|
|
return Global.DateFunctions.LastDateOfMonth(dDate.AddMonths(1));
|
|
}
|
|
else
|
|
{
|
|
if (dDate.Day >= MonthStartDate)
|
|
return Global.DateFunctions.LastDateOfMonth(dDate.AddMonths(1));
|
|
else return Global.DateFunctions.LastDateOfMonth(dDate);
|
|
}
|
|
}
|
|
|
|
|
|
public static DateTime AttendanceMonthStart(DateTime date, int MonthStartDate)
|
|
{
|
|
if (MonthStartDate == 1) // Fisrt date of Current Month
|
|
{
|
|
return new DateTime(date.Year, date.Month, 1);
|
|
}
|
|
else if (MonthStartDate == -1) // Fisrt date of Current Month
|
|
{
|
|
date = date.AddMonths(-1);
|
|
return new DateTime(date.Year, date.Month, 1);
|
|
}
|
|
else
|
|
{
|
|
if (date.Day > MonthStartDate)
|
|
return new DateTime(date.Year, date.Month, MonthStartDate);
|
|
else if (date.Month == 1)
|
|
return new DateTime(date.Year - 1, 12, MonthStartDate);
|
|
else return new DateTime(date.Year, date.AddMonths(-1).Month, MonthStartDate);
|
|
}
|
|
}
|
|
public static DateTime AttendanceMonthEnd(DateTime date, int MonthStartDate)
|
|
{
|
|
if (MonthStartDate == 1) // Fisrt date of Current Month
|
|
{
|
|
return Global.DateFunctions.LastDateOfMonth(date);
|
|
}
|
|
else if (MonthStartDate == -1) // Fisrt date of Current Month
|
|
{
|
|
date = date.AddMonths(-1);
|
|
return Global.DateFunctions.LastDateOfMonth(date);
|
|
}
|
|
else
|
|
{
|
|
if (date.Day < MonthStartDate)
|
|
return new DateTime(date.Year, date.Month, MonthStartDate);
|
|
else
|
|
if (date.Month == 12)
|
|
return new DateTime(date.Year + 1, 1, MonthStartDate);
|
|
else return new DateTime(date.Year, date.AddMonths(1).Month, MonthStartDate);
|
|
}
|
|
}
|
|
|
|
//public static DateTime GetCurrentDate()
|
|
//{
|
|
// object currentDate = null;
|
|
// try
|
|
// {
|
|
// currentDate = Service.GetCurrentDate();
|
|
// }
|
|
// catch (ServiceException e)
|
|
// {
|
|
// throw new ServiceException(e.Message, e);
|
|
// }
|
|
// return Convert.ToDateTime(currentDate);
|
|
//}
|
|
|
|
//private static ErrorProvider _err = new ErrorProvider();
|
|
|
|
//public static void CatchError(Control ctrl, string msg)
|
|
//{
|
|
// _err.Clear();
|
|
// _err.BlinkRate = 250;
|
|
// _err.BlinkStyle = ErrorBlinkStyle.BlinkIfDifferentError;
|
|
// _err.SetError(ctrl, msg);
|
|
//}
|
|
|
|
|
|
public static double Round(double value)
|
|
{
|
|
double roundedValue = 0.00;
|
|
try
|
|
{
|
|
|
|
|
|
roundedValue = Math.Round(value, GetRoundOfDigit(), MidpointRounding.AwayFromZero);
|
|
// roundedValue = Math.Round(value,2, MidpointRounding.AwayFromZero);
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new ServiceException(ex.InnerException.Message);
|
|
}
|
|
|
|
return roundedValue;
|
|
}
|
|
|
|
public static double Round(double value, int roundofdegit)
|
|
{
|
|
double roundedValue = 0.00;
|
|
try
|
|
{
|
|
roundedValue = Math.Round(value, GetRoundOfDigit(roundofdegit), MidpointRounding.AwayFromZero);
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new ServiceException(ex.InnerException.Message);
|
|
}
|
|
|
|
return roundedValue;
|
|
}
|
|
|
|
public static double ConvertToHourlyRate(double nBasic)
|
|
{
|
|
double amount = 0;
|
|
int hours = 0;//ConfigurationManager.GetIntValue("overtime", "hoursonmonth", EnumConfigurationType.Logic);
|
|
if (hours <= 0) hours = 208;
|
|
double doubleHOur = Convert.ToDouble(hours);
|
|
amount = nBasic / doubleHOur;
|
|
return amount;
|
|
}
|
|
|
|
public static enumfractionCalculatinType getFractionateCalType()
|
|
{
|
|
enumfractionCalculatinType type = enumfractionCalculatinType.Monthly;
|
|
string caltype = GlobalFunctions.defaultConfigVal.DayFactionType; //ConfigurationManager.GetStringValue("root", "monthfraction", EnumConfigurationType.Logic);
|
|
if (caltype.ToUpper() == "THIRTYDAYS")
|
|
type = enumfractionCalculatinType.ThirtyDaysMonth;
|
|
else if (caltype.ToUpper() == "THIRTYDAYSACTUAL")
|
|
type = enumfractionCalculatinType.ThirtyDaysMonthActual;
|
|
else if (caltype.ToUpper() == "YEARLY")
|
|
type = enumfractionCalculatinType.Yearly;
|
|
else
|
|
type = enumfractionCalculatinType.Monthly;
|
|
return type;
|
|
}
|
|
//public static int GetdaysInMonth(DateTime dMonth)
|
|
//{
|
|
// int daysinMonth = 30;
|
|
// enumfractionCalculatinType type = enumfractionCalculatinType.Monthly;
|
|
// string caltype = GlobalFunctions.defaultConfigVal.DayFactionType; //ConfigurationManager.GetStringValue("root", "monthfraction", EnumConfigurationType.Logic);
|
|
// if (caltype.ToUpper() == "THIRTYDAYS")
|
|
// daysinMonth = 30;
|
|
// else
|
|
// daysinMonth = GlobalFunctions.FirstDateOfMonth(dMonth) - GlobalFunctions.LastDateOfMonth(dMonth)
|
|
// return type;
|
|
//}
|
|
|
|
public static double GetFraction(DateTime StartDate, DateTime EndDate)
|
|
{
|
|
double WorkDays;
|
|
double MonDays;
|
|
double TotFract;
|
|
double nFraction = 1;
|
|
TotFract = 0;
|
|
// bool isYearly = ConfigurationManager.GetBoolValue("root", "fractionalcalculationyearly", EnumConfigurationType.Logic);
|
|
//bool isYearly = ConfigurationManager.GetBoolValue("root", "fractionalcalculation", EnumConfigurationType.Logic);
|
|
enumfractionCalculatinType ntype = getFractionateCalType();
|
|
WorkDays = Global.DateFunctions.DateDiff("d", StartDate,
|
|
GlobalFunctions.LastDateOfMonth(StartDate)) + 1;
|
|
switch (ntype)
|
|
{
|
|
case enumfractionCalculatinType.Monthly:
|
|
while (StartDate <= EndDate)
|
|
{
|
|
WorkDays = Global.DateFunctions.DateDiff("d", StartDate,
|
|
GlobalFunctions.LastDateOfMonth(StartDate)) + 1;
|
|
|
|
MonDays = Global.DateFunctions.DateDiff("d",
|
|
GlobalFunctions.FirstDateOfMonth(StartDate),
|
|
GlobalFunctions.LastDateOfMonth(StartDate)) + 1;
|
|
if (StartDate.Month == EndDate.Month && EndDate != GlobalFunctions.LastDateOfMonth(EndDate))
|
|
{
|
|
WorkDays = Global.DateFunctions.DateDiff("d",
|
|
GlobalFunctions.FirstDateOfMonth(EndDate), EndDate) + 1;
|
|
}
|
|
TotFract = TotFract + WorkDays / MonDays;
|
|
StartDate = GlobalFunctions.LastDateOfMonth(StartDate).AddDays(1);
|
|
}
|
|
nFraction = TotFract;
|
|
break;
|
|
case enumfractionCalculatinType.Yearly:
|
|
//0.032876712328767123287671232876712
|
|
//0.0328767123
|
|
//if (StartDate == GlobalFunctions.FirstDateOfMonth(StartDate) && EndDate == GlobalFunctions.LastDateOfMonth(EndDate))
|
|
//{
|
|
// WorkDays = Ease.CoreV35.Utility.Global.DateFunctions.DateDiff("m", StartDate, EndDate) + 1;
|
|
// nFraction = WorkDays;
|
|
//}
|
|
//else
|
|
//{
|
|
// WorkDays = Ease.CoreV35.Utility.Global.DateFunctions.DateDiff("d", StartDate, EndDate) + 1;
|
|
// double yearlyFraction = 0.0328767123; // which mean 12/365
|
|
|
|
// nFraction = yearlyFraction * WorkDays;
|
|
//}
|
|
nFraction = 0;
|
|
if (Global.DateFunctions.DateDiff("m", GlobalFunctions.FirstDateOfMonth(StartDate),
|
|
GlobalFunctions.LastDateOfMonth(EndDate)) > 2)
|
|
{
|
|
nFraction = Global.DateFunctions.DateDiff("m", GlobalFunctions.FirstDateOfMonth(StartDate.AddMonths(1)),
|
|
GlobalFunctions.LastDateOfMonth(EndDate.AddMonths(-1)));
|
|
|
|
nFraction = nFraction + (Global.DateFunctions.DateDiff("d", StartDate,
|
|
GlobalFunctions.LastDateOfMonth(StartDate)) + 1) * 0.0328767123;
|
|
nFraction = nFraction + (Global.DateFunctions.DateDiff("d", GlobalFunctions.FirstDateOfMonth(EndDate),
|
|
EndDate) + 1) * 0.0328767123;
|
|
}
|
|
else
|
|
{
|
|
if (StartDate.Month == EndDate.Month && StartDate.Year == EndDate.Year) // if cross two month
|
|
{
|
|
if (StartDate == FirstDateOfMonth(StartDate) && EndDate == LastDateOfMonth(EndDate))
|
|
nFraction = 1;
|
|
else
|
|
nFraction = nFraction + (Global.DateFunctions.DateDiff("d", StartDate,
|
|
EndDate) + 1) * 0.0328767123;
|
|
}
|
|
else
|
|
{
|
|
if (StartDate == FirstDateOfMonth(StartDate) && EndDate == LastDateOfMonth(EndDate))
|
|
nFraction = 1;
|
|
else
|
|
nFraction = nFraction + (Global.DateFunctions.DateDiff("d", StartDate,
|
|
GlobalFunctions.LastDateOfMonth(StartDate)) + 1) * 0.0328767123;
|
|
|
|
if (EndDate == LastDateOfMonth(EndDate))
|
|
nFraction = nFraction + 1;
|
|
else nFraction = nFraction + (Global.DateFunctions.DateDiff("d", GlobalFunctions.FirstDateOfMonth(EndDate),
|
|
EndDate) + 1) * 0.0328767123;
|
|
}
|
|
}
|
|
//while (StartDate <= EndDate)
|
|
//{
|
|
// if (StartDate.Day != 1 )
|
|
// {
|
|
// nFraction = nFraction + ((double)(Ease.CoreV35.Utility.Global.DateFunctions.DateDiff("d",
|
|
// GlobalFunctions.FirstDateOfMonth(EndDate), EndDate) + 1)) * 0.0328767123;
|
|
// }
|
|
// WorkDays = Ease.CoreV35.Utility.Global.DateFunctions.DateDiff("d", StartDate,
|
|
// GlobalFunctions.LastDateOfMonth(StartDate)) + 1;
|
|
|
|
// MonDays = Ease.CoreV35.Utility.Global.DateFunctions.DateDiff("d",
|
|
// GlobalFunctions.FirstDateOfMonth(StartDate),
|
|
// GlobalFunctions.LastDateOfMonth(StartDate)) + 1;
|
|
// if (StartDate.Month == EndDate.Month && EndDate != GlobalFunctions.LastDateOfMonth(EndDate))
|
|
// {
|
|
// nFraction = nFraction + ((double) (Ease.CoreV35.Utility.Global.DateFunctions.DateDiff("d",
|
|
// GlobalFunctions.FirstDateOfMonth(EndDate), EndDate) + 1)) * 0.0328767123;
|
|
// }
|
|
// TotFract = TotFract + WorkDays / MonDays;
|
|
// StartDate = GlobalFunctions.LastDateOfMonth(StartDate).AddDays(1);
|
|
//}
|
|
|
|
break;
|
|
case enumfractionCalculatinType.ThirtyDaysMonth:
|
|
|
|
WorkDays = Global.DateFunctions.DateDiff("d", StartDate,
|
|
GlobalFunctions.LastDateOfMonth(StartDate)) + 1;
|
|
while (StartDate <= EndDate)
|
|
{
|
|
WorkDays = Global.DateFunctions.DateDiff("d", StartDate,
|
|
GlobalFunctions.LastDateOfMonth(StartDate)) + 1;
|
|
|
|
|
|
MonDays = Global.DateFunctions.DateDiff("d",
|
|
GlobalFunctions.FirstDateOfMonth(StartDate), GlobalFunctions.LastDateOfMonth(StartDate)) + 1;
|
|
|
|
int tempDaya = Global.DateFunctions.DateDiff("d", FirstDateOfMonth(StartDate),
|
|
GlobalFunctions.LastDateOfMonth(StartDate)) + 1;
|
|
if (tempDaya == 31) WorkDays = WorkDays - 1;
|
|
else if (tempDaya < 30)
|
|
if (tempDaya == 28) WorkDays = WorkDays + 2;
|
|
else WorkDays = WorkDays + 1;
|
|
|
|
MonDays = 30;
|
|
|
|
|
|
if (StartDate.Month == EndDate.Month && EndDate != GlobalFunctions.LastDateOfMonth(EndDate))
|
|
{
|
|
WorkDays = Global.DateFunctions.DateDiff("d",
|
|
GlobalFunctions.FirstDateOfMonth(EndDate), EndDate) + 1;
|
|
MonDays = 30;
|
|
}
|
|
TotFract = TotFract + WorkDays / MonDays;
|
|
StartDate = GlobalFunctions.LastDateOfMonth(StartDate).AddDays(1);
|
|
}
|
|
nFraction = TotFract;
|
|
break;
|
|
case enumfractionCalculatinType.ThirtyDaysMonthActual:
|
|
|
|
WorkDays = Global.DateFunctions.DateDiff("d", StartDate,
|
|
GlobalFunctions.LastDateOfMonth(StartDate)) + 1;
|
|
while (StartDate <= EndDate)
|
|
{
|
|
WorkDays = Global.DateFunctions.DateDiff("d", StartDate,
|
|
GlobalFunctions.LastDateOfMonth(StartDate)) + 1;
|
|
|
|
|
|
MonDays = Global.DateFunctions.DateDiff("d",
|
|
GlobalFunctions.FirstDateOfMonth(StartDate), GlobalFunctions.LastDateOfMonth(StartDate)) + 1;
|
|
|
|
int tempDaya = Global.DateFunctions.DateDiff("d", FirstDateOfMonth(StartDate),
|
|
GlobalFunctions.LastDateOfMonth(StartDate)) + 1;
|
|
//if (tempDaya == 31) WorkDays = WorkDays - 1;
|
|
//else if (tempDaya < 30)
|
|
// if (tempDaya == 28) WorkDays = WorkDays + 2;
|
|
// else WorkDays = WorkDays + 1;
|
|
|
|
MonDays = 30;
|
|
|
|
|
|
if (StartDate.Month == EndDate.Month && EndDate != GlobalFunctions.LastDateOfMonth(EndDate))
|
|
{
|
|
WorkDays = Global.DateFunctions.DateDiff("d",
|
|
GlobalFunctions.FirstDateOfMonth(EndDate), EndDate) + 1;
|
|
MonDays = 30;
|
|
}
|
|
double temp = WorkDays / MonDays;
|
|
if (temp > 1) temp = 1;
|
|
TotFract = TotFract + temp;
|
|
StartDate = GlobalFunctions.LastDateOfMonth(StartDate).AddDays(1);
|
|
}
|
|
nFraction = TotFract;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return nFraction;
|
|
}
|
|
|
|
private static int GetRoundOfDigit()
|
|
{
|
|
int RoundofDigit = 2;
|
|
try
|
|
{
|
|
if (RoundofDigit != -1)
|
|
{
|
|
//####
|
|
RoundofDigit = GlobalFunctions.defaultConfigVal.roundOfDigit; // ConfigurationManager.GetIntValue("root", "roundofdegit", EnumConfigurationType.Logic);
|
|
if (RoundofDigit > 4 || RoundofDigit < 0)
|
|
{
|
|
RoundofDigit = -1;
|
|
throw new ServiceException("Round of digit not greater 4 digit. Location: "
|
|
+ "logic-Configuration; Node:Root, Child-Node:RoundOfDegit, Value:" + RoundofDigit.ToString());
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new ServiceException(ex.InnerException.Message);
|
|
}
|
|
|
|
return RoundofDigit;
|
|
}
|
|
private static int GetRoundOfDigit(int roundofDigit)
|
|
{
|
|
|
|
try
|
|
{
|
|
if (roundofDigit > 4 || roundofDigit < 0)
|
|
{
|
|
roundofDigit = -1;
|
|
throw new ServiceException("Round of digit not greater 4 digit. Location: "
|
|
+ "logic-Configuration; Node:Root, Child-Node:RoundOfDegit, Value:" + roundofDigit.ToString());
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new ServiceException(ex.InnerException.Message);
|
|
}
|
|
|
|
return roundofDigit;
|
|
}
|
|
|
|
|
|
public static double GetFractinalOfMonth(DateTime dDate)
|
|
{
|
|
double WorkDays;
|
|
double TotalDays;
|
|
double nFraction = 1;
|
|
WorkDays = Global.DateFunctions.DateDiff("d", dDate,
|
|
GlobalFunctions.LastDateOfMonth(dDate)) + 1;
|
|
// bool isYearly = ConfigurationManager.GetBoolValue("root", "fractionalcalculationyearly", EnumConfigurationType.Logic);
|
|
enumfractionCalculatinType ntype = getFractionateCalType();
|
|
switch (ntype)
|
|
{
|
|
case enumfractionCalculatinType.Monthly:
|
|
TotalDays = Global.DateFunctions.DateDiff("d",
|
|
GlobalFunctions.FirstDateOfMonth(dDate), GlobalFunctions.LastDateOfMonth(dDate)) + 1;
|
|
nFraction = (WorkDays / TotalDays);
|
|
break;
|
|
case enumfractionCalculatinType.Yearly:
|
|
double yearlyFraction = 0.0328767123; // which mean 12/365
|
|
if (dDate.Day == 1) // if date is first of month, fractionate should be 1
|
|
nFraction = 1;
|
|
else
|
|
nFraction = yearlyFraction * WorkDays;
|
|
if (nFraction > 1) nFraction = 1; // monthly fraction can't greater 1,
|
|
break;
|
|
case enumfractionCalculatinType.ThirtyDaysMonth:
|
|
if (dDate == LastDateOfMonth(dDate))
|
|
return 1;
|
|
else
|
|
{
|
|
WorkDays = Global.DateFunctions.DateDiff("d", dDate,
|
|
GlobalFunctions.LastDateOfMonth(dDate)) + 1;
|
|
int tempDaya = Global.DateFunctions.DateDiff("d", FirstDateOfMonth(dDate),
|
|
GlobalFunctions.LastDateOfMonth(dDate)) + 1;
|
|
if (tempDaya == 31) WorkDays = WorkDays - 1;
|
|
else if (tempDaya < 30)
|
|
if (tempDaya == 28) WorkDays = WorkDays + 2;
|
|
else WorkDays = WorkDays + 1;
|
|
TotalDays = 30;
|
|
// TotalDays = Ease.CoreV35.Utility.Global.DateFunctions.DateDiff("d",
|
|
// GlobalFunctions.FirstDateOfMonth(dDate), GlobalFunctions.LastDateOfMonth(dDate));
|
|
nFraction = (WorkDays / TotalDays);
|
|
}
|
|
break;
|
|
case enumfractionCalculatinType.ThirtyDaysMonthActual:
|
|
if (dDate == LastDateOfMonth(dDate))
|
|
return 1;
|
|
else
|
|
{
|
|
WorkDays = Global.DateFunctions.DateDiff("d", dDate,
|
|
GlobalFunctions.LastDateOfMonth(dDate)) + 1;
|
|
int tempDaya = Global.DateFunctions.DateDiff("d", FirstDateOfMonth(dDate),
|
|
GlobalFunctions.LastDateOfMonth(dDate)) + 1;
|
|
//if (tempDaya == 31) WorkDays = WorkDays - 1;
|
|
//else if (tempDaya < 30)
|
|
// if (tempDaya == 28) WorkDays = WorkDays + 2;
|
|
// else WorkDays = WorkDays + 1;
|
|
TotalDays = 30;
|
|
// TotalDays = Ease.CoreV35.Utility.Global.DateFunctions.DateDiff("d",
|
|
// GlobalFunctions.FirstDateOfMonth(dDate), GlobalFunctions.LastDateOfMonth(dDate));
|
|
nFraction = (WorkDays / TotalDays);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return nFraction;
|
|
}
|
|
public static double GetFractinalOfTillDate(DateTime dDate)
|
|
{
|
|
double WorkDays;
|
|
double TotalDays;
|
|
double nFraction = 1;
|
|
WorkDays = Global.DateFunctions.DateDiff("d",
|
|
GlobalFunctions.FirstDateOfMonth(dDate), dDate) + 1;
|
|
enumfractionCalculatinType ntype = getFractionateCalType();
|
|
switch (ntype)
|
|
{
|
|
case enumfractionCalculatinType.Monthly:
|
|
TotalDays = Global.DateFunctions.DateDiff("d",
|
|
GlobalFunctions.FirstDateOfMonth(dDate), GlobalFunctions.LastDateOfMonth(dDate)) + 1;
|
|
nFraction = (WorkDays / TotalDays);
|
|
break;
|
|
case enumfractionCalculatinType.Yearly:
|
|
double yearlyFraction = 0.0328767123; // which mean 12/365
|
|
if (WorkDays == dDate.Day)
|
|
nFraction = 1;
|
|
else
|
|
nFraction = yearlyFraction * WorkDays;
|
|
break;
|
|
case enumfractionCalculatinType.ThirtyDaysMonth:
|
|
if (dDate == FirstDateOfMonth(dDate))
|
|
return 1;
|
|
else
|
|
{
|
|
WorkDays = Global.DateFunctions.DateDiff("d",
|
|
GlobalFunctions.FirstDateOfMonth(dDate), dDate) + 1;
|
|
|
|
int tempDaya = Global.DateFunctions.DateDiff("d", FirstDateOfMonth(dDate),
|
|
GlobalFunctions.LastDateOfMonth(dDate)) + 1;
|
|
if (tempDaya == 31) WorkDays = WorkDays - 1;
|
|
else if (tempDaya < 30)
|
|
if (tempDaya == 28) WorkDays = WorkDays + 2;
|
|
else WorkDays = WorkDays + 1;
|
|
|
|
TotalDays = 30;
|
|
// TotalDays = Ease.CoreV35.Utility.Global.DateFunctions.DateDiff("d",
|
|
// GlobalFunctions.FirstDateOfMonth(dDate), GlobalFunctions.LastDateOfMonth(dDate));
|
|
nFraction = (WorkDays / TotalDays);
|
|
}
|
|
break;
|
|
case enumfractionCalculatinType.ThirtyDaysMonthActual:
|
|
if (dDate == FirstDateOfMonth(dDate))
|
|
return 1;
|
|
else
|
|
{
|
|
WorkDays = Global.DateFunctions.DateDiff("d",
|
|
GlobalFunctions.FirstDateOfMonth(dDate), dDate) + 1;
|
|
|
|
int tempDaya = Global.DateFunctions.DateDiff("d", FirstDateOfMonth(dDate),
|
|
GlobalFunctions.LastDateOfMonth(dDate)) + 1;
|
|
//if (tempDaya == 31) WorkDays = WorkDays - 1;
|
|
//else if (tempDaya < 30)
|
|
// if (tempDaya == 28) WorkDays = WorkDays + 2;
|
|
// else WorkDays = WorkDays + 1;
|
|
|
|
TotalDays = 30;
|
|
// TotalDays = Ease.CoreV35.Utility.Global.DateFunctions.DateDiff("d",
|
|
// GlobalFunctions.FirstDateOfMonth(dDate), GlobalFunctions.LastDateOfMonth(dDate));
|
|
nFraction = (WorkDays / TotalDays);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return nFraction;
|
|
}
|
|
|
|
|
|
|
|
//public static DateTime GetYearEnd()
|
|
//{
|
|
// object yearEndDate = null;
|
|
// try
|
|
// {
|
|
// yearEndDate = Service.GetYearEndDate();
|
|
// }
|
|
// catch (ServiceException e)
|
|
// {
|
|
// throw new ServiceException(e.Message, e);
|
|
// }
|
|
// return Convert.ToDateTime(yearEndDate);
|
|
//}
|
|
|
|
|
|
public static DateTime FirstDateOfMonth(DateTime date)
|
|
{
|
|
return Global.DateFunctions.FirstDateOfMonth(date);
|
|
}
|
|
public static string GetShortAttnType(EnumAttendanceType attnType,
|
|
ref int presentDays, ref int absentDays, ref int lateDays,
|
|
ref int leaveDays, ref int weeklyHolidays, ref int osdDays,
|
|
ref int festivalHolidays)
|
|
{
|
|
string type = string.Empty;
|
|
switch (attnType)
|
|
{
|
|
case EnumAttendanceType.Absent:
|
|
type = "AB";
|
|
absentDays++;
|
|
break;
|
|
|
|
case EnumAttendanceType.Delay:
|
|
type = "LP";
|
|
lateDays++;
|
|
break;
|
|
|
|
case EnumAttendanceType.Holiday:
|
|
type = "FH";
|
|
festivalHolidays++;
|
|
break;
|
|
|
|
case EnumAttendanceType.Late:
|
|
type = "LP";
|
|
lateDays++;
|
|
break;
|
|
|
|
case EnumAttendanceType.Leave:
|
|
type = "Lv";
|
|
leaveDays++;
|
|
break;
|
|
|
|
case EnumAttendanceType.Present:
|
|
type = "PR";
|
|
presentDays++;
|
|
break;
|
|
|
|
|
|
case EnumAttendanceType.OutSideDuty:
|
|
type = "OD";
|
|
osdDays++;
|
|
break;
|
|
|
|
case EnumAttendanceType.Early:
|
|
type = "E";
|
|
break;
|
|
|
|
case EnumAttendanceType.WeeklyHoliday:
|
|
type = "WD";
|
|
weeklyHolidays++;
|
|
break;
|
|
}
|
|
return type;
|
|
}
|
|
public static string GetLeaveType(int? ReferenceID, List<Leave> _leaves)
|
|
{
|
|
string leaveType = "Lv";
|
|
Leave leave = null;
|
|
if (ReferenceID != 0)
|
|
{
|
|
leave = new Leave();
|
|
leave = _leaves.Where(o => o.ID == ReferenceID).FirstOrDefault();
|
|
if (leave != null)
|
|
{
|
|
leaveType = leave.Code;
|
|
}
|
|
}
|
|
|
|
return leaveType;
|
|
}
|
|
//return Total Hour and Minutes In string Format(Hour.Minutes)
|
|
public static string GetHourMinutes(List<String> hours)
|
|
{
|
|
string HoursMinutes = string.Empty;
|
|
double hour = 0;
|
|
double minutes = 0;
|
|
foreach (String hr in hours)
|
|
{
|
|
//string[] x = hr.ToString("f").Split('.');
|
|
//string xx = hr.ToString();
|
|
if (hr.Contains(":"))
|
|
{
|
|
hour = hour + Convert.ToDouble(hr.Split(':')[0]);
|
|
if (hr.Split('.').Length > 1)
|
|
minutes = minutes + Convert.ToDouble(hr.Split(':')[1]);
|
|
}
|
|
else
|
|
{
|
|
hour = hour + Convert.ToDouble(hr.Split('.')[0]);
|
|
if(hr.Split('.').Length >1)
|
|
minutes = minutes + Convert.ToDouble(hr.Split('.')[1]);
|
|
}
|
|
|
|
}
|
|
|
|
if (minutes > 60)
|
|
{
|
|
//int hr = Convert.ToInt32(minutes) / 60;
|
|
long hr = Convert.ToInt64(minutes) / 60;
|
|
hour = hour + Convert.ToDouble(hr);
|
|
minutes = minutes % 60;
|
|
}
|
|
|
|
return HoursMinutes = Convert.ToString(hour) + ":" + minutes.ToString("00");
|
|
|
|
}
|
|
|
|
public static string TakaFormat(double _Number)
|
|
{
|
|
//Written by Shaila
|
|
string _sign = "";
|
|
string _NumStr;
|
|
string _TakaFormat;
|
|
|
|
if (_Number < 0)
|
|
{
|
|
_sign = "-";
|
|
_Number = (-_Number);
|
|
}
|
|
|
|
_NumStr = _Number.ToString("0.00");
|
|
_TakaFormat = Right(_NumStr, 6);
|
|
if ((_NumStr.Length) <= 6)
|
|
{
|
|
_NumStr = "";
|
|
}
|
|
else
|
|
_NumStr = Left(_NumStr, _NumStr.Length - 6);
|
|
|
|
if (_NumStr == "")
|
|
{
|
|
_TakaFormat = _sign + _TakaFormat;
|
|
return _TakaFormat;
|
|
}
|
|
|
|
int _CommaCount = 1;
|
|
int _DigitCount = 0;
|
|
|
|
do
|
|
{
|
|
if (_CommaCount % 3 == 0)
|
|
{
|
|
_DigitCount = 3;
|
|
}
|
|
else
|
|
_DigitCount = 2;
|
|
|
|
|
|
_TakaFormat = Right(_NumStr, _DigitCount) + "," + _TakaFormat;
|
|
|
|
if (_NumStr.Length <= _DigitCount)
|
|
{
|
|
_NumStr = "";
|
|
}
|
|
else
|
|
_NumStr = Left(_NumStr, _NumStr.Length - _DigitCount);
|
|
|
|
|
|
_CommaCount = _CommaCount + 1;
|
|
} //end do
|
|
while (_NumStr != "");
|
|
_TakaFormat = _sign + _TakaFormat;
|
|
return _TakaFormat;
|
|
|
|
} //End of TakaFormat
|
|
|
|
public static string Right(string _Str, int _Len)
|
|
{
|
|
//Written by Shaila
|
|
string sStr;
|
|
|
|
if (_Len < _Str.Length)
|
|
{
|
|
sStr = _Str.Substring(_Str.Length - _Len, _Len);
|
|
}
|
|
else
|
|
sStr = _Str;
|
|
return sStr;
|
|
} //EndofRight
|
|
|
|
public static string Left(string _Str, int _Len)
|
|
{
|
|
//Written by Shaila
|
|
string sStr;
|
|
if (_Len < _Str.Length)
|
|
{
|
|
sStr = _Str.Substring(0, _Len);
|
|
}
|
|
else
|
|
sStr = _Str;
|
|
return sStr;
|
|
} //EndofLeft
|
|
|
|
public static string GetHourMinutes(double hours)
|
|
{
|
|
var ts = TimeSpan.FromHours(hours);
|
|
return string.Format("{0}:{1}", ts.Hours, ts.Minutes);
|
|
|
|
}
|
|
public static DateTime LastPayProcessDate(DateTime nextPayProcessDate)
|
|
{
|
|
return Global.DateFunctions.LastDateOfMonth(nextPayProcessDate.AddMonths(-1));
|
|
}
|
|
|
|
public static DateTime LastDateOfMonth(DateTime date)
|
|
{
|
|
return Global.DateFunctions.LastDateOfMonth(date);
|
|
}
|
|
|
|
|
|
|
|
public static String NumWordsWrapper(double value)
|
|
{
|
|
string words = "";
|
|
double intPart;
|
|
double decPart = 0;
|
|
if (value == 0)
|
|
return "zero";
|
|
|
|
try
|
|
{
|
|
string[] splitter = value.ToString().Split('.');
|
|
intPart = double.Parse(splitter[0]);
|
|
if (splitter.Length > 1)
|
|
{
|
|
decPart = double.Parse(splitter[1]);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
intPart = value;
|
|
}
|
|
|
|
words = NumWords(Convert.ToInt32(intPart));
|
|
|
|
if (decPart > 0)
|
|
{
|
|
if (words != "")
|
|
words += " and ";
|
|
int counter = decPart.ToString().Length;
|
|
switch (counter)
|
|
{
|
|
case 1: words += NumWords(Convert.ToInt32(decPart)) + ""; break;// tenths
|
|
case 2: words += NumWords(Convert.ToInt32(decPart)) + ""; break;// hundredths
|
|
case 3: words += NumWords(Convert.ToInt32(decPart)) + ""; break;// thousandths
|
|
case 4: words += NumWords(Convert.ToInt32(decPart)) + ""; break;// ten-thousandths
|
|
case 5: words += NumWords(Convert.ToInt32(decPart)) + ""; break;// hundred-thousandths
|
|
case 6: words += NumWords(Convert.ToInt32(decPart)) + ""; break;// millionths
|
|
case 7: words += NumWords(Convert.ToInt32(decPart)) + ""; break;// ten-millionths
|
|
}
|
|
}
|
|
return words + " Taka Only";
|
|
}
|
|
|
|
private static string NumWords(int Num)
|
|
{
|
|
#region Old Code
|
|
//string[] numbersArr = new string[] { "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen" };
|
|
//string[] tensArr = new string[] { "twenty", "thirty", "fourty", "fifty", "sixty", "seventy", "eighty", "ninty" };
|
|
//string[] suffixesArr = new string[] { "thousand", "million", "billion", "trillion", "quadrillion", "quintillion", "sextillion", "septillion", "octillion", "nonillion", "decillion", "undecillion", "duodecillion", "tredecillion", "Quattuordecillion", "Quindecillion", "Sexdecillion", "Septdecillion", "Octodecillion", "Novemdecillion", "Vigintillion" };
|
|
//string words = "";
|
|
|
|
//bool tens = false;
|
|
|
|
//if (n < 0)
|
|
//{
|
|
// words += "negative ";
|
|
// n *= -1;
|
|
//}
|
|
|
|
//int power = (suffixesArr.Length + 1) * 3;
|
|
|
|
//while (power > 3)
|
|
//{
|
|
// double pow = Math.Pow(10, power);
|
|
// if (n > pow)
|
|
// {
|
|
// if (n % Math.Pow(10, power) > 0)
|
|
// {
|
|
// words += NumWords(Math.Floor(n / pow)) + " " + suffixesArr[(power / 3) - 1] + " and ";
|
|
// }
|
|
// else if (n % pow > 0)
|
|
// {
|
|
// words += NumWords(Math.Floor(n / pow)) + " " + suffixesArr[(power / 3) - 1];
|
|
// }
|
|
// n %= pow;
|
|
// }
|
|
// power -= 3;
|
|
//}
|
|
//if (n >= 1000)
|
|
//{
|
|
// if (n % 1000 > 0) words += NumWords(Math.Floor(n / 1000)) + " thousand and ";
|
|
// else words += NumWords(Math.Floor(n / 1000)) + " thousand";
|
|
// n %= 1000;
|
|
//}
|
|
//if (0 <= n && n <= 999)
|
|
//{
|
|
// if ((int)n / 100 > 0)
|
|
// {
|
|
// words += NumWords(Math.Floor(n / 100)) + " hundred";
|
|
// n %= 100;
|
|
// }
|
|
// if ((int)n / 10 > 1)
|
|
// {
|
|
// if (words != "")
|
|
// words += " ";
|
|
// words += tensArr[(int)n / 10 - 2];
|
|
// tens = true;
|
|
// n %= 10;
|
|
// }
|
|
|
|
// if (n < 20)
|
|
// {
|
|
// if (words != "" && tens == false)
|
|
// words += " ";
|
|
// words += (tens ? "-" + numbersArr[(int)n - 1] : numbersArr[(int)n - 1]);
|
|
// n -= Math.Floor(n);
|
|
// }
|
|
//}
|
|
|
|
//return words;
|
|
#endregion
|
|
string[] Below20 = { "", "One ", "Two ", "Three ", "Four ",
|
|
"Five ", "Six " , "Seven ", "Eight ", "Nine ", "Ten ", "Eleven ",
|
|
"Twelve " , "Thirteen ", "Fourteen ","Fifteen ",
|
|
"Sixteen " , "Seventeen ","Eighteen " , "Nineteen " };
|
|
string[] Below100 = { "", "", "Twenty ", "Thirty ",
|
|
"Forty ", "Fifty ", "Sixty ", "Seventy ", "Eighty ", "Ninety " };
|
|
string InWords = "";
|
|
if (Num >= 1 && Num < 20)
|
|
InWords += Below20[Num];
|
|
if (Num >= 20 && Num <= 99)
|
|
InWords += Below100[Num / 10] + Below20[Num % 10];
|
|
if (Num >= 100 && Num <= 999)
|
|
InWords += NumWords(Num / 100) + " Hundred " + NumWords(Num % 100);
|
|
if (Num >= 1000 && Num <= 99999)
|
|
InWords += NumWords(Num / 1000) + " Thousand " + NumWords(Num % 1000);
|
|
if (Num >= 100000 && Num <= 9999999)
|
|
InWords += NumWords(Num / 100000) + " Lac " + NumWords(Num % 100000);
|
|
if (Num >= 10000000)
|
|
InWords += NumWords(Num / 10000000) + " Crore " + NumWords(Num % 10000000);
|
|
|
|
return InWords;
|
|
}
|
|
}
|
|
|
|
|
|
#region Interface IGlobalFunctionService
|
|
|
|
public interface IGlobalFunctionService
|
|
{
|
|
DateTime GetOperationDate();
|
|
//DateTime GetServerDate();
|
|
//DataTable AvailableUserObject();
|
|
|
|
//DateTime GetCurrentDate();
|
|
|
|
//DateTime GetYearEndDate();
|
|
DefaultConfigurationValue RefreshServerValue();
|
|
|
|
}
|
|
|
|
#endregion
|
|
}
|