public object Get(CurrentAccount request)
{
var session = this.GetSession();
// Just in case someone was able to authenticate with a null session.
if (!session.Id.HasValueTrimmed())
{
throw new HttpError(HttpStatusCode.Forbidden, "NoSession");
}
var account = _accountDao.FindById(new Guid(session.UserAuthId));
var creditCard = account.DefaultCreditCard.HasValue
? _creditCardDao.FindById(account.DefaultCreditCard.Value)
: null;
var creditCardResource = creditCard != null
? new CreditCardDetails
{
CreditCardId = creditCard.CreditCardId,
AccountId = creditCard.AccountId,
NameOnCard = creditCard.NameOnCard,
Token = creditCard.Token,
Last4Digits = creditCard.Last4Digits,
CreditCardCompany = creditCard.CreditCardCompany,
ExpirationMonth = creditCard.ExpirationMonth,
ExpirationYear = creditCard.ExpirationYear,
IsDeactivated = creditCard.IsDeactivated,
Label = creditCard.Label,
ZipCode = creditCard.ZipCode,
StreetNumber = creditCard.StreetNumber,
StreetName = creditCard.StreetName,
Email = creditCard.Email,
Phone = creditCard.Phone
}
: null;
var currentAccount = new CurrentAccountResponse
{
Id = account.Id,
Email = account.Email,
Name = account.Name,
IbsAccountid = account.IBSAccountId ?? 0,
FacebookId = account.FacebookId,
TwitterId = account.TwitterId,
Settings = account.Settings,
Language = account.Language,
HasAdminAccess = account.HasAdminAccess,
IsSuperAdmin = account.RoleNames.Contains(RoleName.SuperAdmin),
DefaultCreditCard = creditCardResource,
DefaultTipPercent = account.DefaultTipPercent,
IsPayPalAccountLinked = account.IsPayPalAccountLinked
};
currentAccount.Settings.ChargeTypeId = account.Settings.ChargeTypeId ?? _serverSettings.ServerData.DefaultBookingSettings.ChargeTypeId;
currentAccount.Settings.VehicleTypeId = account.Settings.VehicleTypeId ?? _serverSettings.ServerData.DefaultBookingSettings.VehicleTypeId;
currentAccount.Settings.ProviderId = account.Settings.ProviderId ?? _serverSettings.ServerData.DefaultBookingSettings.ProviderId;
return(currentAccount);
}
private void ValidateCreditCard(AccountDetail account, string clientLanguageCode, string cvv, CreateReportOrder createReportOrder)
{
// check if the account has a credit card
if (!account.DefaultCreditCard.HasValue)
{
ThrowAndLogException(createReportOrder, ErrorCode.CreateOrder_CardOnFileButNoCreditCard,
GetCreateOrderServiceErrorMessage(ErrorCode.CreateOrder_CardOnFileButNoCreditCard, clientLanguageCode));
}
var creditCard = _creditCardDao.FindById(account.DefaultCreditCard.GetValueOrDefault());
if (creditCard.IsExpired())
{
ThrowAndLogException(createReportOrder, ErrorCode.CreateOrder_RuleDisable, _resources.Get("CannotCreateOrder_CreditCardExpired", clientLanguageCode));
}
if (creditCard.IsDeactivated)
{
ThrowAndLogException(createReportOrder, ErrorCode.CreateOrder_CardOnFileDeactivated, _resources.Get("CannotCreateOrder_CreditCardDeactivated", clientLanguageCode));
}
if (_serverSettings.GetPaymentSettings().AskForCVVAtBooking &&
!cvv.HasValue())
{
ThrowAndLogException(createReportOrder, ErrorCode.CreateOrder_RuleDisable, _resources.Get("CannotCreateOrder_CreditCardCvvRequired", clientLanguageCode));
}
}
public void Handle(OrderStatusChanged @event)
{
_logger.LogMessage("OrderPairingManager Handle : " + @event.Status.IBSStatusId);
switch (@event.Status.IBSStatusId)
{
case VehicleStatuses.Common.Loaded:
{
if (@event.Status.IsPrepaid)
{
// No need to pair, order was already paid
return;
}
var order = _orderDao.FindById(@event.SourceId);
if (order.Settings.ChargeTypeId == ChargeTypes.CardOnFile.Id ||
order.Settings.ChargeTypeId == ChargeTypes.PayPal.Id)
{
var account = _accountDao.FindById(@event.Status.AccountId);
var creditCard = _creditCardDao.FindById(account.DefaultCreditCard.GetValueOrDefault());
var cardToken = creditCard != null ? creditCard.Token : null;
var defaultTipPercentage = account.DefaultTipPercent ?? _serverSettings.ServerData.DefaultTipPercentage;
var errorMessageKey = "TripUnableToPairErrorText";
var response = _paymentFacadeService.Pair(order.CompanyKey, @event.SourceId, cardToken, defaultTipPercentage);
if (response.IgnoreResponse)
{
// no need to interpret the response
return;
}
switch (response.ErrorCode)
{
case CmtErrorCodes.CreditCardDeclinedOnPreauthorization:
errorMessageKey = "CreditCardDeclinedOnPreauthorizationErrorText";
break;
case CmtErrorCodes.UnablePreauthorizeCreditCard:
errorMessageKey = "CreditCardUnableToPreathorizeErrorText";
break;
}
var ibsStatusDescription = response.IsSuccessful ? "OrderStatus_PairingSuccess" : errorMessageKey;
UpdateIBSStatusDescription(order.Id, order.ClientLanguageCode, ibsStatusDescription);
_notificationService.SendAutomaticPairingPush(@event.SourceId, creditCard, defaultTipPercentage, response.IsSuccessful, errorMessageKey);
}
}
break;
}
}
public PreAuthorizePaymentResponse PreAuthorize(string companyKey, Guid orderId, AccountDetail account, decimal amountToPreAuthorize, bool isReAuth = false, bool isSettlingOverduePayment = false, bool isForPrepaid = false, string cvv = null)
{
var paymentId = Guid.NewGuid();
var creditCard = _creditCardDao.FindById(account.DefaultCreditCard.GetValueOrDefault());
_commandBus.Send(new InitiateCreditCardPayment
{
PaymentId = paymentId,
Amount = 0,
TransactionId = string.Empty,
OrderId = orderId,
CardToken = creditCard.Token,
Provider = PaymentProvider.Cmt,
IsNoShowFee = false,
CompanyKey = companyKey
});
return(new PreAuthorizePaymentResponse
{
IsSuccessful = true,
Message = string.Empty
});
}
public PairingResponse Pair(string companyKey, Guid orderId, string cardToken, int autoTipPercentage)
{
var order = _orderDao.FindById(orderId);
if (IsPayPal(null, order))
{
return(_payPalServiceFactory.GetInstance(companyKey).Pair(orderId, autoTipPercentage));
}
var account = _accountDao.FindById(order.AccountId);
var creditCard = _creditCardDao.FindById(account.DefaultCreditCard.GetValueOrDefault());
return(GetInstance(companyKey).Pair(companyKey, orderId, creditCard.Token, autoTipPercentage));
}
private void SendFeesReceipt(Guid orderId, decimal feeAmount, FeeTypes feeType)
{
var order = _orderDao.FindById(orderId);
var account = _accountDao.FindById(order.AccountId);
var creditCard = _creditCardDao.FindById(account.DefaultCreditCard.GetValueOrDefault());
if (feeType == FeeTypes.Cancellation)
{
_notificationService.SendCancellationFeesReceiptEmail(order.IBSOrderId ?? 0, Convert.ToDouble(feeAmount), creditCard.Last4Digits, account.Email, account.Language);
}
else if (feeType == FeeTypes.NoShow)
{
_notificationService.SendNoShowFeesReceiptEmail(order.IBSOrderId ?? 0, Convert.ToDouble(feeAmount), order.PickupAddress, creditCard.Last4Digits, account.Email, account.Language);
}
}
private AccountManagementModel InitializeModel(Guid accountId)
{
var accountDetail = _accountDao.FindById(accountId);
var orders = GetOrderDetails(accountId) ?? new List <OrderDetail>();
var ordersCount = orders.Count();
var accountAgeInDays = (DateTime.UtcNow - accountDetail.CreationDate).TotalDays;
var averageTripsPerDay = decimal.Round((decimal)(ordersCount / accountAgeInDays), 1);
var totalCanceled = GetOrderStatusDetails(accountId).Count(x => x.IBSStatusId == VehicleStatuses.Common.Cancelled || x.IBSStatusId == VehicleStatuses.Common.CancelledDone);
var totalCompleted = orders.Count(order => order.Status == (int)OrderStatus.Completed);
var totalNoShow = GetOrderStatusDetails(accountId).Count(x => x.IBSStatusId == VehicleStatuses.Common.NoShow);
var model = new AccountManagementModel
{
Id = accountId,
Name = accountDetail.Name,
Email = accountDetail.Email,
CustomerNumber = accountDetail.Settings.CustomerNumber,
CreationDate = accountDetail.CreationDate,
FacebookAccount = accountDetail.FacebookId,
IBSAccountId = accountDetail.IBSAccountId,
IsConfirmed = accountDetail.IsConfirmed,
IsEnabled = !accountDetail.DisabledByAdmin,
CountryCode = accountDetail.Settings.Country,
PhoneNumber = accountDetail.Settings.Phone,
ChargeType = accountDetail.Settings.ChargeType,
DefaultTipPercent = accountDetail.DefaultTipPercent,
IsPayPalAccountLinked = accountDetail.IsPayPalAccountLinked,
TotalCanceled = totalCanceled,
TotalCompleted = totalCompleted,
AverageTripsPerDay = averageTripsPerDay,
TotalNoShows = totalNoShow
};
if (accountDetail.DefaultCreditCard != null)
{
var defaultCreditCard = _creditCardDao.FindById(accountDetail.DefaultCreditCard.Value);
model.CreditCardLast4Digits = defaultCreditCard.Last4Digits;
}
model.Notes = _accountNoteService.FindByAccountId(accountId)
.OrderByDescending(c => c.CreationDate)
.Select(x => new NoteModel(x))
.ToList();
return(model);
}
/// <summary>
/// This endpoint is used by Cmt to send us the pairing token.
/// </summary>
public object Post(CmtPaymentPairingRequest request)
{
_logger.LogMessage("Pairing info received for order {0} and PairingToken {1}", request.OrderUuid, request.PairingToken ?? "Unknown");
if (Guid.Empty == request.OrderUuid || request.PairingToken.HasValueTrimmed())
{
throw new HttpError(HttpStatusCode.BadRequest, "400", "Missing required parameter");
}
var orderStatusDetail = _orderDao.FindOrderStatusById(request.OrderUuid);
if (orderStatusDetail == null)
{
throw new HttpError(HttpStatusCode.BadRequest, "401", "Cannot find OrderId");
}
var account = _accountDao.FindById(orderStatusDetail.AccountId);
if (!account.DefaultCreditCard.HasValue)
{
throw new HttpError(HttpStatusCode.BadRequest, "402", "User does not have a currently set creditcard");
}
var creditCard = _creditCardDao.FindById(account.DefaultCreditCard.Value);
var tripInfoServiceHelper = GetTripInfoServiceHelper(orderStatusDetail.CompanyKey);
var tripInfo = tripInfoServiceHelper.WaitForTripInfo(request.PairingToken, request.TimeoutSeconds ?? DefaultTimeoutSeconds);
_commandBus.Send(new PairForPayment
{
OrderId = request.OrderUuid,
Medallion = orderStatusDetail.VehicleNumber,
DriverId = tripInfo.DriverId.ToString(),
PairingToken = tripInfo.PairingToken,
TokenOfCardToBeUsedForPayment = creditCard.Token,
AutoTipPercentage = tripInfo.AutoTipPercentage
});
return(new CmtPaymentPairingResponse
{
CustomerId = account.Id,
CustomerName = account.Name,
CardOnFileId = creditCard.Token,
TripRequestNumber = orderStatusDetail.IBSStatusId
});
}
public PreAuthorizePaymentResponse PreAuthorize(string companyKey, Guid orderId, AccountDetail account, decimal amountToPreAuthorize, bool isReAuth = false, bool isSettlingOverduePayment = false, bool isForPrepaid = false, string cvv = null)
{
var message = string.Empty;
var transactionId = string.Empty;
DateTime?transactionDate = null;
try
{
bool isSuccessful;
var isCardDeclined = false;
var creditCard = _creditCardDao.FindById(account.DefaultCreditCard.GetValueOrDefault());
var order = _orderDao.FindOrderStatusById(orderId);
// We cannot re-use the same id has a previously failed payment
var shouldGenerateNewOrderId = isReAuth || isSettlingOverduePayment;
var orderIdentifier = shouldGenerateNewOrderId
? string.Format("{0}-{1}", orderId, GenerateShortUid())
: orderId.ToString();
if (amountToPreAuthorize > 0)
{
// PreAuthorize transaction
var monerisSettings = _serverPaymentSettings.MonerisPaymentSettings;
var customerId = monerisSettings.UseCarIdInTransaction
? order.SelectOrDefault(o => o.VehicleNumber)
: order != null?order.DriverInfos.SelectOrDefault(driverInfos => driverInfos.DriverId) : null;
var preAuthorizeCommand = new ResPreauthCC(creditCard.Token, orderIdentifier, customerId, amountToPreAuthorize.ToString("F"), CryptType_SSLEnabledMerchant);
AddCvvInfo(preAuthorizeCommand, cvv);
var info = new AvsInfo();
if (_serverPaymentSettings.EnableAddressVerification)
{
info.SetAvsStreetName(creditCard.StreetName);
info.SetAvsStreetNumber(creditCard.StreetNumber);
info.SetAvsZipCode(creditCard.ZipCode);
info.SetAvsCustPhone(creditCard.Phone);
info.SetAvsEmail(creditCard.Email);
preAuthorizeCommand.SetAvsInfo(info);
}
var preAuthRequest = MonerisHttpRequestWrapper.NewHttpsPostRequest(monerisSettings.Host, monerisSettings.StoreId, monerisSettings.ApiToken, preAuthorizeCommand);
var preAuthReceipt = preAuthRequest.GetAndLogReceipt(_logger);
isSuccessful = RequestSuccesful(preAuthReceipt, out message);
isCardDeclined = IsCardDeclined(preAuthReceipt);
transactionId = preAuthReceipt.GetTxnNumber();
transactionDate = GetTransactionDate(preAuthReceipt);
}
else
{
// if we're preauthorizing $0, we skip the preauth with payment provider
// but we still send the InitiateCreditCardPayment command
// this should never happen in the case of a real preauth (hence the minimum of $50)
isSuccessful = true;
}
if (isSuccessful && !isReAuth)
{
var paymentId = Guid.NewGuid();
_commandBus.Send(new InitiateCreditCardPayment
{
PaymentId = paymentId,
Amount = amountToPreAuthorize,
TransactionId = transactionId,
OrderId = orderId,
CardToken = creditCard.Token,
Provider = PaymentProvider.Moneris,
IsNoShowFee = false,
CompanyKey = companyKey
});
}
return(new PreAuthorizePaymentResponse
{
IsSuccessful = isSuccessful,
Message = message,
TransactionId = transactionId,
ReAuthOrderId = shouldGenerateNewOrderId ? orderIdentifier : null,
IsDeclined = isCardDeclined,
TransactionDate = transactionDate,
});
}
catch (Exception e)
{
_logger.LogMessage(string.Format("Error during preauthorization (validation of the card) for client {0}: {1} - {2}", account.Email, message, e));
_logger.LogError(e);
return(new PreAuthorizePaymentResponse
{
IsSuccessful = false,
Message = message
});
}
}
public PreAuthorizePaymentResponse PreAuthorize(string companyKey, Guid orderId, AccountDetail account, decimal amountToPreAuthorize, bool isReAuth = false, bool isSettlingOverduePayment = false, bool isForPrepaid = false, string cvv = null)
{
var message = string.Empty;
var transactionId = string.Empty;
DateTime?transactionDate = null;
try
{
bool isSuccessful;
var isCardDeclined = false;
var orderIdentifier = isReAuth ? string.Format("{0}-{1}", orderId, GenerateShortUid()) : orderId.ToString();
var creditCard = _creditCardDao.FindById(account.DefaultCreditCard.GetValueOrDefault());
if (amountToPreAuthorize > 0)
{
var transactionRequest = new TransactionRequest
{
Amount = amountToPreAuthorize,
PaymentMethodToken = creditCard.Token,
OrderId = orderIdentifier,
Channel = "MobileKnowledgeSystems_SP_MEC",
Options = new TransactionOptionsRequest
{
SubmitForSettlement = false
}
};
AddCvvInfo(transactionRequest, cvv);
//sale
var result = BraintreeGateway.Transaction.Sale(transactionRequest);
message = result.Message;
isSuccessful = result.IsSuccess();
isCardDeclined = IsCardDeclined(result.Transaction);
transactionId = isSuccessful ? result.Target.Id : result.Transaction.Id;
transactionDate = isSuccessful ? result.Target.CreatedAt : result.Transaction.CreatedAt;
}
else
{
// if we're preauthorizing $0, we skip the preauth with payment provider
// but we still send the InitiateCreditCardPayment command
// this should never happen in the case of a real preauth (hence the minimum of $50)
isSuccessful = true;
}
if (isSuccessful && !isReAuth)
{
var paymentId = Guid.NewGuid();
_commandBus.Send(new InitiateCreditCardPayment
{
PaymentId = paymentId,
Amount = amountToPreAuthorize,
TransactionId = transactionId,
OrderId = orderId,
CardToken = creditCard.Token,
Provider = PaymentProvider.Braintree,
IsNoShowFee = false,
CompanyKey = companyKey
});
}
return(new PreAuthorizePaymentResponse
{
IsSuccessful = isSuccessful,
Message = message,
TransactionId = transactionId,
ReAuthOrderId = isReAuth ? orderIdentifier : null,
IsDeclined = isCardDeclined,
TransactionDate = transactionDate
});
}
catch (Exception e)
{
_logger.LogMessage(string.Format("Error during preauthorization (validation of the card) for client {0}: {1} - {2}", account.Email, message, e));
_logger.LogError(e);
return(new PreAuthorizePaymentResponse
{
IsSuccessful = false,
Message = message
});
}
}
public object Post(ManualRideLinqPairingRequest request)
{
try
{
var accountId = new Guid(this.GetSession().UserAuthId);
var account = _accountDao.FindById(accountId);
ValidateAppVersion(account);
var currentRideLinq = _orderDao.GetCurrentManualRideLinq(request.PairingCode, account.Id);
if (currentRideLinq != null)
{
return(new ManualRideLinqResponse
{
Data = currentRideLinq,
IsSuccessful = true,
Message = "Ok"
});
}
var creditCard = account.DefaultCreditCard.HasValue
? _creditCardDao.FindById(account.DefaultCreditCard.Value)
: null;
if (creditCard == null)
{
throw new HttpError(HttpStatusCode.BadRequest,
ErrorCode.ManualRideLinq_NoCardOnFile.ToString(),
_resources.Get("ManualRideLinq_NoCardOnFile", account.Language));
}
if (creditCard.IsDeactivated)
{
throw new HttpError(HttpStatusCode.BadRequest,
ErrorCode.ManualRideLinq_CardOnFileDeactivated.ToString(),
_resources.Get("ManualRideLinq_CreditCardDisabled", account.Language));
}
// Send pairing request to CMT API
var pairingRequest = new ManualRideLinqCoFPairingRequest
{
AutoTipPercentage = account.DefaultTipPercent ?? _serverSettings.ServerData.DefaultTipPercentage,
CustomerId = accountId.ToString(),
CustomerName = account.Name,
Latitude = request.PickupAddress.Latitude,
Longitude = request.PickupAddress.Longitude,
PairingCode = request.PairingCode,
AutoCompletePayment = true,
CardOnFileId = creditCard.Token,
LastFour = creditCard.Last4Digits,
ZipCode = creditCard.ZipCode,
Email = account.Email,
CustomerIpAddress = RequestContext.IpAddress,
BillingFullName = creditCard.NameOnCard,
SessionId = request.KountSessionId
};
_logger.LogMessage("Pairing for manual RideLinq with Pairing Code {0}", request.PairingCode);
var response = _cmtMobileServiceClient.Post(pairingRequest);
_logger.LogMessage("Pairing result: {0}", response.ToJson());
var trip = _cmtTripInfoServiceHelper.WaitForTripInfo(response.PairingToken, response.TimeoutSeconds);
if (trip.HttpStatusCode == (int)HttpStatusCode.OK)
{
var command = new CreateOrderForManualRideLinqPair
{
OrderId = Guid.NewGuid(),
AccountId = accountId,
UserAgent = Request.UserAgent,
ClientVersion = Request.Headers.Get("ClientVersion"),
PairingCode = request.PairingCode,
PickupAddress = request.PickupAddress,
PairingToken = response.PairingToken,
PairingDate = DateTime.Now,
ClientLanguageCode = request.ClientLanguageCode,
Distance = trip.Distance,
StartTime = trip.StartTime,
EndTime = trip.EndTime,
Extra = Math.Round(((double)trip.Extra / 100), 2),
Fare = Math.Round(((double)trip.Fare / 100), 2),
Tax = Math.Round(((double)trip.Tax / 100), 2),
Tip = Math.Round(((double)trip.Tip / 100), 2),
Toll = trip.TollHistory.Sum(toll => Math.Round(((double)toll.TollAmount / 100), 2)),
Surcharge = Math.Round(((double)trip.Surcharge / 100), 2),
Total = Math.Round(((double)trip.Total / 100), 2),
FareAtAlternateRate = Math.Round(((double)trip.FareAtAlternateRate / 100), 2),
Medallion = response.Medallion,
DeviceName = response.DeviceName,
RateAtTripStart = trip.RateAtTripStart,
RateAtTripEnd = trip.RateAtTripEnd,
RateChangeTime = trip.RateChangeTime,
TripId = trip.TripId,
DriverId = trip.DriverId,
LastFour = trip.LastFour,
AccessFee = Math.Round(((double)trip.AccessFee / 100), 2),
OriginatingIpAddress = request.CustomerIpAddress,
KountSessionId = request.KountSessionId,
CreditCardId = creditCard.CreditCardId,
};
_commandBus.Send(command);
var data = new OrderManualRideLinqDetail
{
OrderId = command.OrderId,
Distance = trip.Distance,
StartTime = trip.StartTime,
EndTime = trip.EndTime,
Extra = command.Extra,
Fare = command.Fare,
Tax = command.Tax,
Tip = command.Tip,
Toll = command.Toll,
Surcharge = command.Surcharge,
Total = command.Total,
FareAtAlternateRate = command.FareAtAlternateRate,
Medallion = response.Medallion,
DeviceName = response.DeviceName,
RateAtTripStart = command.RateAtTripStart,
RateAtTripEnd = command.RateAtTripEnd,
RateChangeTime = trip.RateChangeTime,
AccountId = accountId,
PairingDate = command.PairingDate,
PairingCode = pairingRequest.PairingCode,
PairingToken = trip.PairingToken,
DriverId = trip.DriverId,
LastFour = command.LastFour,
AccessFee = command.AccessFee
};
return(new ManualRideLinqResponse
{
Data = data,
IsSuccessful = true,
Message = "Ok",
TripInfoHttpStatusCode = trip.HttpStatusCode,
ErrorCode = trip.ErrorCode.ToString()
});
}
else
{
if (trip.HttpStatusCode == (int)HttpStatusCode.BadRequest)
{
switch (trip.ErrorCode)
{
case CmtErrorCodes.CreditCardDeclinedOnPreauthorization:
_notificationService.SendCmtPaymentFailedPush(accountId, _resources.Get("CreditCardDeclinedOnPreauthorizationErrorText", request.ClientLanguageCode));
break;
case CmtErrorCodes.UnablePreauthorizeCreditCard:
_notificationService.SendCmtPaymentFailedPush(accountId, _resources.Get("CreditCardUnableToPreathorizeErrorText", request.ClientLanguageCode));
break;
default:
_notificationService.SendCmtPaymentFailedPush(accountId, _resources.Get("TripUnableToPairErrorText", request.ClientLanguageCode));
break;
}
}
return(new ManualRideLinqResponse
{
IsSuccessful = false,
TripInfoHttpStatusCode = trip.HttpStatusCode,
ErrorCode = trip.ErrorCode != null?trip.ErrorCode.ToString() : null
});
}
}
catch (WebServiceException ex)
{
_logger.LogMessage(
string.Format("A WebServiceException occured while trying to manually pair with CMT with pairing code: {0}",
request.PairingCode));
_logger.LogError(ex);
ErrorResponse errorResponse = null;
if (ex.ResponseBody != null)
{
_logger.LogMessage("Error Response: {0}", ex.ResponseBody);
errorResponse = ex.ResponseBody.FromJson <ErrorResponse>();
}
return(new ManualRideLinqResponse
{
IsSuccessful = false,
Message = errorResponse != null ? errorResponse.Message : ex.ErrorMessage,
ErrorCode = errorResponse != null?errorResponse.ResponseCode.ToString() : ex.ErrorCode
});
}
catch (Exception ex)
{
_logger.LogMessage(string.Format("An error occured while trying to manually pair with CMT with pairing code: {0}", request.PairingCode));
_logger.LogError(ex);
return(new ManualRideLinqResponse
{
IsSuccessful = false,
Message = ex.Message
});
}
}
public object Get(CreditCardInfoRequest request)
{
return(_dao.FindById(request.CreditCardId));
}
