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)); });
}
