public void CalculateTransactionsTestThrowsNullReferenceException186() { List <Transaction> list; string s; Transaction[] transactions = new Transaction[1]; Transaction s0 = new Transaction(); s0.Amount = 0L; s0.IsPending = false; s0.AggregationTime = (string)null; s0.AccountId = (string)null; s0.ClearDate = 0L; s0.TransactionId = (string)null; s0.RawMerchant = (string)null; s0.Categorization = (string)null; s0.Merchant = (string)null; s0.TransactionTime = default(DateTime); transactions[0] = s0; list = new List <Transaction>((IEnumerable <Transaction>)transactions); Process s1 = new Process(); TransactionCollection s2 = new TransactionCollection(); s2.Error = (string)null; s2.Transactions = list; s = this.CalculateTransactionsTest(s1, s2); }
public TransactionCollection FetchAll() { TransactionCollection coll = new TransactionCollection(); Query qry = new Query(Transaction.Schema); coll.LoadAndCloseReader(qry.ExecuteReader()); return coll; }
private async Task <MongoDbTransaction> GetLastTransactionInternal() { // look for potential last transaction var res = await TransactionCollection.Find(x => true) .SortByDescending(x => x.Timestamp) .FirstOrDefaultAsync(); if (res == null) { return(null); } // look if a pending transaction var resp = await PendingTransactionCollection.Find(x => true).SortByDescending(x => x.Timestamp).FirstOrDefaultAsync(); if (resp == null) // no pending transaction { // return last transaction return(res); } else { // else return last transaction no younger than pending transaction res = await TransactionCollection.Find(x => x.Timestamp < resp.Timestamp) .SortByDescending(x => x.Timestamp) .FirstOrDefaultAsync(); return(res); } }
public int FbExecuteNonQuery(TransactionCollection command) { var rowAffect = 0; try { OpenFbData(); foreach (Transaction t in command) { Com = GetCommandDb(t.SqlCommand, t.ExecuteType); if (t.Parameter != null) { SetParameter(t.Parameter, ref Com); } rowAffect += Com.ExecuteNonQuery(); } } finally { ReleaseResource(); } return(rowAffect); }
public async Task <ByteString> GetTransaction(ByteString mutationHash) { var key = mutationHash.ToByteArray(); var res = await TransactionCollection.Find(x => x.MutationHash == key).SingleOrDefaultAsync(); return(res == null ? null : new ByteString(res.RawData)); }
public async Task <TransactionCollection> GetExpensesByCriteria(SearchCriteria criteria) { var result = new TransactionCollection(); var qry = _dbset.Where(e => DbFunctions.TruncateTime(e.Date) >= DbFunctions.TruncateTime(criteria.DateFrom) && DbFunctions.TruncateTime(e.Date) <= DbFunctions.TruncateTime(criteria.DateTo)); if (criteria.MinAmount.HasValue) { qry = qry.Where(o => o.Amount >= criteria.MinAmount); } if (criteria.MaxAmount.HasValue) { qry = qry.Where(o => o.Amount <= criteria.MaxAmount); } result.Categories = _mapperService.Map <IEnumerable <Category> >(await qry.Select(o => o.Category).Distinct().ToListAsync()); if (criteria.CategoryIDs.Any()) { qry = qry.Where(o => criteria.CategoryIDs.Contains(o.CategoryId)); } if (!string.IsNullOrEmpty(criteria.SortBy)) { qry = qry.OrderBy(criteria.SortBy + (criteria.SortAsc == true ? " ascending" : " descending")); } if (criteria.Skip.HasValue && criteria.Take.HasValue) { qry = qry.Skip(criteria.Skip.Value).Take(criteria.Take.Value); } result.Transactions = _mapperService.Map <IEnumerable <Transaction> >(await qry.Include(e => e.Category).ToListAsync()); return(result); }
public string GetCreditCardTransactions(TransactionCollection transactions) { string returnValue = string.Empty; if (transactions != null && transactions.Transactions != null && transactions.Transactions.Count > 0) { StringBuilder messageBuilder = new StringBuilder(); var ccPayments = from cParent in transactions.Transactions join cChild in transactions.Transactions on cParent.TransactionTime.ToString(Constants.MonthYearFormat) equals cChild.TransactionTime.ToString(Constants.MonthYearFormat) where cParent.TransactionId != cChild.TransactionId && cParent.Amount == -1 * cChild.Amount && cParent.TransactionTime.Subtract(cChild.TransactionTime).Hours < 24 //&& cParent.TransactionTime.ToString(Constants.MonthYearFormat) == "2014-11" select cParent; string print = "Credit Card Payments"; messageBuilder.AppendLine(); messageBuilder.AppendLine(print); messageBuilder.AppendLine(new string('-', print.Length * 2) + "\n"); CultureInfo culture = this.GetCultureInfoForNegativePattern(); messageBuilder.Append("{"); foreach (var ccPayment in ccPayments) { messageBuilder.AppendLine(string.Format(culture, @"""{0}"":{{""Merchant"":""{1}"",""Amount"":""{2:C}""}}", ccPayment.TransactionTime.ToString(Constants.MonthYearFormat), ccPayment.Merchant, ccPayment.Amount)); } messageBuilder.Append("}"); returnValue = messageBuilder.ToString(); } return(returnValue); }
private string PrintTransactions(bool detailedView) { if (selectedCustomer.Transactions.Count == 0) { return("<none>"); } StringBuilder display = new StringBuilder(1000); TransactionCollection transactions = selectedCustomer.Transactions; foreach (Transaction transaction in transactions) { display.Append(transaction.Timestamp.ToString("yyyy-MM-dd")); display.AppendFormat(" {0}", transaction.Name); if (transaction.Status == Transaction.TransactionStatus.Pending) { display.Append(" [Pending]"); } if (detailedView) { display.Append("\r\n"); AppendDetails(display, transaction); } display.Append("\r\n"); display.Append("\r\n"); } return(display.ToString()); }
public async Task <IReadOnlyList <ByteString> > GetTransactions(ByteString from) { // find last transaction to return var resl = await GetLastTransactionInternal(); if (resl == null) { return(new List <ByteString>().AsReadOnly()); } // find first transaction to return MongoDbTransaction resf = null; if (from != null) { var cmpkey = from.ToByteArray(); resf = await TransactionCollection.Find(x => x.TransactionHash == cmpkey).FirstOrDefaultAsync(); } List <MongoDbTransaction> l; if (resf == null) { l = await TransactionCollection.Find(x => x.Timestamp <= resl.Timestamp).SortBy(x => x.Timestamp).ToListAsync(); } else { l = await TransactionCollection.Find(x => x.Timestamp > resf.Timestamp && x.Timestamp <= resl.Timestamp) .SortBy(x => x.Timestamp).ToListAsync(); } return(l.Select(x => new ByteString(x.RawData)).ToList().AsReadOnly()); }
private async void button1_Click(object sender, EventArgs e) { //The below commented code is the calling code for API for some reason I could not able to call and getting the below error //Unable to read data from the transport connection: An existing connection was forcibly closed by the remote host //I decide to get the data from https://2016.api.levelmoney.com/ and store them locally in json file and query the data //HttpClient client = new HttpClient(); //client.BaseAddress = new Uri("https://2016.api.levelmoney.com/"); //client.DefaultRequestHeaders.Accept.Clear(); //client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); //HttpResponseMessage response = client.GetAsync("/api/v2/core/get-all-transactions/?uid=1110590645&token=2B5075227E074DECE543EB29AA60A9D4&api-toke=AppTokenForInterview").Result; //TransactionCollection transactions = await response.Content.ReadAsAsync<TransactionCollection>(); TransactionCollection transactions = null; //Loading json data to transaction collection using (StreamReader stream = new StreamReader(Path.Combine(Application.StartupPath, "TransactionData.json"))) { transactions = (TransactionCollection)JsonConvert.DeserializeObject(stream.ReadToEnd(), typeof(TransactionCollection)); } Process process = new Process(); if (transactions != null && transactions.Transactions != null && transactions.Transactions.Count > 0) { richTextBox1.Text = process.CalculateTransactions(transactions); richTextBox1.Text += process.GetCreditCardTransactions(transactions); } else { richTextBox1.Text = "No Records to process"; } }
private Account BuildAccount(Guid accountId) { var customerId = Guid.NewGuid(); TransactionCollection transactions = BuildTransactions(accountId); return(Account.Load(accountId, customerId, transactions)); }
public TransactionEditor() { Transactions = new TransactionCollection(); UsePreCloseDay = true; InitializeComponent(); }
/// <summary> /// Fetch by order id. /// </summary> /// <param name="orderId">The order id.</param> /// <returns></returns> public TransactionCollection FetchByOrderId(int orderId) { IDataReader reader = SPs.FetchAssociatedOrderTransactions(orderId).GetReader(); TransactionCollection transactionCollection = new TransactionCollection(); transactionCollection.LoadAndCloseReader(reader); transactionCollection.Sort(Transaction.Columns.TransactionDate, true); return transactionCollection; }
private Account BuildAccount(double creditAmount) { var accountId = Guid.NewGuid(); var customerId = Guid.NewGuid(); TransactionCollection transactions = BuildTransactions(accountId, creditAmount); return(Account.Load(accountId, customerId, transactions)); }
public ProgramView(TransactionCollection collection) { _collection = collection; InitializeComponent(); InitializeTransactionsView(); InitializeAddTranasctionView(); Chart(); }
public async Task <AccountResult> GetAccount(Guid accountId) { using (IDbConnection db = new SqlConnection(_connectionString)) { string accountSQL = @"SELECT * FROM Account WHERE Id = @accountId"; Entities.Account account = await db .QueryFirstOrDefaultAsync <Entities.Account>(accountSQL, new { accountId }); if (account == null) { return(null); } string credits = @"SELECT * FROM [Credit] WHERE AccountId = @accountId"; List <ITransaction> transactionsList = new List <ITransaction>(); using (var reader = db.ExecuteReader(credits, new { accountId })) { var parser = reader.GetRowParser <Credit>(); while (reader.Read()) { ITransaction transaction = parser(reader); transactionsList.Add(transaction); } } string debits = @"SELECT * FROM [Debit] WHERE AccountId = @accountId"; using (var reader = db.ExecuteReader(debits, new { accountId })) { var parser = reader.GetRowParser <Debit>(); while (reader.Read()) { ITransaction transaction = parser(reader); transactionsList.Add(transaction); } } TransactionCollection transactionCollection = new TransactionCollection(); foreach (var item in transactionsList.OrderBy(e => e.TransactionDate)) { transactionCollection.Add(item); } Account result = Account.Load(account.Id, account.CustomerId, transactionCollection); AccountResult accountResult = new AccountResult(result); return(accountResult); } }
public string CalculateTransactionsTest( [PexAssumeUnderTest] Process target, TransactionCollection transactions ) { string result = target.CalculateTransactions(transactions); return(result); // TODO: add assertions to method ProcessTest.CalculateTransactionsTest(Process, TransactionCollection) }
public async Task <IReadOnlyList <ByteString> > GetRecordMutations(ByteString recordKey) { var key = recordKey.ToByteArray(); var res = await TransactionCollection.Find(Builders <MongoDbTransaction> .Filter.AnyEq(x => x.Records, key)) .Project(x => x.MutationHash) .SortBy(x => x.Timestamp) .ToListAsync(); return(res.Select(x => new ByteString(x)).ToList().AsReadOnly()); }
/// <summary> /// Get all accounts /// </summary> /// <returns>Collection of accounts</returns> public TransactionCollection Get() { TransactionCollection Transactions = new TransactionCollection(); foreach (Transaction transaction in DB.Transactions) { Transactions.Add(transaction); } return(Transactions); }
/// <summary> /// Metoda uloží kolekce v modelu do XAML souborů (MaterialCollection, EmployeeCollection, ContractCollection, OverviewModel, TransactionCollection, DeletedMaterialCollection, DeletedEmployeeCollection, DeletedContractCollection). /// </summary> public void Save() { // K ukládání je využit serializér XmlSerializer materialSerializer = new XmlSerializer(MaterialCollection.GetType()); using (StreamWriter sw = new StreamWriter(materialTrack)) { materialSerializer.Serialize(sw, MaterialCollection); } XmlSerializer employeeSerializer = new XmlSerializer(EmployeeCollection.GetType()); using (StreamWriter sw = new StreamWriter(employeeTrack)) { employeeSerializer.Serialize(sw, EmployeeCollection); } XmlSerializer contractSerializer = new XmlSerializer(ContractCollection.GetType()); using (StreamWriter sw = new StreamWriter(contractTrack)) { contractSerializer.Serialize(sw, ContractCollection); } XmlSerializer overviwSerializer = new XmlSerializer(OverviewModel.GetType()); using (StreamWriter sw = new StreamWriter(overviewTrack)) { overviwSerializer.Serialize(sw, OverviewModel); } XmlSerializer accountSerializer = new XmlSerializer(TransactionCollection.GetType()); using (StreamWriter sw = new StreamWriter(transactionTrack)) { accountSerializer.Serialize(sw, TransactionCollection); } XmlSerializer deletedMaterialSerializer = new XmlSerializer(DeletedMaterialCollection.GetType()); using (StreamWriter sw = new StreamWriter(deletedMaterialTrack)) { deletedMaterialSerializer.Serialize(sw, DeletedMaterialCollection); } XmlSerializer deletedEmployeeSerializer = new XmlSerializer(DeletedEmployeeCollection.GetType()); using (StreamWriter sw = new StreamWriter(deletedEmployeeTrack)) { deletedEmployeeSerializer.Serialize(sw, DeletedEmployeeCollection); } XmlSerializer deletedContractSerializer = new XmlSerializer(DeletedContractCollection.GetType()); using (StreamWriter sw = new StreamWriter(deletedContractTrack)) { deletedContractSerializer.Serialize(sw, DeletedContractCollection); } FillingAllCollections(); }
public async Task <AccountResult> GetAccount(Guid accountId) { Entities.Account account = await _context .Accounts .FindAsync(accountId); List <Entities.Credit> credits = await _context .Credits .Where(e => e.AccountId == accountId) .ToListAsync(); List <Entities.Debit> debits = await _context .Debits .Where(e => e.AccountId == accountId) .ToListAsync(); List <ITransaction> transactions = new List <ITransaction>(); foreach (Entities.Credit transactionData in credits) { Credit transaction = Credit.Load( transactionData.Id, transactionData.AccountId, transactionData.Amount, transactionData.TransactionDate); transactions.Add(transaction); } foreach (Entities.Debit transactionData in debits) { Debit transaction = Debit.Load( transactionData.Id, transactionData.AccountId, transactionData.Amount, transactionData.TransactionDate); transactions.Add(transaction); } var orderedTransactions = transactions.OrderBy(o => o.TransactionDate).ToList(); TransactionCollection transactionCollection = new TransactionCollection(); transactionCollection.Add(orderedTransactions); Account result = Account.Load( account.Id, account.CustomerId, transactionCollection); AccountResult re = new AccountResult(result); return(re); }
private TransactionCollection BuildTransactions(Guid accountId, double creditAmount) { var transactions = new TransactionCollection(); var amount = new Amount(creditAmount); var credit = new Credit(accountId, amount); transactions.Add(credit); return(transactions); }
public async Task <Account> Get(Guid id) { Entities.Account account = await _context .Accounts .Find(e => e.Id == id) .SingleOrDefaultAsync(); List <Entities.Credit> credits = await _context .Credits .Find(e => e.AccountId == id) .ToListAsync(); List <Entities.Debit> debits = await _context .Debits .Find(e => e.AccountId == id) .ToListAsync(); List <ITransaction> transactions = new List <ITransaction>(); foreach (Entities.Credit transactionData in credits) { Credit transaction = new Credit( transactionData.Id, transactionData.AccountId, transactionData.Amount, transactionData.TransactionDate); transactions.Add(transaction); } foreach (Entities.Debit transactionData in debits) { Debit transaction = new Debit( transactionData.Id, transactionData.AccountId, transactionData.Amount, transactionData.TransactionDate); transactions.Add(transaction); } var orderedTransactions = transactions.OrderBy(o => o.TransactionDate).ToList(); TransactionCollection transactionCollection = new TransactionCollection(); transactionCollection.Add(orderedTransactions); Account result = new Account( account.Id, account.CustomerId, transactionCollection); return(result); }
public TransactionCollection GetTransactions(int transactions) { var collection = new TransactionCollection(); for (int i = 0; i < transactions; i++) { collection.Transactions.Add(GenerateTransaction(i % 2 == 0)); } return(collection); }
internal void AttachTransactions(TransactionCollection transactions) { foreach (Transaction transaction in transactions) { Package package = FindPackageById(transaction.PackageId); if (package == null) continue; package.Transactions.Add(transaction); package.TransactionsLoaded = true; } }
/************************************************************************/ #region Constructor (protected) /// <summary> /// Initializes a new instance of the <see cref="BankStatementBase"/> class. /// </summary> /// <param name="rootNode">The root node from which to find data for this class.</param> protected BankStatementBase(XmlNode rootNode) : base(rootNode) { if (rootNode != null) { StartDate = GetDateTimeValue(rootNode, nameof(StartDate)); EndDate = GetDateTimeValue(rootNode, nameof(EndDate)); Ledger = new Balance(GetNestedNode(rootNode, GetNodeName(nameof(Ledger)))); Available = new Balance(GetNestedNode(rootNode, GetNodeName(nameof(Available)))); Transactions = new TransactionCollection(GetNestedNode(rootNode, GetNodeName(nameof(Transactions))), this); } }
/// <summary> /// Creates an object that commits or rejects several batched operations as a unit. /// </summary> public Transaction(TransactionCollection transactionCollection) { // Initialize the object this.Index = transactionCollection.Count; this.Exceptions = new List <Exception>(); this.Methods = new MethodCollection(); this.transactionCollection = transactionCollection; // This transaction is the current transaction. this.previousTransaction = this.transactionCollection.Current; this.transactionCollection.current = this; }
/// <summary> /// Metoda odstraní zakázku a pokud byla standartně provedena, vytvoří i novou transakci. /// </summary> /// <param name="selectedContract">Vybraná zakázka</param> /// <param name="workPrice">Cena za provedení zakázky</param> /// <param name="changeAccountCollection">Potvrzení, jesti má být vytvořena nová transakce</param> public void DeleteContract(Contract selectedContract, double?workPrice, bool changeAccountCollection) { if (changeAccountCollection) { TransactionCollection.Add(new Transaction(selectedContract.ContractName.ToString(), Transaction.TransactionType.ContractAdd, (selectedContract.Reward - (double)workPrice))); } // Smazání zakáky ContractCollection.Remove(selectedContract); DeletedContractCollection.Add(new Contract(selectedContract.ContractName, selectedContract.SubmitterName, selectedContract.Pieces, selectedContract.Reward, selectedContract.KindMaterials)); RefreshOverviewFactory(); Save(); }
private int FindPayPalOrderId(int paypalGatewayId, string transactionId) { if (!string.IsNullOrEmpty(transactionId)) { TransactionCollection parentTransactions = TransactionDataSource.LoadForProviderTransaction(paypalGatewayId, transactionId); if ((parentTransactions != null) && (parentTransactions.Count > 0)) { return(parentTransactions[0].Payment.OrderId); } } return(0); }
public void CalculateTransactionsTest852() { string s; Process s0 = new Process(); TransactionCollection s1 = new TransactionCollection(); s1.Error = (string)null; s1.Transactions = (List <Transaction>)null; s = this.CalculateTransactionsTest(s0, s1); Assert.AreEqual <string>("", s); Assert.IsNotNull((object)s0); }
public void Multiple_Transactions_Should_Be_Added() { TransactionCollection transactionCollection = new TransactionCollection(); transactionCollection.Add(new List <ITransaction>() { new Credit(Guid.Empty, 100), new Debit(Guid.Empty, 30) }); Assert.Equal(2, transactionCollection.GetTransactions().Count); }
private void OnSubmitReport(object sender, RoutedEventArgs e) { DateTime rpt = DateTime.MinValue; try { rpt = DateTime.Parse(ReportDate); } catch { } Transactions = new TransactionCollection(); Finances = new FinancialObjectCollection(); foreach (InventoryTransactionObject tran1 in Cache.Current.ReadyForOpenCartUpdate) { if (((tran1.TransactionTime.CompareTo(rpt) >= 0 && tran1.TransactionTime.CompareTo(rpt.AddDays(1)) <= 0 || rpt.Year < 2014) && !ShowUnexportedOnly) || (ShowUnexportedOnly && !tran1.ExportedToWeb)) { Transactions.Add(tran1); } } foreach (FinancialObject fin1 in Cache.Current.CurrentFinancials) { if (fin1.TransactionDateTime.CompareTo(rpt) >= 0 && fin1.TransactionDateTime.CompareTo(rpt.AddDays(1)) <= 0) { Finances.Add(fin1); } } MessageBox.Show("Complete"); /* * * foreach (InventoryTransactionObject tran1 in working) * { * * Cache.Current.ReadyForOpenCartUpdate.Add(tran1); * Cache.Current.InventoryActivity.Remove(tran1); * } * if (tran != null) * { * Cache.Current.ReadyForOpenCartUpdate.Add(tran); * working.Add(tran); * } * foreach (FinancialObject fin1 in financialList) * { * Cache.Current.StagedFinancials.Add(fin1); * Cache.Current.CurrentFinancials.Remove(fin1); * } * if (fin != null) * { * Cache.Current.StagedFinancials.Add(fin); * financialList.Add(fin); * } * */ }
private async Task RollbackTransaction(byte[] hash) { // Rollback is idempotent && reentrant : may be call twice even at the same time try { #if DEBUG Logger.LogDebug($"Rollbacking transaction {new ByteString(hash)}"); #endif // get affected records var trn = await PendingTransactionCollection.Find(x => x.TransactionHash.Equals(hash)).SingleOrDefaultAsync(); if (trn != null) { // revert records values & version foreach (var r in trn.InitialRecords) { await RecordCollection.FindOneAndUpdateAsync( x => x.Key.Equals(r.Key) && x.TransactionLock.Equals(trn.LockToken), Builders <MongoDbRecord> .Update.Set(x => x.Value, r.Value).Set(x => x.Version, r.Version).Unset(x => x.TransactionLock) ); } foreach (var r in trn.AddedRecords) { await RecordCollection.FindOneAndDeleteAsync( x => x.Key.Equals(r) && x.TransactionLock.Equals(trn.LockToken) ); } // remove transaction await TransactionCollection.DeleteOneAsync(x => x.TransactionHash.Equals(hash)); await RecordCollection.UpdateOneAsync( x => x.TransactionLock == trn.LockToken, Builders <MongoDbRecord> .Update .Unset(x => x.TransactionLock) ); // remove pending transaction await PendingTransactionCollection.DeleteOneAsync(x => x.TransactionHash.Equals(hash)); Logger.LogInformation($"Transaction {new ByteString(hash)} rollbacked"); } } catch (Exception ex) { var msg = "Error rollbacking transaction : " + new ByteString(hash).ToString(); Logger.LogCritical(msg, ex); throw new Exception(msg, ex); } }
private Cache() { Inventory = new ActiveInventoryCollection(); Inventory.Load(InventoryFile); InventoryActivity = new TransactionCollection(); InventoryActivity.Load(InventoryActivityFile); ReadyForOpenCartUpdate = new TransactionCollection(); ReadyForOpenCartUpdate.Load(ReadyToPostFile); if (Configuration.Current.FileVersion < Configuration.CurrentFileVersion) { DoVersionUpdateProcess(); } CurrentFinancials = new FinancialObjectCollection(); CurrentFinancials.Load(FinancialsFile); StagedFinancials = new FinancialObjectCollection(); StagedFinancials.Load(StagedFinancialsFile); }
protected void gv_Transaction_RowCommand(object sender, GridViewCommandEventArgs e) { GridViewRow row = (GridViewRow)((Control)e.CommandSource).NamingContainer; int id = Convert.ToInt32(gv_Transaction.DataKeys[row.RowIndex].Values[0]); string _FromEntityID =gv_Transaction.DataKeys[row.RowIndex].Values[1].ToString(); string _ToEntityID = gv_Transaction.DataKeys[row.RowIndex].Values[2].ToString(); using (DataEntryServiceClient _client = new DataEntryServiceClient()) { PeriodServiceClient _pclient = new PeriodServiceClient(); Period _period = new PeriodCollection(_pclient.GetCurrentPeriod())[0]; if (e.CommandName.Equals("Btn_Notice")) { _client.SetNotices(id, Convert.ToInt32(Session["Userid"])); GetData(_period); } else if (e.CommandName.Equals("Btn_Confirm")) { Transaction _tran = new TransactionCollection(_client.LoadTransactionByID(id))[0]; _tran.Updater.UserID = Convert.ToInt32(Session["Userid"]); _tran.Period = _period; _client.SetConfirm(_tran); GetData(_period); } else if (e.CommandName.Equals("Btn_Edit")) { Session["IsAdd"] = false; tx_FromEntity.Text = gv_Transaction.Rows[row.RowIndex].Cells[0].Text ; tx_ToEntity.Text = gv_Transaction.Rows[row.RowIndex].Cells[2].Text; tx_Amount.Text = gv_Transaction.Rows[row.RowIndex].Cells[5].Text; lb_FromEntityID.Text = _FromEntityID; lb_ToEntityID.Text = _ToEntityID; lb_FromCurrency.Text = gv_Transaction.Rows[row.RowIndex].Cells[1].Text; lb_ToCurrency.Text = gv_Transaction.Rows[row.RowIndex].Cells[3].Text; tx_ExchangeRate.Text = gv_Transaction.Rows[row.RowIndex].Cells[4].Text; btn_Confirm.Text = ""; lb_ID.Text = id.ToString(); up_Edit.Update(); Session["Rowindex"] = row.RowIndex; mp1.Show(); } gv_Transaction.Rows[row.RowIndex].BackColor = System.Drawing.ColorTranslator.FromHtml("#023e91"); } }
protected void btn_Confirm_Click(object sender, EventArgs e) { CheckExchange(); if (tx_FromEntity.Text.Equals("") || tx_ToEntity.Text.Equals("")) { Alert(" You have to select [ From cloumn ] or [ To Entity ] . "); return; } if (tx_Amount.Text.Equals("")) { Alert(" You have to key in To Amount . "); return; } if (tx_FromAmount.Text.Equals("")) { Alert(" You have to key in From Amount . "); return; } string regex = "^[0-9]{0,5}$|^[0-9]{0,5}\\.[0-9]{0,2}$ "; System.Text.RegularExpressions.RegexOptions options = ((System.Text.RegularExpressions.RegexOptions.IgnorePatternWhitespace | System.Text.RegularExpressions.RegexOptions.Multiline) | System.Text.RegularExpressions.RegexOptions.IgnoreCase); System.Text.RegularExpressions.Regex reg = new System.Text.RegularExpressions.Regex(regex, options); if (!reg.IsMatch(tx_Amount.Text)) { Alert(" Please check Amount column . "); return; } using (DataEntryServiceClient _client = new DataEntryServiceClient()) { PeriodServiceClient _pclient = new PeriodServiceClient(); Period _period = new PeriodCollection(_pclient.GetCurrentPeriod())[0]; int _FromEntityID = Convert.ToInt32(lb_FromEntityID.Text); int _ToEntityID = Convert.ToInt32(lb_ToEntityID.Text); decimal _Amount = Convert.ToDecimal(tx_Amount.Text); decimal _FromAmount = Convert.ToDecimal(tx_FromAmount.Text); if ((bool)Session["IsAdd"]) { Transaction _tran = new Transaction(); _tran.Period.ID = _period.ID; _tran.IsPay = IsPay.N; _tran.Creator.UserID = Convert.ToInt32(Session["Userid"]); _tran.Amount = _FromAmount; _tran.FromEntity.EntityID = _FromEntityID; _tran.ToEntity.EntityID = _ToEntityID; _tran.FromCurrency = lb_FromCurrency.Text; _tran.ToCurrency = lb_ToCurrency.Text; _tran.ExchangeRate = Convert.ToDecimal(tx_ExchangeRate.Text); _tran.To_Amount = _Amount; _client.InsertTransaction(_tran); mp1.Hide(); GetData(_period); } else { Transaction _tran = new TransactionCollection(_client.LoadTransactionByID(Convert.ToInt32(lb_ID.Text)))[0]; _tran.FromEntity.EntityID = _FromEntityID; _tran.ToEntity.EntityID = _ToEntityID; _tran.Amount = _FromAmount; _tran.To_Amount = _Amount; _tran.FromCurrency = lb_FromCurrency.Text; _tran.ToCurrency = lb_ToCurrency.Text; _tran.ExchangeRate = Convert.ToDecimal(tx_ExchangeRate.Text); _client.Updatetransaction(_tran); mp1.Hide(); GetData(_period); } } if(Session["Rowindex"]!=null) gv_Transaction.Rows[Convert.ToInt32(Session["Rowindex"])].BackColor = System.Drawing.ColorTranslator.FromHtml("#023e91"); }
public TransactionCollection FetchByID(object TxKey) { TransactionCollection coll = new TransactionCollection().Where("Tx_Key", TxKey).Load(); return coll; }
public void InsertTransactionCollection(TransactionCollection _collection) { using (TransactionAccessClient _tran = new TransactionAccessClient(EndpointName.TransactionAccess)) { _tran.InsertTransactionCollection(_collection.ToArray()); } }
/// <summary> /// Loads all transactions for the current business from the data source that were applied to a given account. /// </summary> /// <param name="workbook"> /// The workbook used to associate the loaded transactions with. /// </param> /// <param name="account">The account that will be used to search for transactions.</param> /// <returns>The loaded transactions.</returns> public override TransactionCollection FetchTransactions(Workbook workbook, Account account) { TransactionCollection results = new TransactionCollection(); results.AddRange(ReadTransactions(workbook, account)); return results; }
private void GetData(Period _period) { DataEntryServiceClient _client = new DataEntryServiceClient(); TransactionCollection _collection = new TransactionCollection(); if(!_period.ID.Equals(0)) _collection = new TransactionCollection(_client.LoadTransactionByPeriodID(_period.ID)); else _collection = new TransactionCollection(_client.LoadTransaction()); DataTable dt = new DataTable(); dt.Columns.Add("id"); dt.Columns.Add("FromEntity"); dt.Columns.Add("ToEntity"); dt.Columns.Add("FromEntityid"); dt.Columns.Add("ToEntityid"); dt.Columns.Add("Amount"); dt.Columns.Add("Notice"); dt.Columns.Add("NoticeTime"); dt.Columns.Add("Pay"); dt.Columns.Add("Confirm"); dt.Columns.Add("ConfirmTime"); dt.Columns.Add("Updater"); dt.Columns.Add("Creator"); dt.Columns.Add("FromCurrency"); dt.Columns.Add("ToCurrency"); dt.Columns.Add("ExchangeRate"); foreach (Transaction _tran in _collection) { DataRow newRow = dt.NewRow(); newRow["id"] = _tran.ID; newRow["FromEntity"] = _tran.FromEntity.EntityName; newRow["ToEntity"] = _tran.ToEntity.EntityName; newRow["FromEntityid"] = _tran.FromEntity.EntityID; newRow["ToEntityid"] = _tran.ToEntity.EntityID; newRow["Amount"] = string.Format("{0:N2}",_tran.Amount); newRow["Notice"] = _tran.NoticeUser.UserName; if (!_tran.NoticeTime.ToShortDateString().Equals("0001/1/1")) newRow["NoticeTime"] = _tran.NoticeTime; newRow["Pay"] = _tran.IsPay; newRow["Confirm"] = _tran.ConfirmUser.UserName; if (!_tran.ConfirmTime.ToShortDateString().Equals("0001/1/1")) newRow["ConfirmTime"] = _tran.ConfirmTime; newRow["Updater"] = _tran.Updater.UserName; newRow["Creator"] = _tran.Creator.UserName; newRow["FromCurrency"] = _tran.FromCurrency; newRow["ToCurrency"] = _tran.ToCurrency; newRow["ExchangeRate"] = _tran.ExchangeRate; dt.Rows.Add(newRow); } gv_Transaction.DataSource = dt; gv_Transaction.DataBind(); up_gvGrid.Update(); }
private void OnSubmitReport(object sender, RoutedEventArgs e) { DateTime rpt = DateTime.MinValue; try { rpt = DateTime.Parse(ReportDate); } catch { } Transactions = new TransactionCollection(); Finances = new FinancialObjectCollection(); foreach (InventoryTransactionObject tran1 in Cache.Current.ReadyForOpenCartUpdate) { if (((tran1.TransactionTime.CompareTo(rpt) >= 0 && tran1.TransactionTime.CompareTo(rpt.AddDays(1)) <= 0 || rpt.Year < 2014) && !ShowUnexportedOnly) || (ShowUnexportedOnly && !tran1.ExportedToWeb)) { Transactions.Add(tran1); } } foreach (FinancialObject fin1 in Cache.Current.CurrentFinancials) { if (fin1.TransactionDateTime.CompareTo(rpt) >= 0 && fin1.TransactionDateTime.CompareTo(rpt.AddDays(1)) <= 0) { Finances.Add(fin1); } } MessageBox.Show("Complete"); /* * foreach (InventoryTransactionObject tran1 in working) { Cache.Current.ReadyForOpenCartUpdate.Add(tran1); Cache.Current.InventoryActivity.Remove(tran1); } if (tran != null) { Cache.Current.ReadyForOpenCartUpdate.Add(tran); working.Add(tran); } foreach (FinancialObject fin1 in financialList) { Cache.Current.StagedFinancials.Add(fin1); Cache.Current.CurrentFinancials.Remove(fin1); } if (fin != null) { Cache.Current.StagedFinancials.Add(fin); financialList.Add(fin); } * */ }
public DatabaseTransactionFactory(Database database) { this.database = database; OpenTransactions = new TransactionCollection(); }
/// <summary> /// Creates a new customer, which holds account and transaction information. /// </summary> /// <param name="accounts">The accounts for this customer.</param> public Customer(BankAccountCollection accounts) { this.accounts = accounts; this.transactionHistory = new TransactionCollection(); }
/// <summary> /// Creates a new BankAccount instance with a specific opening balance for the account. /// </summary> /// <param name="openingAccountBalance">Balance to open the account with.</param> public BankAccount(decimal openingAccountBalance) { this.balance = openingAccountBalance; this.pendingTransactions = new TransactionCollection(); }
public TransactionHistoryForm(TransactionCollection transactions) { InitializeComponent(); this.transactions = transactions; }
public TransactionCollection FetchByID(object TransactionId) { TransactionCollection coll = new TransactionCollection().Where("TransactionId", TransactionId).Load(); return coll; }
public TransactionCollection FetchByQuery(Query qry) { TransactionCollection coll = new TransactionCollection(); coll.LoadAndCloseReader(qry.ExecuteReader()); return coll; }
private void Dispose(bool disposing) { if (disposing) { if (OpenTransactions != null) { foreach (var transaction in OpenTransactions) { if (transaction != null) transaction.Dispose(); } OpenTransactions.Clear(); } } database = null; OpenTransactions = null; }