public static SignalsEnum Execute(
KernelDatabaseBase database,
KernelQ qManager,
CardQ cardQManager
)
{
if (qManager.GetOutputQCount() > 0) //there is a pending request to the terminal
{
KernelRequest kernel1Request = qManager.DequeueFromInput(false);
switch (kernel1Request.KernelTerminalReaderServiceRequestEnum)
{
case KernelTerminalReaderServiceRequestEnum.STOP:
return(EntryPointSTOP(database, qManager));
default:
throw new EMVProtocolException("Invalid Kernel1TerminalReaderServiceRequestEnum in State_3_WaitingForGPOResponse:" + Enum.GetName(typeof(CardInterfaceServiceResponseEnum), kernel1Request.KernelTerminalReaderServiceRequestEnum));
}
}
else
{
CardResponse cardResponse = cardQManager.DequeueFromOutput(false);
switch (cardResponse.CardInterfaceServiceResponseEnum)
{
case CardInterfaceServiceResponseEnum.RA:
return(EntryPointRA(database, qManager));
case CardInterfaceServiceResponseEnum.L1RSP:
return(EntryPointL1RSP(database, qManager, cardResponse));
default:
throw new EMVProtocolException("Invalid Kernel1CardinterfaceServiceResponseEnum in State_3_WaitingForGPOResponse:" + Enum.GetName(typeof(CardInterfaceServiceResponseEnum), cardResponse.CardInterfaceServiceResponseEnum));
}
}
}
private bool PutCards(Card card)
{
CardResponse cardResponse = new CardResponse();
string cardData = JsonConvert.SerializeObject(card);
var data = Encoding.ASCII.GetBytes(cardData);
try {
HttpWebRequest request = (HttpWebRequest)WebRequest.Create("http://localhost:56698/api/cards/");
request.ContentType = "application/json";
request.Method = "PUT";
request.ContentLength = cardData.Length;
using (Stream stream = request.GetRequestStream()) {
stream.Write(data, 0, data.Length);
}
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
if (response.StatusCode == HttpStatusCode.OK)
{
response.Close();
IsError = false;
return(true);
}
}
catch {
IsError = true;
}
return(false);
}
internal static SignalsEnum PostGenACBalanceReading(KernelDatabaseBase database, KernelQ qManager, CardQ cardQManager)
{
APPLICATION_CAPABILITIES_INFORMATION_9F5D_KRN2 aci = new APPLICATION_CAPABILITIES_INFORMATION_9F5D_KRN2(database);
if (!(database.IsNotEmpty(EMVTagsEnum.APPLICATION_CAPABILITIES_INFORMATION_9F5D_KRN2.Tag) &&
aci.Value.SupportForBalanceReading))
{
return(SignalsEnum.NONE);
}
if (!database.IsPresent(EMVTagsEnum.BALANCE_READ_AFTER_GEN_AC_DF8105_KRN2.Tag))
{
return(SignalsEnum.NONE);
}
EMVGetDataRequest request = new EMVGetDataRequest(Formatting.HexStringToByteArray(EMVTagsEnum.OFFLINE_ACCUMULATOR_BALANCE_9F50_KRN2.Tag));
cardQManager.EnqueueToInput(new CardRequest(request, CardinterfaceServiceRequestEnum.ADPU));
SignalsEnum result = SignalsEnum.WAITING_FOR_POST_GEN_AC_BALANCE;
while (result == SignalsEnum.WAITING_FOR_POST_GEN_AC_BALANCE)
{
CardResponse cardResponse = cardQManager.DequeueFromOutput(false);
result = State_17_WaitingForPostGenACBalance_7_4.Execute_State_17_WaitingForPostGenACBalance(database, qManager, cardQManager);
}
return(result);
}
/*
* 15.2
*/
private static SignalsEnum EntryPointRA(Kernel2Database database, CardResponse cardResponse, KernelQ qManager, CardQ cardQManager, TornTransactionLogManager tornTransactionLogManager, Stopwatch sw)
{
#region 15.5
if (cardResponse.ApduResponse.Succeeded)
#endregion
{
#region 15.6
if (database.TagsToWriteAfterGenACYet.Count != 0)
#endregion
{
#region 15.7
TLV tagToPut = database.TagsToWriteAfterGenACYet.GetFirstAndRemoveFromList();
EMVPutDataRequest requestPutData = new EMVPutDataRequest(tagToPut);
#endregion
#region 15.8
cardQManager.EnqueueToInput(new CardRequest(requestPutData, CardinterfaceServiceRequestEnum.ADPU));
return(SignalsEnum.WAITING_FOR_PUT_DATA_RESPONSE_AFTER_GEN_AC);
#endregion
}
else
{
#region 15.9
byte pgacps = database.Get(EMVTagsEnum.POSTGEN_AC_PUT_DATA_STATUS_DF810E_KRN2).Value[0];
pgacps = (byte)(pgacps | 0x80);
database.Get(EMVTagsEnum.POSTGEN_AC_PUT_DATA_STATUS_DF810E_KRN2).Value[0] = pgacps;
#endregion
}
}
return(DoCommon(database, cardResponse, qManager));
}
/*
* 14.1
*/
private static SignalsEnum EntryPointL1RSP(Kernel2Database database, CardResponse cardResponse, KernelQ qManager, TornTransactionLogManager tornTransactionLogManager)
{
#region 14.2
int waitTime = ((2 ^ database.FailedMSCntr) * 300);
Task.Delay(TimeSpan.FromMilliseconds(waitTime)).Wait();
#endregion
#region 14.3
database.FailedMSCntr = Math.Min(database.FailedMSCntr + 1, 5);
#endregion
#region 14.4 - 14.5
CommonRoutines.CreateEMVDiscretionaryData(database);
return(CommonRoutines.PostOutcome(database, qManager,
KernelMessageidentifierEnum.TRY_AGAIN,
KernelStatusEnum.READY_TO_READ,
new byte[] { 0x00, 0x00, 0x00 },
Kernel2OutcomeStatusEnum.END_APPLICATION,
Kernel2StartEnum.B,
false,
KernelMessageidentifierEnum.TRY_AGAIN,
L1Enum.NOT_SET,
cardResponse.ApduResponse.SW12,
L2Enum.STATUS_BYTES,
L3Enum.NOT_SET));
#endregion
}
private static SignalsEnum EntryPointRA(KernelDatabase database, CardResponse cardResponse, KernelQ qManager, CardQ cardQManager, Stopwatch sw, PublicKeyCertificateManager publicKeyCertificateManager, EMVSelectApplicationResponse emvSelectApplicationResponse)
{
if (!cardResponse.ApduResponse.Succeeded)
{
return(State_7_10_CommonProcessing.DoInvalidResponsePart_C(database, qManager, L1Enum.NOT_SET, L2Enum.STATUS_BYTES, L3Enum.NOT_SET));
}
SignalsEnum result = ProcessGenACCommand(database, cardResponse, qManager, cardQManager, sw, publicKeyCertificateManager, emvSelectApplicationResponse);
TLV _72 = database.Get(EMVTagsEnum.ISSUER_SCRIPT_TEMPLATE_2_72_KRN);
if (_72 != null)
{
database.ScriptsToRunAfterGenAC = CardActionAnalysis.BuildScriptList(_72);
if (database.ScriptsToRunAfterGenAC.Count > 0)
{
//post first script
TLV firstScript = database.ScriptsToRunAfterGenAC.GetFirstAndRemoveFromList();
EMVScriptCommandRequest scriptRequest = new EMVScriptCommandRequest();
scriptRequest.Deserialize(firstScript.Value);
cardQManager.EnqueueToInput(new CardRequest(scriptRequest, CardinterfaceServiceRequestEnum.ADPU));
return(SignalsEnum.WAITING_FOR_SCRIPT_PROCESSING);
}
}
return(result);
}
public async Task <IActionResult> UpdateCardAsync([FromBody] UpdateCardCommand command)
{
if (command == null)
{
return(BadRequest());
}
var cardToUpdate = new Card
{
Id = command.Id,
Name = command.Name,
Description = command.Description
};
var updatedCard = await _cardsService.UpdateCardAsync(cardToUpdate);
if (updatedCard == null)
{
return(NotFound());
}
var response = new CardResponse
{
Id = updatedCard.Id,
Name = updatedCard.Name,
Description = updatedCard.Description
};
return(Ok(response));
}
public CardResponse Transmit(CardCommand command)
{
this.LogCommand(command, "");
CardResponse Response = this.Channel.Transmit(command);
this.LogResponse(Response, "");
return(Response);
}
//-----------------------------------------------------------------------------------------
// CardRedeem - Redeems an amount to a card in a single call (i.e. does an Auth/Capture in a single call.
// Returns the tranactionCode for the request.
//-----------------------------------------------------------------------------------------
public string CardRedeem(string cardNumber, string tenderCode, string transExternalId, decimal amount, Guid?customerUid = null)
{
var transCode = "";
var svc = GetPaymentEngineService();
try
{
CardRedeemRequest request = new CardRedeemRequest
{
// Build up the card redeem request based on what the user/cashier entered.
CardNumber = cardNumber,
CustomerUid = customerUid ?? Guid.Empty, // Optionally provide the bLoyal customer uid if you have it.
CardPin = "", // Some clients require a PIN.
Swiped = false, // Set to true when a card is swiped and false if manually keyed.
Amount = amount,
TenderCode = tenderCode,
TransactionExternalId = transExternalId, // Provide either your transaction number or the bLoyal TransactionToken.
ReferenceNumber = transExternalId
};
CardResponse response = svc.CardRedeem(_accessKey, _storeCode, _deviceCode, request); // StoreCode and DeviceCode are not required if you are using a device AccessKey.
List <string> msg = new List <string>();
if (response.Status == CardRequestStatus.Approved)
{
transCode = response.TransactionCode;
msg.Add(string.Format("CardRedeem() succeeded. Transaction Code:{0}", response.TransactionCode));
msg.Add(string.Format(" Current Balance={0}, Available Balance={1} ", response.CurrentBalance, response.AvailableBalance));
}
else
{
msg.Add(string.Format("CardRedeem() FAILED. Status={0} ", response.Status));
msg.Add(string.Format(" Message:{0} ", response.Message));
}
//tbResults.Lines = msg.ToArray();
}
catch (bLoyal.Connectors.ApiException ex)
{
if (ex != null && !string.IsNullOrWhiteSpace(ex.Code) && ex.Code == "ServiceRedirect")
{
ServiceURLHelper.IsbLoyalServiceUrlDown = true;
}
_logger.WriteLogError(ex, "CardRedeem in PaymentEngineConnector");
}
catch (Exception ex)
{
_logger.WriteLogError(ex, "CardRedeem in PaymentEngineConnector");
}
finally
{
if (svc != null)
{
svc.Abort();
}
}
return(transCode);
}
//-----------------------------------------------------------------------------------------
// GetCardBalance - Gets the current balance on a gift card, egift card, loyalty card, or certificate.
//-----------------------------------------------------------------------------------------
public CardResponse GetCardBalance(string cardNumber, string tenderCode, Guid?customerUid = null)
{
var svc = GetPaymentEngineService();
try
{
CardBalanceRequest request = new CardBalanceRequest
{
CustomerUid = customerUid ?? Guid.Empty,
TenderCode = tenderCode,
CardNumber = cardNumber,
CardPin = "", // Some clients require a PIN.
Swiped = false, // Set to true when a card is swiped and false if manually keyed.
};
CardResponse response = svc.GetCardBalance(_accessKey, _storeCode, _deviceCode, request); // StoreCode and DeviceCode are not required if you are using a device AccessKey.
List <string> msg = new List <string>();
if (response.Status == CardRequestStatus.Approved)
{
msg.Add(string.Format("CardBalance() succeeded. Current Balance={0}, Available Balance={1} ", response.CurrentBalance, response.AvailableBalance));
}
else
{
msg.Add(string.Format("CardBalance() FAILED. Status={0} ", response.Status));
msg.Add(string.Format(" Message:{0} ", response.Message));
}
//tbResults.Lines = msg.ToArray();
svc.Close(); // Closes the transport channel.
svc = null;
return(response);
}
catch (bLoyal.Connectors.ApiException ex)
{
if (ex != null && !string.IsNullOrWhiteSpace(ex.Code) && ex.Code == "ServiceRedirect")
{
ServiceURLHelper.IsbLoyalServiceUrlDown = true;
}
_logger.WriteLogError(ex, "GetCardBalance in PaymentEngineConnector");
}
catch (Exception ex)
{
//tbResults.Text = string.Format("GetCardBalance() failed. Exception: {0}", ex.ToString());
_logger.WriteLogError(ex, "GetCardBalance in PaymentEngineConnector");
}
finally
{
if (svc != null)
{
svc.Abort();
}
}
return(null);
}
internal static void UpdateErrorIndication(KernelDatabaseBase database, CardResponse cardResponse, L1Enum l1Enum, L2Enum l2Enum, L3Enum l3Enum)
{
ERROR_INDICATION_DF8115_KRN2 kei = new ERROR_INDICATION_DF8115_KRN2(database);
kei.Value.L1Enum = l1Enum;
kei.Value.L2Enum = l2Enum;
kei.Value.L3Enum = l3Enum;
kei.Value.SW12 = cardResponse.ApduResponse.SW12;
kei.UpdateDB();
}
internal CardCommand GetNextCommand(CardCommand command, CardResponse response)
{
foreach (AutoResponseTrigger Trigger in this.InnerList)
{
if (Trigger.IsMatch(command, response))
{
return(Trigger.GetCommand(command, response));
}
}
return(null);
}
public async Task <CardResponse> CreateCardAsync(CreateCardCommand command)
{
using var channel = GrpcChannel.ForAddress(_options.Uri);
var client = new Cards.CardsService.CardsServiceClient(channel);
var grpcRequest = command.ToGrpcRequest();
var grpcResponse = await client.CreateCardAsync(grpcRequest);
var response = CardResponse.FromGrpcResponse(grpcResponse);
return(response);
}
public object updatecard(CardDetails card)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Icard icard = new CardImpl();
CardResponse rs = icard.updatecard(card);
return(rs);
}
public object addpaymentdetail(CardDetails card)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Icard addcard = new CardImpl();
CardResponse rs = addcard.addpaymentdetail(card);
return(rs);
}
/// <summary>
///
/// </summary>
/// <param name="response"></param>
/// <param name="processingCard"></param>
/// <returns></returns>
public static CardResponse ValidateIsAmexCard15Digit(this CardResponse response, string processingCard)
{
if (processingCard.IsCard15Digita())
{
response.Result = "Valid";
}
else
{
response.Result = "InValid";
}
return(response);
}
/// <summary>
///
/// </summary>
/// <param name="response"></param>
/// <param name="year"></param>
/// <returns></returns>
public static CardResponse ValidateIsMaterYearPrimeNumber(this CardResponse response, int year)
{
if (year.IsPrime())
{
response.Result = "Valid";
}
else
{
response.Result = "InValid";
}
return(response);
}
internal CardCommand GetCommand(CardCommand command, CardResponse response)
{
this.commandMatch = this.originalCommandTrigger.Match(Conversion.ToHexString(command.Serialize()));
this.responseMatch = this.originalResponseTrigger.Match(Conversion.ToHexString(response.Serialize()));
string DynamicCommand = this.Resolve(this.dynamicCommandConstructionExpression);
this.commandMatch = null;
this.responseMatch = null;
return(new CardCommand(Conversion.ToByteArray(DynamicCommand)));
}
private static SignalsEnum EntryPointRA(KernelDatabase database, CardResponse cardResponse, KernelQ qManager, CardQ cardQManager, Stopwatch sw)
{
CARDHOLDER_VERIFICATION_METHOD_CVM_RESULTS_9F34_KRN cvr = new CARDHOLDER_VERIFICATION_METHOD_CVM_RESULTS_9F34_KRN(database);
EMVGetDataResponse response = (EMVGetDataResponse)cardResponse.ApduResponse;
if (!response.Succeeded)
{
cvr.Value.CVMResult = 0x01;//failed
cvr.UpdateDB();
return(SignalsEnum.WAITING_FOR_CVM_PROCESSING);
}
//store the pin try counter value
database.AddToList(response.GetResponseTag());
int pinTryCounter = Formatting.ConvertToInt16(database.Get(EMVTagsEnum.PERSONAL_IDENTIFICATION_NUMBER_PIN_TRY_COUNTER_9F17_KRN).Value);
TERMINAL_VERIFICATION_RESULTS_95_KRN tvr = new TERMINAL_VERIFICATION_RESULTS_95_KRN(database);
if (cvr.Value.GetCVMPerformed() == CVMCode.EncipheredPINVerificationPerformedByICC ||
cvr.Value.GetCVMPerformed() == CVMCode.EncipheredPINVerificationPerformedByICCAndSignature_Paper)
{
string pin = Formatting.ByteArrayToASCIIString(database.Get(EMVTagsEnum.TRANSACTION_PERSONAL_IDENTIFICATION_NUMBER_PIN_DATA_99_KRN.Tag).Value);
if (!PinProcessing.VerifyOfflinePin(pin, pinTryCounter, tvr, cvr))
{
return(SignalsEnum.WAITING_FOR_CVM_PROCESSING);
}
//fire off get challenge command
EMVGetChallengeRequest request = new EMVGetChallengeRequest();
cardQManager.EnqueueToInput(new CardRequest(request, CardinterfaceServiceRequestEnum.ADPU));
return(SignalsEnum.WAITING_FOR_GET_CHALLENGE);
}
if (cvr.Value.GetCVMPerformed() == CVMCode.PlaintextPINVerificationPerformedByICC ||
cvr.Value.GetCVMPerformed() == CVMCode.PlaintextPINVerificationPerformedByICCAndSignature_Paper)
{
string pin = Formatting.ByteArrayToASCIIString(database.Get(EMVTagsEnum.TRANSACTION_PERSONAL_IDENTIFICATION_NUMBER_PIN_DATA_99_KRN.Tag).Value);
if (!PinProcessing.VerifyOfflinePin(pin, pinTryCounter, tvr, cvr))
{
return(SignalsEnum.WAITING_FOR_CVM_PROCESSING);
}
byte[] pinData = PinProcessing.BuildPlainTextPinBlock(pin);
//fire off verify for plain text pin
EMVVerifyRequest request = new EMVVerifyRequest(VerifyCommandDataQualifier.Plaintext_PIN, pinData);
cardQManager.EnqueueToInput(new CardRequest(request, CardinterfaceServiceRequestEnum.ADPU));
return(SignalsEnum.WAITING_FOR_VERIFY);
}
throw new EMVProtocolException("Invalid cvr in State_5b_WaitingForGetPinTryCounter");
}
//-----------------------------------------------------------------------------------------
// CardCapture - Captures a previously authorized card amount.
// Returns the tranactionCode for the request.
//-----------------------------------------------------------------------------------------
public string CardCapture(string authTransCode, string transExternalId, decimal amount, System.Windows.Forms.TextBox tbResults)
{
var transCode = "";
var svc = GetPaymentEngineService();
try
{
CardCaptureRequest request = new CardCaptureRequest
{
TransactionCode = authTransCode, // Transaction code for the previously authorized transaction.
Amount = amount,
TransactionExternalId = transExternalId,
ReferenceNumber = transExternalId,
};
CardResponse response = svc.CardCapture(_accessKey, _storeCode, _deviceCode, request); // StoreCode and DeviceCode are not required if you are using a device AccessKey.
List <string> msg = new List <string>();
if (response.Status == CardRequestStatus.Approved)
{
transCode = response.TransactionCode;
msg.Add(string.Format("CardCapture() succeeded. Transaction Code:{0}", response.TransactionCode));
msg.Add(string.Format(" Current Balance={0}, Available Balance={1} ", response.CurrentBalance, response.AvailableBalance));
}
else
{
msg.Add(string.Format("CardCapture() FAILED. Status={0} ", response.Status));
msg.Add(string.Format(" Message:{0} ", response.Message));
}
tbResults.Lines = msg.ToArray();
}
catch (bLoyal.Connectors.ApiException ex)
{
if (ex != null && !string.IsNullOrWhiteSpace(ex.Code) && ex.Code == "ServiceRedirect")
{
ServiceURLHelper.IsbLoyalServiceUrlDown = true;
}
_logger.WriteLogError(ex, "CardCapture in PaymentEngineConnector");
}
catch (Exception ex)
{
_logger.WriteLogError(ex, "CardCapture in PaymentEngineConnector");
}
finally
{
if (svc != null)
{
svc.Abort();
}
}
return(transCode);
}
/// <summary>
///
/// </summary>
/// <param name="response"></param>
/// <param name="year"></param>
/// <returns></returns>
public static CardResponse ValidateVisaYear(this CardResponse response, int year)
{
if (year.IsExpiryDateLeadYear())
{
response.Result = "Valid";
}
else
{
response.Result = "InValid";
}
return(response);
}
//-----------------------------------------------------------------------------------------
// CardRefund - Refunds an amount to a previously captured card transaction.
// Returns the tranactionCode for the request.
//-----------------------------------------------------------------------------------------
public string CardRefund(string captureTransCode, string transExternalId, decimal amount)
{
var transCode = "";
var svc = GetPaymentEngineService();
try
{
CardRefundRequest request = new CardRefundRequest
{
Amount = amount,
TransactionCode = captureTransCode, // Transction code of the previously captured card amount.
TransactionExternalId = transExternalId, // Provide either your transaction number or the bLoyal TransactionToken.
ReferenceNumber = transExternalId
};
CardResponse response = svc.CardRefund(_accessKey, _storeCode, _deviceCode, request); // StoreCode and DeviceCode are not required if you are using a device AccessKey.
List <string> msg = new List <string>();
if (response.Status == CardRequestStatus.Approved)
{
transCode = response.TransactionCode;
msg.Add(string.Format("CardRefund() succeeded. Transaction Code:{0}", response.TransactionCode));
msg.Add(string.Format(" Current Balance={0}, Available Balance={1} ", response.CurrentBalance, response.AvailableBalance));
}
else
{
msg.Add(string.Format("CardRefund() FAILED. Status={0} ", response.Status));
msg.Add(string.Format(" Message:{0} ", response.Message));
}
}
catch (bLoyal.Connectors.ApiException ex)
{
if (ex != null && !string.IsNullOrWhiteSpace(ex.Code) && ex.Code == "ServiceRedirect")
{
ServiceURLHelper.IsbLoyalServiceUrlDown = true;
}
_logger.WriteLogError(ex, "CardRefund in PaymentEngineConnector");
}
catch (Exception ex)
{
_logger.WriteLogError(ex, "CardRefund in PaymentEngineConnector");
}
finally
{
if (svc != null)
{
svc.Abort();
}
}
return(transCode);
}
private static SignalsEnum DoCommon(Kernel2Database database, CardResponse cardResponse, KernelQ qManager)
{
#region 15.9.1
if (database.IsNotEmpty(EMVTagsEnum.POS_CARDHOLDER_INTERACTION_INFORMATION_DF4B_KRN2.Tag) &&
((int)Formatting.ConvertToInt32(database.Get(EMVTagsEnum.POS_CARDHOLDER_INTERACTION_INFORMATION_DF4B_KRN2).Value) & 0x00030F) != 0x000000)
#endregion
{
#region 15.10
CommonRoutines.PostUIOnly(database, qManager, KernelMessageidentifierEnum.CLEAR_DISPLAY, KernelStatusEnum.CARD_READ_SUCCESSFULLY, true);
#endregion
//TODO: this changes ui in db which means when response is dequeued, it will have been
//changed by code below, should we not create a copy in Kernel2Response constructor
#region 15.11
CommonRoutines.CreateEMVDiscretionaryData(database);
return(CommonRoutines.PostOutcome(database, qManager,
KernelMessageidentifierEnum.N_A,
KernelStatusEnum.READY_TO_READ,
new byte[] { 0x00, 0x00, 0x00 },
Kernel2OutcomeStatusEnum.END_APPLICATION,
Kernel2StartEnum.N_A,
false,
KernelMessageidentifierEnum.N_A,
L1Enum.NOT_SET,
null,
L2Enum.NOT_SET,
L3Enum.NOT_SET));
#endregion
}
else
{
#region 15.12
CommonRoutines.PostUIOnly(database, qManager, KernelMessageidentifierEnum.CLEAR_DISPLAY, KernelStatusEnum.CARD_READ_SUCCESSFULLY, false);
//TODO: we created a temp ui and never saved it to db, so what ui is used below
CommonRoutines.CreateEMVDiscretionaryData(database);
return(CommonRoutines.PostOutcome(database, qManager,
KernelMessageidentifierEnum.N_A,
KernelStatusEnum.N_A,
new byte[] { 0x00, 0x00, 0x00 },
Kernel2OutcomeStatusEnum.N_A,
Kernel2StartEnum.N_A,
true,
KernelMessageidentifierEnum.N_A,
L1Enum.NOT_SET,
null,
L2Enum.NOT_SET,
L3Enum.NOT_SET));
#endregion
}
}
/// <summary>
/// The POST method for the ticket controller.
/// </summary>
/// <param name="cardResponse">Value from the POST request body.</param>
/// <returns>The asynchronous task.</returns>
// POST api/ticket
public async Task <HttpResponseMessage> Post(CardResponse cardResponse)
{
HttpRequestMessage request = this.ActionContext.Request;
// Validate that we have a bearer token.
if (request.Headers.Authorization == null ||
!string.Equals(request.Headers.Authorization.Scheme, BearerTokenType, StringComparison.OrdinalIgnoreCase) ||
string.IsNullOrEmpty(request.Headers.Authorization.Parameter))
{
return(request.CreateErrorResponse(HttpStatusCode.Unauthorized, new HttpError()));
}
string bearerToken = request.Headers.Authorization.Parameter;
ActionableMessageTokenValidator validator = new ActionableMessageTokenValidator();
// ValidateTokenAsync will verify the following
// 1. The token is issued by Microsoft and its digital signature is valid.
// 2. The token has not expired.
// 3. The audience claim matches the service domain URL.
ActionableMessageTokenValidationResult result = await validator.ValidateTokenAsync(bearerToken, WebServiceHost);
if (!result.ValidationSucceeded)
{
if (result.Exception != null)
{
Trace.TraceError(result.Exception.ToString());
}
return(request.CreateErrorResponse(HttpStatusCode.Unauthorized, new HttpError()));
}
// We have a valid token. Your application should verify the sender and/or the ActionPerformer
//
// You should also return the CARD-ACTION-STATUS header in the response.
// The value of the header will be displayed to the user.
if (!result.Sender.ToLowerInvariant().EndsWith(SenderEmailDomain.ToLowerInvariant()))
{
HttpResponseMessage errorResponse = request.CreateErrorResponse(HttpStatusCode.Forbidden, new HttpError());
errorResponse.Headers.Add("CARD-ACTION-STATUS", "Invalid sender or the action performer is not allowed.");
return(errorResponse);
}
// prepare the response
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK);
response.Headers.Add("CARD-ACTION-STATUS", "Comment recorded...");
#region Business logic code here to process the support ticket.
#endregion
return(response);
}
private static SignalsEnum EntryPointRA(KernelDatabase database, CardResponse cardResponse, KernelQ qManager, CardQ cardQManager, Stopwatch sw, PublicKeyCertificateManager publicKeyCertificateManager, EMVSelectApplicationResponse emvSelectApplicationResponse)
{
if (database.IsScriptProcessingBeforeGenACInProgress)
{
if (cardResponse.ApduResponse.SW1 != 0x90 && cardResponse.ApduResponse.SW1 != 0x62 && cardResponse.ApduResponse.SW1 != 0x63)
{
TERMINAL_VERIFICATION_RESULTS_95_KRN tvr = new TERMINAL_VERIFICATION_RESULTS_95_KRN(database);
tvr.Value.ScriptProcessingFailedBeforeFinalGENERATEAC = true;
tvr.UpdateDB();
database.IsScriptProcessingBeforeGenACInProgress = false;
return(CardActionAnalysis.Initiate2ndCardActionAnalysis(database, qManager, cardQManager, emvSelectApplicationResponse));
}
if (database.ScriptsToRunBeforeGenAC.Count == 0)
{
database.IsScriptProcessingBeforeGenACInProgress = false;
return(CardActionAnalysis.Initiate2ndCardActionAnalysis(database, qManager, cardQManager, emvSelectApplicationResponse, true));
}
TLV firstScript = database.ScriptsToRunBeforeGenAC.GetFirstAndRemoveFromList();
EMVScriptCommandRequest scriptRequest = new EMVScriptCommandRequest();
scriptRequest.Deserialize(firstScript.Value);
cardQManager.EnqueueToInput(new CardRequest(scriptRequest, CardinterfaceServiceRequestEnum.ADPU));
return(SignalsEnum.WAITING_FOR_SCRIPT_PROCESSING);
}
else
{
if (cardResponse.ApduResponse.SW1 != 0x90 && cardResponse.ApduResponse.SW1 != 0x62 && cardResponse.ApduResponse.SW1 != 0x63)
{
TERMINAL_VERIFICATION_RESULTS_95_KRN tvr = new TERMINAL_VERIFICATION_RESULTS_95_KRN(database);
tvr.Value.ScriptProcessingFailedAfterFinalGENERATEAC = true;
tvr.UpdateDB();
//update emv data to return with this updated value
if (database.Get(EMVTagsEnum.DATA_RECORD_FF8105_KRN2) != null)
{
database.Get(EMVTagsEnum.DATA_RECORD_FF8105_KRN2).Children.RemoveFromList(database.Get(EMVTagsEnum.TERMINAL_VERIFICATION_RESULTS_95_KRN.Tag));
database.Get(EMVTagsEnum.DATA_RECORD_FF8105_KRN2).Children.AddToList(TLV.Create(EMVTagsEnum.TERMINAL_VERIFICATION_RESULTS_95_KRN.Tag, database.Get(EMVTagsEnum.TERMINAL_VERIFICATION_RESULTS_95_KRN).Value));
}
return(SignalsEnum.STOP);
}
if (database.ScriptsToRunAfterGenAC.Count == 0)
{
return(SignalsEnum.STOP);
}
TLV firstScript = database.ScriptsToRunAfterGenAC.GetFirstAndRemoveFromList();
EMVScriptCommandRequest scriptRequest = new EMVScriptCommandRequest();
scriptRequest.Deserialize(firstScript.Value);
cardQManager.EnqueueToInput(new CardRequest(scriptRequest, CardinterfaceServiceRequestEnum.ADPU));
return(SignalsEnum.WAITING_FOR_SCRIPT_PROCESSING);
}
}
private static SignalsEnum EntryPointRA(KernelDatabase database, CardResponse cardResponse, KernelQ qManager, CardQ cardQManager, PublicKeyCertificateManager pkcm, EMVSelectApplicationResponse emvSelectApplicationResponse, Stopwatch sw)
{
CARDHOLDER_VERIFICATION_METHOD_CVM_RESULTS_9F34_KRN cvr = new CARDHOLDER_VERIFICATION_METHOD_CVM_RESULTS_9F34_KRN(database);
EMVGetChallengeResponse response = (EMVGetChallengeResponse)cardResponse.ApduResponse;
if (!response.Succeeded)
{
cvr.Value.CVMResult = 0x01;//failed
cvr.UpdateDB();
return(SignalsEnum.WAITING_FOR_CVM_PROCESSING);
}
//store the challenge
byte[] pinChallenge = response.ResponseData;
if (cvr.Value.GetCVMPerformed() == CVMCode.EncipheredPINVerificationPerformedByICC ||
cvr.Value.GetCVMPerformed() == CVMCode.EncipheredPINVerificationPerformedByICCAndSignature_Paper)
{
string aid = emvSelectApplicationResponse.GetDFName();
string rid = aid.Substring(0, 10);
RIDEnum ridEnum = (RIDEnum)Enum.Parse(typeof(RIDEnum), rid);
CAPublicKeyCertificate capk = pkcm.GetCAPK(ridEnum, database.Get(EMVTagsEnum.CERTIFICATION_AUTHORITY_PUBLIC_KEY_INDEX_8F_KRN).Value[0]);
if (capk == null)
{
cvr.Value.CVMResult = 0x01;//failed
cvr.UpdateDB();
return(SignalsEnum.WAITING_FOR_CVM_PROCESSING);
}
string pin = Formatting.ByteArrayToASCIIString(database.Get(EMVTagsEnum.TRANSACTION_PERSONAL_IDENTIFICATION_NUMBER_PIN_DATA_99_KRN.Tag).Value);
byte[] pinBlock = PinProcessing.BuildPlainTextPinBlock(pin);
//encrypt the pin
byte[] encipheredPin = PinProcessing.BuildPinVerifyData(database, capk, pinBlock, pinChallenge);
if (encipheredPin == null)
{
cvr.Value.CVMResult = 0x01;//failed
cvr.UpdateDB();
return(SignalsEnum.WAITING_FOR_CVM_PROCESSING);
}
//fire off verify for enciphered pin
EMVVerifyRequest request = new EMVVerifyRequest(VerifyCommandDataQualifier.Enciphered_PIN, encipheredPin);
cardQManager.EnqueueToInput(new CardRequest(request, CardinterfaceServiceRequestEnum.ADPU));
}
//verify message for plain text pin fired in waiting for pin response
return(SignalsEnum.WAITING_FOR_VERIFY);
}
public CardResponse Transmit(CardCommand command)
{
CardResponse Response = this.channel.Transmit(command);
CardCommand AutoResponseCommand = this.autoResponseTrigger.GetNextCommand(command, Response);
if (AutoResponseCommand != null)
{
return(this.channel.Transmit(AutoResponseCommand));
}
else
{
return(Response);
}
}
//-----------------------------------------------------------------------------------------
// CardCredit - Credits a card with an amount. This is used to to activate or add to a card.
// Returns the tranactionCode for the request.
//-----------------------------------------------------------------------------------------
public string CardCredit(string cardNumber, string tenderCode, string transExternalId, decimal amount, System.Windows.Forms.TextBox tbResults, Guid?customerUid = null)
{
var transCode = "";
var svc = GetPaymentEngineService();
try
{
CardCreditRequest request = new CardCreditRequest();
// Build up the card credit request based on what the user/cashier entered.
request.CardNumber = cardNumber;
request.CustomerUid = customerUid ?? Guid.Empty; // Optionally provide the bLoyal customer uid if you have it.
// request.CardPin = ""; // Some clients require a PIN.
request.Swiped = false; // Set to true when a card is swiped and false if manually keyed.
request.Amount = amount;
request.TenderCode = tenderCode; // This is optional. Fill in if you have it to validate the card type with the tender.
request.TransactionExternalId = transExternalId; // Provide either your transaction number or the bLoyal TransactionToken.
CardResponse response = svc.CardCredit(_accessKey, _storeCode, _deviceCode, request); // StoreCode and DeviceCode are not required if you are using a device AccessKey.
List <string> msg = new List <string>();
if (response.Status == CardRequestStatus.Approved)
{
transCode = response.TransactionCode;
msg.Add(string.Format("CardCredit() succeeded. Transaction Code:{0}", response.TransactionCode));
msg.Add(string.Format(" Current Balance={0}, Available Balance={1} ", response.CurrentBalance, response.AvailableBalance));
}
else
{
msg.Add(string.Format("CardCredit() FAILED. Status={0} ", response.Status));
msg.Add(string.Format(" Message:{0} ", response.Message));
}
tbResults.Lines = msg.ToArray();
svc.Close(); // Closes the transport channel.
svc = null;
}
catch (System.Exception ex)
{
tbResults.Text = string.Format("CardCredit() failed. Exception: {0}", ex.ToString());
}
finally
{
if (svc != null)
{
svc.Abort();
}
}
return(transCode);
}
private static SignalsEnum EntryPointRA(KernelDatabase database, CardResponse cardResponse, KernelQ qManager, CardQ cardQManager, Stopwatch sw, PublicKeyCertificateManager publicKeyCertificateManager, EMVSelectApplicationResponse emvSelectApplicationResponse)
{
if (!cardResponse.ApduResponse.Succeeded)
{
return(CommonRoutines.PostOutcome(database, qManager,
KernelMessageidentifierEnum.N_A,
KernelStatusEnum.N_A,
null,
Kernel2OutcomeStatusEnum.END_APPLICATION,
Kernel2StartEnum.N_A,
true,
KernelMessageidentifierEnum.ERROR_OTHER_CARD,
L1Enum.NOT_SET,
cardResponse.ApduResponse.SW12,
L2Enum.STATUS_BYTES,
L3Enum.NOT_SET));
}
EMVInternalAuthenticateResponse response = cardResponse.ApduResponse as EMVInternalAuthenticateResponse;
string aid = emvSelectApplicationResponse.GetDFName();
string rid = aid.Substring(0, 10);
RIDEnum ridEnum = (RIDEnum)Enum.Parse(typeof(RIDEnum), rid);
CAPublicKeyCertificate capk = database.PublicKeyCertificateManager.GetCAPK(ridEnum, database.Get(EMVTagsEnum.CERTIFICATION_AUTHORITY_PUBLIC_KEY_INDEX_8F_KRN).Value[0]);
#region 3.8.1.1
bool ddaPassed = DoDDA(database, qManager, capk, response.GetTLVSignedApplicationData());
#endregion
if (!ddaPassed)
{
TERMINAL_VERIFICATION_RESULTS_95_KRN tvr = new TERMINAL_VERIFICATION_RESULTS_95_KRN(database);
tvr.Value.DDAFailed = true;
tvr.UpdateDB();
}
TLV cdol1 = database.Get(EMVTagsEnum.CARD_RISK_MANAGEMENT_DATA_OBJECT_LIST_1_CDOL1_8C_KRN);
CommonRoutines.PackRelatedDataTag(database, EMVTagsEnum.CDOL1_RELATED_DATA_DF8107_KRN2, cdol1);
REFERENCE_CONTROL_PARAMETER_DF8114_KRN2 rcpST = new REFERENCE_CONTROL_PARAMETER_DF8114_KRN2(database);
rcpST.Value.ACTypeEnum = database.ACType.Value.DSACTypeEnum;
rcpST.Value.CDASignatureRequested = false;
rcpST.UpdateDB();
EMVGenerateACRequest request = new EMVGenerateACRequest(database.Get(EMVTagsEnum.CDOL1_RELATED_DATA_DF8107_KRN2), null, rcpST);
cardQManager.EnqueueToInput(new CardRequest(request, CardinterfaceServiceRequestEnum.ADPU));
return(SignalsEnum.WAITING_FOR_GEN_AC_1);
}
private static SignalsEnum EntryPointL1RSP(KernelDatabase database, CardResponse cardResponse, KernelQ qManager)
{
CommonRoutines.InitializeDiscretionaryData(database);
return(CommonRoutines.PostOutcome(database, qManager,
KernelMessageidentifierEnum.TRY_AGAIN,
KernelStatusEnum.READY_TO_READ,
new byte[] { 0x00, 0x00, 0x00 },
Kernel2OutcomeStatusEnum.END_APPLICATION,
Kernel2StartEnum.B,
false,
KernelMessageidentifierEnum.TRY_AGAIN,
L1Enum.NOT_SET,
cardResponse.ApduResponse.SW12,
L2Enum.STATUS_BYTES,
L3Enum.NOT_SET));
}
