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 static IExternalTransaction GetActiveTransaction(IEnumerable <IExternalTransaction> extTrans) { extTrans = extTrans.OrderByDescending(i => i.TransactionID); IExternalTransaction extTran = extTrans.Where(i => i.Active == true).FirstOrDefault(); return(extTran); }
private void CheckPaymentTransaction(TPrimary doc) { if (!IsFeatureSupported(SelectedProcessingCenter, CCProcessingFeature.TransactionGetter)) { return; } ICCPayment pDoc = GetPaymentDoc(doc); IEnumerable <V2.TransactionData> trans = null; if (LockExists(doc)) { retryUnsettledTran.HandleError(i => GetTransByDoc(pDoc, i).Count > 0 ? true : false); try { trans = retryUnsettledTran.Execute(() => GetPaymentProcessing().GetUnsettledTransactions(SelectedProcessingCenter)); } catch (InvalidOperationException) { } } if (trans != null) { IEnumerable <string> result = PrepeareTransactionIds(GetTransByDoc(pDoc, trans)); SyncPaymentTransactionById(doc, result); } ClearTransactionСaches(); IExternalTransaction tran = ExternalTranHelper.GetActiveTransaction(GetExtTrans()); if (tran != null) { TranStatusChanged(pDoc, tran.TransactionID); } }
private void CheckInput(ICCPayment doc, IExternalTransaction tran) { if (doc == null) { throw new ArgumentNullException(nameof(doc)); } }
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 void CheckPaymentTranForceSync(TPrimary doc) { CheckPaymentTransaction(doc); IExternalTransaction storedTran = GetExtTrans().FirstOrDefault(); bool needSyncUnsettled = false; if (storedTran != null && ExternalTranHelper.GetTransactionState(Base, storedTran).IsActive) { SyncPaymentTransactionById(doc, new List <string>() { storedTran.TranNumber }); ClearTransactionСaches(); storedTran = GetExtTrans().FirstOrDefault(); if (storedTran?.Active == false) { needSyncUnsettled = true; } } else { needSyncUnsettled = true; } if (needSyncUnsettled) { ICCPayment pDoc = GetPaymentDoc(doc); IEnumerable <V2.TransactionData> trans = GetPaymentProcessing().GetUnsettledTransactions(SelectedProcessingCenter); IEnumerable <string> result = PrepeareTransactionIds(GetTransByDoc(pDoc, trans)); SyncPaymentTransactionById(doc, result); } }
private void SetProps(IExternalTransaction extTran) { ProcessingStatus = ExtTransactionProcStatusCode.GetProcessingStatusByProcStatusStr(extTran.ProcessingStatus); IsActive = extTran.Active.GetValueOrDefault(); IsCompleted = extTran.Completed.GetValueOrDefault(); IsVoided = ProcessingStatus == ProcessingStatus.VoidSuccess || ProcessingStatus == ProcessingStatus.VoidHeldForReview; IsCaptured = ProcessingStatus == ProcessingStatus.CaptureSuccess || ProcessingStatus == ProcessingStatus.CaptureHeldForReview; IsPreAuthorized = ProcessingStatus == ProcessingStatus.AuthorizeSuccess || ProcessingStatus == ProcessingStatus.AuthorizeHeldForReview; IsRefunded = ProcessingStatus == ProcessingStatus.CreditSuccess || ProcessingStatus == ProcessingStatus.CreditHeldForReview; IsUnknown = ProcessingStatus == ProcessingStatus.Unknown; IsOpenForReview = ProcessingStatus == ProcessingStatus.AuthorizeHeldForReview || ProcessingStatus == ProcessingStatus.CaptureHeldForReview || ProcessingStatus == ProcessingStatus.AuthorizeHeldForReview || ProcessingStatus == ProcessingStatus.VoidHeldForReview || ProcessingStatus == ProcessingStatus.CreditHeldForReview; IsDeclined = ProcessingStatus == ProcessingStatus.AuthorizeDecline || ProcessingStatus == ProcessingStatus.CaptureDecline || ProcessingStatus == ProcessingStatus.VoidDecline || ProcessingStatus == ProcessingStatus.CreditDecline; HasErrors = ProcessingStatus == ProcessingStatus.AuthorizeFail || ProcessingStatus == ProcessingStatus.CaptureFail || ProcessingStatus == ProcessingStatus.VoidFail || ProcessingStatus == ProcessingStatus.CreditFail; }
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); } }); }
public static bool HasSuccessfulTrans(PXSelectBase <ExternalTransaction> extTrans) { IExternalTransaction extTran = GetActiveTransaction(extTrans); if (extTran != null && !IsExpired(extTran)) { return(true); } return(false); }
public static bool HasOpenCCProcTran(PXGraph graph, IExternalTransaction extTran) { if (graph == null) { throw new ArgumentNullException(nameof(graph)); } if (extTran == null) { return(false); } CCProcTranRepository repo = new CCProcTranRepository(graph); var records = repo.GetCCProcTranByTranID(extTran.TransactionID); return(CCProcTranHelper.HasOpenCCTran(records)); }
public static bool HasVoidPreAuthorizedInHistory(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); var history = repo.GetCCProcTranByTranID(extTran.TransactionID); return(CCProcTranHelper.HasVoidPreAuthorized(history)); }
public void ProcessCredit(ICCPayment doc, IExternalTransaction tran) { CheckInput(doc, tran); Process(() => { TranOperationResult opRes = null; if (tran.TransactionID.HasValue) { opRes = _processingClass.Credit(doc, tran.TransactionID.Value); } else { opRes = _processingClass.Credit(doc, tran.TranNumber); } return(opRes); }); }
public void CaptureOnlyCCPayment(InputPaymentInfo paymentInfo, ICCPayment doc, IExternalTransactionAdapter paymentTransaction) { if (doc == null || doc.CuryDocBal == null) { return; } IExternalTransaction extTran = ExternalTranHelper.GetActiveTransaction(paymentTransaction.Select()); if (ExternalTranHelper.HasOpenCCProcTran(graph, extTran)) { throw new PXException(Messages.ERR_CCTransactionCurrentlyInProgress); } if (string.IsNullOrEmpty(paymentInfo.AuthNumber)) { throw new PXException(Messages.ERR_CCExternalAuthorizationNumberIsRequiredForCaptureOnlyTrans); } 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 { IExternalTransaction tran = new ExternalTransaction(); tran.AuthNumber = paymentInfo.AuthNumber; TransactionProcessor.ProcessCaptureOnly(toProc, tran); } catch { success = false; throw; } finally { RunCallbacks((IBqlTable)toProc, CCTranType.CaptureOnly, success); } }); }
public bool TranStatusChanged(ICCPayment doc, int?tranId) { bool ret = false; IExternalTransaction storedExtTran = GetExtTrans().Where(i => i.TransactionID == tranId).FirstOrDefault(); CustomerPaymentMethod cpm = GetPaymentProcessing().Repository.GetCustomerPaymentMethod(doc.PMInstanceID); string procCenter = cpm?.CCProcessingCenterID; if (storedExtTran != null && procCenter != null) { bool supported = IsFeatureSupported(procCenter, CCProcessingFeature.TransactionGetter); if (supported) { V2.TransactionData tranData = GetPaymentProcessing().GetTransactionById(storedExtTran.TranNumber, cpm.CCProcessingCenterID); SelectedProcessingCenter = procCenter; string newProcStatus = GetProcessingStatus(tranData); if (storedExtTran.ProcessingStatus != newProcStatus) { if (tranData.TranType == V2.CCTranType.AuthorizeOnly) { RecordTran(doc, tranData, RecordAuth); ret = true; } if (tranData.TranType == V2.CCTranType.PriorAuthorizedCapture) { RecordTran(doc, tranData, RecordCapture); ret = true; } if (tranData.TranType == V2.CCTranType.AuthorizeAndCapture) { RecordTran(doc, tranData, RecordCapture); ret = true; } if (tranData.TranType == V2.CCTranType.Void) { RecordTran(doc, tranData, RecordVoid); ret = true; } } } } return(ret); }
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 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 virtual IEnumerable ValidateCCPayment(PXAdapter adapter) { string methodName = GetClassMethodName(); PXTrace.WriteInformation($"{methodName} started."); List <TPrimary> list = new List <TPrimary>(); foreach (TPrimary doc in adapter.Get <TPrimary>()) { list.Add(doc); ICCPayment pDoc = GetPaymentDoc(doc); PXLongOperation.StartOperation(Base, delegate { IExternalTransaction tran = ExternalTranHelper.GetActiveTransaction(GetExtTrans()); if (tran != null) { TranStatusChanged(pDoc, tran.TransactionID); } }); } return(list); }
public void CreditCCPayment(ICCPayment doc, IExternalTransactionAdapter paymentTransaction) { if (doc == null || doc.CuryDocBal == null) { return; } IExternalTransaction extTran = ExternalTranHelper.GetActiveTransaction(paymentTransaction.Select()); if (ExternalTranHelper.HasOpenCCProcTran(graph, extTran)) { throw new PXException(Messages.ERR_CCTransactionCurrentlyInProgress); } 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 { IExternalTransaction tran = new ExternalTransaction(); tran.TranNumber = doc.RefTranExtNbr; TransactionProcessor.ProcessCredit(toProc, tran); } catch { success = false; throw; } finally { RunCallbacks((IBqlTable)doc, CCTranType.VoidOrCredit, success); } }); }
public void ProcessCaptureOnly(ICCPayment doc, IExternalTransaction tran) { CheckInput(doc, tran); Process(() => { return(_processingClass.CaptureOnly(doc, tran.AuthNumber)); }); }
public void ProcessVoidOrCredit(ICCPayment doc, IExternalTransaction tran) { CheckInput(doc, tran); Process(() => { return(_processingClass.VoidOrCredit(doc.PMInstanceID, tran.TransactionID)); }); }
public static bool IsExpired(IExternalTransaction extTran) { return((extTran.ExpirationDate.HasValue && extTran.ExpirationDate.Value < PXTimeZoneInfo.Now) || extTran.ProcessingStatus == ExtTransactionProcStatusCode.AuthorizeExpired); }
public void ProcessAuthorizeCapture(ICCPayment doc, IExternalTransaction tran) { CheckInput(doc, tran); Process(() => { return(_processingClass.Authorize(doc, true)); }); }
public ExternalTransactionState(IExternalTransaction extTran) { ExternalTransaction = extTran; SetProps(extTran); }
public static void ValidateCCPayment(PXGraph graph, List <IExternalTransaction> list, bool isMassProcess) { bool failed = false; ARCashSaleEntry arCashSaleGraph = null; ARPaymentEntry arPaymentGraph = null; SOInvoiceEntry soInvoiceGraph = null; for (int i = 0; i < list.Count; i++) { if (list[i] == null) { continue; } if ((i % 100) == 0) { if (arCashSaleGraph != null) { arCashSaleGraph.Clear(); } if (arPaymentGraph != null) { arPaymentGraph.Clear(); } if (soInvoiceGraph != null) { soInvoiceGraph.Clear(); } } IExternalTransaction tran = list[i]; var resultSet = PXSelectJoin <Standalone.ARRegister, LeftJoin <ARPayment, On <ARPayment.refNbr, Equal <Standalone.ARRegister.refNbr>, And <ARPayment.docType, Equal <Standalone.ARRegister.docType> > >, LeftJoin <ARInvoice, On <ARInvoice.refNbr, Equal <Standalone.ARRegister.refNbr>, And <ARInvoice.docType, Equal <Standalone.ARRegister.docType> > >, LeftJoin <SOInvoice, On <SOInvoice.refNbr, Equal <Standalone.ARRegister.refNbr>, And <SOInvoice.docType, Equal <Standalone.ARRegister.docType> > >, LeftJoin <Standalone.ARCashSale, On <Standalone.ARCashSale.refNbr, Equal <Standalone.ARRegister.refNbr>, And <Standalone.ARCashSale.docType, Equal <Standalone.ARRegister.docType> > > > > > >, Where <Standalone.ARRegister.refNbr, Equal <Required <Standalone.ARRegister.refNbr> >, And <Standalone.ARRegister.docType, Equal <Required <Standalone.ARRegister.docType> > > > > .SelectSingleBound(graph, null, tran.RefNbr, tran.DocType); foreach (PXResult <Standalone.ARRegister, ARPayment, ARInvoice, SOInvoice, Standalone.ARCashSale> arDoc in resultSet) { if (arDoc == null) { continue; } try { if ((ARInvoice)arDoc is ARInvoice arInvoice && arInvoice != null && arInvoice.RefNbr != null) { if ((SOInvoice)arDoc is SOInvoice soInvoice && soInvoice != null && soInvoice.RefNbr != null) { soInvoiceGraph = soInvoiceGraph != null ? soInvoiceGraph : PXGraph.CreateInstance <SOInvoiceEntry>(); SOInvoiceEntry.PaymentTransaction ext = soInvoiceGraph.GetExtension <SOInvoiceEntry.PaymentTransaction>(); soInvoiceGraph.Document.Current = arInvoice; soInvoiceGraph.SODocument.Current = soInvoice; if (ext.CanValidate(arInvoice)) { ext.validateCCPayment.Press(); } } else if ((Standalone.ARCashSale)arDoc is Standalone.ARCashSale arCashSale && arCashSale != null && arCashSale.RefNbr != null) { arCashSaleGraph = arCashSaleGraph != null ? arCashSaleGraph : PXGraph.CreateInstance <ARCashSaleEntry>(); ARCashSaleEntry.PaymentTransaction ext = arCashSaleGraph.GetExtension <ARCashSaleEntry.PaymentTransaction>(); arCashSaleGraph.Document.Current = arCashSale; if (ext.CanValidate(arCashSaleGraph.Document.Current)) { ext.validateCCPayment.Press(); } } }
public void ProcessPriorAuthorizedCapture(ICCPayment doc, IExternalTransaction tran) { CheckInput(doc, tran); Process(() => { return(_processingClass.Capture(doc, tran.TransactionID)); }); }