private SalaryInfo GetPrevRowA()
{
var dt1 = SalarySheet.DT1;
var dt2 = SalarySheet.DT2;
var idp = Row.IDP;
var idam = Row["IDAM"];
var id = Row.ID;
var dtp1 = dt2.FirstDayOfMonth().AddMonths(-1);
var dtp2 = dtp1.LastDayOfMonth();
var table_lapas_r = MyData.DataSetKlons.SALARY_SHEETS_R;
var dr_lapas_r = table_lapas_r.WhereX(
d =>
d.ID != id &&
d.IDP == idp &&
object.Equals(d["IDAM"], idam) &&
d.SALARY_SHEETSRowByFK_SALARY_SHEETS_R_IDS.DT2.IsBetween(dtp1, dtp2) &&
d.SALARY_SHEETSRowByFK_SALARY_SHEETS_R_IDS.IS_TEMP == 0 &&
d.SALARY_SHEETSRowByFK_SALARY_SHEETS_R_IDS.XKind != ESalarySheetKind.Total
).WithMaxOrDefault(d => d.SALARY_SHEETSRowByFK_SALARY_SHEETS_R_IDS.DT2);
if (dr_lapas_r == null)
{
return(null);
}
var dtm = dr_lapas_r.SALARY_SHEETSRowByFK_SALARY_SHEETS_R_IDS.DT2;
var ret = new SalaryInfo();
ret.SetFromRow(dr_lapas_r);
return(ret);
}
public ErrorList CalcPayWithAvPay(SalarySheetRowInfo sr, SalaryInfo totalwt = null)
{
var err = DoAvPay(sr, TotalRow, totalwt);
if (err.HasErrors)
{
return(err);
}
if (PreparingReport)
{
foreach (var rr in ReportRows)
{
DoAvPay(sr, rr, totalwt);
}
}
TotalRow._SALARY = TotalRow.SumSalary();
TotalRow.AddAvPay();
if (PreparingReport)
{
PrepareList(sr.GetPositionTitle());
}
return(err);
}
public decimal CalcCashNotPaid(SalaryInfo si, decimal iinrate, decimal dnsrate)
{
decimal sai = NotPaidTaxed * dnsrate;
decimal aftersai = NotPaidTaxed - sai;
decimal beforeIIN = aftersai + NotPaidNoSAI;
decimal totalbeforeiin =
si._AMOUNT_BEFORE_SN +
si._PLUS_NOSAI +
si._PLUS_AUTHORS_FEES -
si._DNSN_AMOUNT;
decimal iin = 0.0M;
if (totalbeforeiin != 0.0M)
{
iin = si._IIN_AMOUNT * beforeIIN / totalbeforeiin;
}
decimal notPaiTotal = NotPaidNotTaxed + NotPaidTaxed + NotPaidNoSAI +
NotPaidFromEndCash - sai - iin;
notPaiTotal = KlonsData.RoundA(notPaiTotal, 2);
return(notPaiTotal);
}
public void AddWorkTime(SalaryInfo wi)
{
/*
* _CALENDAR_DAYS += wi._CALENDAR_DAYS;
* _CALENDAR_DAYS_USE += wi._CALENDAR_DAYS_USE;
* _MONTH_WORKDAYS += wi._MONTH_WORKDAYS;
* _MONTH_WORKHOURS += wi._MONTH_WORKHOURS;
*
* _PLAN_DAYS += wi._PLAN_DAYS;
* _PLAN_HOURS += wi._PLAN_HOURS;
* _PLAN_HOURS_NIGHT += wi._PLAN_HOURS_NIGHT;
* _PLAN_HOURS_OVERTIME += wi._PLAN_HOURS_OVERTIME;
*
* _PLAN_WORK_DAYS += wi._PLAN_WORK_DAYS;
* _PLAN_WORK_HOURS += wi._PLAN_WORK_HOURS;
* _PLAN_WORK_HOURS_NIGHT += wi._PLAN_WORK_HOURS_NIGHT;
* _PLAN_WORK_HOURS_OVERTIME += wi._PLAN_WORK_HOURS_OVERTIME;
*
* _PLAN_HOLIDAYS_DAYS += wi._PLAN_HOLIDAYS_DAYS;
* _PLAN_HOLIDAYS_HOURS += wi._PLAN_HOLIDAYS_HOURS;
* _PLAN_HOLIDAYS_HOURS_NIGHT += wi._PLAN_HOLIDAYS_HOURS_NIGHT;
* _PLAN_HOLIDAYS_HOURS_OVERTIME += wi._PLAN_HOLIDAYS_HOURS_OVERTIME;
*/
_FACT_DAYS += wi._FACT_DAYS;
_FACT_HOURS += wi._FACT_HOURS;
_FACT_HOURS_NIGHT += wi._FACT_HOURS_NIGHT;
_FACT_HOURS_OVERTIME += wi._FACT_HOURS_OVERTIME;
_FACT_WORK_DAYS += wi._FACT_WORK_DAYS;
_FACT_WORK_HOURS += wi._FACT_WORK_HOURS;
_FACT_WORK_HOURS_NIGHT += wi._FACT_WORK_HOURS_NIGHT;
_FACT_WORK_HOURS_OVERTIME += wi._FACT_WORK_HOURS_OVERTIME;
_FACT_HOLIDAYS_DAYS += wi._FACT_HOLIDAYS_DAYS;
_FACT_HOLIDAYS_HOURS += wi._FACT_HOLIDAYS_HOURS;
_FACT_HOLIDAYS_HOURS_NIGHT += wi._FACT_HOLIDAYS_HOURS_NIGHT;
_FACT_HOLIDAYS_HOURS_OVERTIME += wi._FACT_HOLIDAYS_HOURS_OVERTIME;
// ..............
_FACT_AVPAY_FREE_DAYS += wi._FACT_AVPAY_FREE_DAYS;
_FACT_AVPAY_FREE_HOURS += wi._FACT_AVPAY_FREE_HOURS;
_FACT_AVPAY_WORK_DAYS += wi._FACT_AVPAY_WORK_DAYS;
_FACT_AVPAY_WORKINHOLIDAYS += wi._FACT_AVPAY_WORKINHOLIDAYS;
_FACT_AVPAY_HOURS += wi._FACT_AVPAY_HOURS;
_FACT_AVPAY_HOURS_OVERTIME += wi._FACT_AVPAY_HOURS_OVERTIME;
_FACT_AVPAY_HOLIDAYS_HOURS += wi._FACT_AVPAY_HOLIDAYS_HOURS;
_FACT_AVPAY_HOLIDAYS_HOURS_OVERT += wi._FACT_AVPAY_HOLIDAYS_HOURS_OVERT;
// ..............
FACT_AVPAY_FREE_DAYS_2 += wi.FACT_AVPAY_FREE_DAYS_2;
FACT_AVPAY_FREE_HOURS_2 += wi.FACT_AVPAY_FREE_HOURS_2;
FACT_AVPAY_WORK_DAYS_2 += wi.FACT_AVPAY_WORK_DAYS_2;
FACT_AVPAY_WORKINHOLIDAYS_2 += wi.FACT_AVPAY_WORKINHOLIDAYS_2;
FACT_AVPAY_HOURS_2 += wi.FACT_AVPAY_HOURS_2;
FACT_AVPAY_HOURS_OVERTIME_2 += wi.FACT_AVPAY_HOURS_OVERTIME_2;
FACT_AVPAY_HOLIDAYS_HOURS_2 += wi.FACT_AVPAY_HOLIDAYS_HOURS_2;
FACT_AVPAY_HOLIDAYS_HOURS_OVERT_2 += wi.FACT_AVPAY_HOLIDAYS_HOURS_OVERT_2;
}
public List <PayFx2> CalcProc(SalaryInfo si, EBonusFrom efrom, decimal dfrom)
{
var ret = new List <PayFx2>();
foreach (var dr in DataRows)
{
if (dr.XRateType != EBonusRateType.Percent ||
dr.XBonusType == EBonusType.ReverseCalc)
{
continue;
}
if (dr.XBonusFrom != efrom)
{
continue;
}
decimal v = KlonsData.RoundA(dfrom * dr.RATE / 100.0M, 2);
if (dr.AMOUNT != v)
{
dr.AMOUNT = v;
}
var pfx = AddRow(si, dr, dfrom, dr.AMOUNT, 1);
ret.Add(pfx);
}
return(ret);
}
public void AddSalaryAvPayPart(SalaryInfo wi)
{
_SALARY_AVPAY_FREE_DAYS += wi._SALARY_AVPAY_FREE_DAYS;
_SALARY_AVPAY_WORK_DAYS += wi._SALARY_AVPAY_WORK_DAYS;
_SALARY_AVPAY_WORK_DAYS_OVERTIME += wi._SALARY_AVPAY_WORK_DAYS_OVERTIME;
_SALARY_AVPAY_HOLIDAYS += wi._SALARY_AVPAY_HOLIDAYS;
_SALARY_AVPAY_HOLIDAYS_OVERTIME += wi._SALARY_AVPAY_HOLIDAYS_OVERTIME;
}
public ErrorList CalcAvPay(SalarySheetRowSetInfo srs, SalaryInfo si)
{
var err_list = CalcList(srs.SalarySheet, srs.IDP, srs.TotalPersonPay);
si._AVPAYCALC_HOUR = KlonsData.RoundA(RateHour, 4);
si._AVPAYCALC_DAY = KlonsData.RoundA(RateDay, 4);
return(err_list);
}
public void ApplyRatio(decimal r, SalaryInfo si)
{
ExDivided.SetFrom(ExMax2);
ExDivided.ApplyRatio(r);
if (si != null)
{
ExDivided.ApplyTo(si);
}
}
// used only for making report
public void CalcWorkPay(SalarySheetRowSetInfo sr, SalaryInfo si = null)
{
var dt1 = sr.SalarySheet.DT1;
var dt2 = sr.SalarySheet.DT2;
if (si == null)
{
TotalRow = new SalaryInfo();
}
else
{
TotalRow = si;
}
TotalRow._CALENDAR_DAYS = sr.SalarySheet.CalendarMonth.DaysInMonth;
TotalRow._CALENDAR_DAYS_USE = sr.CountCalendarDays();
var dlrowlist = sr.GetDLRowSetList();
dlrowlist.CountPlanMonth(TotalRow, sr.SalarySheet.MDT1, sr.SalarySheet.MDT2);
dlrowlist.CountTotalPlan(TotalRow, sr.SalarySheet.MDT1, sr.SalarySheet.MDT2);
dlrowlist.CountTotalFact(TotalRow, sr.SalarySheet.MDT1, sr.SalarySheet.MDT2);
LinkedWorkPayCalcs = new WorkPayCalcInfo[sr.LinkedRows.Length];
for (int i = 0; i < sr.LinkedRows.Length; i++)
{
var lr = sr.LinkedRows[i];
var si2 = new SalaryInfo();
var wpc = new WorkPayCalcInfo(PreparingReport);
wpc.CalcWorkPay(lr, si2);
TotalRow.AddSalary(si2);
if (wpc.AvPayCalcRequired)
{
AvPayCalcRequired = true;
}
wpc.PositionTitle = lr.GetPositionTitle();
LinkedWorkPayCalcs[i] = wpc;
}
TotalRow._SALARY = TotalRow.SumSalary();
TotalRow.SumForAvPay();
if (AvPayCalcRequired)
{
CalcWorkPayAvPay(sr, TotalRow);
}
if (PreparingReport)
{
PrepareListT();
}
}
public void ApplyTo0(SalaryInfo si)
{
si._IIN_EXEMPT_UNTAXED_MINIMUM0 = ExUntaxedMinimum;
si._IIN_EXEMPT_DEPENDANTS0 = ExDependants;
si._IIN_EXEMPT_INVALIDITY0 = ExInvalidity;
si._IIN_EXEMPT_RETALIATION0 = ExRetaliation;
si._IIN_EXEMPT_NATIONAL_MOVEMENT0 = ExNationalMovements;
si._IIN_EXEMPT_20 = ExInvalidity + ExRetaliation + ExNationalMovements;
}
public decimal CalcFromEndC(SalaryInfo si,
decimal totalinex,
decimal curbruto, decimal brutonosai,
decimal brutomargin,
bool useprogressiveiin, bool hastaxdoc,
decimal iinrate1, decimal iinrate2, decimal dnsrate, int divby,
out List <PayFx2> rpfx)
{
rpfx = new List <PayFx2>();
decimal ret = 0.0M;
if (PlusFromEnd <= 0.0M)
{
return(ret);
}
decimal calcbruto = curbruto;
var p1 = new PayFx(useprogressiveiin);
p1.Ir = iinrate1 / 100.0M;
p1.Ir2 = iinrate2 / 100.0M;
p1.Sr = dnsrate / 100.0M;
p1.IM = brutomargin;
p1.HasTaxDoc = hastaxdoc;
p1.Pay = curbruto;
p1.PayNs = brutonosai;
p1.IinEx = totalinex;
for (int i = 0; i < DataRows.Length; i++)
{
var dr = DataRows[i];
if (dr.XRateType != EBonusRateType.Money ||
dr.XBonusType != EBonusType.ReverseCalc)
{
continue;
}
decimal v = dr.RATE;
calcbruto = p1.GetPayByIncCash(v);
calcbruto = KlonsData.RoundA(calcbruto, 2);
v = calcbruto - curbruto;
p1.Pay = calcbruto;
curbruto = calcbruto;
if (dr.AMOUNT != v)
{
dr.AMOUNT = v;
}
var rpfx1 = AddRow(si, dr, dr.RATE, v, 1);
rpfx.Add(rpfx1);
ret += v;
}
return(ret);
}
public WorkPayCalcInfo(bool filllist)
{
TotalRow = new SalaryInfo();
PreparingReport = filllist;
if (PreparingReport)
{
ReportRows = new List <SalaryInfo>();
JoinRows = new List <WorkPayCalcJoinRow>();
}
}
public void SetFrom(SalaryInfo si)
{
ExUntaxedMinimum = si._IIN_EXEMPT_UNTAXED_MINIMUM;
ExDependants = si._IIN_EXEMPT_DEPENDANTS;
ExInvalidity = si._IIN_EXEMPT_INVALIDITY;
ExRetaliation = si._IIN_EXEMPT_RETALIATION;
ExNationalMovements = si._IIN_EXEMPT_NATIONAL_MOVEMENT;
ExExpenses = si._IIN_EXEMPT_EXPENSES;
Ex2Tp = si.IINExempt2Kind;
}
public SalaryCalcInfo(SalarySheetRowInfo sr, SalaryInfo si, bool filllist)
{
SR = sr;
SI = si;
PositionTitle = sr.GetPositionTitle();
PreparingReport = filllist;
if (PreparingReport)
{
}
}
public void ApplyTo(SalaryInfo si)
{
si._IIN_EXEMPT_UNTAXED_MINIMUM = ExUntaxedMinimum;
si._IIN_EXEMPT_DEPENDANTS = ExDependants;
si._IIN_EXEMPT_INVALIDITY = ExInvalidity;
si._IIN_EXEMPT_RETALIATION = ExRetaliation;
si._IIN_EXEMPT_NATIONAL_MOVEMENT = ExNationalMovements;
si._IIN_EXEMPT_EXPENSES = ExExpenses;
si._IIN_EXEMPT_2 = ExInvalidity + ExRetaliation + ExNationalMovements;
si.IINExempt2Kind = Ex2Tp;
}
public SalaryCalcTInfo(SalarySheetRowSetInfo srs, SalaryInfo si, bool filllist)
{
if (srs?.TotalRow == null || srs.LinkedRows == null || srs.LinkedRows.Length == 0)
{
throw new Exception("Bad init.");
}
PreparingReport = filllist;
SRS = srs;
TotalSI = si;
if (PreparingReport)
{
}
}
public void SetFrom(SalaryInfo si)
{
SNR = si._SNR;
Caption = string.Format("{0} {1}, {2}", si._FNAME, si._LNAME, si._POSITION_TITLE.ToLower());
Caption2 = string.Format("{0} {1}", si._FNAME, si._LNAME);
WorkDays = si._FACT_DAYS;
WorkHours = si._FACT_HOURS;
FreeAvPayDays = si._FACT_AVPAY_FREE_DAYS;
VacationDays = si._VACATION_DAYS_CURRENT;
SickDays = si._SICKDAYS;
WorkPay = si._SALARY;
SickPay = si._SICKDAYS_PAY;
VacationPay = si._VACATION_PAY_CURRENT;
FreeAvPay = si._SALARY_AVPAY_FREE_DAYS;
WorkAvPay =
si._SALARY_AVPAY_HOLIDAYS +
si._SALARY_AVPAY_HOLIDAYS_OVERTIME +
si._SALARY_AVPAY_WORK_DAYS +
si._SALARY_AVPAY_WORK_DAYS_OVERTIME;
PlusTaxed =
si._PLUS_TAXED +
si._PLUS_PF_TAXED +
si._PLUS_LI_TAXED +
si._PLUS_HI_TAXED;
PlusNotTaxed =
si._PLUS_NOTTAXED +
si._PLUS_PF_NOTTAXED +
si._PLUS_LI_NOTTAXED +
si._PLUS_HI_NOTTAXED;
PlusNoSAI = si._PLUS_NOSAI;
PlusAuthorsFees = si._PLUS_AUTHORS_FEES;
TotalPay = si._TOTAL_BEFORE_TAXES;
ForSAI = si._AMOUNT_BEFORE_SN;
DDSAI = si._DDSN_AMOUNT;
DNSAI = si._DNSN_AMOUNT;
SAI = si._SN_AMOUNT;
UntaxedMinimum = si._IIN_EXEMPT_UNTAXED_MINIMUM;
ExDependants = si._IIN_EXEMPT_DEPENDANTS;
ExInvalidity = si._IIN_EXEMPT_INVALIDITY;
ExRetaliation = si._IIN_EXEMPT_RETALIATION;
ExNatMovement = si._IIN_EXEMPT_NATIONAL_MOVEMENT;
ExExpenses = si._IIN_EXEMPT_EXPENSES;
IIN = si._IIN_AMOUNT;
MinusBeforeIIN = si._MINUS_BEFORE_IIN;
MinusAfterIIN = si._MINUS_AFTER_IIN;
AdvanceOrDebt = si._ADVANCE;
Pay = si._PAYT;
}
public void CalcPayWithHourRate(SalaryInfo wt, KlonsADataSet.POSITIONS_RRow dr_amati_r)
{
wt.PlanedWorkPay = wt.R_HR * (decimal)wt._PLAN_HOURS;
wt._SALARY_DAY = wt.R_HR * (decimal)wt._FACT_WORK_HOURS;
wt._SALARY_NIGHT = wt.R_HR_NIGHT * (decimal)wt._FACT_WORK_HOURS_NIGHT;
wt._SALARY_OVERTIME = wt.R_HR_OVERTIME * (decimal)wt._FACT_WORK_HOURS_OVERTIME;
wt._SALARY_HOLIDAYS_DAY = wt.R_HR_HOLIDAY * (decimal)wt._FACT_HOLIDAYS_HOURS;
wt._SALARY_HOLIDAYS_NIGHT = wt.R_HR_HOLIDAY_NIGHT * (decimal)wt._FACT_HOLIDAYS_HOURS_NIGHT;
wt._SALARY_HOLIDAYS_OVERTIME = wt.R_HR_HOLIDAY_OVERTIME * (decimal)wt._FACT_HOLIDAYS_HOURS_OVERTIME;
wt._SALARY_AVPAY_FREE_DAYS = wt.R_HR * (decimal)wt._FACT_AVPAY_FREE_HOURS;
wt._SALARY_AVPAY_WORK_DAYS = wt.R_HR * (decimal)wt._FACT_AVPAY_HOURS;
wt._SALARY_AVPAY_WORK_DAYS_OVERTIME = wt.R_HR_OVERTIME * (decimal)wt._FACT_AVPAY_HOURS_OVERTIME;
wt._SALARY_AVPAY_HOLIDAYS = wt.R_HR_HOLIDAY * (decimal)wt._FACT_AVPAY_HOLIDAYS_HOURS;
wt._SALARY_AVPAY_HOLIDAYS_OVERTIME = wt.R_HR_HOLIDAY_OVERTIME * (decimal)wt._FACT_AVPAY_HOLIDAYS_HOURS_OVERT;
}
public ErrorList FillRow()
{
var dt1 = SalarySheet.DT1;
var dt2 = SalarySheet.DT2;
TotalPersonPay = new SalaryInfo();
var sci = new SalaryCalcTInfo(this, TotalPersonPay, false);
var err_list = sci.FillRow();
if (err_list.HasErrors)
{
return(err_list);
}
sci.WriteData();
return(err_list);
}
public void AddSalary(SalaryInfo wi)
{
_SALARY += wi._SALARY;
_SALARY_DAY += wi._SALARY_DAY;
_SALARY_NIGHT += wi._SALARY_NIGHT;
_SALARY_OVERTIME += wi._SALARY_OVERTIME;
_SALARY_HOLIDAYS_DAY += wi._SALARY_HOLIDAYS_DAY;
_SALARY_HOLIDAYS_NIGHT += wi._SALARY_HOLIDAYS_NIGHT;
_SALARY_HOLIDAYS_OVERTIME += wi._SALARY_HOLIDAYS_OVERTIME;
_SALARY_PAID_HOLIDAYS_DAY += wi._SALARY_PAID_HOLIDAYS_DAY;
_SALARY_PAID_HOLIDAYS_NIGHT += wi._SALARY_PAID_HOLIDAYS_NIGHT;
_SALARY_PIECEWORK += wi._SALARY_PIECEWORK;
PlanedWorkPay += wi.PlanedWorkPay;
AddSalaryAvPayPart(wi);
}
//part = 0 - skip MinusAfterIIN
//part = 1 - only MinusAfterIIN
public List <PayFx2> CalcNotProc(SalaryInfo si, int part, int divby = 1)
{
var ret = new List <PayFx2>();
foreach (var dr in DataRows)
{
if (dr.XRateType != EBonusRateType.Money ||
dr.XBonusType == EBonusType.ReverseCalc)
{
continue;
}
if (part == 0 && dr.XBonusType == EBonusType.MinusAfterIIN)
{
continue;
}
if (part == 1 && dr.XBonusType != EBonusType.MinusAfterIIN)
{
continue;
}
decimal v = 0.0M;
if (dr.IsIDANull())
{
v = KlonsData.RoundA(dr.RATE / (decimal)divby, 2);
if (dr.AMOUNT != v)
{
dr.AMOUNT = v;
}
v += GetRoundingError(dr.RATE, divby);
}
else
{
v = dr.RATE;
if (dr.AMOUNT != v)
{
dr.AMOUNT = v;
}
}
var pfx = AddRow(si, dr, dr.RATE, v, divby);
ret.Add(pfx);
}
return(ret);
}
public void FillLinkedRow(SalaryInfo target)
{
decimal ratio = target._AMOUNT_BEFORE_IIN / TotalSI._AMOUNT_BEFORE_IIN;
target._IIN_EXEMPT_UNTAXED_MINIMUM = KlonsData.RoundA(TotalSI._IIN_EXEMPT_UNTAXED_MINIMUM * ratio, 2);
target._IIN_EXEMPT_DEPENDANTS = KlonsData.RoundA(TotalSI._IIN_EXEMPT_DEPENDANTS * ratio, 2);
target._IIN_EXEMPT_INVALIDITY = KlonsData.RoundA(TotalSI._IIN_EXEMPT_INVALIDITY * ratio, 2);
target._IIN_EXEMPT_NATIONAL_MOVEMENT = KlonsData.RoundA(TotalSI._IIN_EXEMPT_NATIONAL_MOVEMENT * ratio, 2);
target._IIN_EXEMPT_RETALIATION = KlonsData.RoundA(TotalSI._IIN_EXEMPT_RETALIATION * ratio, 2);
/*
* target._PLUS_PF_NOTTAXED = Math.Round(total._PLUS_PF_NOTTAXED * ratio, 2);
* target._PLUS_PF_TAXED = Math.Round(total._PLUS_PF_TAXED * ratio, 2);
* target._PLUS_LI_NOTTAXED = Math.Round(total._PLUS_PF_NOTTAXED * ratio, 2);
* target._PLUS_LI_TAXED = Math.Round(total._PLUS_PF_TAXED * ratio, 2);
* target._PLUS_HI_NOTTAXED = Math.Round(total._PLUS_PF_NOTTAXED * ratio, 2);
* target._PLUS_HI_TAXED = Math.Round(total._PLUS_PF_TAXED * ratio, 2);
*/
}
public ErrorList CalcWorkPayTAvPay(SalaryCalcTInfo scti)
{
if (!AvPayCalcRequired)
{
return(new ErrorList());
}
TotalRow = scti.TotalSI;
//TotalRow.ClearSalaryAvPayPart();
var sis = scti.LinkedSCI.Select(x => x.SI).ToArray();
SummAvPayTime2(TotalRow, sis);
//uses avcalc from LinkedSCI[0] and applies to TotalRow
LinkedWorkPayCalcs[0].DoAvPay(scti.SRS.TotalRow, TotalRow, null);
for (int i = 0; i < scti.LinkedSCI.Length; i++)
{
var lsci = scti.LinkedSCI[i];
var wpc = LinkedWorkPayCalcs[i];
wpc.TotalRow = lsci.SI;
var err = wpc.CalcPayWithAvPay(lsci.SR, TotalRow);
if (err.HasErrors)
{
return(err);
}
//TotalRow.AddSalaryAvPayPart(wpc.TotalRow);
}
TotalRow._SALARY = TotalRow.SumSalary();
TotalRow.AddAvPay();
MakeAvPayExactSum();
if (PreparingReport)
{
PrepareListT();
}
return(new ErrorList());
}
public static List <SalaryRepRow2> MakeReport2(SalarySheetInfo sh)
{
var ret = new List <SalaryRepRow2>();
var drs = sh.DR_algas_lapa.KIND == 1 ?
sh.DR_algas_lapa.GetSALARY_SHEETS_RRowsByFK_SALARY_SHEETS_R_IDST().OrderBy(d => d.SNR) :
sh.DR_algas_lapa.GetSALARY_SHEETS_RRowsByFK_SALARY_SHEETS_R_IDS().OrderBy(d => d.SNR);
var drsa = drs.ToArray();
for (int i = 0; i < drsa.Length; i++)
{
var dr = drsa[i];
var si = new SalaryInfo();
si.SetFromRow(dr);
var reprow = new SalaryRepRow2();
reprow.SetFrom(si);
reprow.SNR = i + 1;
ret.Add(reprow);
}
return(ret);
}
public void PrepareListT()
{
if (LinkedWorkPayCalcs.Length == 1)
{
var w0 = LinkedWorkPayCalcs[0];
w0.PrepareList(w0.PositionTitle);
ReportRows = w0.ReportRows;
JoinRows = w0.JoinRows;
return;
}
ReportRows.Add(TotalRow);
var tjr = new WorkPayCalcJoinRow();
tjr.Caption = "Kopā amati";
JoinRows.Add(tjr);
var emptyrow = new SalaryInfo();
var emptyjoinrow = new WorkPayCalcJoinRow()
{
IsTitle = true
};
for (int i = 0; i < LinkedWorkPayCalcs.Length; i++)
{
ReportRows.Add(emptyrow);
JoinRows.Add(emptyjoinrow);
var wpc = LinkedWorkPayCalcs[i];
var pos = wpc.PositionTitle;
ReportRows.Add(emptyrow);
var jr = new WorkPayCalcJoinRow();
jr.Caption = pos;
jr.IsTitle = true;
JoinRows.Add(jr);
ReportRows.AddRange(wpc.ReportRows);
JoinRows.AddRange(wpc.JoinRows);
}
}
public void CalcWorkPayT(SalaryCalcTInfo scti)
{
TotalRow = scti.TotalSI;
var sr = scti.SRS;
TotalRow._CALENDAR_DAYS = sr.SalarySheet.CalendarMonth.DaysInMonth;
TotalRow._CALENDAR_DAYS_USE = sr.CountCalendarDays();
var dlrowlist = sr.GetDLRowSetList();
dlrowlist.CountPlanMonth(TotalRow, sr.SalarySheet.MDT1, sr.SalarySheet.MDT2);
dlrowlist.CountTotalPlan(TotalRow, sr.SalarySheet.MDT1, sr.SalarySheet.MDT2);
dlrowlist.CountTotalFact(TotalRow, sr.SalarySheet.MDT1, sr.SalarySheet.MDT2);
LinkedWorkPayCalcs = new WorkPayCalcInfo[scti.LinkedSCI.Length];
for (int i = 0; i < scti.LinkedSCI.Length; i++)
{
var lsci = scti.LinkedSCI[i];
var wpc = new WorkPayCalcInfo(PreparingReport);
wpc.CalcWorkPay(lsci.SR, lsci.SI);
TotalRow.AddSalary(lsci.SI);
if (wpc.AvPayCalcRequired)
{
AvPayCalcRequired = true;
}
lsci.WorkPayCalc = wpc;
wpc.PositionTitle = lsci.SR.GetPositionTitle();
LinkedWorkPayCalcs[i] = wpc;
}
TotalRow._SALARY = TotalRow.SumSalary();
TotalRow.SumForAvPay();
if (PreparingReport && !AvPayCalcRequired)
{
PrepareListT();
}
}
private void CalcWorkPayAvPay(SalarySheetRowSetInfo sr, SalaryInfo si)
{
TotalRow = si;
var sis = LinkedWorkPayCalcs.Select(x => x.TotalRow).ToArray();
SummAvPayTime2(TotalRow, sis);
LinkedWorkPayCalcs[0].DoAvPay(sr.TotalRow, TotalRow, null);
for (int i = 0; i < sr.LinkedRows.Length; i++)
{
var lr = sr.LinkedRows[i];
var wpc = LinkedWorkPayCalcs[i];
wpc.CalcPayWithAvPay(lr, TotalRow);
//TotalRow.AddSalaryAvPayPart(wpc.TotalRow);
}
TotalRow._SALARY = TotalRow.SumSalary();
TotalRow.AddAvPay();
MakeAvPayExactSum();
}
public void WriteTo(SalaryInfo si)
{
si._VACATION_ADVANCE_PREV = AdvancePrev;
si._VACATION_CASH_NEXT = VcrNext.Cash;
si._VACATION_ADVANCE_CURRENT = 0.0M;
si._VACATION_ADVANCE_NEXT = 0.0M;
si._VACATION_PAY_PREV = VcrPrevCurrent.Pay;
si._VACATION_DNS_PREV = VcrPrevCurrent.DNS;
//si._VACATION_DDS_PREV = VcrPrevCurrent.DDS;
si._VACATION_IIN_PREV = VcrPrevCurrent.IIN;
si._VACATION_DAYS_CURRENT = VcrCurrent.Days + VcrCompensation.Days;
si._VACATION_HOURS_CURRENT = VcrCurrent.Hours;
si._VACATION_PAY_CURRENT = VcrCurrent.Pay + VcrCompensation.Pay;
si._VACATION_DAYS_NEXT = VcrNext.Days;
si._VACATION_HOURS_NEXT = VcrNext.Hours;
si._VACATION_PAY_NEXT = VcrNext.Pay;
si._VACATION_DNS_NEXT = VcrNext.DNS;
//si._VACATION_DDS_NEXT = VcrNext.DDS;
si._VACATION_IIN_NEXT = VcrNext.IIN;
si._VACATION_IIN_REDUCE_NEXT = IINReverse;
}
public void SummAvPayTime2(SalaryInfo totalsi, SalaryInfo[] sis)
{
totalsi.FACT_AVPAY_FREE_DAYS_2 = 0;
totalsi.FACT_AVPAY_FREE_HOURS_2 = 0.0f;
totalsi.FACT_AVPAY_WORK_DAYS_2 = 0;
totalsi.FACT_AVPAY_WORKINHOLIDAYS_2 = 0;
totalsi.FACT_AVPAY_HOURS_2 = 0.0f;
totalsi.FACT_AVPAY_HOURS_OVERTIME_2 = 0.0f;
totalsi.FACT_AVPAY_HOLIDAYS_HOURS_2 = 0.0f;
totalsi.FACT_AVPAY_HOLIDAYS_HOURS_OVERT_2 = 0.0f;
for (int i = 0; i < sis.Length; i++)
{
var si = sis[i];
totalsi.FACT_AVPAY_FREE_DAYS_2 += si.FACT_AVPAY_FREE_DAYS_2;
totalsi.FACT_AVPAY_FREE_HOURS_2 += si.FACT_AVPAY_FREE_HOURS_2;
totalsi.FACT_AVPAY_WORK_DAYS_2 += si.FACT_AVPAY_WORK_DAYS_2;
totalsi.FACT_AVPAY_WORKINHOLIDAYS_2 += si.FACT_AVPAY_WORKINHOLIDAYS_2;
totalsi.FACT_AVPAY_HOURS_2 += si.FACT_AVPAY_HOURS_2;
totalsi.FACT_AVPAY_HOURS_OVERTIME_2 += si.FACT_AVPAY_HOURS_OVERTIME_2;
totalsi.FACT_AVPAY_HOLIDAYS_HOURS_2 += si.FACT_AVPAY_HOLIDAYS_HOURS_2;
totalsi.FACT_AVPAY_HOLIDAYS_HOURS_OVERT_2 += si.FACT_AVPAY_HOLIDAYS_HOURS_OVERT_2;
}
}
public SalaryInfo GetPrevRow()
{
if (Row.XType != ESalarySheetRowType.Total)
{
return(GetPrevRowA());
}
var dt1 = SalarySheet.DT1;
var dt2 = SalarySheet.DT2;
var idp = Row.IDP;
var id = Row.ID;
var dtp1 = dt2.FirstDayOfMonth().AddMonths(-1);
var dtp2 = dtp1.LastDayOfMonth();
var table_lapas_r = MyData.DataSetKlons.SALARY_SHEETS_R;
var dr_lapas_r = table_lapas_r.WhereX(
d =>
d.ID != id &&
d.IDP == idp &&
d.IsIDAMNull() &&
d.SALARY_SHEETSRowByFK_SALARY_SHEETS_R_IDS.DT2 >= dtp1 &&
d.SALARY_SHEETSRowByFK_SALARY_SHEETS_R_IDS.DT2 <= dtp2 &&
d.SALARY_SHEETSRowByFK_SALARY_SHEETS_R_IDS.IS_TEMP == 0 &&
d.SALARY_SHEETSRowByFK_SALARY_SHEETS_R_IDS.XKind == ESalarySheetKind.Total
).WithMaxOrDefault(d => d.SALARY_SHEETSRowByFK_SALARY_SHEETS_R_IDS.DT2);
if (dr_lapas_r == null)
{
return(null);
}
var ret = new SalaryInfo();
ret.SetFromRow(dr_lapas_r);
return(ret);
}
