public void Cannot_get_non_existing_transaction_for_single_date()
{
ITransactionRepository repository = new TransactionRepository();
var fromDb = repository.GetByDate(_transaction1.Date.AddDays(-1));
Assert.AreEqual(0, fromDb.Count);
}
protected void btnCheckIn_Click(object sender, EventArgs e)
{
using (CrackerEntities myEntity = new CrackerEntities())
{
ITransactionRepository transactionRepo = new TransactionRepository();
IBugRepository bugRepo = new BugRepository();
string bugName = Request.QueryString.Get("BugID");
var bugId = bugRepo.GetBugIdByTitle(bugName);
Transaction myTransaction = new Transaction
{
BugId = (int)bugId,
ChangedBy = HttpContext.Current.User.Identity.Name,
ChangedOn = DateTime.Now,
StatusId = Int32.Parse(((DropDownList)LoginView1.FindControl("ddlResolution")).SelectedValue),
TimeSpent = Int32.Parse(((TextBox)LoginView1.FindControl("txtTime")).Text),
LanguageId = Int32.Parse(((DropDownList)LoginView1.FindControl("ddlLanguages")).SelectedValue),
Note = HttpUtility.HtmlEncode(((TextBox)LoginView1.FindControl("txtNote")).Text)
};
transactionRepo.InsertTransaction(myTransaction);
transactionRepo.Save();
}
Response.Redirect("~/Default.aspx");
}
public void Init()
{
_server = MongoServer.Create();
var database = _server["kapital-tests"];
var collection = database.GetCollection<Transaction>("transactions");
_repository = new TransactionRepository(collection);
_transactions = _repository.GetAll();
_toAdd = CreateNewTransaction("Add:TransactionRepository_BasicCrud_Tests");
_repository.Add(_toAdd);
_findBy = _repository.FindBy(t => t.AccountId == _accountId).ToList();
_toDelete = CreateNewTransaction("Delete:TransactionRepository_BasicCrud_Tests");
_repository.Add(_toDelete);
_repository.Delete(_toDelete.Id);
_toDeletePost = _repository.FindBy(t => t.Id == _toDelete.Id).SingleOrDefault();
_toEdit = CreateNewTransaction("Edit:TransactionRepository_BasicCrud_Tests");
_repository.Add(_toEdit);
_toEdit.Description = "Editted:TransactionRepository_BasicCrud_Tests";
_repository.Edit(_toEdit);
_toEditPost = _repository.FindBy(t => t.Id == _toEdit.Id).SingleOrDefault();
}
private DataProvider()
{
Companies = new CompanyRepository();
Addresses = new AddressRepository();
Accounts = new AccountRepsitory();
Employees = new EmployeeRepository();
Transactions = new TransactionRepository();
}
public ReturnState ChargeCreditCard(CustomerObject co, Promotion promo, int payTypeFk, decimal budget)
{
var sw = new ServiceClientWrapper();
var gr = sw.CreateProfile(co);
if (gr != null && gr.isGood && !gr.isError)
{
var refNum = gr.CustomerRefNum;
gr = sw.AuthorizeAndCapture(refNum, double.Parse(budget.ToString()));
if (gr != null && gr.isApproved && !gr.isError && gr.ResponseCode == "00")
{
var tr = new TransactionRepository(_dbcontext);
var amount = decimal.Parse(gr.amountRedeemedNoDecimal);
var cp =
_dbcontext.CreditCardProfiles.Add(new CreditCardProfile
{
CustomerRefNum = refNum,
CustomerFK = promo.ProductGroup.CustomerFK
});
var tran = _dbcontext.Transactions.Add(new Transaction
{
CreatedDate = DateTime.Now,
Amount = amount,
CreditCardProfileFK = cp.CreditCardProfilePK,
AuthCode = gr.AuthCode,
TxRefNum = gr.TxRefNum
});
tran.SemplestTransactions.Add(new SemplestTransaction
{
CreatedDate = DateTime.Now,
Amount = amount,
TransactionTypeFK = tr.GetTransactionTypeCode("MediaSpend")
});
promo.RemainingBudgetInCycle += amount;
promo.StartBudgetInCycle += amount;
promo.CreditCardProfileFK = cp.CreditCardProfilePK;
_dbcontext.PromotionBudgets.Add(new PromotionBudget
{
TransactionsFK = tran.TransactionsPK,
PromotionFK = promo.PromotionPK,
BudgetCarryOverAmount = 0,
BudgetToAddAmount = amount,
BudgetToAddDate = DateTime.Now,
CreatedDate = DateTime.Now,
IsValid = true,
IsAppliedToPromotion = true
});
return new ReturnState(false, false, string.Empty, null);
}
return gr == null
? new ReturnState(true, false, "Server Exception", null)
: new ReturnState(true, true, gr.Message, null);
}
return gr == null
? new ReturnState(true, false, "Server Exception", null)
: new ReturnState(true, true, "Card Declined", null);
}
public ModelContext()
: base("CashManager")
{
Configuration.ValidateOnSaveEnabled = false;
OrderRepository = new OrderRepository();
SessionRepository = new SessionRepository();
TransactionRepository = new TransactionRepository();
UserRepository = new UserRepository();
}
public void Can_get_all()
{
ITransactionRepository repository = new TransactionRepository();
var fromDb = repository.GetAll();
Assert.AreEqual(3, fromDb.Count);
Assert.IsTrue(IsInCollection(_transaction1, fromDb));
Assert.IsTrue(IsInCollection(_transaction2, fromDb));
Assert.IsTrue(IsInCollection(_transaction3, fromDb));
}
public void Can_delete_existing_transaction()
{
var transaction = _transaction1;
ITransactionRepository repository = new TransactionRepository();
repository.Remove(transaction);
using (ISession session = SessionFactory.OpenSession())
{
var fromDb = session.Get<Transaction>(transaction.Id);
Assert.IsNull(fromDb);
}
}
public static void DeleteAssociatedTransactionsFromDatabase(Account account)
{
if (TransactionRepository.Data == null)
{
return;
}
var transactionsToDelete = TransactionRepository.GetRelatedTransactions(account);
foreach (FinancialTransaction transaction in transactionsToDelete)
{
TransactionRepository.Delete(transaction);
}
}
private static Iso8583Message GetReversalMessage(Iso8583Message isoMsg, out bool isReversal)
{
isReversal = true;
string originalDataElement;
try
{
originalDataElement = isoMsg.Fields[MessageField.ORIGINAL_DATA_ELEMENT_FIELD].ToString().TrimStart('0');
}
catch (Exception ex)
{
MessageLogger.LogError("Original data element is empty1 " + ex.Message + " Inner Exception: " + ex.InnerException);
isReversal = false;
SetReponseMessage(isoMsg, ResponseCode.INVALID_TRANSACTION);
isoMsg.MessageTypeIdentifier = MTI.REVERSAL_ADVICE_RESPONSE;
return(isoMsg);
}
Transaction transaction = new TransactionRepository().GetByOriginalDataElement(originalDataElement);
MessageLogger.LogMessage("Original Data Element: " + originalDataElement);
if (transaction == null)
{
MessageLogger.LogMessage("\n Transaction log not found");
isReversal = false;
SetReponseMessage(isoMsg, ResponseCode.UNABLE_TO_LOCATE_RECORD.ToString());
isoMsg.MessageTypeIdentifier = MTI.REVERSAL_ADVICE_RESPONSE;
return(isoMsg);
}
if (transaction.IsReversed)
{
MessageLogger.LogMessage("\n Transaction has already been reversed");
isReversal = false;
SetReponseMessage(isoMsg, ResponseCode.DUPLICATE_TRANSACTION.ToString());
return(isoMsg);
}
MessageLogger.LogMessage("\n Continue with reversal");
isoMsg.Fields.Add(MessageField.FROM_ACCOUNT_ID_FIELD, transaction.Account1);
isoMsg.Fields.Add(MessageField.TO_ACCOUNT_ID_FIELD, transaction.Account2);
isoMsg.Fields.Add(MessageField.AMOUNT_FIELD, transaction.Amount.ToString());
isoMsg.Fields.Add(MessageField.TRANSACTION_FEE_FIELD, transaction.TransactionFee.ToString());
isoMsg.Fields.Add(MessageField.PROCESSING_FEE_FIELD, transaction.ProcessingFee.ToString());
//get the transaction type int he msg and replace the first two elements by the Transaction code of the logged transaction
string processingCode = isoMsg.Fields[MessageField.TRANSACTION_TYPE_FIELD].ToString();
processingCode = transaction.TransactionTypeCode + processingCode.Substring(2, processingCode.Length - 2);
isoMsg.Fields.Add(MessageField.TRANSACTION_TYPE_FIELD, processingCode); //error
return(isoMsg);
}
public void ShowTransactionCardAccount()
{
var content = File.ReadAllText("../../../Fixtures/transactions_show_card_account.json");
var client = GetMockClient(content);
var repo = new TransactionRepository(client.Object);
var response = repo.ShowTransactionCardAccount("100fd4a0-0538-11e6-b512-3e1d05defe78");
client.VerifyAll();
var accounts = JsonConvert.DeserializeObject <IDictionary <string, object> >(JsonConvert.SerializeObject(response["card_accounts"]));
Assert.NotNull(accounts);
Assert.AreEqual("930a7f78-6bf6-4f33-8cfc-b82c787b5f83", accounts["id"]);
}
public void Verify_QueryByMerchantAndDateRange(string fromDate, string toDate, string merchant, int n)
{
var loader = new FakeTransactionLoader();
var transactions = new TransactionRepository(loader)
.QueryByMerchantAndDateRange(
merchant,
DateTime.ParseExact(fromDate, "dd/MM/yyyy HH:mm:ss", CultureInfo.InvariantCulture,
DateTimeStyles.None),
DateTime.ParseExact(toDate, "dd/MM/yyyy HH:mm:ss", CultureInfo.InvariantCulture,
DateTimeStyles.None)
);
Assert.Equal(n, transactions.Length);
}
public TransactionService(
AccountRepository accountRepository,
StatementRepository statementRepository,
TransactionRepository transactionRepository,
TransactionTransferMoneyValidator transferMoneyValidator,
IOptions <AppSettings> appSettings
)
{
_accountRepository = accountRepository;
_statementRepository = statementRepository;
_transactionRepository = transactionRepository;
_transferMoneyValidator = transferMoneyValidator;
_appSettings = appSettings.Value;
}
static void CreateTransaction()
{
AccountRepository accountRepository = new AccountRepository();
TransactionRepository transactionRepository = new TransactionRepository();
Transaction transaction = new Transaction
{
Iban = "FI49123456789",
Amount = -3000,
TimeStamp = DateTime.Today
};
accountRepository.CreateTransaction(transaction);
}
static void Main()
{
EnsureFileExistence();
var transactionRepository = new TransactionRepository(new FileReader(TransactionsFilePath));
var feeAccountant = new Accountant();
RegisterMerchants(feeAccountant);
foreach (var transaction in feeAccountant.CalculateAllFees(transactionRepository))
{
Console.WriteLine(transaction);
}
}
public static async Task ClearTransactions()
{
IEnumerable <FinancialTransaction> transactions = TransactionRepository.GetUnclearedTransactions();
foreach (FinancialTransaction transaction in transactions)
{
try {
await AccountLogic.AddTransactionAmount(transaction);
}
catch (Exception ex) {
InsightHelper.Report(ex);
}
}
}
static void Main(string[] args)
{
var clock = new Clock();
var console = new ConsoleWriter();
var transactionRepository = new TransactionRepository(clock);
var statementPrinter = new StatementPrinter(console);
var account = new Account(transactionRepository, statementPrinter);
account.Deposit(1000);
account.Withdraw(400);
account.Deposit(100);
account.PrintStatement();
}
public static void checkout(int userid, int paymentTypeid, List <Cart> carts)
{
HeaderTransaction headerTransaction = TransactionFactory.headerTransaction(userid, paymentTypeid, DateTime.Now);
int TrID = TransactionRepository.addHT(headerTransaction).Id;
foreach (Cart i in carts)
{
DetailTransaction detailTransaction = TransactionFactory.detailTransaction(TrID, i.ProductID, i.Quantity);
TransactionRepository.addDT(detailTransaction);
ProductRepository.decreaseproduct(i.ProductID, i.Quantity);
}
CartRepository.deleteCarts(carts);
}
public void ShowTransactionWalletAccount()
{
var content = File.ReadAllText("../../../Fixtures/transactions_show_wallet_account.json");
var client = GetMockClient(content);
var repo = new TransactionRepository(client.Object);
var response = repo.ShowTransactionWalletAccount("100fd4a0-0538-11e6-b512-3e1d05defe78");
client.VerifyAll();
var accounts = JsonConvert.DeserializeObject <IDictionary <string, object> >(JsonConvert.SerializeObject(response["wallet_accounts"]));
Assert.NotNull(accounts);
Assert.AreEqual("4f4a9428-5fdd-4b4a-a7e3-0919cbba5e20", accounts["id"]);
}
protected void checkout_Click(object sender, EventArgs e)
{
int userID = Int32.Parse(Session["UserID"].ToString());
List <CartModel> data = CartController.cartByUserId(userID);
foreach (CartModel datum in data)
{
Transaction trans = TransactionFactory.createTransaction("Pending", DateTime.Now, datum.ShoeId, datum.UserId, datum.Quantity, datum.SubTotal);
TransactionRepository.insertTransaction(trans);
ShoeController.updateStockAfterCheckout(datum.Quantity, datum.ShoeId);
CartController.deleteCartById(datum.CartId);
}
Response.Redirect("/View/ViewTransaction.aspx");
}
public static void CheckOut(List <DetailedCart> Cart, int paymentId, int userId)
{
DateTime today = DateTime.Now;
HeaderTransaction ht = TransactionRepository.insertHeaderTransaction(userId, paymentId, today);
foreach (DetailedCart cart in Cart)
{
TransactionRepository.insertDetailTransaction(ht.Id, cart.ProductId, cart.Quantity);
ProductRepository.UpdateProductBought(cart.ProductId, cart.Quantity);
CartHandler.DeleteCart(userId, cart.ProductId);
}
}
public void ShowTransactionBankAccount()
{
var content = File.ReadAllText("../../../Fixtures/transactions_show_bank_account.json");
var client = GetMockClient(content);
var repo = new TransactionRepository(client.Object);
var response = repo.ShowTransactionBankAccount("100fd4a0-0538-11e6-b512-3e1d05defe78");
client.VerifyAll();
var accounts = JsonConvert.DeserializeObject <IDictionary <string, object> >(JsonConvert.SerializeObject(response["transactions"]));
Assert.NotNull(accounts);
Assert.AreEqual("2f2870f5-7c8f-45cb-8aeb-95190d54f125", accounts["id"]);
}
public void Setup()
{
Repository = new TransactionRepository(Context, new AccountRepository(Context), new CategoryRepository(Context), new SubCategoryRepository(Context), new TransactionTypeRepository(Context));
var user = new Entity.User()
{
FirstName = "test", LastName = "test", Email = "*****@*****.**", Phone = "123-123-1234"
};
Context.Users.Add(user);
Context.SaveChanges();
var account = new Entity.Account()
{
User = user.ID, Name = "test", Description = "test"
};
Context.Accounts.Add(account);
Context.SaveChanges();
var category = new Entity.Category()
{
User = user.ID, Name = "test", Description = "test"
};
Context.Categories.Add(category);
Context.SaveChanges();
var subCategory = new Entity.SubCategory()
{
User = user.ID, Category = category.ID, Name = "test", Description = "test"
};
Context.SubCategories.Add(subCategory);
Context.SaveChanges();
var type = new Entity.TransactionType()
{
Name = "test", Description = "test"
};
Context.TransactionTypes.Add(type);
Context.SaveChanges();
UserId = user.ID;
AccountId = account.ID;
CategoryId = category.ID;
SubCategoryId = subCategory.ID;
TransactionTypeId = type.ID;
}
public MainPage()
{
this.InitializeComponent();
AccountSource.Source = new AccountRepository().ReadAll();
var tmp=new TransactionRepository().ReadAll();
var primaryGroup = new TransactionsGroup() { Name = "Test", Items = tmp };
var moreGroup = new TransactionsGroup() { Name = "Download More", Items = new ObservableCollection<Transaction>(){ new Transaction()} };
TransactionsSource.Source = new ObservableCollection<TransactionsGroup>() { primaryGroup, moreGroup };
}
static void Main(string[] args)
{
var transactionRepo = new TransactionRepository();
var transactionRepoResult = transactionRepo.GetTransactionStats();
Console.WriteLine("END GetTransactionStats");
var tagRepo = new TagRepository();
var tagRepoResult = tagRepo.GetAllTagDetailedSummary();
Console.WriteLine("END GetAllTagDetailedSummary");
Console.WriteLine("Program ended.");
}
) Transfer(string fromAccount, string toAccount, string currency, decimal money, string message)
{
if (money < 0)
{
throw new BusinessException("Money should be greater than 0.");
}
var nowUtc = DateTime.Now.ToUniversalTime();
var sourceAccountEntity = BankAccountService.Get(fromAccount);
var targetAccountEntity = BankAccountService.Get(toAccount);
var currencyEntity = CurrencyService.Get(currency);
var exchangeRateFromSourceAccount = ExchangeRateHistoryService.GetExchangeRate(sourceAccountEntity.Currency, currencyEntity, nowUtc);
var exchangeRateToTargetAccount = ExchangeRateHistoryService.GetExchangeRate(currencyEntity, targetAccountEntity.Currency, nowUtc);
var deltaFromSourceAccount = money * exchangeRateFromSourceAccount;
var deltaToTargetAccount = money * exchangeRateToTargetAccount;
if (deltaFromSourceAccount > sourceAccountEntity.Balance)
{
throw new BusinessException("Source account balance is not sufficient");
}
else if (deltaFromSourceAccount <= 0 || deltaToTargetAccount <= 0)
{
throw new BusinessException("Transfer delta is not valid.");
}
sourceAccountEntity.Balance -= deltaFromSourceAccount;
targetAccountEntity.Balance += deltaToTargetAccount;
var entity = new TransferMoneyTransaction
{
DateTimeUtc = nowUtc,
SourceAccount = sourceAccountEntity,
Account = targetAccountEntity,
Currency = currencyEntity,
Money = money,
Message = message
};
TransactionRepository.Create(entity);
BankAccountRepository.Update(sourceAccountEntity);
BankAccountRepository.Update(targetAccountEntity);
UnitOfWork.SaveChanges();
return(
entity.Id,
exchangeRateFromSourceAccount, deltaFromSourceAccount, sourceAccountEntity.Balance,
exchangeRateToTargetAccount, deltaToTargetAccount, targetAccountEntity.Balance
);
}
/// <summary>
/// Gets a singleton instance of Transaction repository.
/// </summary>
/// <returns></returns>
public static ITransactionRepository GetTransactionRepository()
{
if (null == _transactionRepositoryInstance)
{
lock (_syncObject)
{
if (null == _transactionRepositoryInstance)
{
_transactionRepositoryInstance = new TransactionRepository();
}
}
}
return(_transactionRepositoryInstance);
}
static void Main(string[] args)
{
IClock clock = new Clock();
ITransactionRepository transactionRepository = new TransactionRepository(clock);
IConsole console = new Console();
IStatementPrinter statementPrinter = new StatementPrinter(console);
Account account = new Account(transactionRepository, statementPrinter);
account.Deposit(1000);
account.Withdraw(100);
account.Deposit(500);
account.PrintStatement();
}
public ViewTransactions(bool recurring)
{
InitializeComponent();
isRecurring = recurring;
Text = Strings.RecurringTransactions;
if (isRecurring)
{
lv_transactions.Columns.Add("Status");
lv_transactions.Columns.Add("End date");
recurringTransactionRepository = RecurringTransactionRepository.Instance;
}
ResizeColumns();
transactionRepository = TransactionRepository.Instance;
}
private void insertIntoTransaction()
{
Member m = (Member)Session["User"];
List <Cart> c = CartRepository.getCartProductByMember(m.MemberEmail);
string date = DateTime.Today.ToShortDateString();
HeaderTransaction ht = TransactionFactory.createTransaction(date, "Pending", m.MemberEmail);
TransactionRepository.addTransactionToDatabase(ht);
foreach (Cart item in c)
{
TransactionDetail td = TransactionFactory.createDetailTransaction(ht.HeaderTransactionId, item.ProductId, item.ProductQuantity);
TransactionRepository.addTransactionDetailToDatabase(td);
}
}
protected void adminTransactionView_RowCommand(object sender, GridViewCommandEventArgs e)
{
int id = Int32.Parse(e.CommandArgument.ToString());
HeaderTransaction ht = TransactionRepository.getHeaderTransactionById(id);
if (ht.TransactionStatus == "Pending")
{
TransactionRepository.updateStatusTransactionById(id, "Approved");
}
else if (ht.TransactionStatus == "Approved")
{
TransactionRepository.updateStatusTransactionById(id, "Pending");
}
Response.Redirect("TransactionPage.aspx");
}
private void loadData()
{
Member m = (Member)Session["User"];
if (m.MemberRole == 1)
{
memberTransactionView.DataSource = TransactionRepository.getMemberTransactionViewByEmail(m.MemberEmail);
memberTransactionView.DataBind();
}
else if (m.MemberRole == 2)
{
adminTransactionView.DataSource = TransactionRepository.getAllTransactionView();
adminTransactionView.DataBind();
}
}
public void Add_a_withdrawal()
{
var transactionRepository =
new TransactionRepository();
transactionRepository.AddWithdrawal(new Transaction(-200, DateTime.Today));
//Assert.That(transactionRepository.GetTransactions().Contains(
// new Transaction(-200, DateTime.Today)));
Assert.AreEqual(
transactionRepository.GetTransactions()[0],
new Transaction(-200, DateTime.Today));
}
public ActionResult Edit(int id, TransactionViewModel transaction)
{
try
{
//Updating transaction isfraud value
TransactionRepository transacRep = new TransactionRepository();
transacRep.SetIsFraud(transaction.Id, transaction.IsFraud);
return(RedirectToAction("Index"));
}
catch (Exception e)
{
return(View());
}
}
public bool VerifyExistInState(TransactionState state)
{
try
{
GenericError error;
var exist = TransactionRepository.GetEntities(out error,
t => t.TransactionId == TransactionId &&
t.StateName == state.StateName).Any();
return(error == null && exist);
}
catch (Exception)
{
return(false);
}
}
public override async Task <Response> Handle(Query query, CancellationToken cancellationToken)
{
if (!await _budgetRepository.IsAccessibleToUser(query.BudgetId))
{
throw new AccessViolationException("Requested budget not available");
}
var filters = Mapper.Map <TransactionsFilterModel>(query);
var transactions = await TransactionRepository.ListWithFilter(new Domain.Entities.Budget(query.BudgetId), filters);
return(new Response {
Data = Mapper.Map <List <TransactionDto> >(transactions)
});
}
protected virtual IEnumerable <ApplicationEvent> WhenDepositFailed(Guid appOperationId, Transfer transfer)
{
transfer.Fail(string.Format(Messages.TransferFailed, transfer.Deposit.ErrorMessage));
var transactionName = TransactionReferenceBook.CompensationFor(transfer.Withdrawal);
var compensationTransaction = Compensate(transfer.From, transfer, transactionName.Code, transactionName.Description);
TransactionRepository.Create(compensationTransaction);
TransferRepository.Update(transfer);
var transactionModel = compensationTransaction.ToModel <Transaction, TransactionModel>();
return(new List <ApplicationEvent>
{
new TransactionProgressEvent(appOperationId, transactionModel, transfer.Id)
});
}
public ActionResult EndHireAction(int hireId, int endMileage)
{
var hire = HireRepository.RetrieveSingleHire(hireId);
if (hire == null || endMileage < hire.StartMileage)
{
return(Redirect($"/manage/Hire/EndHire?hireId={hireId}"));
}
hire = HireRepository.SetEndMileage(hireId, endMileage);
TransactionRepository.CreateTransaction(hire.UserId, endMileage - hire.StartMileage, TransactionType.Mileage);
return(Redirect($"/manage/Hire/EndHireComplete?bref={hire.BookingReference}"));
}
public static void Checkout(int userId, int paymentID)
{
List <Cart> cp = CartRepository.getAllCartProducts(userId);
DateTime now = DateTime.Now;
HeaderTransaction transactionHeader = TransactionRepository.CreateHeaderTransaction(userId, now, paymentID);
int headerId = TransactionRepository.AddTransactionHeader(transactionHeader).ID;
for (int i = 0; i < cp.Count(); i++)
{
DetailTransaction transactionDetail = TransactionRepository.CreateDetailTransaction(headerId, cp[i].ProductID, cp[i].Quantity);
TransactionRepository.AddTransactionDetail(transactionDetail);
}
CartRepository.deleteCartProductByUser(cp);
}
protected void Page_Load(object sender, EventArgs e)
{
string bugName = Request.QueryString.Get("BugID");
string checkedOutBy;
DateTime changedOn;
using (CrackerEntities myEntity = new CrackerEntities())
{
ITransactionRepository transactionRepo = new TransactionRepository();
//Verify that the bug we are going to check in can be checked in
//Get bug ID
var result = (from bug in myEntity.Bugs
where bug.Bug1 == bugName
select bug).SingleOrDefault();
if (result != null)
{
var check = transactionRepo.GetLastTransactionForBug(result.Id);
changedOn = Convert.ToDateTime(check.ChangedOn);
checkedOutBy = Convert.ToString(check.ChangedBy);
if (checkedOutBy != HttpContext.Current.User.Identity.Name)
{
((Label)LoginView1.FindControl("lblWarning")).ForeColor = System.Drawing.Color.Red;
((Label)LoginView1.FindControl("lblWarning")).Text = "You're about to check in a bug that was not checked out by you!";
}
//get how long has the bug been checked out
((TextBox)LoginView1.FindControl("txtTime")).Text = Math.Round(DateTime.Now.Subtract(changedOn).TotalMinutes, 0).ToString();
((Label)LoginView1.FindControl("lblBugId")).Text = bugName;
}
else
{
((Label)LoginView1.FindControl("lblBugId")).ForeColor = System.Drawing.Color.Red;
((Label)LoginView1.FindControl("lblBugId")).Text = bugName + " does not exist!";
((Button)LoginView1.FindControl("btnCheckIn")).Enabled = false;
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
string bugName = Request.QueryString.Get("BugID");
((Label)LoginView1.FindControl("lblBugID")).Text = bugName;
string checkedOutBy;
DateTime changedOn;
string status;
ITransactionRepository transactionRepo = new TransactionRepository();
IBugRepository bugRepo = new BugRepository();
//Verify that the bug we are going to check in can be checked in
//Get bug ID
var result = bugRepo.GetBugIdByTitle(bugName);
if (result != null)
{
//check if the bug is checked out & if it's checked by current user
var check = transactionRepo.GetLastTransactionForBug((int)result);
status = Convert.ToString(check.Status.StatusName);
changedOn = Convert.ToDateTime(check.ChangedOn);
checkedOutBy = Convert.ToString(check.ChangedBy);
if (checkedOutBy != HttpContext.Current.User.Identity.Name)
{
((Label)LoginView1.FindControl("lblWarning")).ForeColor = System.Drawing.Color.Red;
((Label)LoginView1.FindControl("lblWarning")).Text = "You're about to undo a bug that was not checked out by you!";
}
//get how long has the bug been checked out
((TextBox)LoginView1.FindControl("txtTime")).Text = Math.Round(DateTime.Now.Subtract(changedOn).TotalMinutes, 0).ToString();
((Label)LoginView1.FindControl("lblBugID")).Text = bugName;
}
else
{
((Label)LoginView1.FindControl("lblBugID")).ForeColor = System.Drawing.Color.Red;
((Label)LoginView1.FindControl("lblBugID")).Text = bugName + " does not exist!";
((Button)LoginView1.FindControl("btnUNdo")).Enabled = false;
}
}
public void CreateInitialData()
{
mocks = new Mockery();
mockAccountRepository = mocks.NewMock<IAccountRepository>();
mockJournalRepository = mocks.NewMock<IJournalRepository>();
Expect.Once.On(mockAccountRepository).Method("GetById").With(1).Will(Return.Value(_account1));
Expect.Once.On(mockJournalRepository).Method("GetById").With(1).Will(Return.Value(_journal1));
Expect.Once.On(mockJournalRepository).Method("Save").With(_journal1);
Expect.Once.On(mockJournalRepository).Method("GetById").With(2).Will(Return.Value(_journal2));
Expect.Once.On(mockJournalRepository).Method("Save").With(_journal2);
using (StringReader stringReader = new StringReader(testData))
using (XmlReader transactionXml = new XmlTextReader(stringReader))
{
XElement transactions = XElement.Load(transactionXml);
_repository = new TransactionRepository(transactions, mockAccountRepository, mockJournalRepository);
}
}
public void Can_add_new_transaction()
{
DateTime testDate = new DateTime(2009, 1, 28);
Transaction transaction = new Transaction { Date = testDate, Description = "Test Transaction2", IsVerified = true };
ITransactionRepository repository = new TransactionRepository();
repository.Add(transaction);
using (ISession session = SessionFactory.OpenSession())
{
var fromDb = session.Get<Transaction>(transaction.Id);
Assert.IsNotNull(fromDb);
Assert.AreNotSame(transaction, fromDb);
Assert.AreEqual(transaction.Date, fromDb.Date);
Assert.AreEqual(transaction.IsVerified, fromDb.IsVerified);
Assert.AreEqual(transaction.Description, fromDb.Description);
Assert.AreEqual(transaction.BusinessKey, fromDb.BusinessKey);
}
}
public void Initialize(string filename)
{
IDatabaseFactory databaseFactory = new DatabaseFactory();
IUnitOfWork unitOfWork = new UnitOfWork(databaseFactory);
IAccountRepository accountRepository = new AccountRepository(databaseFactory);
ITransactionRepository transactionRepository = new TransactionRepository(databaseFactory);
ICategoryRepository categoryRepository = new CategoryRepository(databaseFactory);
IVendorRepository vendorRepository = new VendorRepository(databaseFactory);
ICategoryGroupRepository categoryGroupRepository = new CategoryGroupRepository(databaseFactory);
IBillRepository billRepository = new BillRepository(databaseFactory);
IBillTransactionRepository billTransactionRepository = new BillTransactionRepository(databaseFactory);
IBillGroupRepository billGroupRepository = new BillGroupRepository(databaseFactory);
IBudgetCategoryRepository budgetCategoryRepository = new BudgetCategoryRepository(databaseFactory);
IAccountGroupRepository accountGroupRepository = new AccountGroupRepository(databaseFactory);
IImportDescriptionVendorMapRepository importDescriptionVendorMapRepository = new ImportDescriptionVendorMapRepository(databaseFactory);
IAccountService accountService = new AccountService(unitOfWork, accountRepository, transactionRepository, categoryRepository, vendorRepository, billRepository, billTransactionRepository, billGroupRepository, categoryGroupRepository, budgetCategoryRepository, importDescriptionVendorMapRepository);
TransactionImporter importer = new TransactionImporter(unitOfWork, accountService, accountRepository, transactionRepository, vendorRepository, categoryGroupRepository, accountGroupRepository, importDescriptionVendorMapRepository);
importer.Import(filename);
}
public override void Configure(Container container)
{
LogManager.LogFactory = new Log4NetFactory(true);
container.Register(_appDbConnectionFactory);
Plugins.Add(new AuthFeature(() => new AuthUserSession(),
new IAuthProvider[] {new BasicAuthProvider(), new CredentialsAuthProvider(),}) {HtmlRedirect = null});
//No use a custom one
//Plugins.Add(new RegistrationFeature());
var userRepo = new OrmLiteAuthRepository(_authDbConnectionFactory);
container.Register<IUserAuthRepository>(userRepo);
//wire-up a validator for the UserRegistrationService
var userRegistrationValidator = new UserRegistrationRequestValidator {UserAuthRepo = userRepo};
container.Register<IValidator<UserRegistrationRequest>>(userRegistrationValidator);
var currencyTypeRepository = new CurrencyTypeRepository { DbConnectionFactory = _appDbConnectionFactory };
var transactionTypeRepository = new TransactionTypeRepository { DbConnectionFactory = _appDbConnectionFactory };
var transactionStatusTypeRepository = new TransactionStatusTypeRepository { DbConnectionFactory = _appDbConnectionFactory };
var transactionNotificationStatusTypeRepository = new TransactionNotificationStatusTypeRepository { DbConnectionFactory = _appDbConnectionFactory };
var transactionRepository = new TransactionRepository { DbConnectionFactory = _appDbConnectionFactory };
var currencyTypeLogic = new CurrencyTypeLogic { Repository = currencyTypeRepository };
var transactionTypeLogic = new TransactionTypeLogic { Repository = transactionTypeRepository };
var transactionStatusTypeLogic = new TransactionStatusTypeLogic { Repository = transactionStatusTypeRepository };
var transactionNotificationStatusTypeLogic = new TransactionNotificationStatusTypeLogic { Repository = transactionNotificationStatusTypeRepository };
var transactionLogic = new TransactionLogic {Repository = transactionRepository};
container.Register<IRest<CurrencyType, GetCurrencyTypes>>(currencyTypeLogic);
container.Register<IRest<TransactionType, GetTransactionTypes>>(transactionTypeLogic);
container.Register<IRest<TransactionStatusType, GetTransactionStatusTypes>>(transactionStatusTypeLogic);
container.Register<IRest<TransactionNotificationStatusType, GetTransactionNotificationStatusTypes>>(transactionNotificationStatusTypeLogic);
container.Register<IRest<Transaction, GetTransactions>>(transactionLogic);
CatchAllHandlers.Add((httpMethod, pathInfo, filePath) => pathInfo.StartsWith("/favicon.ico") ? new FavIconHandler() : null);
}
public static void ImportFromExcelFile(string filename)
{
IDictionary<string, AccountType> accountTypes = new Dictionary<string, AccountType>();
IDictionary<string, AccountCategory> accountCategories = new Dictionary<string, AccountCategory>();
IDictionary<string, Account> accounts = new Dictionary<string, Account>();
Iesi.Collections.Generic.ISet<Item> items = new HashedSet<Item>();
IDictionary<int, Transaction> transactions = new Dictionary<int, Transaction>();
OleDbConnection excelConnection;
excelConnection = new OleDbConnection(
"Provider=Microsoft.ACE.OLEDB.12.0; " +
"Data Source=" + filename + "; " +
"Extended Properties=\"Excel 12.0 Xml;HDR=YES;IMEX=1\"");
excelConnection.Open();
RecreateDatabase();
ImportAccountTypes(excelConnection, accountTypes);
ImportAccountCategories(excelConnection, accountCategories);
ImportAccounts(excelConnection, accounts, accountTypes, accountCategories);
ImportTransactions(excelConnection, transactions);
ImportItems(excelConnection, items, accounts, transactions);
AccountTypeRepository atr = new AccountTypeRepository();
AccountCategoryRepository acr = new AccountCategoryRepository();
AccountRepository ar = new AccountRepository();
TransactionRepository tr = new TransactionRepository();
ItemRepository ir = new ItemRepository();
foreach (AccountType at in accountTypes.Values) atr.Add(at);
foreach (AccountCategory ac in accountCategories.Values) acr.Add(ac);
foreach (Account a in accounts.Values) ar.Add(a);
foreach (Transaction t in transactions.Values) tr.Add(t);
foreach (Item i in items) ir.Add(i);
excelConnection.Close();
}
protected void btnUndo_Click(object sender, EventArgs e)
{
ITransactionRepository transactionRepo = new TransactionRepository();
IBugRepository bugRepo = new BugRepository();
string bugName = Request.QueryString.Get("BugID");
var bugId = bugRepo.GetBugIdByTitle(bugName);
Transaction myTransaction = new Transaction
{
ChangedBy = HttpContext.Current.User.Identity.Name,
ChangedOn = DateTime.Now,
BugId = (int)bugId,
StatusId = 9,
TimeSpent = Int32.Parse(((TextBox)LoginView1.FindControl("txtTime")).Text),
LanguageId = 14
};
transactionRepo.InsertTransaction(myTransaction);
transactionRepo.Save();
Response.Redirect("~/Default.aspx");
}
protected void btnDisplay_Click(object sender, EventArgs e)
{
if (User.Identity.IsAuthenticated && Page.IsValid)
{
string selectedUser = ((DropDownList)LoginView1.FindControl("ddlUsers")).SelectedItem.Text;
ITransactionRepository transactionRepo = new TransactionRepository();
if (((CheckBox)LoginView1.FindControl("on")).Checked)
{
string wtf = ((TextBox)LoginView1.FindControl("onDate")).Text;
DateTime myDate = DateTime.Parse(((TextBox)LoginView1.FindControl("onDate")).Text);
DateTime myDateNext = myDate.AddDays(1);
var result = transactionRepo.GetTransactionsByUserAndDate(selectedUser, myDate, myDateNext);
((GridView)LoginView1.FindControl("gvStats")).DataSource = result;
((GridView)LoginView1.FindControl("gvStats")).DataBind();
((Label)LoginView1.FindControl("lblTest")).Text = "<strong>Total: </strong>" + result.Count();
}
else
{
DateTime myStartDate = DateTime.Parse(((TextBox)LoginView1.FindControl("betweenStartDate")).Text);
DateTime myEndDate = DateTime.Parse(((TextBox)LoginView1.FindControl("betweenEndDate")).Text).AddHours(23).AddMinutes(59).AddSeconds(59);
var result = transactionRepo.GetTransactionsByUserAndDate(selectedUser, myStartDate, myEndDate);
((GridView)LoginView1.FindControl("gvStats")).DataSource = result;
((GridView)LoginView1.FindControl("gvStats")).DataBind();
((Label)LoginView1.FindControl("lblTest")).Text = "<strong>Total: </strong>" + result.Count();
}
}
}
public void Can_get_existing_transaction_by_key()
{
ITransactionRepository repository = new TransactionRepository();
var fromDb = repository.GetByKey(_transaction1.BusinessKey);
Assert.IsNotNull(fromDb);
Assert.AreNotSame(_transaction1, fromDb);
Assert.AreEqual(_transaction1.Date, fromDb.Date);
Assert.AreEqual(_transaction1.BusinessKey, fromDb.BusinessKey);
Assert.AreEqual(_transaction1.Description, fromDb.Description);
Assert.AreEqual(_transaction1.IsVerified, fromDb.IsVerified);
}
public void Can_get_existing_transaction_by_single_date()
{
ITransactionRepository repository = new TransactionRepository();
var fromDb = repository.GetByDate(_transaction1.Date);
Assert.AreEqual(1, fromDb.Count);
Assert.IsTrue(IsInCollection(_transaction1, fromDb));
}
public void Can_get_existing_transaction_by_isVerified_false()
{
ITransactionRepository repository = new TransactionRepository();
var fromDb = repository.GetByIsVerified(_transaction2.IsVerified);
Assert.AreEqual(2, fromDb.Count);
Assert.IsTrue(IsInCollection(_transaction2, fromDb));
Assert.IsTrue(IsInCollection(_transaction3, fromDb));
}
public void Can_get_next_Transaction_Business_Key()
{
ITransactionRepository repository = new TransactionRepository();
var fromDb = repository.GetNextTransactionBusinessKey();
DateTime testDate = new DateTime(2009, 1, 28);
Transaction _transaction4 = new Transaction { Date = testDate.AddDays(1), BusinessKey = repository.GetNextTransactionBusinessKey(), Description = "Test Transaction4", IsVerified = true };
repository.Add(_transaction4);
var fromDb2 = repository.GetNextTransactionBusinessKey();
Assert.IsNotNull(fromDb);
Assert.IsNotNull(fromDb2);
Assert.AreNotEqual(fromDb, fromDb2);
Assert.AreEqual(4, fromDb);
Assert.AreEqual(5, fromDb2);
}
/// <summary>
/// Gets checked out bugs and binds them to GridView
/// </summary>
/// <param name="gridID">GridView ID</param>
/// <param name="myBugs">True for bugs for current user only, false for all bugs except those checked by current user</param>
protected void setGridView(string gridID, bool myBugs)
{
ITransactionRepository transactionRepo = new TransactionRepository();
var checkedOutTransactions = transactionRepo.GetTransactionsByStatus(8);
var transactions = checkedOutTransactions;
if (myBugs)
{
transactions = checkedOutTransactions.Where(r => r.ChangedBy == currentUserName);
}
else
{
transactions = checkedOutTransactions.Where(r => r.ChangedBy != currentUserName);
}
((GridView)LoginView1.FindControl(gridID)).DataSource = transactions;
((GridView)LoginView1.FindControl(gridID)).DataBind();
}
public void Can_update_existing_transaction()
{
var transaction = _transaction1;
transaction.Description = "Something Testy";
ITransactionRepository repository = new TransactionRepository();
repository.Update(transaction);
using (ISession session = SessionFactory.OpenSession())
{
var fromDb = session.Get<Transaction>(transaction.Id);
Assert.AreEqual(transaction.Description, fromDb.Description);
}
}
public StockService(StockRepository stockRepo, TransactionRepository transactionRepo, ApplicationUserManager userRepo) {
_stockRepo = stockRepo;
_transactionRepo = transactionRepo;
_userRepo = userRepo;
}
private static void ExportTransactions(OleDbConnection dbConnection)
{
OleDbCommand createTable = new OleDbCommand("CREATE TABLE `Transactions` (" +
"`BusinessKey` LongText, " +
"`Date` LongText, " +
"`Description` LongText," +
"`IsVerified` LongText" +
")", dbConnection);
createTable.ExecuteNonQuery();
TransactionRepository repository = new TransactionRepository();
var transactions = repository.GetAll();
foreach (Transaction t in transactions)
{
if (t.Description != null)
{
t.Description = t.Description.Replace("'", "''");
}
string insertStatement = "INSERT INTO [Transactions] ([BusinessKey], [Date], [Description], [IsVerified]) VALUES ('" +
t.BusinessKey + "', '" +
t.Date.ToString("dd-MMM-yy") + "', '" +
t.Description + "', '" +
t.IsVerified + "')";
OleDbCommand insert = new OleDbCommand(insertStatement, dbConnection);
insert.ExecuteNonQuery();
}
}
public void Can_get_existing_transaction_by_date_range1()
{
ITransactionRepository repository = new TransactionRepository();
var fromDb = repository.GetByDate(_transaction1.Date.AddDays(-1D), _transaction1.Date.AddDays(1D));
Assert.AreEqual(2, fromDb.Count);
Assert.IsTrue(IsInCollection(_transaction1, fromDb));
Assert.IsTrue(IsInCollection(_transaction3, fromDb));
}
protected void btnCheckOut_Click(object sender, EventArgs e)
{
string bug = ((TextBox)LoginView1.FindControl("txtBugId")).Text;
int bugId;
try
{
ITransactionRepository transactionRepo = new TransactionRepository();
IBugRepository bugRepo = new BugRepository();
var result = bugRepo.GetBugIdByTitle(bug);
if (result == 0)
{
Bug newBug = new Bug()
{
Bug1 = bug
};
bugRepo.InsertBug(newBug);
bugRepo.Save();
}
bugId = (int)bugRepo.GetBugIdByTitle(bug);
//check if bug was not checked out previously (check if there is any transaction for this bug)
var testCheckout = transactionRepo.GetLastTransactionForBug(bugId);
//if there is an transaction
if (testCheckout != null)
{
//check if bug is not checked out now
if (testCheckout.StatusId != 8)
{
//check out bug
CheckoutBug(bugId, transactionRepo);
((Label)LoginView1.FindControl("lblAlreadyCheckedOut")).Visible = false;
setGridView(gridIdBugsMe, true);
setGridView(gridIdBugsOthers, false);
}
else
{
((Label)LoginView1.FindControl("lblAlreadyCheckedOut")).Visible = true;
}
}
else
{
CheckoutBug(bugId, transactionRepo);
((Label)LoginView1.FindControl("lblAlreadyCheckedOut")).Visible = false;
setGridView(gridIdBugsMe, true);
setGridView(gridIdBugsOthers, false);
}
}
catch (DataException ex)
{
((Label)LoginView1.FindControl("lblException")).Visible = true;
((Label)LoginView1.FindControl("lblException")).Text = "Data not available, please try again later (" + ex.Message + ex.InnerException.Message + ").";
}
}
public override void Configure(Container container)
{
LogManager.LogFactory = new Log4NetFactory(true);
container.Register(_dbConnectionFactory);
var basicAuthProvider = new BasicAuthProvider();
container.Register(basicAuthProvider);
Plugins.Add(new AuthFeature( () => new AuthUserSession(), new IAuthProvider[] {basicAuthProvider, }, SystemConstants.LoginUrl ));
var userRepo = new OrmLiteAuthRepository(_dbConnectionFactory);
container.Register<IAuthRepository>(userRepo);
var cacheClient = new MemoryCacheClient();
container.Register(cacheClient);
var currencyTypeRepository = new CurrencyTypeRepository { DbConnectionFactory = _dbConnectionFactory };
var transactionTypeRepository = new TransactionTypeRepository { DbConnectionFactory = _dbConnectionFactory };
var transactionStatusTypeRepository = new TransactionStatusTypeRepository { DbConnectionFactory = _dbConnectionFactory };
var transactionNotificationStatusTypeRepository = new TransactionNotificationStatusTypeRepository { DbConnectionFactory = _dbConnectionFactory };
var transactionRepository = new TransactionRepository { DbConnectionFactory = _dbConnectionFactory };
var currencyTypeLogic = new CurrencyTypeLogic { Repository = currencyTypeRepository };
var transactionTypeLogic = new TransactionTypeLogic { Repository = transactionTypeRepository };
var transactionStatusTypeLogic = new TransactionStatusTypeLogic { Repository = transactionStatusTypeRepository };
var transactionNotificationStatusTypeLogic = new TransactionNotificationStatusTypeLogic { Repository = transactionNotificationStatusTypeRepository };
var transactionLogic = new TransactionLogic {Repository = transactionRepository};
container.Register<IRest<CurrencyType, GetCurrencyTypes>>(currencyTypeLogic);
container.Register<IRest<TransactionType, GetTransactionTypes>>(transactionTypeLogic);
container.Register<IRest<TransactionStatusType, GetTransactionStatusTypes>>(transactionStatusTypeLogic);
container.Register<IRest<TransactionNotificationStatusType, GetTransactionNotificationStatusTypes>>(transactionNotificationStatusTypeLogic);
container.Register<IRest<Transaction, GetTransactions>>(transactionLogic);
CatchAllHandlers.Add((httpMethod, pathInfo, filePath) => pathInfo.StartsWith("/favicon.ico") ? new FavIconHandler() : null);
var redisLocation = ConfigurationManager.AppSettings["ReddisService"];
Container.Register<IRedisClientsManager>(new PooledRedisClientManager(redisLocation));
var mqService = new RedisMqServer(container.Resolve<IRedisClientsManager>());
var messagingHandlers = new MessageService { Log = new Logger(typeof(MessageService).Name) };
Func<IMessage, IMessage> filterSecureRequests = (message) =>
{
/*
var tag = message.Tag;
if (string.IsNullOrWhiteSpace(tag))
return message;
if (tag.StartsWith("basic ", StringComparison.InvariantCultureIgnoreCase))
{
var creds = Encoding.UTF8.GetString(Convert.FromBase64String(tag.Substring(5)));
var i = creds.IndexOf(':');
var userName = creds.Substring(0, i);
var userPass = creds.Substring(i + 1);
if (userName != SystemConstants.AllowedUser || userPass != SystemConstants.AllowedPass)
{
message.Tag = null;
return message;
}
_currentSessionGuid = Guid.NewGuid();
var sessionKey = userName + "/" + _currentSessionGuid.ToString("N");
SessionContext = new SessionContext { SessionKey = sessionKey, Username = userName };
container.Register(SessionContext);
message.Tag = sessionKey;
return message;
}
message.Tag = null;*/
return message;
};
mqService.RequestFilter = filterSecureRequests;
Func<IMessage<Transaction>, PostResponse<Transaction>> handlePostTransactions = (message) =>
{
var service = new TransactionWebService { Logic = transactionLogic };
var request = new BasicRequest {Message = message, Dto = message.GetBody()};
var response = new BasicResponse(request);
//userRepo.TryAuthenticate()
service.SessionFactory.GetOrCreateSession(request, response);
var session = service.GetSession();
session.UserName = "******";
var results = new PostResponse<Transaction> {Result = (Transaction) service.Post(message.GetBody())};
return results;
};
// Dto Get Operations
mqService.RegisterHandler<GetCurrencyTypes>(m => messagingHandlers.MessagingGetWrapper(m.GetBody(), currencyTypeLogic));
mqService.RegisterHandler<GetTransactions>(m => messagingHandlers.MessagingGetWrapper(m.GetBody(), transactionLogic));
mqService.RegisterHandler<GetTransactionStatusTypes>(m => messagingHandlers.MessagingGetWrapper(m.GetBody(), transactionStatusTypeLogic));
mqService.RegisterHandler<GetTransactionNotificationStatusTypes>(m => messagingHandlers.MessagingGetWrapper(m.GetBody(), transactionNotificationStatusTypeLogic));
mqService.RegisterHandler<GetTransactionTypes>(m => messagingHandlers.MessagingGetWrapper(m.GetBody(), transactionTypeLogic));
// Dto Post Operations
mqService.RegisterHandler<CurrencyType>(m => messagingHandlers.MessagingPostRequest(m.GetBody(), currencyTypeLogic.Post));
mqService.RegisterHandler<Transaction>(handlePostTransactions);
mqService.RegisterHandler<TransactionStatusType>(m => messagingHandlers.MessagingPostRequest(m.GetBody(), transactionStatusTypeLogic.Post));
mqService.RegisterHandler<TransactionNotificationStatusType>(m => messagingHandlers.MessagingPostRequest(m.GetBody(), transactionNotificationStatusTypeLogic.Post));
mqService.RegisterHandler<TransactionType>(m => messagingHandlers.MessagingPostRequest(m.GetBody(), transactionTypeLogic.Post));
// Dto Put Opertations
mqService.RegisterHandler<DeleteCurrencyType>(m => messagingHandlers.MessagingDeleteWrapper(m.GetBody(), currencyTypeLogic));
mqService.RegisterHandler<DeleteTransaction>(m => messagingHandlers.MessagingDeleteWrapper(m.GetBody(), transactionLogic));
mqService.RegisterHandler<DeleteTransactionStatusType>(m => messagingHandlers.MessagingDeleteWrapper(m.GetBody(), transactionStatusTypeLogic));
mqService.RegisterHandler<DeleteTransactionNotificationStatusType>(m => messagingHandlers.MessagingDeleteWrapper(m.GetBody(), transactionNotificationStatusTypeLogic));
mqService.RegisterHandler<DeleteTransactionType>(m => messagingHandlers.MessagingDeleteWrapper(m.GetBody(), transactionTypeLogic));
mqService.Start();
}
