private void payTaxes(Player player, Amounts fee)
{
if ((player != _activePlayer.Player) || ((fee != Amounts.IncomeTaxPercent) && (fee != Amounts.IncomeTaxFlat))) {
return;
}
UnhandledDebt unhandledDebt = UnhandledDebtList.getUnhandledDebt(player);
if ((unhandledDebt == null) || (!unhandledDebt.IncomeTax)) {
return;
} else {
unhandledDebt.payTaxDebt(fee);
}
resolvedDebt(player);
}
public void releaseFromJail(Amounts fee)
{
if (_jailStatus != JailStatus.Outside) {
Irc.Output(Irc.getChannel(), ".move " + _name + " " + (int)Tile.Jail);
_jailStatus = JailStatus.Outside;
payFlatFee((int)fee);
}
}
public Subject(string name, Amounts amounts, double factor = .95)
{
Name = name;
Amounts = amounts;
Factor = factor;
}
public void AddToCart(Food food, int amount)
{
Items.Add(food);
Amounts.Add(amount);
}
public void payTaxDebt(Amounts fee)
{
if (_incomeTax) {
_incomeTax = false;
if (fee == Amounts.IncomeTaxFlat) {
_player.payFlatFee((int)fee);
Irc.Output(Irc.getChannel(), ".paidTax " + Player.Name);
} else if (fee == Amounts.IncomeTaxPercent) {
_player.payPercentTax((int)fee);
Irc.Output(Irc.getChannel(), ".paidTax " + Player.Name);
} else {
_incomeTax = true;
}
}
}
public virtual IEnumerable amts(PXAdapter adapter)
{
AccBalanceByAssetFilter filter = Filter.Current;
if (filter == null)
{
yield break;
}
PXSelectBase <FATran> select = new PXSelectJoin <FATran,
InnerJoin <FixedAsset, On <FixedAsset.assetID, Equal <FATran.assetID>, And <FixedAsset.recordType, Equal <FARecordType.assetType> > >,
InnerJoin <FADetails, On <FADetails.assetID, Equal <FixedAsset.assetID> >,
InnerJoin <FALocationHistoryCurrent, On <FALocationHistoryCurrent.assetID, Equal <FixedAsset.assetID> >,
InnerJoin <FALocationHistory, On <FALocationHistory.assetID, Equal <FixedAsset.assetID>,
And <FALocationHistory.periodID, Equal <FALocationHistoryCurrent.lastPeriodID>,
And <FALocationHistory.revisionID, Equal <FALocationHistoryCurrent.lastRevisionID> > > > > > > >,
Where <FATran.released, Equal <True>,
And <FATran.finPeriodID, LessEqual <Current <AccBalanceByAssetFilter.periodID> >,
And <FATran.bookID, Equal <Current <AccBalanceByAssetFilter.bookID> >,
And2 <Where <FALocationHistory.fAAccountID, Equal <Current <AccBalanceByAssetFilter.accountID> >,
And <FALocationHistory.fASubID, Equal <Current <AccBalanceByAssetFilter.subID> >,
Or <FALocationHistory.accumulatedDepreciationAccountID, Equal <Current <AccBalanceByAssetFilter.accountID> >,
And <FALocationHistory.accumulatedDepreciationSubID, Equal <Current <AccBalanceByAssetFilter.subID> > > > > >,
And <Where <FATran.debitAccountID, Equal <Current <AccBalanceByAssetFilter.accountID> >,
And <FATran.debitSubID, Equal <Current <AccBalanceByAssetFilter.subID> >,
Or <FATran.creditAccountID, Equal <Current <AccBalanceByAssetFilter.accountID> >,
And <FATran.creditSubID, Equal <Current <AccBalanceByAssetFilter.subID> > > > > > > > > > > >(this);
if (filter.BranchID != null)
{
select.WhereAnd <Where <FALocationHistory.locationID, Equal <Current <AccBalanceByAssetFilter.branchID> > > >();
}
Dictionary <int?, Amounts> dict = new Dictionary <int?, Amounts>();
foreach (PXResult <FATran, FixedAsset, FADetails, FALocationHistoryCurrent, FALocationHistory> res in select.Select())
{
FATran tran = (FATran)res;
FixedAsset asset = (FixedAsset)res;
FADetails details = (FADetails)res;
FALocationHistory location = (FALocationHistory)res;
Amounts record = null;
if (!dict.TryGetValue(asset.AssetID, out record))
{
record = new Amounts
{
AssetID = asset.AssetID,
Description = asset.Description,
Status = details.Status,
ClassID = asset.ClassID,
DepreciateFromDate = details.DepreciateFromDate,
BranchID = location.BranchID,
Department = location.Department,
ItdAmt = decimal.Zero,
YtdAmt = decimal.Zero,
PtdAmt = decimal.Zero
};
}
decimal tranAmt = tran.TranAmt ?? decimal.Zero;
decimal amount = tran.DebitAccountID == tran.CreditAccountID && tran.DebitSubID == tran.CreditSubID
? decimal.Zero
: tran.DebitAccountID == filter.AccountID && tran.DebitSubID == filter.SubID ? tranAmt : -tranAmt;
record.ItdAmt += amount;
record.YtdAmt += (FinPeriodIDAttribute.FinPeriodEqual(filter.PeriodID, tran.FinPeriodID, FinPeriodIDAttribute.FinPeriodComparison.Year) ? amount : decimal.Zero);
record.PtdAmt += (filter.PeriodID == tran.FinPeriodID ? amount : decimal.Zero);
dict[asset.AssetID] = record;
}
foreach (Amounts amt in dict.Values)
{
if (amt.ItdAmt != decimal.Zero || amt.YtdAmt != decimal.Zero || amt.PtdAmt != decimal.Zero)
{
yield return(amt);
}
}
}
public virtual IEnumerable amts(PXAdapter adapter)
{
FixedAssetFilter filter = Filter.Current;
if (filter == null || filter.AssetID == null || filter.PeriodID == null)
{
yield break;
}
FixedAsset asset = PXSelect <FixedAsset, Where <FixedAsset.assetID, Equal <Current <FixedAssetFilter.assetID> > > > .Select(this);
PXSelectBase <FATran> select = new PXSelectJoin <FATran,
LeftJoin <Account, On <FATran.debitAccountID, Equal <Account.accountID> >,
LeftJoin <Sub, On <FATran.debitSubID, Equal <Sub.subID> >,
LeftJoin <CreditAccount, On <FATran.creditAccountID, Equal <CreditAccount.accountID> >,
LeftJoin <CreditSub, On <FATran.creditSubID, Equal <CreditSub.subID> >,
LeftJoin <Branch, On <FATran.branchID, Equal <Branch.branchID> >,
LeftJoin <FABook, On <FATran.bookID, Equal <FABook.bookID> >,
LeftJoin <FABookPeriod, On <FATran.bookID, Equal <FABookPeriod.bookID>,
And <FABookPeriod.organizationID, Equal <IIf <Where <FABook.updateGL, Equal <True> >, Branch.organizationID, FinPeriod.organizationID.masterValue> >,
And <FATran.finPeriodID, Equal <FABookPeriod.finPeriodID> > > > > > > > > > >,
Where <FATran.assetID, Equal <Current <FixedAssetFilter.assetID> >,
And <FATran.finPeriodID, LessEqual <Current <FixedAssetFilter.periodID> >,
And <FATran.released, Equal <True>,
And <Where <FATran.tranType, NotEqual <FATran.tranType.calculatedPlus>,
And <FATran.tranType, NotEqual <FATran.tranType.calculatedMinus>,
And <FATran.tranType, NotEqual <FATran.tranType.reconcilliationPlus>,
And <FATran.tranType, NotEqual <FATran.tranType.reconcilliationMinus> > > > > > > > > >(this);
if (filter.BookID != null)
{
select.WhereAnd <Where <FATran.bookID, Equal <Current <FixedAssetFilter.bookID> > > >();
}
Dictionary <string, Amounts> dict = new Dictionary <string, Amounts>();
foreach (PXResult <FATran, Account, Sub, CreditAccount, CreditSub, Branch, FABook, FABookPeriod> res in select.Select())
{
Account dacct = res;
Sub dsub = res;
CreditAccount cacct = res;
CreditSub csub = res;
FATran tran = res;
FABookPeriod period = res;
if (!IsAccrualAccount <FATran.debitAccountID, FATran.debitSubID>(tran, asset))
{
Amounts record = null;
string dkey = string.Format("{0}{1}", dacct.AccountCD, dsub.SubCD);
if (!dict.TryGetValue(dkey, out record))
{
record = new Amounts
{
BookID = tran.BookID,
AccountID = tran.DebitAccountID,
SubID = tran.DebitSubID,
AcctDescr = dacct.Description,
SubDescr = dsub.Description,
BranchID = tran.BranchID,
ItdAmt = 0m,
YtdAmt = 0m,
PtdAmt = 0m
};
}
record.ItdAmt += tran.TranAmt;
if (filter.PeriodID.Substring(0, 4) == period.FinYear)
{
record.YtdAmt += tran.TranAmt;
}
if (filter.PeriodID == tran.FinPeriodID)
{
record.PtdAmt += tran.TranAmt;
}
dict[dkey] = record;
}
if (!IsAccrualAccount <FATran.creditAccountID, FATran.creditSubID>(tran, asset))
{
Amounts record = null;
string ckey = string.Format("{0}{1}", cacct.AccountCD, csub.SubCD);
if (!dict.TryGetValue(ckey, out record))
{
record = new Amounts
{
BookID = tran.BookID,
AccountID = tran.CreditAccountID,
SubID = tran.CreditSubID,
AcctDescr = cacct.Description,
SubDescr = csub.Description,
BranchID = tran.BranchID,
ItdAmt = 0m,
YtdAmt = 0m,
PtdAmt = 0m
};
}
record.ItdAmt -= tran.TranAmt;
if (filter.PeriodID.Substring(0, 4) == period.FinYear)
{
record.YtdAmt -= tran.TranAmt;
}
if (filter.PeriodID == tran.FinPeriodID)
{
record.PtdAmt -= tran.TranAmt;
}
dict[ckey] = record;
}
}
foreach (Amounts amt in dict.Values)
{
if (amt.ItdAmt != 0m || amt.YtdAmt != 0m || amt.PtdAmt != 0m)
{
yield return(amt);
}
}
}