public static bool UpdateCapturedState <T>(T doc, ExternalTransactionState tranState) where T : class, IBqlTable, ICCCapturePayment { bool needUpdate = false; IExternalTransaction extTran = tranState.ExternalTransaction; if (doc.IsCCCaptured != tranState.IsCaptured) { doc.IsCCCaptured = tranState.IsCaptured; needUpdate = true; } if (tranState.IsCaptured) { doc.CuryCCCapturedAmt = extTran.Amount; doc.IsCCCaptureFailed = false; needUpdate = true; } if (tranState.ProcessingStatus == ProcessingStatus.CaptureFail) { doc.IsCCCaptureFailed = true; needUpdate = true; } if (doc.IsCCCaptured == false && (doc.CuryCCCapturedAmt != decimal.Zero)) { doc.CuryCCCapturedAmt = decimal.Zero; needUpdate = true; } return(needUpdate); }
public void CheckHeldForReviewTranStatus(ICCPayment doc) { ExternalTransactionState state = GetActiveTransactionState(); if (state.IsOpenForReview) { int? tranID = state.ExternalTransaction.TransactionID; bool changed = TranStatusChanged(doc, tranID); if (changed) { IExternalTransaction affectedTran = GetExtTrans().Where(i => i.TransactionID == tranID).FirstOrDefault(); if (affectedTran != null && affectedTran.ProcessingStatus == ExtTransactionProcStatusCode.VoidSuccess || affectedTran.Active == false) { PaymentDoc.Cache.Clear(); PaymentDoc.Cache.ClearQueryCache(); ClearTransactionСaches(); throw new PXException(AR.Messages.CCProcessingAuthTranDeclined); } } else { string procCenter = GetPaymentProcessing().Repository.GetCustomerPaymentMethod(doc.PMInstanceID)?.CCProcessingCenterID; if (IsFeatureSupported(procCenter, CCProcessingFeature.TransactionGetter)) { throw new PXException(TranHeldwarnMsg); } else { throw new PXException(AR.Messages.CCProcessingApprovalHoldingTranNotSupported, procCenter); } } } }
private static void CheckAuthExpired(ExternalTransactionState state) { if (state.IsPreAuthorized && IsExpired(state.ExternalTransaction)) { state.IsPreAuthorized = false; state.ProcessingStatus = ProcessingStatus.AuthorizeExpired; state.HasErrors = false; } }
public static bool UpdateCCPaymentState <T>(T doc, ExternalTransactionState tranState) where T : class, ICCAuthorizePayment, ICCCapturePayment { IExternalTransaction externalTran = tranState.ExternalTransaction; bool needUpdate = false; if (doc.IsCCAuthorized != tranState.IsPreAuthorized || doc.IsCCCaptured != tranState.IsCaptured) { if (!(tranState.ProcessingStatus == ProcessingStatus.VoidFail || tranState.ProcessingStatus == ProcessingStatus.CreditFail)) { doc.IsCCAuthorized = tranState.IsPreAuthorized; doc.IsCCCaptured = tranState.IsCaptured; needUpdate = true; } else { doc.IsCCAuthorized = false; doc.IsCCCaptured = false; needUpdate = false; } } if (externalTran != null && tranState.IsPreAuthorized) { doc.CCAuthExpirationDate = externalTran.ExpirationDate; doc.CuryCCPreAuthAmount = externalTran.Amount; needUpdate = true; } if (doc.IsCCAuthorized == false && (doc.CCAuthExpirationDate != null || doc.CuryCCPreAuthAmount > Decimal.Zero)) { doc.CCAuthExpirationDate = null; doc.CuryCCPreAuthAmount = Decimal.Zero; needUpdate = true; } if (tranState.IsCaptured) { doc.CuryCCCapturedAmt = externalTran.Amount; doc.IsCCCaptureFailed = false; needUpdate = true; } if (tranState.ProcessingStatus == ProcessingStatus.CaptureFail) { doc.IsCCCaptureFailed = true; needUpdate = true; } if (doc.IsCCCaptured == false && (doc.CuryCCCapturedAmt != decimal.Zero)) { doc.CuryCCCapturedAmt = decimal.Zero; needUpdate = true; } return(needUpdate); }
public void CaptureCCpayment(ICCPayment doc, IExternalTransactionAdapter paymentTransaction) { if (doc == null || doc.CuryDocBal == null) { return; } ExternalTransactionState state = ExternalTranHelper.GetActiveTransactionState(graph, paymentTransaction.Select()); if (ExternalTranHelper.HasOpenCCProcTran(graph, state.ExternalTransaction)) { throw new PXException(Messages.ERR_CCTransactionCurrentlyInProgress); } if (state.IsCaptured) { throw new PXException(Messages.ERR_CCAuthorizedPaymentAlreadyCaptured); } if (doc.Released == false) { graph.Actions.PressSave(); } ICCPayment toProc = graph.Caches[doc.GetType()].CreateCopy(doc) as ICCPayment; IExternalTransaction tranCopy = null; if (state.IsPreAuthorized && !ExternalTranHelper.IsExpired(state.ExternalTransaction)) { tranCopy = graph.Caches[state.ExternalTransaction.GetType()].CreateCopy(state.ExternalTransaction) as IExternalTransaction; } CCTranType operation = tranCopy != null ? CCTranType.PriorAuthorizedCapture : CCTranType.AuthorizeAndCapture; PXLongOperation.StartOperation(graph, delegate() { bool success = true; try { if (operation == CCTranType.PriorAuthorizedCapture) { TransactionProcessor.ProcessPriorAuthorizedCapture(toProc, tranCopy); } else { TransactionProcessor.ProcessAuthorizeCapture(toProc, tranCopy); } } catch { success = false; throw; } finally { RunCallbacks((IBqlTable)doc, operation, success); } }); }
protected virtual int?GetOrCreatePaymentProfilrByTran(V2.TransactionData tranData, ICCPayment pDoc) { int?instanceID; try { V2.TranProfile profile = null; if (tranData.CustomerId != null && tranData.PaymentId != null) { profile = new V2.TranProfile() { CustomerProfileId = tranData.CustomerId, PaymentProfileId = tranData.PaymentId }; ICCPaymentProfile cpm = null; try { cpm = PrepeareCpmRecord(); } catch (Exception ex) { var v = ex; } cpm.CustomerCCPID = tranData.CustomerId; } ExternalTransactionState state = GetActiveTransactionState(); if (profile == null && state.IsPreAuthorized) { profile = GetCustomerProfileFromDoc(pDoc); } if (profile == null) { profile = GetOrCreateCustomerProfileByTranId(tranData.TranID); } instanceID = GetInstanceId(profile); using (PXTransactionScope tran = new PXTransactionScope()) { if (instanceID == PaymentTranExtConstants.NewPaymentProfile) { instanceID = CreatePaymentProfile(profile); } CreateCustomerProcessingCenterRecord(profile); tran.Complete(); } } finally { NewCpm.Cache.Clear(); NewCpmd.Cache.Clear(); } pDoc.PMInstanceID = instanceID; return(instanceID); }
public void RecordCCCredit(ICCPayment doc, ICCManualInputPaymentInfo info, IExternalTransactionAdapter paymentTransaction) { if (doc == null || doc.CuryDocBal == null) { return; } ExternalTransactionState state = ExternalTranHelper.GetActiveTransactionState(graph, paymentTransaction.Select()); if (ExternalTranHelper.HasOpenCCProcTran(graph, state.ExternalTransaction)) { throw new PXException(Messages.ERR_CCTransactionCurrentlyInProgress); } if (string.IsNullOrEmpty(info.PCTranNumber)) { throw new PXException(Messages.ERR_PCTransactionNumberOfTheOriginalPaymentIsRequired); } if (state.IsRefunded) { throw new PXException(Messages.ERR_CCPaymentIsAlreadyRefunded); } if (doc.Released == false) { graph.Actions.PressSave(); } ICCPayment toProc = graph.Caches[doc.GetType()].CreateCopy(doc) as ICCPayment; CCTranType operation = CCTranType.Credit; PXLongOperation.StartOperation(graph, delegate() { bool success = true; try { var procGraph = PXGraph.CreateInstance <CCPaymentProcessingGraph>(); TranRecordData recordData = new TranRecordData(); recordData.RefExternalTranId = toProc.RefTranExtNbr; recordData.ExternalTranId = info.PCTranNumber; recordData.AuthCode = info.AuthNumber; procGraph.RecordCredit(doc, recordData); } catch { success = false; throw; } finally { RunCallbacks((IBqlTable)doc, operation, success); } }); }
public void VoidCCPayment(ICCPayment doc, IExternalTransactionAdapter paymentTransaction) { if (doc == null || doc.CuryDocBal == null) { return; } ExternalTransactionState state = ExternalTranHelper.GetActiveTransactionState(graph, paymentTransaction.Select()); if (ExternalTranHelper.HasOpenCCProcTran(graph, state.ExternalTransaction)) { throw new PXException(Messages.ERR_CCTransactionCurrentlyInProgress); } if (!state.IsActive) { throw new PXException(Messages.ERR_CCNoTransactionToVoid); } if (state.IsRefunded) { throw new PXException(Messages.ERR_CCTransactionOfThisTypeInvalidToVoid); } if (ExternalTranHelper.IsExpired(state.ExternalTransaction)) { throw new PXException(Messages.TransactionHasExpired); } if (doc.Released == false) { graph.Actions.PressSave(); } ICCPayment toProc = graph.Caches[doc.GetType()].CreateCopy(doc) as ICCPayment; PXLongOperation.StartOperation(graph, delegate() { bool success = true; try { TransactionProcessor.ProcessVoidOrCredit(toProc, state.ExternalTransaction); } catch { success = false; throw; } finally { RunCallbacks((IBqlTable)doc, CCTranType.VoidOrCredit, success); } }); }
public static void CheckForHeldForReviewStatusAfterProc(IBqlTable aTable, CCTranType procTran, bool success) { ICCPayment doc = aTable as ICCPayment; if (doc != null && success) { var graph = PXGraph.CreateInstance <ARPaymentEntry>(); var query = new PXSelect <ExternalTransaction, Where <ExternalTransaction.docType, Equal <Required <ExternalTransaction.docType> >, And <ExternalTransaction.refNbr, Equal <Required <ExternalTransaction.refNbr> > > >, OrderBy <Desc <ExternalTransaction.transactionID> > >(graph); var result = query.Select(doc.DocType, doc.RefNbr); ExternalTransactionState state = ExternalTranHelper.GetActiveTransactionState(graph, result.RowCast <ExternalTransaction>()); if (state.IsOpenForReview) { throw new PXSetPropertyException(AR.Messages.CCProcessingTranHeldWarning, PXErrorLevel.RowWarning); } } }
public void AuthorizeCCpayment(ICCPayment doc, IExternalTransactionAdapter paymentTransaction) { if (doc == null || doc.CuryDocBal == null) { return; } ExternalTransactionState state = ExternalTranHelper.GetActiveTransactionState(graph, paymentTransaction.Select()); if (ExternalTranHelper.HasOpenCCProcTran(graph, state.ExternalTransaction)) { throw new PXException(Messages.ERR_CCTransactionCurrentlyInProgress); } if (state.IsCaptured || state.IsPreAuthorized) { throw new PXException(Messages.ERR_CCPaymentAlreadyAuthorized); } if (doc.Released == false) { graph.Actions.PressSave(); } ICCPayment toProc = graph.Caches[doc.GetType()].CreateCopy(doc) as ICCPayment; PXLongOperation.StartOperation(graph, delegate() { bool success = true; try { TransactionProcessor.ProcessAuthorize(toProc, null); } catch { success = false; throw; } finally { RunCallbacks((IBqlTable)doc, CCTranType.AuthorizeOnly, success); } }); }
public static void FormatDescription(CCProcTranRepository repo, ExternalTransactionState extTranState) { string descr = null; string currStatus = null; string prevStatus = null; IExternalTransaction extTran = extTranState.ExternalTransaction; if (extTran == null) { return; } ExtTransactionProcStatusCode.ListAttribute attr = new ExtTransactionProcStatusCode.ListAttribute(); string procStatusStr = ExtTransactionProcStatusCode.GetProcStatusStrByProcessingStatus(extTranState.ProcessingStatus); if (!string.IsNullOrEmpty(procStatusStr)) { currStatus = PXMessages.LocalizeNoPrefix(attr.ValueLabelDic[procStatusStr]); } bool needPrevStatus = extTranState.HasErrors; if (!string.IsNullOrEmpty(currStatus) && needPrevStatus) { ICCPaymentTransaction procTran = LastSuccessfulCCProcTranTran(extTranState.ExternalTransaction.TransactionID, repo); if (procTran != null) { prevStatus = GetStatusByTranType(procTran.TranType); } } if (!string.IsNullOrEmpty(currStatus) && !string.IsNullOrEmpty(prevStatus)) { descr = prevStatus + ", " + currStatus; } else if (!string.IsNullOrEmpty(currStatus)) { descr = currStatus; } else { descr = string.Empty; } extTranState.Description = descr; }
public static ExternalTransactionState GetActiveTransactionState(PXGraph graph, IEnumerable <IExternalTransaction> extTrans) { if (graph == null) { throw new ArgumentNullException(nameof(graph)); } if (extTrans == null) { throw new ArgumentNullException(nameof(extTrans)); } ExternalTransactionState state = new ExternalTransactionState(); CCProcTranRepository repo = new CCProcTranRepository(graph); var extTran = GetActiveTransaction(extTrans); if (extTran != null) { state = GetTransactionState(graph, extTran); } return(state); }
private static void ApplyLastSuccessfulTran(CCProcTranRepository repo, ExternalTransactionState state) { ICCPaymentTransaction paymentTran = LastSuccessfulCCProcTranTran(state.ExternalTransaction.TransactionID, repo); if (paymentTran != null) { switch (paymentTran.TranType) { case CCTranTypeCode.Authorize: state.IsPreAuthorized = true; break; case CCTranTypeCode.AuthorizeAndCapture: case CCTranTypeCode.PriorAuthorizedCapture: case CCTranTypeCode.CaptureOnly: state.IsCaptured = true; break; case CCTranTypeCode.Credit: state.IsRefunded = true; break; } state.IsOpenForReview = paymentTran.TranStatus == CCTranStatusCode.HeldForReview; CheckAuthExpired(state); } }
public static ExternalTransactionState GetTransactionState(PXGraph graph, IExternalTransaction extTran) { if (graph == null) { throw new ArgumentNullException(nameof(graph)); } if (extTran == null) { throw new ArgumentNullException(nameof(extTran)); } CCProcTranRepository repo = new CCProcTranRepository(graph); ExternalTransactionState state = new ExternalTransactionState(extTran); CheckAuthExpired(state); if (state.HasErrors) { ApplyLastSuccessfulTran(repo, state); } FormatDescription(repo, state); return(state); }
public static void ReleaseARDocument(IBqlTable aTable, CCTranType procTran, bool success) { AR.ARRegister doc = aTable as AR.ARRegister; if (doc != null && success) { ExternalTransaction tran = null; PXGraph graph = null; if (doc.DocType == ARDocType.CashSale || doc.DocType == ARDocType.CashReturn) { ARCashSaleEntry cashSaleGraph = PXGraph.CreateInstance <ARCashSaleEntry>(); cashSaleGraph.Document.Current = PXSelect <ARCashSale, Where <ARCashSale.docType, Equal <Required <ARCashSale.docType> >, And <ARCashSale.refNbr, Equal <Required <ARCashSale.refNbr> > > > > .SelectWindowed(cashSaleGraph, 0, 1, doc.DocType, doc.RefNbr); tran = cashSaleGraph.ExternalTran.SelectSingle(doc.DocType, doc.RefNbr); graph = cashSaleGraph; } else { ARPaymentEntry paymentGraph = PXGraph.CreateInstance <ARPaymentEntry>(); paymentGraph.Document.Current = PXSelect <AR.ARPayment, Where <AR.ARPayment.docType, Equal <Required <AR.ARPayment.docType> >, And <AR.ARPayment.refNbr, Equal <Required <AR.ARPayment.refNbr> > > > > .SelectWindowed(paymentGraph, 0, 1, doc.DocType, doc.RefNbr); tran = paymentGraph.ExternalTran.SelectSingle(doc.DocType, doc.RefNbr); graph = paymentGraph; } if (tran != null) { ExternalTransactionState state = ExternalTranHelper.GetTransactionState(graph, tran); if (!state.IsDeclined && !state.IsOpenForReview) { ReleaseARDocument(aTable); } } } }
private bool TranHeldForReview() { ExternalTransactionState state = GetActiveTransactionState(); return(state.IsOpenForReview ? true : false); }
private bool FindPreAuthorizing() { ExternalTransactionState state = GetActiveTransactionState(); return(state.IsPreAuthorized ? true : false); }
protected virtual IEnumerable ardocumentlist() { DateTime now = DateTime.Now.Date; PXSelectBase <ExternalTransaction> tranSelect = new PXSelect <ExternalTransaction, Where <ExternalTransaction.docType, Equal <Optional <ExternalTransaction.docType> >, And <ExternalTransaction.refNbr, Equal <Optional <ExternalTransaction.refNbr> > > >, OrderBy <Desc <ExternalTransaction.transactionID> > >(this); foreach (PXResult <ARPaymentInfo, Customer, PaymentMethod, CustomerPaymentMethod, CCProcessingCenterPmntMethod> it in PXSelectJoin <ARPaymentInfo, InnerJoin <Customer, On <Customer.bAccountID, Equal <ARPaymentInfo.customerID> >, InnerJoin <PaymentMethod, On <PaymentMethod.paymentMethodID, Equal <ARPaymentInfo.paymentMethodID>, And <PaymentMethod.paymentType, Equal <PaymentMethodType.creditCard>, And <PaymentMethod.aRIsProcessingRequired, Equal <True> > > >, LeftJoin <CustomerPaymentMethod, On <CustomerPaymentMethod.pMInstanceID, Equal <ARPaymentInfo.pMInstanceID> >, LeftJoin <CCProcessingCenterPmntMethod, On <CCProcessingCenterPmntMethod.paymentMethodID, Equal <PaymentMethod.paymentMethodID>, And <CCProcessingCenterPmntMethod.isDefault, Equal <True>, And <CCProcessingCenterPmntMethod.isActive, Equal <True> > > > > > > >, Where <ARPaymentInfo.released, Equal <False>, And <ARPaymentInfo.hold, Equal <False>, And <ARPaymentInfo.voided, Equal <False>, And <ARPaymentInfo.docType, Equal <ARPaymentType.payment>, And <ARPaymentInfo.docDate, LessEqual <Current <PaymentFilter.payDate> >, And <ARPaymentInfo.isMigratedRecord, NotEqual <True>, And2 <Where <Customer.statementCycleId, Equal <Current <PaymentFilter.statementCycleId> >, Or <Current <PaymentFilter.statementCycleId>, IsNull> >, And2 <Where <PaymentMethod.paymentMethodID, Equal <Current <PaymentFilter.paymentMethodID> >, Or <Current <PaymentFilter.paymentMethodID>, IsNull> >, And <Match <Customer, Current <AccessInfo.userName> > > > > > > > > > >, OrderBy <Asc <ARPaymentInfo.refNbr> > > .Select(this)) { ARPaymentInfo doc = (ARPaymentInfo)it; CustomerPaymentMethod cpm = (CustomerPaymentMethod)it; CCProcessingCenterPmntMethod pcpm = (CCProcessingCenterPmntMethod)it; if (!string.IsNullOrEmpty(this.Filter.Current.ProcessingCenterID) && (this.Filter.Current.ProcessingCenterID != pcpm.ProcessingCenterID)) { continue; } ARDocKey key = new ARDocKey(doc); if (Filter.Current == null || Filter.Current.CustomerID == null || object.Equals(Filter.Current.CustomerID, doc.CustomerID)) { if (cpm?.PMInstanceID != null) { doc.PMInstanceDescr = cpm.Descr; doc.PaymentMethodID = cpm.PaymentMethodID; doc.IsCCExpired = (cpm.ExpirationDate < now); } doc.ProcessingCenterID = (pcpm != null) ? pcpm.ProcessingCenterID : string.Empty; ExternalTransactionState paymentState = ExternalTranHelper.GetActiveTransactionState(this, tranSelect.Select(doc.DocType, doc.RefNbr).RowCast <ExternalTransaction>()); ExternalTransaction lastTran = (ExternalTransaction)paymentState.ExternalTransaction; doc.CCPaymentStateDescr = paymentState.Description; int?tranId = paymentState?.ExternalTransaction?.TransactionID; if (paymentState.HasErrors && tranId != null) { string errText = tranRepo.GetCCProcTranByTranID(tranId).OrderByDescending(i => i.TranNbr).Select(i => i.ErrorText).FirstOrDefault(); doc.CCTranDescr = errText; } if (doc.IsCCExpired == true && string.IsNullOrEmpty(doc.CCTranDescr)) { doc.CCTranDescr = Messages.CreditCardIsExpired; } if (doc.PMInstanceID == PaymentTranExtConstants.NewPaymentProfile && paymentState.IsOpenForReview) { yield return(doc); } if (doc.PMInstanceID != PaymentTranExtConstants.NewPaymentProfile && (!paymentState.IsCaptured || (paymentState.IsCaptured && paymentState.IsOpenForReview))) { yield return(doc); } } } }