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