/// <summary>
/// Initialize the application
/// </summary>
/// <param name="initializationInformation"></param>
private void Initialize(IInitializationInformation initializationInformation)
{
Application = new Application(initializationInformation);
InternalTransaction = new InternalTransaction(initializationInformation);
ExternalTransaction = new ExternalTransaction(initializationInformation);
RelationalDatabase = new RelationalDatabase(initializationInformation);
}
public static bool HasTransactions(PXGraph graph, int?pmInstanceId)
{
ExternalTransaction tran = PXSelect <ExternalTransaction,
Where <ExternalTransaction.pMInstanceID, Equal <Required <ExternalTransaction.pMInstanceID> > > >
.SelectWindowed(graph, 0, 1, pmInstanceId);
return(tran != null);
}
private void UpdateParentTransaction(ExternalTransaction extTran, CCProcTran procTran)
{
if (procTran.TranType == CCTranTypeCode.Credit && extTran.ParentTranID != null && extTran.Active.GetValueOrDefault())
{
ExternalTransaction parentExtTran = _externalTran.GetExternalTransaction(extTran.ParentTranID);
if (extTran.DocType == parentExtTran.DocType && extTran.RefNbr == parentExtTran.RefNbr &&
extTran.OrigDocType == parentExtTran.OrigDocType && extTran.OrigRefNbr == parentExtTran.OrigRefNbr)
{
parentExtTran.Active = false;
_externalTran.UpdateExternalTransaction(parentExtTran);
}
}
}
public CCProcTran UpdateTransaction(CCProcTran procTran)
{
if (procTran.TransactionID.GetValueOrDefault() == 0)
{
throw new ArgumentNullException(nameof(procTran.TransactionID));
}
using (var scope = new PXTransactionScope())
{
ExternalTransaction extTran = _externalTran.GetExternalTransaction(procTran.TransactionID);
if (extTran == null)
{
throw new Exception($"Could not find External transaction record by TransactionID = {procTran.TransactionID}");
}
if (procTran.ProcStatus != CCProcStatus.Opened)
{
if (procTran.AuthNumber != null)
{
extTran.AuthNumber = procTran.AuthNumber;
}
if (procTran.ExpirationDate != null)
{
extTran.ExpirationDate = procTran.ExpirationDate;
}
if (procTran.CVVVerificationStatus != null)
{
extTran.CVVVerification = procTran.CVVVerificationStatus;
}
if (procTran.PCTranNumber != null)
{
extTran.TranNumber = procTran.PCTranNumber;
}
if (procTran.Amount != null)
{
extTran.Amount = procTran.Amount;
}
extTran.PMInstanceID = procTran.PMInstanceID;
extTran.ProcessingStatus = ExtTransactionProcStatusCode.GetStatusByTranStatusTranType(procTran.TranStatus, procTran.TranType);
extTran.LastActivityDate = procTran.EndTime;
extTran.Active = CCProcTranHelper.IsActiveTran(procTran);
extTran.Completed = CCProcTranHelper.IsCompletedTran(procTran);
_externalTran.UpdateExternalTransaction(extTran);
UpdateParentTransaction(extTran, procTran);
}
procTran = _cctranRepository.UpdateCCProcTran(procTran);
Save();
scope.Complete();
return(procTran);
}
}
public CCProcTran InsertTransaction(CCProcTran procTran)
{
using (var scope = new PXTransactionScope())
{
ExternalTransaction extTran = new ExternalTransaction();
extTran.DocType = procTran.DocType;
extTran.RefNbr = procTran.RefNbr;
extTran.OrigDocType = procTran.OrigDocType;
extTran.OrigRefNbr = procTran.OrigRefNbr;
extTran.Amount = procTran.Amount;
extTran.Direction = ExternalTransaction.TransactionDirection.Debet;
extTran.PMInstanceID = procTran.PMInstanceID;
extTran.CVVVerification = procTran.CVVVerificationStatus;
extTran.ExpirationDate = procTran.ExpirationDate;
if (procTran.TranType == CCTranTypeCode.Credit)
{
extTran.Direction = ExternalTransaction.TransactionDirection.Credit;
if (procTran.RefTranNbr != null)
{
CCProcTran refProcTran = _cctranRepository.GetCCProcTran(procTran.RefTranNbr);
extTran.ParentTranID = refProcTran.TransactionID;
}
}
if (procTran.ProcStatus == CCProcStatus.Opened)
{
extTran.ProcessingStatus = ExtTransactionProcStatusCode.Unknown;
}
else
{
extTran.ProcessingStatus = ExtTransactionProcStatusCode.GetStatusByTranStatusTranType(procTran.TranStatus, procTran.TranType);
extTran.Active = CCProcTranHelper.IsActiveTran(procTran);
extTran.Completed = CCProcTranHelper.IsCompletedTran(procTran);
extTran.TranNumber = procTran.PCTranNumber;
extTran.AuthNumber = procTran.AuthNumber;
extTran.ExpirationDate = procTran.ExpirationDate;
extTran.LastActivityDate = procTran.EndTime;
}
extTran = _externalTran.InsertExternalTransaction(extTran);
UpdateParentTransaction(extTran, procTran);
procTran.TransactionID = extTran.TransactionID;
procTran = _cctranRepository.InsertCCProcTran(procTran);
Save();
scope.Complete();
return(procTran);
}
}
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 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);
}
}
}
}
public ExternalTransaction UpdateExternalTransaction(ExternalTransaction extTran)
{
return(graph.Caches[typeof(ExternalTransaction)].Update(extTran) as ExternalTransaction);
}
public ExternalTransaction InsertExternalTransaction(ExternalTransaction extTran)
{
return(graph.Caches[typeof(ExternalTransaction)].Insert(extTran) as ExternalTransaction);
}
