public virtual bool Authorize(ICCPayment aPmtInfo, bool aCapture, ref int aTranNbr)
{
Customer customer;
CustomerPaymentMethod pmInstance = this.findPMInstance(aPmtInfo.PMInstanceID, out customer);
if (pmInstance == null)
{
throw new PXException(Messages.CreditCardWithID_0_IsNotDefined, aPmtInfo.PMInstanceID);
}
CCProcessingCenter procCenter = _repository.FindProcessingCenter(pmInstance.PMInstanceID, null);
if (procCenter == null)
{
throw new PXException(Messages.ERR_CCProcessingCenterIsNotSpecified, pmInstance.Descr);
}
if (!(procCenter.IsActive ?? false))
{
throw new PXException(Messages.ERR_CCProcessingIsInactive, procCenter.ProcessingCenterID);
}
if (!IsValidForProcessing(pmInstance, customer))
{
return(false);
}
CCTranType tranType = aCapture ? CCTranType.AuthorizeAndCapture : CCTranType.AuthorizeOnly;
CCProcTran tran = new CCProcTran();
tran.Copy(aPmtInfo);
return(this.DoTransaction(ref aTranNbr, tranType, tran, null, customer.AcctCD, procCenter));
}
protected virtual bool HasTransactions(CCProcessingCenter aRow)
{
CCProcTran tran = PXSelect <CCProcTran, Where <CCProcTran.processingCenterID, Equal <Required <CCProcTran.processingCenterID> > >, OrderBy <Desc <CCProcTran.tranNbr> > >
.SelectWindowed(this, 0, 1, aRow.ProcessingCenterID);
return(tran != null);
}
protected virtual void RecordTransaction(ref int?aTranNbr, CCTranType aTranType, CCProcTran aTran, CCProcessingCenter aProcCenter)
{
//Add later - use ProcessCenter to fill ExpirationDate
aTran.ProcessingCenterID = aProcCenter.ProcessingCenterID;
aTran.TranType = CCTranTypeCode.GetTypeCode(aTranType);
aTran.CVVVerificationStatus = CVVVerificationStatusCode.RelyOnPriorVerification;
bool cvvVerified = false;
bool needCvvVerification = isCvvVerificationRequired(aTranType);
if (needCvvVerification)
{
bool isStored;
CCProcTran verifyTran = this.findCVVVerifyingTran(aTran.PMInstanceID, out isStored);
if (verifyTran != null)
{
cvvVerified = true;
}
if (!cvvVerified)
{
aTran.CVVVerificationStatus = CVVVerificationStatusCode.NotVerified;
}
}
aTran.TranNbr = null;
aTran.StartTime = aTran.EndTime = PXTimeZoneInfo.Now;
if (aTranType != CCTranType.AuthorizeOnly)
{
aTran.ExpirationDate = null;
}
aTran.TranStatus = CCTranStatusCode.Approved;
aTran.ProcStatus = CCProcStatus.Finalized;
aTran = _repository.InsertCCProcTran(aTran);
_repository.Save();
aTranNbr = aTran.TranNbr;
}
public virtual bool CaptureOnly(ICCPayment aPmtInfo, string aAuthorizationNbr, ref int aTranNbr)
{
Customer customer;
CustomerPaymentMethod pmInstance = this.findPMInstance(aPmtInfo.PMInstanceID, out customer);
if (string.IsNullOrEmpty(aAuthorizationNbr))
{
throw new PXException(Messages.ERR_CCExternalAuthorizationNumberIsRequiredForCaptureOnlyTrans, aAuthorizationNbr);
}
CCProcessingCenter procCenter = _repository.GetCCProcessingCenter(pmInstance.CCProcessingCenterID);
if (procCenter == null)
{
throw new PXException(Messages.ERR_CCProcessingCenterUsedForAuthIsNotValid, pmInstance.CCProcessingCenterID, aTranNbr);
}
if (!(procCenter.IsActive ?? false))
{
throw new PXException(Messages.ERR_CCProcessingCenterUsedForAuthIsNotActive, procCenter, aTranNbr);
}
if (!IsCCValidForProcessing(aPmtInfo.PMInstanceID))
{
return(false);
}
CCProcTran tran = new CCProcTran();
tran.Copy(aPmtInfo);
CCProcTran refTran = new CCProcTran {
AuthNumber = aAuthorizationNbr
};
return(this.DoTransaction(ref aTranNbr, CCTranType.CaptureOnly, tran, refTran, customer.AcctCD, procCenter));
}
public virtual bool Credit(ICCPayment aPmtInfo, string aExtRefTranNbr, ref int aTranNbr)
{
if (!IsCCValidForProcessing(aPmtInfo.PMInstanceID))
{
return(false);
}
Customer customer;
CustomerPaymentMethod pmInstance = this.findPMInstance(aPmtInfo.PMInstanceID, out customer);
CCProcTran refTran = _repository.FindReferencedCCProcTran(aPmtInfo.PMInstanceID, aExtRefTranNbr);
if (refTran != null)
{
return(Credit(aPmtInfo, refTran.TranNbr.Value, ref aTranNbr));
}
else
{
CCProcTran tran = new CCProcTran();
tran.Copy(aPmtInfo);
tran.RefTranNbr = null;
tran.RefPCTranNumber = aExtRefTranNbr;
refTran = new CCProcTran();
refTran.PCTranNumber = aExtRefTranNbr;
return(this.DoTransaction(ref aTranNbr, CCTranType.Credit, tran, refTran, customer.AcctCD, null));
}
}
public static void VoidCCPayment <TNode>(TNode doc,
PXSelectBase <CCProcTran> ccProcTran,
CCPaymentEntry.ReleaseDelegate aReleaseDelegate,
UpdateDocStateDelegate aDocStateUpdater,
ICCTransactionsProcessor processor = null)
where TNode : class, IBqlTable, ICCPayment, new()
{
if (processor == null)
{
processor = CCTransactionsProcessor.GetCCTransactionsProcessor();
}
if (doc != null && doc.PMInstanceID != null && doc.CuryDocBal != null)
{
if (CCProcTranHelper.HasOpenCCTran(ccProcTran))
{
throw new PXException(Messages.ERR_CCTransactionCurrentlyInProgress);
}
CCProcTran toVoid = CCProcTranHelper.FindCCLastSuccessfulTran(ccProcTran);
if (toVoid == null)
{
throw new PXException(Messages.ERR_CCNoTransactionToVoid);
}
else if (toVoid.TranType == CCTranTypeCode.VoidTran || toVoid.TranType == CCTranTypeCode.Credit)
{
throw new PXException(Messages.ERR_CCTransactionOfThisTypeInvalidToVoid);
}
if (CCProcTranHelper.IsExpired(toVoid))
{
throw new PXException(Messages.TransactionHasExpired);
}
if (doc.Released == false)
{
ccProcTran.View.Graph.Actions.PressSave();
}
TNode toProc = PXCache <TNode> .CreateCopy(doc);
PXLongOperation.StartOperation(ccProcTran.View.Graph, delegate()
{
try
{
processor.ProcessCCTransaction(toProc, toVoid, CCTranType.VoidOrCredit);
}
finally
{
if (aDocStateUpdater != null)
{
aDocStateUpdater(doc, CCTranType.VoidOrCredit);
}
}
if (aReleaseDelegate != null)
{
aReleaseDelegate(toProc);
}
});
}
}
public virtual bool Credit(int?aPMInstanceID, int?aRefTranNbr, string aCuryID, decimal?aAmount, ref int aTranNbr)
{
CCProcTran authTran = _repository.GetCCProcTran(aRefTranNbr);
Customer customer;
CustomerPaymentMethod pmInstance = this.findPMInstance(aPMInstanceID, out customer);
if (authTran == null)
{
throw new PXException(Messages.ERR_CCTransactionToCreditIsNotFound, aRefTranNbr);
}
if (!MayBeCredited(authTran))
{
throw new PXException(Messages.ERR_CCProcessingTransactionMayNotBeCredited, authTran.TranType);
}
if (!IsAuthorized(authTran))
{
throw new PXException(Messages.ERR_CCProcessingReferensedTransactionNotAuthorized, aRefTranNbr);
}
if (!IsCCValidForProcessing(aPMInstanceID))
{
return(false);
}
CCProcessingCenter procCenter = _repository.GetCCProcessingCenter(authTran.ProcessingCenterID);
if (procCenter == null)
{
throw new PXException(Messages.ERR_CCProcessingCenterUsedInReferencedTranNotFound, authTran.ProcessingCenterID, aRefTranNbr);
}
if (!(procCenter.IsActive ?? false))
{
throw new PXException(Messages.ERR_CCProcessingCenterUsedInReferencedTranNotActive, authTran.ProcessingCenterID, aRefTranNbr);
}
CCProcTran tran = new CCProcTran
{
PMInstanceID = aPMInstanceID,
DocType = authTran.DocType,
RefNbr = authTran.RefNbr,
OrigDocType = authTran.OrigDocType,
OrigRefNbr = authTran.OrigRefNbr,
RefTranNbr = authTran.TranNbr
};
if (aAmount.HasValue)
{
tran.CuryID = aCuryID;
tran.Amount = aAmount;
}
else
{
tran.CuryID = authTran.CuryID;
tran.Amount = authTran.Amount;
}
return(this.DoTransaction(ref aTranNbr, CCTranType.Credit, tran, authTran, customer.AcctCD, procCenter));
}
protected static void FillRecordedTran(CCProcTran aTran, string aReasonText = Messages.ImportedExternalCCTransaction)
{
aTran.PCResponseReasonText = aReasonText;
aTran.TranNbr = null;
aTran.StartTime = aTran.EndTime = PXTimeZoneInfo.Now;
aTran.ExpirationDate = null;
aTran.TranStatus = CCTranStatusCode.Approved;
aTran.ProcStatus = CCProcStatus.Finalized;
}
public static void CaptureCCPayment <TNode>(TNode doc, PXSelectBase <CCProcTran> ccProcTran,
CCPaymentEntry.ReleaseDelegate aReleaseDelegate,
UpdateDocStateDelegate aDocStateUpdater,
ICCTransactionsProcessor processor = null)
where TNode : class, IBqlTable, ICCPayment, new()
{
if (processor == null)
{
processor = CCTransactionsProcessor.GetCCTransactionsProcessor();
}
if (doc != null && doc.PMInstanceID != null && doc.CuryDocBal != null)
{
if (CCProcTranHelper.HasOpenCCTran(ccProcTran))
{
throw new PXException(Messages.ERR_CCTransactionCurrentlyInProgress);
}
CCPaymentState paymentState = CCProcTranHelper.ResolveCCPaymentState(ccProcTran.Select());
if ((paymentState & (CCPaymentState.Captured)) > 0)
{
throw new PXException(Messages.ERR_CCAuthorizedPaymentAlreadyCaptured);
}
if (doc.Released == false)
{
ccProcTran.View.Graph.Actions.PressSave();
}
CCProcTran authTran = CCProcTranHelper.FindCCPreAthorizing(ccProcTran.Select());
TNode toProc = PXCache <TNode> .CreateCopy(doc);
CCProcTran authTranCopy = null;
if (authTran != null && !CCProcTranHelper.IsExpired(authTran))
{
authTranCopy = PXCache <CCProcTran> .CreateCopy(authTran);
}
CCTranType operation = (authTranCopy) != null ? CCTranType.PriorAuthorizedCapture : CCTranType.AuthorizeAndCapture;
PXLongOperation.StartOperation(ccProcTran.View.Graph, delegate()
{
try
{
processor.ProcessCCTransaction(toProc, authTranCopy, operation);
}
finally
{
//Update doc state in any case
if (aDocStateUpdater != null)
{
aDocStateUpdater(doc, operation);
}
}
if (aReleaseDelegate != null)
{
aReleaseDelegate(toProc); //On Success Only
}
});
}
}
public static void Copy(ProcessingInput aDst, CCProcTran aSrc)
{
aDst.TranID = aSrc.TranNbr.Value;
aDst.PMInstanceID = aSrc.PMInstanceID.Value;
bool useOrigDoc = String.IsNullOrEmpty(aSrc.DocType);
aDst.DocType = useOrigDoc ? aSrc.OrigDocType : aSrc.DocType;
aDst.DocRefNbr = useOrigDoc ? aSrc.OrigRefNbr : aSrc.RefNbr;
aDst.Amount = aSrc.Amount.Value;
}
public static bool HasSuccessfulCCTrans(PXSelectBase <CCProcTran> ccProcTran)
{
CCProcTran lastSTran = findCCLastSuccessfulTran(ccProcTran);
if (lastSTran != null && !IsExpired(lastSTran))
{
return(true);
}
return(false);
}
public static void RecordCCPayment <TNode>(TNode doc, string aExtPCTranNbr, string aPCAuthNbr, PXSelectBase <CCProcTran> ccProcTran, CCPaymentEntry.ReleaseDelegate aReleaseDelegate, UpdateDocStateDelegate aDocStateUpdater)
where TNode : class, IBqlTable, ICCPayment, new()
{
if (doc != null && doc.PMInstanceID != null && doc.CuryDocBal != null)
{
if (CCProcTranHelper.HasOpenCCTran(ccProcTran))
{
throw new PXException(Messages.ERR_CCTransactionCurrentlyInProgress);
}
if (string.IsNullOrEmpty(aExtPCTranNbr))
{
throw new PXException(Messages.ERR_PCTransactionNumberOfTheOriginalPaymentIsRequired);
}
CCPaymentState paymentState = CCProcTranHelper.ResolveCCPaymentState(ccProcTran.Select());
if ((paymentState & (CCPaymentState.Captured)) > 0)
{
throw new PXException(Messages.ERR_CCAuthorizedPaymentAlreadyCaptured);
}
if (doc.Released == false)
{
ccProcTran.View.Graph.Actions.PressSave();
}
TNode toProc = PXCache <TNode> .CreateCopy(doc);
CCProcTran authTran = CCProcTranHelper.FindCCPreAthorizing(ccProcTran.Select());
CCTranType operation = CCTranType.AuthorizeAndCapture;
PXLongOperation.StartOperation(ccProcTran.View.Graph, delegate()
{
try
{
var graph = PXGraph.CreateInstance <CCPaymentProcessingGraph>();
int?tranID = 0;
string extTranID = aExtPCTranNbr;
graph.RecordCapture(doc, extTranID, aPCAuthNbr, null, ref tranID);
}
finally
{
//Update doc state in any case
if (aDocStateUpdater != null)
{
aDocStateUpdater(doc, operation);
}
}
if (aReleaseDelegate != null)
{
aReleaseDelegate(toProc); //On Success Only
}
});
}
}
public static bool MayBeCredited(CCProcTran aOrigTran)
{
switch (aOrigTran.TranType)
{
case CCTranTypeCode.AuthorizeAndCapture:
case CCTranTypeCode.PriorAuthorizedCapture:
case CCTranTypeCode.CaptureOnly:
return(true);
}
return(false);
}
protected virtual CCProcTran StartTransaction(CCProcTran aTran, int?aAutoExpTimeout)
{
aTran.TranNbr = null;
aTran.StartTime = PXTimeZoneInfo.Now;
if (aAutoExpTimeout.HasValue)
{
aTran.ExpirationDate = aTran.StartTime.Value.AddSeconds(aAutoExpTimeout.Value);
}
aTran = _repository.InsertCCProcTran(aTran);
_repository.Save();
return(aTran);
}
public static bool IsCompletedTran(CCProcTran procTran)
{
bool ret = false;
if (procTran.TranStatus == CCTranStatusCode.Approved &&
(procTran.TranType == CCTranTypeCode.AuthorizeAndCapture || procTran.TranType == CCTranTypeCode.CaptureOnly ||
procTran.TranType == CCTranTypeCode.PriorAuthorizedCapture || procTran.TranType == CCTranTypeCode.Credit))
{
ret = true;
}
return(ret);
}
public virtual bool VoidOrCredit(int?aPMInstanceID, int?aRefTranNbr, ref int aTranNbr)
{
if (!this.Void(aPMInstanceID, aRefTranNbr, ref aTranNbr))
{
CCProcTran refTRan = _repository.GetCCProcTran(aRefTranNbr);
if (MayBeCredited(refTRan))
{
return(this.Credit(aPMInstanceID, aRefTranNbr, null, null, ref aTranNbr));
}
}
return(true);
}
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 static void CaptureOnlyCCPayment <TNode>(TNode doc,
string aAuthorizationNbr,
PXSelectBase <CCProcTran> ccProcTran,
CCPaymentEntry.ReleaseDelegate aReleaseDelegate,
UpdateDocStateDelegate aDocStateUpdater,
ICCTransactionsProcessor processor = null)
where TNode : class, IBqlTable, ICCPayment, new()
{
if (processor == null)
{
processor = CCTransactionsProcessor.GetCCTransactionsProcessor();
}
if (doc != null && doc.PMInstanceID != null && doc.CuryDocBal != null)
{
if (CCProcTranHelper.HasOpenCCTran(ccProcTran))
{
throw new PXException(Messages.ERR_CCTransactionCurrentlyInProgress);
}
if (string.IsNullOrEmpty(aAuthorizationNbr))
{
throw new PXException(Messages.ERR_CCExternalAuthorizationNumberIsRequiredForCaptureOnlyTrans);
}
if (doc.Released == false)
{
ccProcTran.View.Graph.Actions.PressSave();
}
TNode toProc = PXCache <TNode> .CreateCopy(doc);
PXLongOperation.StartOperation(ccProcTran.View.Graph, delegate()
{
try
{
CCProcTran refTran = new CCProcTran();
refTran.AuthNumber = aAuthorizationNbr;
processor.ProcessCCTransaction(toProc, refTran, CCTranType.CaptureOnly);
}
finally
{
if (aDocStateUpdater != null)
{
aDocStateUpdater(doc, CCTranType.VoidOrCredit);
}
}
if (aReleaseDelegate != null)
{
aReleaseDelegate(toProc);
}
});
}
}
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);
}
}
protected virtual void ProcessTranResult(CCProcTran aTran, CCProcTran aRefTran, ProcessingResult aResult)
{
if (aTran.TranType == CCTranTypeCode.GetTypeCode(CCTranType.Void) &&
aRefTran.IsManuallyEntered())
{
if (aResult.TranStatus != CCTranStatus.Approved &&
((aResult.ResultFlag & (CCResultFlag.OrigTransactionNotFound | CCResultFlag.OrigTransactionExpired)) != CCResultFlag.None))
{
//Force Void over Missed of Expired Authorization transaction;
int voidingTranNbr;
RecordVoidingTran(aRefTran, null, out voidingTranNbr);
aResult.isAuthorized = true;
}
}
}
public virtual bool Capture(int?aPMInstanceID, int?aAuthTranNbr, string aCuryID, decimal?aAmount, ref int aTranNbr)
{
CCProcTran authTran = _repository.GetCCProcTran(aAuthTranNbr);
Customer customer;
CustomerPaymentMethod pmInstance = this.findPMInstance(aPMInstanceID, out customer);
if (authTran == null)
{
throw new PXException(Messages.ERR_CCAuthorizationTransactionIsNotFound, aAuthTranNbr);
}
if (!IsAuthorized(authTran))
{
throw new PXException(Messages.ERR_CCProcessingReferensedTransactionNotAuthorized, aAuthTranNbr);
}
if (authTran.ExpirationDate.HasValue && authTran.ExpirationDate.Value < PXTimeZoneInfo.Now)
{
throw new PXException(Messages.ERR_CCAuthorizationTransactionHasExpired, aAuthTranNbr);
}
if (!IsCCValidForProcessing(aPMInstanceID))
{
return(false);
}
CCProcessingCenter procCenter = _repository.GetCCProcessingCenter(authTran.ProcessingCenterID);
if (procCenter == null)
{
throw new PXException(Messages.ERR_CCProcessingCenterUsedForAuthIsNotValid, authTran.ProcessingCenterID, aAuthTranNbr);
}
if (!(procCenter.IsActive ?? false))
{
throw new PXException(Messages.ERR_CCProcessingCenterUsedForAuthIsNotActive, procCenter, aAuthTranNbr);
}
CCProcTran tran = new CCProcTran
{
PMInstanceID = aPMInstanceID,
RefTranNbr = aAuthTranNbr,
DocType = authTran.DocType,
RefNbr = authTran.RefNbr,
CuryID = aCuryID,
Amount = aAmount,
OrigDocType = authTran.OrigDocType,
OrigRefNbr = authTran.OrigRefNbr
};
return(this.DoTransaction(ref aTranNbr, CCTranType.PriorAuthorizedCapture, tran, authTran, customer.AcctCD, procCenter));
}
public virtual bool Credit(ICCPayment aPmtInfo, int aRefTranNbr, ref int aTranNbr)
{
Customer customer;
CustomerPaymentMethod pmInstance = this.findPMInstance(aPmtInfo.PMInstanceID, out customer);
CCProcTran authTran = _repository.GetCCProcTran(aRefTranNbr);
if (authTran == null)
{
throw new PXException(Messages.ERR_CCTransactionToCreditIsNotFound, aRefTranNbr);
}
if (!MayBeCredited(authTran))
{
throw new PXException(Messages.ERR_CCProcessingTransactionMayNotBeCredited, authTran.TranType);
}
if (!IsAuthorized(authTran))
{
throw new PXException(Messages.ERR_CCProcessingReferensedTransactionNotAuthorized, aRefTranNbr);
}
if (!IsCCValidForProcessing(aPmtInfo.PMInstanceID))
{
return(false);
}
CCProcessingCenter procCenter = _repository.GetCCProcessingCenter(authTran.ProcessingCenterID);
if (procCenter == null)
{
throw new PXException(Messages.ERR_CCProcessingCenterUsedInReferencedTranNotFound, authTran.ProcessingCenterID, aRefTranNbr);
}
if (!(procCenter.IsActive ?? false))
{
throw new PXException(Messages.ERR_CCProcessingCenterUsedInReferencedTranNotActive, authTran.ProcessingCenterID, aRefTranNbr);
}
CCProcTran tran = new CCProcTran();
tran.Copy(aPmtInfo);
tran.RefTranNbr = authTran.TranNbr;
if (!aPmtInfo.CuryDocBal.HasValue)
{
tran.CuryID = authTran.CuryID;
tran.Amount = authTran.Amount;
}
return(this.DoTransaction(ref aTranNbr, CCTranType.Credit, tran, authTran, customer.AcctCD, procCenter));
}
protected virtual CCProcTran findCVVVerifyingTran(int?aPMInstanceID, out bool aIsStored)
{
CustomerPaymentMethod pmInstance = _repository.GetCustomerPaymentMethod(aPMInstanceID);
if (pmInstance.CVVVerifyTran.HasValue)
{
aIsStored = true;
return(_repository.GetCCProcTran(pmInstance.CVVVerifyTran));
}
else
{
aIsStored = false;
CCProcTran verifyingTran = _repository.FindVerifyingCCProcTran(aPMInstanceID);
return(verifyingTran);
}
}
public virtual bool Void(int?aPMInstanceID, int?aRefTranNbr, ref int aTranNbr)
{
CCProcTran refTran = _repository.GetCCProcTran(aRefTranNbr);
Customer customer;
CustomerPaymentMethod pmInstance = this.findPMInstance(aPMInstanceID, out customer);
if (refTran == null)
{
throw new PXException(Messages.ERR_CCTransactionToVoidIsNotFound, aRefTranNbr);
}
if (!MayBeVoided(refTran))
{
throw new PXException(Messages.ERR_CCProcessingTransactionMayNotBeVoided, refTran.TranType);
}
if (!IsAuthorized(refTran))
{
throw new PXException(Messages.ERR_CCProcessingReferensedTransactionNotAuthorized, aRefTranNbr);
}
if (!IsCCValidForProcessing(aPMInstanceID))
{
return(false);
}
CCProcessingCenter procCenter = _repository.GetCCProcessingCenter(refTran.ProcessingCenterID);
if (procCenter == null)
{
throw new PXException(Messages.ERR_CCProcessingCenterUsedInReferencedTranNotFound, refTran.ProcessingCenterID, aRefTranNbr);
}
if (!(procCenter.IsActive ?? false))
{
throw new PXException(Messages.ERR_CCProcessingCenterUsedInReferencedTranNotFound, procCenter, aRefTranNbr);
}
CCProcTran tran = new CCProcTran
{
PMInstanceID = aPMInstanceID,
RefTranNbr = aRefTranNbr,
DocType = refTran.DocType,
RefNbr = refTran.RefNbr,
CuryID = refTran.CuryID,
Amount = refTran.Amount,
OrigDocType = refTran.OrigDocType,
OrigRefNbr = refTran.OrigRefNbr
};
return(this.DoTransaction(ref aTranNbr, CCTranType.Void, tran, refTran, customer.AcctCD, procCenter));
}
public virtual bool RecordCredit(ICCPayment aPmtInfo, string aRefPCTranNbr, string aExtTranRef, string aExtAuthNbr, out int?aTranNbr)
{
aTranNbr = null;
if (!IsCCValidForProcessing(aPmtInfo.PMInstanceID))
{
return(false);
}
CCProcTran tran = new CCProcTran();
tran.Copy(aPmtInfo);
CCProcTran origCCTran = null;
if (!String.IsNullOrEmpty(aRefPCTranNbr))
{
origCCTran = _repository.FindReferencedCCProcTran(aPmtInfo.PMInstanceID, aRefPCTranNbr);
}
if (origCCTran != null && (aPmtInfo.PMInstanceID == origCCTran.PMInstanceID))
{
//Override Orig Doc Ref by those from orig CC Tran if any
tran.RefTranNbr = origCCTran.TranNbr;
tran.ProcessingCenterID = origCCTran.ProcessingCenterID;
}
else
{
CCProcessingCenter procCenter = _repository.FindProcessingCenter(aPmtInfo.PMInstanceID, aPmtInfo.CuryID);
if (procCenter == null || string.IsNullOrEmpty(procCenter.ProcessingTypeName))
{
throw new PXException(Messages.ERR_ProcessingCenterForCardNotConfigured);
}
CashAccount cashAccount = _repository.GetCashAccount(procCenter.CashAccountID);
if (cashAccount.CuryID != aPmtInfo.CuryID)
{
throw new PXException(Messages.ProcessingCenterCurrencyDoesNotMatch, aPmtInfo.CuryID, cashAccount.CuryID);
}
tran.ProcessingCenterID = procCenter.ProcessingCenterID;
tran.RefPCTranNumber = aRefPCTranNbr;
}
tran.PCTranNumber = aExtTranRef;
tran.AuthNumber = aExtAuthNbr;
tran.TranType = CCTranTypeCode.GetTypeCode(CCTranType.Credit);
FillRecordedTran(tran);
tran = _repository.InsertCCProcTran(tran);
_repository.Save();
aTranNbr = tran.TranNbr;
return(true);
}
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 CCProcTran InsertOrUpdateTransaction(CCProcTran procTran)
{
int extTranId = 0;
if (procTran.TransactionID.GetValueOrDefault() != 0)
{
extTranId = procTran.TransactionID.Value;
}
if (extTranId == 0)
{
procTran = InsertTransaction(procTran);
}
else
{
procTran = UpdateTransaction(procTran);
}
return(procTran);
}
protected virtual void UpdateCvvVerificationStatus(CCProcTran aTran)
{
if (aTran.TranStatus == CCTranStatusCode.Approved &&
aTran.CVVVerificationStatus == CVVVerificationStatusCode.Match &&
(aTran.TranType == CCTranTypeCode.AuthorizeAndCapture || aTran.TranType == CCTranTypeCode.Authorize))
{
CustomerPaymentMethod pmInstance = _repository.GetCustomerPaymentMethod(aTran.PMInstanceID);
if (!pmInstance.CVVVerifyTran.HasValue)
{
pmInstance.CVVVerifyTran = aTran.TranNbr;
CustomerPaymentMethodDetail cvvDetail = _repository.GetCustomerPaymentMethodDetail(aTran.PMInstanceID, CreditCardAttributes.CVV);
if (cvvDetail != null)
{
_repository.DeletePaymentMethodDetail(cvvDetail);
}
_repository.UpdateCustomerPaymentMethod(pmInstance);
_repository.Save();
}
}
}
public static bool IsActiveTran(CCProcTran procTran)
{
bool ret = true;
if (procTran.TranStatus == CCTranStatusCode.Declined ||
(procTran.TranType == CCTranTypeCode.VoidTran && procTran.TranStatus == CCTranStatusCode.Approved))
{
ret = false;
}
if ((procTran.RefTranNbr == null || procTran.TranType == CCTranTypeCode.Credit) && procTran.TranStatus == CCTranStatusCode.Error)
{
ret = false;
}
if (procTran.TranStatus == CCTranStatusCode.Expired)
{
ret = false;
}
return(ret);
}
public static void Copy(CCProcTran aDst, ProcessingResult aSrc)
{
aDst.PCTranNumber = aSrc.PCTranNumber;
aDst.PCResponseCode = aSrc.PCResponseCode;
aDst.PCResponseReasonCode = aSrc.PCResponseReasonCode;
aDst.AuthNumber = aSrc.AuthorizationNbr;
aDst.PCResponse = aSrc.PCResponse;
aDst.PCResponseReasonText = aSrc.PCResponseReasonText;
aDst.CVVVerificationStatus = CVVVerificationStatusCode.GetCCVCode(aSrc.CcvVerificatonStatus);
aDst.TranStatus = CCTranStatusCode.GetCode(aSrc.TranStatus);
if (aSrc.ErrorSource != CCErrors.CCErrorSource.None)
{
aDst.ErrorSource = CCErrors.GetCode(aSrc.ErrorSource);
aDst.ErrorText = aSrc.ErrorText;
if (aSrc.ErrorSource != CCErrors.CCErrorSource.ProcessingCenter)
{
aDst.PCResponseReasonText = aSrc.ErrorText;
}
}
}
