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);
}
}
public ExternalTransactionState GetActiveTransactionState()
{
var trans = GetExtTrans();
var ret = ExternalTranHelper.GetActiveTransactionState(Base, trans);
return(ret);
}
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);
}
}
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 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 string GetLastTransactionDescription()
{
string ret = null;
var tran = GetExtTrans().FirstOrDefault();
if (tran != null)
{
if (!ExternalTranHelper.HasVoidPreAuthorizedInHistory(Base, tran))
{
ret = ExternalTranHelper.GetTransactionState(Base, tran).Description;
}
}
return(ret);
}
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 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 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 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 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);
}
}
}
}
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);
}
}
}
}
