protected override void LoadKernelDefaultConfigurationDataObjects(TransactionTypeEnum transactionTypeEnum, IConfigurationProvider configProvider)
{
Logger.Log("Using Global Kernel 3 Values:");
Kernel3Configuration = XMLUtil <Kernel3Configuration> .Deserialize(configProvider.GetKernel3GlobalConfigurationDataXML());
#region 3.3.4.2 and 3.3.4.3
TERMINAL_TRANSACTION_QUALIFIERS_9F66_KRN ttq = new TERMINAL_TRANSACTION_QUALIFIERS_9F66_KRN(this);
if (Kernel3Configuration.FDDAForOnlineSupported)
{
ttq.Value.OfflineDataAuthenticationForOnlineAuthorizationsSupported = true;
}
else
{
ttq.Value.OfflineDataAuthenticationForOnlineAuthorizationsSupported = false;
}
#endregion
Logger.Log("Using Kernel 3 Defaults:");
KernelConfigurationDataForTransactionType kcdott = new KernelConfigurationDataForTransactionType()
{
TransactionTypeEnum = transactionTypeEnum,
KernelConfigurationDataObjects = TLVListXML.XmlDeserialize(configProvider.GetKernel3ConfigurationDataXML(Formatting.ByteArrayToHexString(new byte[] { (byte)transactionTypeEnum })))
};
int depth = 0;
Logger.Log("Transaction Type: " + transactionTypeEnum + " Using Kernel3 Defaults: \n" + kcdott.KernelConfigurationDataObjects.ToPrintString(ref depth));
KernelConfigurationData.Add(kcdott);
}
private static Collection <StockAdjustmentDetail> GetModels(string json)
{
Collection <StockAdjustmentDetail> models = new Collection <StockAdjustmentDetail>();
JavaScriptSerializer jss = new JavaScriptSerializer();
dynamic result = jss.Deserialize <dynamic>(json);
foreach (var item in result)
{
StockAdjustmentDetail detail = new StockAdjustmentDetail();
TransactionTypeEnum typeEnum = TransactionTypeEnum.Credit;
if (Conversion.TryCastString(item[0]).ToString().Equals("Dr"))
{
typeEnum = TransactionTypeEnum.Debit;
}
detail.TransferTypeEnum = typeEnum;
detail.StoreName = Conversion.TryCastString(item[1]);
detail.ItemCode = Conversion.TryCastString(item[2]);
detail.ItemName = Conversion.TryCastString(item[3]);
detail.UnitName = Conversion.TryCastString(item[4]);
detail.Quantity = Conversion.TryCastInteger(item[5]);
models.Add(detail);
}
return(models);
}
public Kernel(TransactionTypeEnum tt, CardQProcessor cardQProcessor, PublicKeyCertificateManager publicKeyCertificateManager, EntryPointPreProcessingIndicators processingIndicatorsForSelected, CardExceptionManager cardExceptionManager, IConfigurationProvider configProvider, EMVSelectApplicationResponse emvSelectApplicationResponse)
: base(cardQProcessor, publicKeyCertificateManager, processingIndicatorsForSelected, cardExceptionManager, configProvider)
{
database = new KernelDatabase(publicKeyCertificateManager);
database.InitializeDefaultDataObjects(tt, configProvider);
this.emvSelectApplicationResponse = emvSelectApplicationResponse;
}
public void ActiveOrder(string tansctionId, bool isApproved, TransactionTypeEnum tansctionType, DateTime tansctionTime, string tansctionMeta)
{
var tansction = TransactionRecord.Create(
tansctionId,
isApproved,
tansctionType,
tansctionTime,
tansctionMeta
);
TransactionRecords.Add(tansction);
if (isApproved)
{
// redeem coupons if user used, and make sure apply to this user one time only
var coupons = OrderCoupons.Select(oc => oc.Coupon);
foreach(var c in coupons)
{
c.Redeem(User);
}
Approve();
}
else
{
Reject();
}
}
public TransactionRequest(long amount, long amountOther, TransactionTypeEnum transactionTypeEnum)
{
this.amount = amount;
this.amountOther = amountOther;
this.transactionTypeEnum = transactionTypeEnum;
this.transactionDate = DateTime.Now;
}
private static Transaction ParseTransaction(string accountId, string tType, string tDate, string tAmt, string tMemo)
{
tType = RemoveTabsAndSpaces(tType);
tDate = RemoveTabsAndSpaces(tDate);
tAmt = RemoveTabsAndSpaces(tAmt).Replace('.', ',');
tMemo = RemoveTabsAndSpaces(tMemo);
TransactionTypeEnum parsedTransactionType = TransactionTypeEnum.ATM;
float parsedAmount;
DateTime parsedDate = DateTime.Now;
parsedDate = ParseDatetime(tDate);
if (!Enum.TryParse(tType, out parsedTransactionType) ||
!float.TryParse(tAmt, out parsedAmount) ||
string.IsNullOrEmpty(tMemo))
{
throw new Exception();
}
return(new Transaction {
AccountId = accountId,
Type = parsedTransactionType,
Value = parsedAmount,
Date = parsedDate,
Memo = tMemo
});
}
protected override void LoadKernelDefaultConfigurationDataObjects(TransactionTypeEnum transactionTypeEnum, IConfigurationProvider configProvider)
{
Logger.Log("Using Kernel 2 Defaults:");
KernelConfigurationDataForTransactionType kcdott = new KernelConfigurationDataForTransactionType()
{
TransactionTypeEnum = transactionTypeEnum,
KernelConfigurationDataObjects = TLVListXML.XmlDeserialize(configProvider.GetKernel2ConfigurationDataXML(Formatting.ByteArrayToHexString(new byte[] { (byte)transactionTypeEnum })))
};
int depth = 0;
Logger.Log("Transaction Type: " + transactionTypeEnum + " Using Kernel2 Defaults: \n" + kcdott.KernelConfigurationDataObjects.ToPrintString(ref depth));
TLV _9f1d = kcdott.KernelConfigurationDataObjects.Get(EMVTagsEnum.TERMINAL_RISK_MANAGEMENT_DATA_9F1D_KRN.Tag);
TERMINAL_CAPABILITIES_9F33_KRN tc = new TERMINAL_CAPABILITIES_9F33_KRN(kcdott.KernelConfigurationDataObjects.Get(EMVTagsEnum.TERMINAL_CAPABILITIES_9F33_KRN.Tag));
if (tc.Value.EncipheredPINForOnlineVerificationCapable)
{
Formatting.SetBitPosition(ref _9f1d.Value[0], true, 7);
}
KERNEL_CONFIGURATION_DF811B_KRN2 kc = new KERNEL_CONFIGURATION_DF811B_KRN2(kcdott.KernelConfigurationDataObjects.Get(EMVTagsEnum.KERNEL_CONFIGURATION_DF811B_KRN2.Tag));
if (kc.Value.OnDeviceCardholderVerificationSupported)
{
Formatting.SetBitPosition(ref _9f1d.Value[0], true, 3);
}
KernelConfigurationData.Add(kcdott);
}
public Transaction(int transactionId, TransactionTypeEnum transactionType, DateTime timestamp, decimal amount)
{
TransactionId = transactionId;
TransactionType = transactionType;
Timestamp = timestamp;
Amount = amount;
}
public void ExecuteTransaction(TransactionTypeEnum transactionType, decimal value)
{
try
{
_transactionLock.Wait();
switch (transactionType)
{
case TransactionTypeEnum.WithDrawal:
Withdrawal(value);
break;
case TransactionTypeEnum.Deposit:
Deposit(value);
break;
default:
throw new ArgumentOutOfRangeException(nameof(transactionType), transactionType, null);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
throw;
}
finally
{
_transactionLock.Release();
}
}
//[Authorize]
public IActionResult GetDeliveryOrder(Guid hblid, TransactionTypeEnum type)
{
string transactionType = DataTypeEx.GetType(type);
var result = arrivalFreightChargeServices.GetDeliveryOrder(hblid, transactionType);
return(Ok(result));
}
public Kernel2(TransactionTypeEnum tt, TornTransactionLogManager tornTransactionLogManager, CardQProcessor cardQProcessor, PublicKeyCertificateManager publicKeyCertificateManager, EntryPointPreProcessingIndicators processingIndicatorsForSelected, CardExceptionManager cardExceptionManager, IConfigurationProvider configProvider)
: base(cardQProcessor, publicKeyCertificateManager, processingIndicatorsForSelected, cardExceptionManager, configProvider)
{
this.tornTransactionLogManager = tornTransactionLogManager;
database = new Kernel2Database(publicKeyCertificateManager);
database.InitializeDefaultDataObjects(tt, configProvider);
}
public ShardingConnection(IDictionary <string, IDataSource> dataSourceMap, ShardingRuntimeContext runtimeContext,
TransactionTypeEnum transactionType) : this(
dataSourceMap,
runtimeContext,
transactionType,
dataSourceMap.Values.FirstOrDefault(o => o.IsDefault())?.CreateConnection() ?? throw new ShardingException("not found default data source"))
{
}
public ShardingConnection(IDictionary <string, IDataSource> dataSourceMap, ShardingRuntimeContext runtimeContext,
TransactionTypeEnum transactionType, DbConnection defaultDbConnection)
{
_dataSourceMap = dataSourceMap;
_runtimeContext = runtimeContext;
_transactionType = transactionType;
_defaultDbConnection = defaultDbConnection;
}
public TransactionViewItem(ITransactionViewEntity viewEntity, int sourceUser)
{
this.Id = viewEntity.Id;
this.Amount = viewEntity.Amount;
this.User = sourceUser == viewEntity.UserFrom.Id ? new UserViewItem(viewEntity.UserTo) : new UserViewItem(viewEntity.UserFrom);
this.Date = viewEntity.Date;
this.TypeEnum = sourceUser == viewEntity.UserFrom.Id ? TransactionTypeEnum.Credit : TransactionTypeEnum.Debit;
}
internal TLVList Get(TransactionTypeEnum transactionType)
{
foreach (KernelConfigurationDataForTransactionType kct in KernelConfigurationDataObjects)
{
if (kct.TransactionTypeEnum == transactionType)
{
return(kct.KernelConfigurationDataObjects);
}
}
return(new TLVList());
}
public static TransactionRecord Create(string id, bool isApproved, TransactionTypeEnum type, DateTime createTime, string metadata)
{
return(new TransactionRecord()
{
Id = id,
CreateDateUTC = createTime,
Status = isApproved ? TransactionStatusEnum.Approved : TransactionStatusEnum.Rejected,
Type = type,
Metadata = metadata
});
}
public TLV Get(string tag, TransactionTypeEnum transactionType)
{
foreach (KernelConfigurationDataForTransactionType kct in KernelConfigurationDataObjects)
{
if (kct.TransactionTypeEnum == transactionType)
{
return(kct.KernelConfigurationDataObjects.Get(tag));
}
}
return(null);
}
public ActionResult <ApiResponse <object> > TransferAssets([FromBody] TransferAssetsMessage message)
{
TransactionTypeEnum transactionType = message.TransactionType.ParseToEnum <TransactionTypeEnum>();
return(this.HandleResult(
() =>
serviceContext.AccountManagerService.TransferAssets(
message.FromAccountId,
message.ToAccountId,
message.Amount,
transactionType)));
}
public static decimal GetPriceMultiplier(this TransactionTypeEnum transactionType)
{
switch (transactionType)
{
case TransactionTypeEnum.Buy:
return(1m);
case TransactionTypeEnum.Sell:
return(-1m);
}
throw new NotImplementedException();
}
public TransactionOrderDomainEntity CreateTransactionOrder(
TransactionTypeEnum transactionType,
string orderDescription,
DateTime operationDate,
int fromAccountId,
int toAccountId,
decimal amount)
{
var fromAccount = GetAccountById(fromAccountId);
var toAccount = GetAccountById(toAccountId);
return(CreateTransactionOrder(transactionType, orderDescription, operationDate, fromAccount, toAccount, amount));
}
public TransactionCreatorService(ILogger logger, IMapper mapper, int accountId, decimal amount, DateTime date, IAccountRepositoryAsync accountRepo, ITransactionRepositoryAsync transRepo, TransactionStatusEnum status, TransactionTypeEnum type, string server500Error)
{
this._logger = logger;
this._mapper = mapper;
this._accountId = accountId;
this._amount = amount;
this._date = date;
this._accountRepo = accountRepo;
this._transRepo = transRepo;
this._status = status;
this._type = type;
this._server500Error = server500Error;
}
/// <summary>
/// Does assets transfer from one account to another account with given TransactionType
/// </summary>
/// <param name="fromAccount"></param>
/// <param name="toAccount"></param>
/// <param name="amount"></param>
/// <param name="transactionTypeEnum"></param>
private void TransferAssets(
AccountDomainEntity fromAccount,
AccountDomainEntity toAccount,
decimal amount,
TransactionTypeEnum transactionTypeEnum)
{
AccountTransactionDomainEntity transaction = null;
bool isWithdrawOk = false;
bool isDepositOk = false;
try
{
if (fromAccount.AccountType.AccountTypeKey != toAccount.AccountType.AccountTypeKey)
{
throw new AccountManagementException.DifferentAccountTypesCouldNotTransferAssetsToEachOther(string
.Format("FromAccountType: {0} - ToAccountType: {1}", fromAccount.AccountType.AccountTypeName, toAccount.AccountType.AccountTypeName));
}
transaction = coreContext.New <AccountTransactionDomainEntity>()
.With(fromAccount, toAccount, amount, transactionTypeEnum, TransactionStatusEnum.InProgress, null);
transaction.Insert();
isWithdrawOk = fromAccount.Withdraw(amount);
isDepositOk = toAccount.Deposit(amount);
transaction.SetStatus(TransactionStatusEnum.Succeeded);
transaction.Save();
var transactionDetailIn = transaction.CreateTransactionDetail(TransactionDirection.In);
transactionDetailIn.Insert();
var transactionDetailOut = transaction.CreateTransactionDetail(TransactionDirection.Out);
transactionDetailOut.Insert();
}
catch (Exception ex)
{
if (transaction != null)
{
if (isWithdrawOk && isDepositOk == false)
{
fromAccount.Deposit(amount);
transaction.SetStatus(TransactionStatusEnum.Failed);
transaction.Save();
}
}
throw ex;
}
}
public Transaction registerTransaction(CalculResultBean calculBean, TransactionTypeEnum transactionType)
{
using (var context = new bourseContainer())
{
decimal giftCouponValue = calculBean.totalBonCadeau;
decimal couponValue = calculBean.totalAvoir;
decimal usedCouponExchangeValue = calculBean.totalEchangeAndAvoirUtil;
decimal exchangeValue = calculBean.totalEchange;
decimal convertedCouponExchangeValue = calculBean.avoirEchangeConverti;
decimal discountOfferValue = calculBean.totalRemise;
decimal payCardValue = calculBean.monnaiePayeeCB;
decimal cashValue = calculBean.monnaiePayeeESP;
decimal realCashValue = calculBean.monnaiePayeeReelESP;
decimal emittedCouponValue = calculBean.ARendreAvoir;
decimal emittedCashValue = calculBean.ARendreESP;
decimal realEmittedCashValue = calculBean.ARendreReelESP;
decimal totalSalesValue = calculBean.totalProduits;
decimal totalBuyValue = calculBean.totalEchange;
int productCount = calculBean.productCount;
string store = ""; //TODO
Transaction transaction = new Transaction
{
giftCouponValue = giftCouponValue,
couponValue = couponValue,
usedCouponExchangeValue = usedCouponExchangeValue,
exchangeValue = exchangeValue,
convertedCouponExchangeValue = convertedCouponExchangeValue,
discountOfferValue = discountOfferValue,
paycardValue = payCardValue,
cashValue = cashValue,
realCashValue = realCashValue,
emittedCashValue = emittedCashValue,
realEmittedCashValue = realEmittedCashValue,
totalSalesValue = totalSalesValue,
totalBuyValue = totalBuyValue,
productCount = productCount,
store = store,
datetime = DateTime.Now,
transactionType = transactionType.ToString()
};
context.Entry(transaction).State = EntityState.Added;
context.SaveChanges();
context.Entry(transaction).State = EntityState.Detached;
return(transaction);
}
}
public Transaction registerTransaction(CalculResultBean calculBean, TransactionTypeEnum transactionType)
{
using (var context = new bourseContainer())
{
decimal giftCouponValue = calculBean.totalBonCadeau;
decimal couponValue = calculBean.totalAvoir;
decimal usedCouponExchangeValue = calculBean.totalEchangeAndAvoirUtil;
decimal exchangeValue = calculBean.totalEchange;
decimal convertedCouponExchangeValue = calculBean.avoirEchangeConverti;
decimal discountOfferValue = calculBean.totalRemise;
decimal payCardValue = calculBean.monnaiePayeeCB;
decimal cashValue = calculBean.monnaiePayeeESP;
decimal realCashValue = calculBean.monnaiePayeeReelESP;
decimal emittedCouponValue = calculBean.ARendreAvoir;
decimal emittedCashValue = calculBean.ARendreESP;
decimal realEmittedCashValue = calculBean.ARendreReelESP;
decimal totalSalesValue = calculBean.totalProduits;
decimal totalBuyValue = calculBean.totalEchange;
int productCount = calculBean.productCount;
string store = ""; //TODO
Transaction transaction = new Transaction
{
giftCouponValue = giftCouponValue,
couponValue = couponValue,
usedCouponExchangeValue = usedCouponExchangeValue,
exchangeValue = exchangeValue,
convertedCouponExchangeValue = convertedCouponExchangeValue,
discountOfferValue = discountOfferValue,
paycardValue = payCardValue,
cashValue = cashValue,
realCashValue = realCashValue,
emittedCashValue = emittedCashValue,
realEmittedCashValue = realEmittedCashValue,
totalSalesValue = totalSalesValue,
totalBuyValue = totalBuyValue,
productCount = productCount,
store = store,
datetime = DateTime.Now,
transactionType = transactionType.ToString()
};
context.Entry(transaction).State = EntityState.Added;
context.SaveChanges();
context.Entry(transaction).State = EntityState.Detached;
return transaction;
}
}
public AccountTransactionDomainEntity With(
ITransactionOwner from,
ITransactionOwner to,
decimal amount,
TransactionTypeEnum type,
TransactionStatusEnum status,
ITransactionOwner transactionOwner)
{
var transactionType = coreContext.Query <ITransactionTypeRepository>()
.GetByKey(type.ToString());
var transactionStatus = coreContext.Query <ITransactionStatusRepository>()
.GetByKey(status.ToString());
return(With(from, to, amount, transactionType, transactionStatus, transactionOwner));
}
public void InitializeDefaultDataObjects(TransactionTypeEnum tt, IConfigurationProvider configProvider)
{
DataObjects = new TLVList();
LoadKernelDefaultConfigurationDataObjects(tt, configProvider);
TLVList defaults = KernelConfigurationData.Get(tt);
foreach (TLV tlv in defaults)
{
byte[] val = new byte[tlv.Value.Length];
Array.Copy(tlv.Value, 0, val, 0, val.Length);
AddToList(TLV.Create(tlv.Tag.TagLable, val));
}
ActiveAFL = new APPLICATION_FILE_LOCATOR_AFL_94_KRN(this);
}
//Forming the Unique ChacheId
private string UniqueCachingKey(TransactionHistoryInput pageinput)
{
string terminalId = pageinput.LIDValue;
PaginationTransactionHistory page = pageinput.Page;
TransactionTypeEnum transactionType = page.TransactionType;
var key = _localizer["UniqueKeyTerminalList"] + "_" + transactionType.ToString() + "_" + terminalId;
if (page.PageSize > 0)
{
key = key + "_PageSize_" + page.PageSize;
}
if (page.SkipRecordNumber > 0)
{
key = key + "_SkipRecord_" + page.SkipRecordNumber;
}
if (page.SortField != null)
{
key = key + "_" + page.SortField + "_" + page.SortFieldByAsc;
}
if (page.FilterByAmount != null)
{
key = key + "_FilterByAmount_" + page.FilterByAmount;
}
if (page.FilterByDate != null)
{
key = key + "_FilterByDate_" + page.FilterByDate;
}
if (page.FilterByLast4 != null)
{
key = key + "_FilterByLast4_" + page.FilterByLast4;
}
if (page.FilterByNetworkCD != null)
{
key = key + "_FilterByNetworkCD_" + page.FilterByNetworkCD;
}
if (page.FilterByTranType != null)
{
key = key + "_FilterByTranType_" + page.FilterByTranType;
}
return(key);
}
private TransactionOrderDomainEntity CreateTransactionOrder(
TransactionTypeEnum transactionType,
string orderDescription,
DateTime operationDate,
AccountDomainEntity fromAccount,
AccountDomainEntity toAccount,
decimal amount)
{
TransactionOrderDomainEntity transactionOrder = coreContext
.New <TransactionOrderDomainEntity>()
.With(transactionType, orderDescription, operationDate, fromAccount, toAccount, amount, TransactionStatusEnum.Created);
transactionOrder.Insert();
return(transactionOrder);
}
public static void WriteTransactionType()
{
using (var ctx = new VarlikContext())
{
TransactionTypeEnum transactionTypeEnum = new TransactionTypeEnum();
transactionTypeEnum.Code = "coin_sales";
transactionTypeEnum.Name = "Coin Satışı";
ctx.TransactionTypeEnum.Add(transactionTypeEnum);
ctx.SaveChanges();
transactionTypeEnum = new TransactionTypeEnum();
transactionTypeEnum.Code = "coin_purchasing";
transactionTypeEnum.Name = "Coin Alımı";
ctx.TransactionTypeEnum.Add(transactionTypeEnum);
ctx.SaveChanges();
transactionTypeEnum = new TransactionTypeEnum();
transactionTypeEnum.Code = "to_bank";
transactionTypeEnum.Name = "Para Çekme";
ctx.TransactionTypeEnum.Add(transactionTypeEnum);
ctx.SaveChanges();
transactionTypeEnum = new TransactionTypeEnum();
transactionTypeEnum.Code = "from_bank";
transactionTypeEnum.Name = "Para Yatırma";
ctx.TransactionTypeEnum.Add(transactionTypeEnum);
ctx.SaveChanges();
transactionTypeEnum = new TransactionTypeEnum();
transactionTypeEnum.Code = "to_wallet";
transactionTypeEnum.Name = "Cüzdana Aktar";
ctx.TransactionTypeEnum.Add(transactionTypeEnum);
ctx.SaveChanges();
transactionTypeEnum = new TransactionTypeEnum();
transactionTypeEnum.Code = "from_wallet";
transactionTypeEnum.Name = "Cüzdandan Aktar";
ctx.TransactionTypeEnum.Add(transactionTypeEnum);
ctx.SaveChanges();
}
}
public static string GetType(TransactionTypeEnum type)
{
string result = "";
switch (type)
{
case TransactionTypeEnum.InlandTrucking:
result = TermData.InlandTrucking;
break;
case TransactionTypeEnum.AirExport:
result = TermData.AirExport;
break;
case TransactionTypeEnum.AirImport:
result = TermData.AirImport;
break;
case TransactionTypeEnum.SeaConsolExport:
result = TermData.SeaConsolExport;
break;
case TransactionTypeEnum.SeaConsolImport:
result = TermData.SeaConsolImport;
break;
case TransactionTypeEnum.SeaFCLExport:
result = TermData.SeaFCLExport;
break;
case TransactionTypeEnum.SeaFCLImport:
result = TermData.SeaFCLImport;
break;
case TransactionTypeEnum.SeaLCLExport:
result = TermData.SeaLCLExport;
break;
case TransactionTypeEnum.SeaLCLImport:
result = TermData.SeaLCLImport;
break;
default:
break;
}
return(result);
}
public Transaction(TransactionTypeEnum transactionType, Money amount, DateTime transactionTime)
: this()
{
if (transactionTime > DateTime.Now)
{
throw new InvalidOperationException("You can't have a future dated transaction");
}
if (amount > 0)
{
throw new ArgumentException("You cannot perform a transaction for a zero amount.");
}
this.transactionType = transactionType;
this.amount = amount;
this.transactionTime = transactionTime;
}