private GLTran EditReclassifyingTran(GLTranForReclassification tranForReclass, List <GLTran> transMovedFromExistingBatch)
        {
            var reclassifyingTran = LocateReclassifyingTran(JournalEntryInstance.GLTranModuleBatNbr.Cache, tranForReclass);

            var anyChanged = reclassifyingTran.BranchID != tranForReclass.NewBranchID ||
                             reclassifyingTran.AccountID != tranForReclass.NewAccountID ||
                             reclassifyingTran.SubID != tranForReclass.NewSubID ||
                             reclassifyingTran.TranDate != tranForReclass.NewTranDate ||
                             reclassifyingTran.TranDesc != tranForReclass.NewTranDesc;

            if (anyChanged)
            {
                var newTran = CopyTranForMovingIfNeed(reclassifyingTran, transMovedFromExistingBatch);

                if (newTran != null)
                {
                    SetReclassifyingTranBusinessAttrs(newTran, tranForReclass);
                    return(JournalEntryInstance.GLTranModuleBatNbr.Insert(newTran));
                }

                SetReclassifyingTranBusinessAttrs(reclassifyingTran, tranForReclass);
                return(JournalEntryInstance.GLTranModuleBatNbr.Update(reclassifyingTran));
            }

            return(reclassifyingTran);
        }
        private GLTran CreateOrEditReclassTranPair(GLTranForReclassification tranForReclass,
                                                   ReclassificationItem reclassItem,
                                                   List <GLTran> transMovedFromExistingBatch)
        {
            GLTran reclassifyingTran;

            if (tranForReclass.ReclassRowType == ReclassRowTypes.Editing)
            {
                EditReverseTran(tranForReclass, transMovedFromExistingBatch);

                reclassifyingTran = EditReclassifyingTran(tranForReclass, transMovedFromExistingBatch);
            }
            else
            {
                var newTranCuryInfo = CreateCurrencyInfo(reclassItem.CuryInfo);

                BuildReverseTran(tranForReclass, reclassItem, newTranCuryInfo);

                reclassifyingTran = BuildReclassifyingTran(tranForReclass, reclassItem, newTranCuryInfo);

                reclassItem.NewReclassifyingTrans.Add(reclassifyingTran);
            }

            reclassItem.ReclassifyingTrans.Add(reclassifyingTran);

            return(reclassifyingTran);
        }
 public ReclassificationItem(GLTranForReclassification tran, List <GLTranForReclassification> splittingTransForReclass, CurrencyInfo curyInfo)
 {
     HeadTranForReclass       = tran;
     SplittingTransForReclass = splittingTransForReclass;
     CuryInfo              = curyInfo;
     ReclassifyingTrans    = new List <GLTran>();
     NewReclassifyingTrans = new List <GLTran>();
 }
        private GLTran BuildReclassifyingTran(GLTranForReclassification tranForReclass, CurrencyInfo tranCuryInfo)
        {
            var reclassifyingTran = JournalEntry.BuildReleasableTransaction(JournalEntryInstance, tranForReclass, JournalEntry.TranBuildingModes.SetLinkToOriginal, tranCuryInfo);

            SetReclassifyingTranBusinessAttrs(reclassifyingTran, tranForReclass);
            SetReclassificationLinkingAttrs(reclassifyingTran, tranForReclass);

            return(JournalEntryInstance.GLTranModuleBatNbr.Insert(reclassifyingTran));
        }
        private void BuildReverseTran(GLTranForReclassification tranForReclass, CurrencyInfo tranCuryInfo)
        {
            var reverseTran = JournalEntry.BuildReverseTran(JournalEntryInstance, tranForReclass, JournalEntry.TranBuildingModes.SetLinkToOriginal, tranCuryInfo);

            reverseTran.IsReclassReverse = true;
            SetCommonBusinessAttrs(reverseTran, tranForReclass);
            SetReclassificationLinkingAttrs(reverseTran, tranForReclass);

            JournalEntryInstance.GLTranModuleBatNbr.Insert(reverseTran);
        }
Exemple #6
0
        private GLTran BuildReclassifyingTran(GLTranForReclassification tranForReclass, ReclassificationItem reclassItem, CurrencyInfo newTranCuryInfo)
        {
            var reclassifyingTran = JournalEntry.BuildReleasableTransaction(JournalEntryInstance, tranForReclass, JournalEntry.TranBuildingModes.SetLinkToOriginal, newTranCuryInfo);

            SetOrigLineNumber(reclassifyingTran, reclassItem);
            SetReclassifyingTranBusinessAttrs(reclassifyingTran, tranForReclass);
            SetReclassificationLinkingAttrs(reclassifyingTran, tranForReclass, reclassItem);
            SetDependingOnReclassTypeAttrs(reclassifyingTran, tranForReclass);

            return(JournalEntryInstance.GLTranModuleBatNbr.Insert(reclassifyingTran));
        }
        private GLTran LocateReverseTran(PXCache cache, GLTranForReclassification tranForReclass)
        {
            var reverseTran = new GLTran()
            {
                Module   = State.EditingBatchModule,
                BatchNbr = State.EditingBatchNbr,
                LineNbr  = tranForReclass.EditingPairReclassifyingLineNbr - 1
            };

            return((GLTran)cache.Locate(reverseTran));
        }
Exemple #8
0
        private void BuildReverseTran(GLTranForReclassification tranForReclass, ReclassificationItem reclassItem, CurrencyInfo newTranCuryInfo)
        {
            var reverseTran = JournalEntry.BuildReverseTran(JournalEntryInstance, tranForReclass, JournalEntry.TranBuildingModes.SetLinkToOriginal, newTranCuryInfo);

            reverseTran.IsReclassReverse = true;
            SetOrigLineNumber(reverseTran, reclassItem);
            SetCommonBusinessAttrs(reverseTran, tranForReclass);
            SetReclassificationLinkingAttrs(reverseTran, tranForReclass, reclassItem);
            SetDependingOnReclassTypeAttrs(reverseTran, tranForReclass);

            JournalEntryInstance.GLTranModuleBatNbr.Insert(reverseTran);
        }
        private GLTran BuildReclassifyingTran(GLTranForReclassification tranForReclass, ReclassificationItem reclassItem, CurrencyInfo newTranCuryInfo)
        {
            var reclassifyingTran = JournalEntry.BuildReleasableTransaction(JournalEntryInstance, tranForReclass, JournalEntry.TranBuildingModes.SetLinkToOriginal, newTranCuryInfo);

            SetOrigLineNumber(reclassifyingTran, reclassItem);
            SetReclassifyingTranBusinessAttrs(reclassifyingTran, tranForReclass);
            SetReclassificationLinkingAttrs(reclassifyingTran, tranForReclass, reclassItem);
            SetDependingOnReclassTypeAttrs(reclassifyingTran, tranForReclass);

            bool BaseCalc = (reclassifyingTran.TranClass != GLTran.tranClass.RealizedAndRoundingGOL);

            PXDBCurrencyAttribute.SetBaseCalc <GLTran.curyCreditAmt>(JournalEntryInstance.GLTranModuleBatNbr.Cache, null, BaseCalc);
            PXDBCurrencyAttribute.SetBaseCalc <GLTran.curyDebitAmt>(JournalEntryInstance.GLTranModuleBatNbr.Cache, null, BaseCalc);
            return(JournalEntryInstance.GLTranModuleBatNbr.Insert(reclassifyingTran));
        }
        private void SetReclassifyingTranBusinessAttrs(GLTran reclassifyingTran, GLTranForReclassification tranForReclass)
        {
            reclassifyingTran.BranchID  = tranForReclass.NewBranchID;
            reclassifyingTran.AccountID = tranForReclass.NewAccountID;

            if (tranForReclass.NewSubCD != null)
            {
                JournalEntryInstance.GLTranModuleBatNbr.SetValueExt <GLTran.subID>(reclassifyingTran, tranForReclass.NewSubCD);
            }
            else
            {
                reclassifyingTran.SubID = tranForReclass.NewSubID;
            }

            SetCommonBusinessAttrs(reclassifyingTran, tranForReclass);
        }
 private void SetReclassificationLinkingAttrs(GLTran tran, GLTranForReclassification tranForReclassification)
 {
     if (JournalEntry.IsReclassifacationTran(tranForReclassification))
     {
         tran.ReclassSourceTranModule   = tranForReclassification.ReclassSourceTranModule;
         tran.ReclassSourceTranBatchNbr = tranForReclassification.ReclassSourceTranBatchNbr;
         tran.ReclassSourceTranLineNbr  = tranForReclassification.ReclassSourceTranLineNbr;
         tran.ReclassSeqNbr             = tranForReclassification.ReclassSeqNbr + 1;
     }
     else
     {
         tran.ReclassSourceTranModule   = tranForReclassification.Module;
         tran.ReclassSourceTranBatchNbr = tranForReclassification.BatchNbr;
         tran.ReclassSourceTranLineNbr  = tranForReclassification.LineNbr;
         tran.ReclassSeqNbr             = 1;
     }
 }
        private void SetReclassificationLinkingAttrs(GLTran tran, GLTranForReclassification tranForReclassification, ReclassificationItem reclassItem)
        {
            if (JournalEntry.IsReclassifacationTran(tranForReclassification))
            {
                tran.ReclassSourceTranModule   = tranForReclassification.ReclassSourceTranModule;
                tran.ReclassSourceTranBatchNbr = tranForReclassification.ReclassSourceTranBatchNbr;
                tran.ReclassSourceTranLineNbr  = tranForReclassification.ReclassSourceTranLineNbr;
                tran.ReclassSeqNbr             = tranForReclassification.ReclassSeqNbr + 1;
            }
            else
            {
                tran.ReclassSourceTranModule   = tranForReclassification.Module;
                tran.ReclassSourceTranBatchNbr = tranForReclassification.BatchNbr;
                tran.ReclassSourceTranLineNbr  = reclassItem.HeadTranForReclass.LineNbr;
                tran.ReclassSeqNbr             = 1;
            }

            tran.ReclassOrigTranDate = tranForReclassification.TranDate;
        }
        private void EditReverseTran(GLTranForReclassification tranForReclass, List <GLTran> transMovedFromExistingBatch)
        {
            var reverseTran = LocateReverseTran(JournalEntryInstance.GLTranModuleBatNbr.Cache, tranForReclass);

            bool anyChanged;

            if (reverseTran == null && tranForReclass.EditingPairReclassifyingLineNbr == null)
            {
                anyChanged = false;
            }
            else
            {
                anyChanged = reverseTran.TranDate != tranForReclass.NewTranDate ||
                             reverseTran.TranDesc != tranForReclass.NewTranDesc ||
                             tranForReclass.CuryNewAmt != null && (reverseTran.CuryDebitAmt + reverseTran.CuryCreditAmt) != tranForReclass.CuryNewAmt;
            }


            if (anyChanged)
            {
                var newTran = CopyTranForMovingIfNeed(reverseTran, transMovedFromExistingBatch);

                if (newTran != null)
                {
                    SetCommonBusinessAttrs(newTran, tranForReclass);
                    SetReclassAmount(newTran, tranForReclass);

                    JournalEntryInstance.GLTranModuleBatNbr.Insert(newTran);
                }
                else
                {
                    SetCommonBusinessAttrs(reverseTran, tranForReclass);
                    SetReclassAmount(reverseTran, tranForReclass);

                    JournalEntryInstance.GLTranModuleBatNbr.Update(reverseTran);
                }
            }
        }
        private void EditReverseTran(GLTranForReclassification tranForReclass, List <GLTran> transMovedFromExistingBatch)
        {
            var reverseTran = LocateReverseTran(JournalEntryInstance.GLTranModuleBatNbr.Cache, tranForReclass);

            var anyChanged = reverseTran.TranDate != tranForReclass.NewTranDate ||
                             reverseTran.TranDesc != tranForReclass.NewTranDesc;

            if (anyChanged)
            {
                var newTran = CopyTranForMovingIfNeed(reverseTran, transMovedFromExistingBatch);

                if (newTran != null)
                {
                    SetCommonBusinessAttrs(newTran, tranForReclass);
                    JournalEntryInstance.GLTranModuleBatNbr.Insert(newTran);
                }
                else
                {
                    SetCommonBusinessAttrs(reverseTran, tranForReclass);
                    JournalEntryInstance.GLTranModuleBatNbr.Update(reverseTran);
                }
            }
        }
        private void SetReclassAmount(GLTran tran, GLTranForReclassification rtran)
        {
            if (rtran.IsSplitting == false && rtran.IsSplitted == false)
            {
                return;
            }

            if (rtran.IsSplitting)
            {
                if (tran.IsReclassReverse == true)
                {
                    tran.CuryDebitAmt  = rtran.SourceCuryCreditAmt != 0m ? rtran.CuryNewAmt : 0m;
                    tran.CuryCreditAmt = rtran.SourceCuryDebitAmt != 0m ? rtran.CuryNewAmt : 0m;
                    return;
                }

                tran.CuryDebitAmt  = rtran.SourceCuryDebitAmt != 0m ? rtran.CuryNewAmt : 0m;
                tran.CuryCreditAmt = rtran.SourceCuryCreditAmt != 0m ? rtran.CuryNewAmt : 0m;
                return;
            }

            tran.CuryDebitAmt  = tran.CuryDebitAmt != 0m ? rtran.CuryNewAmt : 0m;
            tran.CuryCreditAmt = tran.CuryCreditAmt != 0m ? rtran.CuryNewAmt : 0m;
        }
 public GLTranForReclassTriple(GLTranForReclassification tran, CurrencyInfo curyInfo)
 {
     Tran     = tran;
     CuryInfo = curyInfo;
 }
 private void SetCommonBusinessAttrs(GLTran tran, GLTranForReclassification tranForReclassification)
 {
     tran.TranDate = tranForReclassification.NewTranDate;
     tran.TranDesc = tranForReclassification.NewTranDesc;
 }
 private void SetDependingOnReclassTypeAttrs(GLTran tran, GLTranForReclassification tranForReclassification)
 {
     tran.ReclassType = tranForReclassification.IsSplitting ? ReclassType.Split : ReclassType.Common;
     SetReclassAmount(tran, tranForReclassification);
 }