private void ApplyNowTransactions(IEnumerable <ITransaction> transactions)
{
foreach (var transaction in transactions)
{
var plannedTransaction = transaction as PlannedTransactionModel <EventModel>;
// simple event
if (plannedTransaction?.Event is SimpleEventModel)
{
_recordService.Add(_recordService.Create(plannedTransaction.Event as SimpleEventModel));
}
// repay debt
if (plannedTransaction?.Event is RepayDebtEventModel)
{
_recordService.Add(_recordService.Create(plannedTransaction.Event as RepayDebtEventModel));
}
// money transfer
if (plannedTransaction?.Event is MoneyTransferEventModel)
{
_moneyTransferService.Add(_moneyTransferService.Create(plannedTransaction.Event as MoneyTransferEventModel));
}
RefreshTodayTransactions();
}
}
public List <ITransaction> ExecutePlanned(IEnumerable <ITransaction> transactions, DateTime?date = null, bool isAutoExecution = false)
{
var result = new List <ITransaction>();
foreach (var transaction in transactions)
{
var plannedTransaction = transaction as PlannedTransactionModel <EventModel>;
if (plannedTransaction == null)
{
continue;
}
// simple event
if (plannedTransaction.Event is SimpleEventModel)
{
result.Add(_recordService.Add(_recordService.Create(plannedTransaction.Event as SimpleEventModel, x =>
{
x.Date = date ?? plannedTransaction.TransactionDate;
x.IsAutoExecuted = isAutoExecution;
})));
}
// repay debt
if (plannedTransaction.Event is RepayDebtEventModel)
{
result.Add(_recordService.Add(_recordService.Create(plannedTransaction.Event as RepayDebtEventModel, x =>
{
x.Date = date ?? plannedTransaction.TransactionDate;
x.IsAutoExecuted = isAutoExecution;
})));
}
// money transfer
if (plannedTransaction.Event is MoneyTransferEventModel)
{
result.Add(_moneyTransferService.Add(_moneyTransferService.Create(plannedTransaction.Event as MoneyTransferEventModel, x =>
{
x.Date = date ?? plannedTransaction.TransactionDate;
x.IsAutoExecuted = isAutoExecution;
})));
}
}
return(result);
}
public async Task <IActionResult> CreateRecords([FromBody] RecordDto StructureRecord)
{
if (StructureRecord == null)
{
_logger.LogInformation($"bad data durinng creating structured records ");
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_recordService.Add(StructureRecord);
//RecordsDataStore.Current.Records.Add(finalRecord);
return(Ok(true));
}
private IMCCommand InitTransactionApplyNowCommand()
{
return(new DataGridSelectedItemsCommand <ITransaction>(GridTransactions,
(items) =>
{
foreach (var item in items)
{
ITransaction newTransaction = null;
var plannedTransaction = item as PlannedTransactionModel <EventModel>;
// simple event
if (plannedTransaction?.Event is SimpleEventModel)
{
newTransaction = _recordService.Add(
_recordService.Create(plannedTransaction.Event as SimpleEventModel));
}
// repay debt
if (plannedTransaction?.Event is RepayDebtEventModel)
{
newTransaction = _recordService.Add(
_recordService.Create(plannedTransaction.Event as RepayDebtEventModel));
}
// money transfer
if (plannedTransaction?.Event is MoneyTransferEventModel)
{
newTransaction = _moneyTransferService.Add(
_moneyTransferService.Create(plannedTransaction.Event as MoneyTransferEventModel));
}
AddNew(newTransaction);
}
NotifyDataChanged();
},
(items) => items.All(_ => _.IsPlanned)));
}
public CommonResponse Add(RecordViewModel recordViewModel)
{
CommonResponse <RecordViewModel> response = new CommonResponse <RecordViewModel>();
try
{
var model = _recordService.Add(_mapper.Map <Record>(recordViewModel));
response.Result = _mapper.Map <RecordViewModel>(model);
}
catch (ServiceException ex)
{
response.StatusText = ex.Message;
}
return(response);
}
public async Task <ActionResult> Create(RecordViewModel recordViewModel)
{
if (ModelState.IsValid)
{
await _recordService.Add(recordViewModel.MapToDto());
return(RedirectToAction("Index"));
}
var clients = _clientService.GetItems();
ViewBag.ClientId = new SelectList(clients, "Id", "Name", recordViewModel.ClientId);
var procedures = _procedureService.GetItems();
ViewBag.ProcedureId = new SelectList(procedures, "Id", "Name", recordViewModel.ProcedureId);
var products = _productService.GetItems();
ViewBag.ProductId = new SelectList(products, "Id", "Name", recordViewModel.ProductId);
return(View(recordViewModel));
}
private void InitializeViewModel()
{
_viewModel = new ChequeViewModel();
_viewModel.AddCommand = new Command(() =>
{
var record = new RecordModel()
{
UserId = GlobalVariables.UserId,
RecordType = _viewModel.Entities.Count > 0 ? _viewModel.Entities.Last().RecordType : RecordType.Expense
};
record.PropertyChanged += (sender, e) =>
{
if (e.PropertyName == nameof(RecordModel.Value) || e.PropertyName == nameof(RecordModel.RecordType))
{
_viewModel.RefreshTotalAmount();
}
};
_viewModel.Entities.Add(record);
});
_viewModel.DuplicateCommand = new DataGridSelectedItemCommand <RecordModel>(GridRecords, (item) =>
{
_viewModel.Entities.Add(new RecordModel()
{
Description = item.Description,
RecordType = item.RecordType,
Value = item.Value,
Remark = item.Remark,
CategoryId = item.CategoryId,
UserId = item.UserId
});
});
_viewModel.DeleteCommand = new DataGridSelectedItemsCommand <RecordModel>(GridRecords, (items) =>
{
// remove in only grid
foreach (var item in items.ToList())
{
_viewModel.Entities.Remove(item);
}
});
_viewModel.SaveCommand = new Command(() =>
{
// check valid data
if (!ValidateData())
{
MessageBox.Show(MultiLangResourceManager.Instance[MultiLangResourceName.SaveFailedMessage],
MultiLangResourceManager.Instance[MultiLangResourceName.SaveFailed], MessageBoxButton.OK,
MessageBoxImage.Exclamation);
return;
}
foreach (var entity in _viewModel.Entities)
{
entity.Date = _viewModel.Date;
entity.CurrencyId = _viewModel.CurrencyId;
entity.StorageId = _viewModel.StorageId;
entity.Storage = _viewModel.Storage;
entity.CurrencyExchangeRate = _viewModel.CurrencyExchangeRate;
if (string.IsNullOrEmpty(entity.Description))
{
entity.Description = _viewModel.Description;
}
if (string.IsNullOrEmpty(entity.Remark))
{
entity.Remark = _viewModel.Remark;
}
_service.Add(entity);
}
_viewModel.Entities.Clear();
DialogResult = true;
this.Close();
});
_viewModel.CancelCommand = new Command(() =>
{
DialogResult = false;
this.Close();
});
// init columns
_viewModel.RecordTypeList = MultiLangEnumHelper.ToCollection(typeof(RecordType));
// fill defaults
_viewModel.Date = DateTime.Now;
_viewModel.CurrencyId = _currencies.FirstOrDefault(x => x.IsMain)?.Id ?? _currencies.FirstOrDefault()?.Id ?? 0;
_viewModel.Currency = _currencies.FirstOrDefault(x => x.Id == _viewModel.CurrencyId)?.ToReferenceView();
_viewModel.StorageId = _storages.FirstOrDefault(x => x.CurrencyId == _viewModel.CurrencyId)?.Id ?? 0;
_viewModel.Storage = _storages.FirstOrDefault(x => x.Id == _viewModel.StorageId)?.ToReferenceView();
_viewModel.Entities.CollectionChanged += (sender, e) => _viewModel.RefreshTotalAmount();
this.DataContext = _viewModel;
}
public void MenuLoop()
{
// Start MenuLoop
while (true)
{
// Display Menu Selection Header
ConsoleIO.DisplayHeader("Main Menu");
// Display Menu Options
ConsoleIO.DisplayMenuOptions(
"Load a Record",
"View Records by Date Range",
"Add Record",
"Edit Record",
"Delete Record",
"Exit");
// Prompt User Choice
int choice = ConsoleIO.GetIntInRange("Enter Choice: ", 1, 6);
Result <DateRecord> result;
// switch on choice
switch (choice)
{
case 1:
// Load Record
result = _recordService.Get(ConsoleIO.GetDateTime("Enter the record date: "));
if (result.Success)
{
ConsoleIO.DisplaySuccess(result.Message);
ConsoleIO.DisplayDateRecord(result.Data);
}
else
{
ConsoleIO.DisplayFailure(result.Message);
}
break;
case 2:
// View Records by Date Range
var resultList = _recordService.LoadRange(
ConsoleIO.GetDateTime("Enter start date: "),
ConsoleIO.GetDateTime("Enter end date: "));
if (resultList.Success)
{
ConsoleIO.DisplaySuccess(resultList.Message);
foreach (var record in resultList.Data)
{
ConsoleIO.DisplayDateRecord(record);
}
}
else
{
ConsoleIO.DisplayFailure(resultList.Message);
}
break;
case 3:
// Add Record
result = _recordService.Add(ConsoleIO.GetDateRecord());
if (result.Success)
{
ConsoleIO.DisplaySuccess(result.Message);
}
else
{
ConsoleIO.DisplayFailure(result.Message);
}
break;
case 4:
// Edit Record
result = _recordService.Edit(ConsoleIO.GetDateTime("Enter Date to be Edited: "), ConsoleIO.GetDateRecord());
if (result.Success)
{
ConsoleIO.DisplaySuccess(result.Message);
}
else
{
ConsoleIO.DisplayFailure(result.Message);
}
break;
case 5:
// Delete Record
result = _recordService.Remove(ConsoleIO.GetDateTime("Enter the date to remove: "));
if (result.Success)
{
ConsoleIO.DisplaySuccess(result.Message);
}
else
{
ConsoleIO.DisplayFailure(result.Message);
}
break;
case 6:
// Quit
return;
}
// Prompt Continue so user can see printed output before clear
ConsoleIO.PromptContinue();
}
}
public RecordBl Add(RecordBl item)
{
var dto = _service.Add(item?.ToDto());
return(dto != null ? new RecordBl(dto) : null);
}
/// <summary>
/// Service call to add new record.
/// </summary>
/// <param name="User"></param>
private void InsertRecord(string[] User)
{
_service.Add(User);
}
public Task Add([FromBody] NewRecord record)
{
return(_records.Add(record));
}
public IActionResult StartMemoProcess([FromBody] StartProcessInput <AddRecordInput> input)
{
var id = _recordService.Add(input);
return(Created("", new { id }));
}
private void InitializeViewModel()
{
_viewModel = new PlanningPageViewModel()
{
SimpleEventsViewModel = new EventListViewModel <SimpleEventViewModel>()
{
AddCommand = new Command(
() => OpenDetails(_simpleEventService.PrepareNew(new SimpleEventViewModel()
{
UserId = GlobalVariables.UserId
}) as SimpleEventViewModel, true)),
EditCommand = new DataGridSelectedItemCommand <SimpleEventViewModel>(GridSimpleEvents,
(item) => OpenDetails(item), null, true),
DeleteCommand = new DataGridSelectedItemsCommand <SimpleEventViewModel>(GridSimpleEvents,
(items) => Delete(_simpleEventService, items, _viewModel.SimpleEventsViewModel)),
ApplyNowCommand = new DataGridSelectedItemsCommand <SimpleEventViewModel>(GridSimpleEvents,
(items) =>
{
foreach (var item in items)
{
_recordService.Add(_recordService.Create(item));
}
NotifyDataChanged();
}),
CreateTransactionCommand = new DataGridSelectedItemCommand <SimpleEventViewModel>(GridSimpleEvents,
(item) => OpenDetails(_recordService.Create(item), true)),
RunCommand = ChangeStateCommand(_simpleEventService, EventState.Active, GridSimpleEvents),
PauseCommand = ChangeStateCommand(_simpleEventService, EventState.Paused, GridSimpleEvents),
CloseCommand = ChangeStateCommand(_simpleEventService, EventState.Closed, GridSimpleEvents)
},
MoneyTransferEventsViewModel = new EventListViewModel <MoneyTransferEventViewModel>()
{
AddCommand = new Command(
() => OpenDetails(_moneyTransferEventService.PrepareNew(new MoneyTransferEventViewModel()
{
UserId = GlobalVariables.UserId
}) as MoneyTransferEventViewModel, true)),
EditCommand = new DataGridSelectedItemCommand <MoneyTransferEventViewModel>(GridMoneyTransferEvents,
(item) => OpenDetails(item), null, true),
DeleteCommand = new DataGridSelectedItemsCommand <MoneyTransferEventViewModel>(GridMoneyTransferEvents,
(items) => Delete(_moneyTransferEventService, items, _viewModel.MoneyTransferEventsViewModel)),
ApplyNowCommand = new DataGridSelectedItemsCommand <MoneyTransferEventViewModel>(GridMoneyTransferEvents,
(items) =>
{
foreach (var item in items)
{
_moneyTransferService.Add(_moneyTransferService.Create(item));
}
NotifyDataChanged();
}),
CreateTransactionCommand = new DataGridSelectedItemCommand <MoneyTransferEventViewModel>(GridMoneyTransferEvents,
(item) => OpenDetails(_moneyTransferService.Create(item), true)),
RunCommand = ChangeStateCommand(_moneyTransferEventService, EventState.Active, GridMoneyTransferEvents),
PauseCommand = ChangeStateCommand(_moneyTransferEventService, EventState.Paused, GridMoneyTransferEvents),
CloseCommand = ChangeStateCommand(_moneyTransferEventService, EventState.Closed, GridMoneyTransferEvents)
},
RepayDebtEventsViewModel = new EventListViewModel <RepayDebtEventViewModel>()
{
AddCommand = new Command(
() => OpenDetails(_repayDebtEventService.PrepareNew(new RepayDebtEventViewModel()
{
UserId = GlobalVariables.UserId
}) as RepayDebtEventViewModel, true)),
EditCommand = new DataGridSelectedItemCommand <RepayDebtEventViewModel>(GridRepayDebtEvents,
(item) => OpenDetails(item), null, true),
DeleteCommand = new DataGridSelectedItemsCommand <RepayDebtEventViewModel>(GridRepayDebtEvents,
(items) => Delete(_repayDebtEventService, items, _viewModel.RepayDebtEventsViewModel)),
ApplyNowCommand = new DataGridSelectedItemsCommand <RepayDebtEventViewModel>(GridRepayDebtEvents,
(items) =>
{
foreach (var item in items)
{
_recordService.Add(_recordService.Create(item));
}
NotifyDataChanged();
}),
CreateTransactionCommand = new DataGridSelectedItemCommand <RepayDebtEventViewModel>(GridRepayDebtEvents,
(item) => OpenDetails(_recordService.Create(item), true)),
RunCommand = ChangeStateCommand(_repayDebtEventService, EventState.Active, GridRepayDebtEvents),
PauseCommand = ChangeStateCommand(_repayDebtEventService, EventState.Paused, GridRepayDebtEvents),
CloseCommand = ChangeStateCommand(_repayDebtEventService, EventState.Closed, GridRepayDebtEvents)
},
LimitsViewModel = new LimitListViewModel <LimitModel>()
{
AddCommand = new Command(
() => OpenDetails(_limitService.PrepareNew(new LimitModel {
UserId = GlobalVariables.UserId
}), true)),
EditCommand = new DataGridSelectedItemCommand <LimitModel>(GridLimits,
(item) => OpenDetails(item), null, true),
DeleteCommand = new DataGridSelectedItemsCommand <LimitModel>(GridLimits,
(items) => Delete <LimitModel, LimitModel>(_limitService, items, _viewModel.LimitsViewModel)),
RemoveClosedCommand = new Command(
() =>
{
_limitService.RemoveClosed(GlobalVariables.UserId);
// remove in grid
foreach (var item in _viewModel.LimitsViewModel.Entities.Where(x => x.State == LimitState.Closed).ToList())
{
_viewModel.LimitsViewModel.Entities.Remove(item);
}
NotifyDataChanged();
})
}
};
SimpleEventsBorder.DataContext = _viewModel.SimpleEventsViewModel;
MoneyTransferEventsBorder.DataContext = _viewModel.MoneyTransferEventsViewModel;
RepayDebtEventsBorder.DataContext = _viewModel.RepayDebtEventsViewModel;
ExpanderLimits.DataContext = _viewModel.LimitsViewModel;
}
