private void btnOk_Click(object sender, EventArgs e)
{
MoneyDataSet.AccountsRow account = cbAccount.SelectedItem as MoneyDataSet.AccountsRow;
double amount = account.Balance - ((double)numBalance.Value);
MoneyDataSet.TransactionsRow preCreate =
keeper.PreCreateTransaction(keeper.GetTransactionType(MoneyDataSet.IDs.TransactionTypes.Correction),
Resources.Labels.AccountCorrectionLabel, tbDescription.Text, DateTime.Now, account, amount);
ValidationResult result = keeper.Validate(transaction: preCreate);
if (!result.Success)
{
if (result.PreventAction)
{
MessageBox.Show(String.Format(Resources.Labels.TransactionValidationErrorsFoundFormat, result.Message),
Resources.Labels.TransactionValidationTitle, MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
else
{
if (MessageBox.Show(String.Format(Resources.Labels.TransactionValidationWarningsFoundFormat, result.Message),
Resources.Labels.TransactionValidationTitle, MessageBoxButtons.OKCancel, MessageBoxIcon.Warning) == DialogResult.Cancel)
{
return;
}
}
}
keeper.CreateTransaction(preCreate, ttbTags.Tags);
this.DialogResult = DialogResult.OK;
this.Close();
}
private void updateBalanceInfo()
{
if (cbAccount.SelectedItem != null)
{
MoneyDataSet.AccountsRow account = cbAccount.SelectedItem as MoneyDataSet.AccountsRow;
MoneyDataSet.CurrenciesRow currency = account.CurrenciesRow;
lblCurrency.Visible = false;
numBalance.Visible = false;
lblCurrency.Text = CultureInfo.CreateSpecificCulture(currency.CurrencyCulture).NumberFormat.CurrencySymbol;
if (currency.IsSymbolAfterAmount)
{
tlpBalance.SetCellPosition(lblCurrency, new TableLayoutPanelCellPosition(2, 0));
tlpBalance.SetCellPosition(numBalance, new TableLayoutPanelCellPosition(0, 0));
lblCurrency.TextAlign = ContentAlignment.MiddleLeft;
lblCurrency.Dock = DockStyle.Left;
}
else
{
tlpBalance.SetCellPosition(lblCurrency, new TableLayoutPanelCellPosition(0, 0));
tlpBalance.SetCellPosition(numBalance, new TableLayoutPanelCellPosition(1, 0));
lblCurrency.TextAlign = ContentAlignment.MiddleRight;
lblCurrency.Dock = DockStyle.Right;
}
numBalance.Value = (decimal)account.Balance;
numBalance.Select(0, Int32.MaxValue);
lblCurrency.Visible = true;
numBalance.Visible = true;
}
}
private void cbDestinationPlan_SelectionChangeCommitted(object sender, EventArgs e)
{
MoneyDataSet.PlannedTransactionsRow plan = cbDestinationPlan.SelectedItem as MoneyDataSet.PlannedTransactionsRow;
// protection from old schema
if (plan.TransactionTemplatesRow == null)
{
ErrorHelper.ShowErrorBox(ErrorHelper.Errors.PlanTemplateIsNull);
return;
}
// cbDestinationAccount.DataSource = keeper.GetAccounts(plan.AccountTypeRow, plan.TransactionTemplatesRow.ExactDestinationAccountType);
cbDestinationAccount.Items.Clear();
foreach (var acc in keeper.GetAccounts(plan.AccountTypeRow, plan.TransactionTemplatesRow.ExactDestinationAccountType))
{
cbDestinationAccount.Items.Add(acc);
}
cbDestinationAccount.SelectedIndex = 0;
cbDestinationAccount_SelectionChangeCommitted(null, null);
if (!plan.IsAggregated)
{
MoneyDataSet.AccountsRow account = cbDestinationAccount.SelectedItem as MoneyDataSet.AccountsRow;
numDestinationAmount.Value = (decimal)(plan.Amount * plan.CurrenciesRow.ExchangeRate / account.CurrenciesRow.ExchangeRate);
}
else
{
numDestinationAmount.Value = 0;
}
numDestinationAmount.Select(0, Int32.MaxValue);
}
public AccountEditForm(bool isDebit, MoneyDataSet.AccountTypesRow accountType = null, MoneyDataSet.AccountsRow account = null)
{
InitializeComponent();
this.keeper = MoneyDataKeeper.Instance;
this.isDebit = isDebit;
this.accountType = accountType;
this.account = account;
}
public static bool DeleteAccount(MoneyDataSet.AccountsRow account)
{
if (MessageBox.Show(String.Format(Resources.Labels.DeleteAccountFormat, account.Title),
Resources.Labels.DeleteAccountTitle, MessageBoxButtons.OKCancel,
MessageBoxIcon.Warning, MessageBoxDefaultButton.Button2) == DialogResult.OK)
{
MoneyDataKeeper.Instance.DeleteAccount(account.ID);
return(true);
}
return(false);
}
public AccountViewForm(MoneyDataSet.AccountsRow account)
{
InitializeComponent();
this.account = account;
tbTitle.Text = account.FullTitle;
tbBalance.Text = account.Balance.ToString(Consts.UI.CurrencyFormat, account.CurrenciesRow.CurrencyCultureInfo);
tbDescription.Text = account.Description;
ttbTags.Tags = keeper.GetAccountTagStrings(account);
DialogResult = DialogResult.Cancel;
}
private void updateDestinationAmount()
{
if (template.HasDestinationAccount)
{
MoneyDataSet.AccountsRow source = cbSourceAccount.SelectedItem as MoneyDataSet.AccountsRow;
MoneyDataSet.AccountsRow destination = cbDestinationAccount.SelectedItem as MoneyDataSet.AccountsRow;
double amount = ((double)numSourceAmount.Value) * source.CurrenciesRow.ExchangeRate /
destination.CurrenciesRow.ExchangeRate;
numDestinationAmount.Value = (decimal)amount;
numDestinationAmount.Select(0, Int32.MaxValue);
}
}
private void tsmiAccountBalanceCorrection_Click(object sender, EventArgs e)
{
MoneyDataSet.AccountsRow selected = dgvSearchResults.CurrentRow.Tag as MoneyDataSet.AccountsRow;
AccountCorrectionForm form = new AccountCorrectionForm(selected);
if (form.ShowDialog(this) == DialogResult.OK)
{
updateTagCloud();
dgvSearchResults.CurrentRow.Cells[2].Value = selected.EntryTime;
dgvSearchResults.CurrentRow.Cells[3].Value = selected.Balance.ToString(Consts.UI.CurrencyFormat,
selected.CurrenciesRow.CurrencyCultureInfo);
}
}
private void cbSourcePlan_SelectionChangeCommitted(object sender, EventArgs e)
{
MoneyDataSet.PlannedTransactionsRow plan = cbSourcePlan.SelectedItem as MoneyDataSet.PlannedTransactionsRow;
// protection from old schema
if (plan.TransactionTemplatesRow == null)
{
ErrorHelper.ShowErrorBox(ErrorHelper.Errors.PlanTemplateIsNull);
return;
}
// cbSourceAccount.DataSource = keeper.GetAccounts(plan.AccountTypeRow, plan.TransactionTemplatesRow.ExactSourceAccountType);
cbSourceAccount.Items.Clear();
foreach (var acc in keeper.GetAccounts(plan.AccountTypeRow, plan.TransactionTemplatesRow.ExactSourceAccountType))
{
cbSourceAccount.Items.Add(acc);
}
cbSourceAccount.SelectedIndex = 0;
cbSourceAccount_SelectionChangeCommitted(null, null);
MoneyDataSet.AccountsRow account = cbSourceAccount.SelectedItem as MoneyDataSet.AccountsRow;
if (!plan.IsAggregated)
{
numSourceAmount.Value = (decimal)(plan.Amount * plan.CurrenciesRow.ExchangeRate / account.CurrenciesRow.ExchangeRate);
}
else
{
numSourceAmount.Value = 0;
}
numSourceAmount.Select(0, Int32.MaxValue);
if ((tbTitle.Text.Equals(template.TransactionDefaultTitle)) || (sourcePlans.Count(p => (p.Title.Equals(tbTitle.Text))) > 0))
{
if (String.IsNullOrWhiteSpace(plan.Title))
{
tbTitle.Text = template.Title;
}
else
{
tbTitle.Text = plan.Title;
}
}
ttbTags.Tags = keeper.GetPlannedTransactionTagStrings(plan);
}
private void tsbEdit_Click(object sender, EventArgs e)
{
if (dgvAccounts.SelectedRows.Count == 1)
{
MoneyDataSet.AccountsRow account = dgvAccounts.SelectedRows[0].Tag as MoneyDataSet.AccountsRow;
AccountEditForm form = new AccountEditForm(account.AccountTypesRow.IsDebit, account: account);
if (form.ShowDialog(this) == DialogResult.OK)
{
refreshAccounts();
foreach (DataGridViewRow row in dgvAccounts.Rows)
{
if (row.Tag == form.UpdatedAccount)
{
dgvAccounts.FirstDisplayedCell = dgvAccounts.CurrentCell = row.Cells[0];
break;
}
}
}
}
}
private void updateDestinationCurrency()
{
if ((template.HasDestinationAccount) && (cbDestinationAccount.SelectedItem != null))
{
MoneyDataSet.AccountsRow account = cbDestinationAccount.SelectedItem as MoneyDataSet.AccountsRow;
MoneyDataSet.CurrenciesRow currency = account.CurrenciesRow;
lblDestinationCurrency.Visible = false;
numDestinationAmount.Visible = false;
CultureInfo culture = account.CurrenciesRow.CurrencyCultureInfo;
lblDestinationBalance.Text = String.Format(culture, Resources.Labels.BalanceFormat, account.Balance);
lblDestinationCurrency.Text = culture.NumberFormat.CurrencySymbol;
if (destinationAccountSelected != null)
{
numDestinationAmount.Value = (decimal)(((double)numDestinationAmount.Value) *
destinationAccountSelected.CurrenciesRow.ExchangeRate / currency.ExchangeRate);
numDestinationAmount.Select(0, Int32.MaxValue);
}
if (currency.IsSymbolAfterAmount)
{
tlpDestination.SetCellPosition(lblDestinationCurrency, new TableLayoutPanelCellPosition(2, 6));
tlpDestination.SetCellPosition(numDestinationAmount, new TableLayoutPanelCellPosition(0, 6));
lblDestinationCurrency.TextAlign = ContentAlignment.MiddleLeft;
lblDestinationCurrency.Dock = DockStyle.Left;
}
else
{
tlpDestination.SetCellPosition(lblDestinationCurrency, new TableLayoutPanelCellPosition(0, 6));
tlpDestination.SetCellPosition(numDestinationAmount, new TableLayoutPanelCellPosition(1, 6));
lblDestinationCurrency.TextAlign = ContentAlignment.MiddleRight;
lblDestinationCurrency.Dock = DockStyle.Right;
}
lblDestinationCurrency.Visible = true;
numDestinationAmount.Visible = true;
destinationAccountSelected = account;
}
}
private void btnOk_Click(object sender, EventArgs e)
{
tbTitle.Text = tbTitle.Text.Trim();
if (account != null)
{
// updating existing account
account = keeper.UpdateAccount(account.ID, tbTitle.Text, tbDescription.Text, cbHideAccount.Checked, ttbTags.Tags);
}
else
{
// creating new account
account = keeper.PreCreateAccount(cbAccountType.SelectedItem as MoneyDataSet.AccountTypesRow, tbTitle.Text, tbDescription.Text,
cbCurrency.SelectedItem as MoneyDataSet.CurrenciesRow, 0);
ValidationResult result = keeper.Validate(account: account);
if (!result.Success)
{
if (result.PreventAction)
{
MessageBox.Show(String.Format(Resources.Labels.AccountValidationErrorsFoundFormat, result.Message),
Resources.Labels.AccountValidationTitle, MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
else
{
if (MessageBox.Show(String.Format(Resources.Labels.AccountValidationWarningsFoundFormat, result.Message),
Resources.Labels.AccountValidationTitle, MessageBoxButtons.OKCancel, MessageBoxIcon.Warning) == DialogResult.Cancel)
{
return;
}
}
}
account = keeper.CreateAccount(account, ttbTags.Tags);
}
keeper.AddTextHistory(Consts.Keeper.AccountTitleHistoryID, tbTitle.Text);
this.DialogResult = DialogResult.OK;
this.Close();
}
private void openSearchResult(bool editMode = false)
{
object tag = dgvSearchResults.CurrentRow.Tag;
if (tag is MoneyDataSet.AccountsRow)
{
MoneyDataSet.AccountsRow account = tag as MoneyDataSet.AccountsRow;
if (editMode)
{
AccountEditForm form = new AccountEditForm(account.AccountTypesRow.IsDebit, account: account);
if (form.ShowDialog() != DialogResult.Cancel)
{
updateTagCloud();
dgvSearchResults.Rows.Clear();
}
}
else
{
AccountViewForm form = new AccountViewForm(account);
if (form.ShowDialog() != DialogResult.Cancel)
{
updateTagCloud();
dgvSearchResults.Rows.Clear();
}
}
}
else if (tag is MoneyDataSet.TransactionsRow)
{
MoneyDataSet.TransactionsRow transaction = tag as MoneyDataSet.TransactionsRow;
TransactionViewForm form = new TransactionViewForm(transaction);
if (form.ShowDialog() != DialogResult.Cancel)
{
dgvSearchResults.Rows.Remove(dgvSearchResults.CurrentRow);
}
}
else if (tag is MoneyDataSet.PlannedTransactionsRow)
{
MoneyDataSet.PlannedTransactionsRow plan = tag as MoneyDataSet.PlannedTransactionsRow;
if (editMode)
{
MoneyDataSet.PlannedTransactionsRow sourcePlan = null;
MoneyDataSet.PlannedTransactionsRow destinationPlan = null;
if (plan.TransactionTemplatesRow == null)
{
ErrorHelper.ShowErrorBox(ErrorHelper.Errors.PlanWithoutTemplate);
Log.Write("Plan", plan);
return;
}
if (plan.TransactionTemplatesRow.HasDestinationAccount)
{
sourcePlan = keeper.PlannedTransactions.SingleOrDefault(p => ((!p.IsPairReferenceIDNull()) &&
(p.PairReferenceID == plan.PairReferenceID) &&
(p.TransactionTypeID.Equals(plan.TransactionTemplatesRow.SourceTransactionTypeID))));
destinationPlan = keeper.PlannedTransactions.SingleOrDefault(p => ((!p.IsPairReferenceIDNull()) &&
(p.PairReferenceID == plan.PairReferenceID) &&
(p.TransactionTypeID.Equals(plan.TransactionTemplatesRow.DestinationTransactionTypeID))));
}
else
{
sourcePlan = plan;
}
PlanEditForm form = new PlanEditForm(sourcePlan.TransactionTemplatesRow,
sourcePlan, destinationPlan);
if (form.ShowDialog(this) != DialogResult.Cancel)
{
updateTagCloud();
dgvSearchResults.Rows.Clear();
}
}
else
{
PlanViewForm form = new PlanViewForm(plan);
if (form.ShowDialog(this) != DialogResult.Cancel)
{
updateTagCloud();
dgvSearchResults.Rows.Clear();
}
}
}
else
{
ErrorHelper.ShowErrorBox(ErrorHelper.Errors.UnknownSearchResult);
Log.Write("Found in search", tag);
}
//updateTagCloud();
//dgvSearchResults.Rows.Clear();
}
public AccountCorrectionForm(MoneyDataSet.AccountsRow selectedAccount = null)
{
InitializeComponent();
existingAccount = selectedAccount;
keeper = MoneyDataKeeper.Instance;
}
private void btnOk_Click(object sender, EventArgs e)
{
tbTitle.Text = tbTitle.Text.Trim();
MoneyDataSet.AccountsRow sourceAccount = cbSourceAccount.SelectedItem as MoneyDataSet.AccountsRow;
double sourceAmount = (double)numSourceAmount.Value;
MoneyDataSet.PlannedTransactionsRow sourcePlan = null;
if (cbSourceImplementsPlan.Checked)
{
sourcePlan = cbSourcePlan.SelectedItem as MoneyDataSet.PlannedTransactionsRow;
}
MoneyDataSet.TransactionsRow preCreateSource =
keeper.PreCreateTransaction(template.TransactionTypesRowByFK_TransactionTypes_Source_TransactionTemplates,
tbTitle.Text, tbDescription.Text, dtpTransactionDate.Value, sourceAccount, sourceAmount,
plan: sourcePlan, template: template);
MoneyDataSet.TransactionsRow preCreateDestination = null;
ValidationResult resultSource = keeper.Validate(transaction: preCreateSource);
ValidationResult resultDestination = new ValidationResult(success: true, preventAction: false, message: String.Empty);
if (template.HasDestinationAccount)
{
MoneyDataSet.AccountsRow destinationAccount = cbDestinationAccount.SelectedItem as MoneyDataSet.AccountsRow;
double destinationAmount = (double)numDestinationAmount.Value;
MoneyDataSet.PlannedTransactionsRow destinationPlan = null;
if (cbDestinationImplementsPlan.Checked)
{
destinationPlan = cbDestinationPlan.SelectedItem as MoneyDataSet.PlannedTransactionsRow;
}
preCreateDestination = keeper.PreCreateTransaction(template.TransactionTypesRowByFK_TransactionTypes_Destination_TransactionTemplates,
tbTitle.Text, tbDescription.Text, dtpTransactionDate.Value, destinationAccount, destinationAmount,
plan: destinationPlan, template: template, pairReference: preCreateSource.ID);
resultDestination = keeper.Validate(transaction: preCreateDestination);
}
if (!((resultSource.Success) && (resultDestination.Success)))
{
StringBuilder message = new StringBuilder();
if (String.IsNullOrWhiteSpace(resultSource.Message))
{
message.AppendLine(Resources.Labels.TransactionDestinationValidation);
message.Append(resultDestination.Message);
}
else if (String.IsNullOrWhiteSpace(resultDestination.Message))
{
if (template.HasDestinationAccount)
{
message.AppendLine(Resources.Labels.TransactionSourceValidation);
}
message.Append(resultSource.Message);
}
else
{
message.Append(String.Join(Environment.NewLine, new String[] { Resources.Labels.TransactionSourceValidation,
resultSource.Message, String.Empty, Resources.Labels.TransactionDestinationValidation,
resultDestination.Message }));
}
if ((resultSource.PreventAction) || (resultDestination.PreventAction))
{
MessageBox.Show(String.Format(Resources.Labels.TransactionValidationErrorsFoundFormat, message.ToString()),
Resources.Labels.TransactionValidationTitle, MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
else
{
if (MessageBox.Show(String.Format(Resources.Labels.TransactionValidationWarningsFoundFormat, message.ToString()),
Resources.Labels.TransactionValidationTitle, MessageBoxButtons.OKCancel, MessageBoxIcon.Warning) == DialogResult.Cancel)
{
return;
}
}
}
transaction = keeper.CreateTransaction(preCreateSource, ttbTags.Tags);
if (template.HasDestinationAccount)
{
keeper.CreateTransaction(preCreateDestination, ttbTags.Tags);
}
keeper.AddTextHistory(String.Format(Consts.Keeper.TransactionTitleHistoryIDFormat, template.ID), tbTitle.Text);
this.DialogResult = DialogResult.OK;
this.Close();
}
