private ExpenseDTO GetExpenseChannelInfo(string shortName, string expenseName, decimal expense)
{
CRUDOperation cRUDOperation = new CRUDOperation();
List <tbl_ExpenseChannel> expenseChannels = cRUDOperation.GetExpenseChannelsByName(shortName, expenseName);
ExpenseDTO expenseDTO = null;
foreach (var item in expenseChannels)
{
if (expense <= item.Expense)
{
expenseDTO = new ExpenseDTO {
Expense = item.Expense,
ApproximateExpense = item.ExpenseFactor,
};
break;
}
}
if (expenseDTO == null)
{
expenseDTO = new ExpenseDTO()
{
Expense = expense,
ApproximateExpense = expense * 2,
};
}
return(expenseDTO);
}
public async Task <ExpenseDTO> GetExpenseByIdAsync(int id)
{
SqlDataReader reader;
using (var connection = new SqlConnection(_connectionString))
{
using (var cmd = new SqlCommand())
{
cmd.CommandType = System.Data.CommandType.StoredProcedure;
cmd.CommandText = "[dbo].[SpGetExpense]";
cmd.Parameters.AddWithValue("@expenseId", id);
cmd.Connection = connection;
connection.Open();
reader = await cmd.ExecuteReaderAsync();
}
}
await reader.ReadAsync();
var result = new ExpenseDTO
{
ExpenseId = id,
BuildingId = Convert.ToInt32(reader["BuildingId"]),
CategoryId = Convert.ToInt32(reader["CategoryId"]),
From = Convert.ToDateTime(reader["From"]),
To = Convert.ToDateTime(reader["To"]),
Amount = Convert.ToDecimal(reader["Amount"]),
Name = Convert.ToString(reader["Name"])
};
return(result);
}
public async Task <bool> AddExpense(ExpenseDTO expense)
{
try
{
if (expense.Value > 0)
{
var data = new Expense
{
Value = expense.Value,
Reason = expense.Reason,
DateOfExpense = expense.Date,
DateCreated = DateTime.Now
};
data.VAT = ExtractVATFromValue(expense.Value);
_context.Expenses.Add(data);
await _context.SaveChangesAsync();
return(true);
}
return(false);
}
catch (Exception)
{
return(false);
}
}
public async Task <IActionResult> AddNewExpense([FromBody] ExpenseDTO expenseDTO)
{
if (ModelState.IsValid)
{
var resp = await expenseService.AddExpense(expenseDTO);
if (resp)
{
return(Ok(new ResponseMessage
{
Status = "success"
}));
}
else
{
return(Ok(new ResponseMessage
{
Status = "failed"
}));
}
}
else
{
var errors = ModelState.Values.Select(cx => cx.Errors?.FirstOrDefault()?.ErrorMessage);
return(Ok(new ResponseMessage
{
Status = "failed",
ErrorMessages = errors.ToList()
}));
}
}
public void Add(int userId, ExpenseDTO expense)
{
var elementToAdd = new Expense(expense.ExpenseDate, expense.Cost, expense.ExpenseCause, userId);
db.Expenses.InsertOnSubmit(elementToAdd);
db.SubmitChanges();
}
public bool delete(ExpenseDTO pt)
{
string query = string.Empty;
query += "DELETE FROM expense WHERE [ide] = @ide";;
using (SqlConnection con = new SqlConnection(ConnectionString))
{
using (SqlCommand cmd = new SqlCommand())
{
cmd.Connection = con;
cmd.CommandType = System.Data.CommandType.Text;
cmd.CommandText = query;
cmd.Parameters.AddWithValue("@ide", pt.IDE);
try
{
con.Open();
cmd.ExecuteNonQuery();
con.Close();
con.Dispose();
}
catch (Exception ex)
{
con.Close();
Console.WriteLine(ex);
throw;
}
}
}
return(true);
}
public async Task <IActionResult> PutExpense(int id, ExpenseDTO expense)
{
if (id != expense.Id)
{
return(BadRequest());
}
_context.Entry(expense).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ExpenseExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public ModifyExpensePage(ExpenseDTO selectedItem)
{
InitializeComponent();
expenseId = selectedItem.Expenseid;
int i = 0;
categories = new List <Category>();
cancelButton.Clicked += delegate(object sender, EventArgs args)
{
Application.Current.MainPage.Navigation.PopModalAsync();
};
foreach (var category in Enum.GetNames(typeof(CategoryEnum)))
{
categories.Add(new Category {
CategoryName = category, CategoryInt = i
});
i++;
}
modExpenseCategory.ItemsSource = (System.Collections.IList)categories;
this.modExpenseCategory.SelectedItem = selectedItem.Expensecategory;
this.modMoneyUsed.Text = (selectedItem.Moneyused).ToString();
this.modExpenseName.Text = selectedItem.Expensename;
}
public void ProcessMailForExpenses(string subjectName)
{
List <MailMessage> claims = mailHelper.getStringMessages(subjectName);
foreach (MailMessage claim in claims)
{
//store the request....
RequestDAO request = new RequestDAO();
if (request.shouldProcess(claim.id))
{
Request req = request.createRequestOrGetRequest(claim.from, claim.body, DateTime.Now, claim.id);
//call the rest service.
XmlDocument xdoc = RestHelper.callRestService(restEndPoint, claim.body);
ExpenseDTO expenseDTO = Deserialiser.deserialiseContent <ExpenseDTO>(xdoc);
ExpenseDAO expenseDAO = new ExpenseDAO();
Expense expenseToValidate = expenseDAO.CreateExpense(expenseDTO, req);
ExpenseValidator validator = new ExpenseValidator(expenseToValidate);
mailHelper.sendMessage(claim.from, validator.getMessage(), claim.id, string.Format("response to claim dated {0}", claim.date));
//deserialise the content
//validate the request
//store - valid request or failure and respond to user
}
}
}
public void GetExpenses_Success_Test()
{
// Arrange
R_Expense expense = SampleExpense(1);
IList <R_Expense> list = new List <R_Expense>();
list.Add(expense);
// create mock for repository
var mock = new Mock <IExpenseRepository>();
mock.Setup(s => s.GetExpenses()).Returns(list);
// service
ExpenseService expenseService = new ExpenseService();
ExpenseService.Repository = mock.Object;
// Act
var resultList = expenseService.GetExpenses();
ExpenseDTO result = resultList.FirstOrDefault();
// Assert
Assert.IsNotNull(result);
Assert.AreEqual(1, result.ExpenseId);
}
public async Task <ActionResult <ExpenseDTO> > PostExpenses(ExpenseDTO expenses)
{
_context.ExpenseDTO.Add(expenses);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetExpense), new { id = expenses.Id }, expenses));
}
private ExpenseDTO Create(ExpenseViewModel viewModel)
{
try
{
log.Debug(ExpenseViewModel.FormatExpenseViewModel(viewModel));
ExpenseDTO expense = new ExpenseDTO();
// copy values
viewModel.UpdateDTO(expense, null); //RequestContext.Principal.Identity.GetUserId());
// audit
expense.CreateBy = null; //RequestContext.Principal.Identity.GetUserId();
expense.CreateOn = DateTime.UtcNow;
// add
log.Debug("_expenseService.AddExpense - " + ExpenseDTO.FormatExpenseDTO(expense));
int id = _expenseService.AddExpense(expense);
expense.ExpenseId = id;
log.Debug("result: 'success', id: " + id);
return(expense);
}
catch (Exception e)
{
// error
log.Error(e.ToString());
throw;
}
}
public void GetExpensesPaged_Success_Test()
{
// Arrange
string searchTerm = "";
int pageIndex = 0;
int pageSize = 10;
// list
IList <R_Expense> list = new List <R_Expense>();
for (int i = 1; i <= pageSize; i++)
{
list.Add(SampleExpense(i));
}
// create mock for repository
var mock = new Mock <IExpenseRepository>();
mock.Setup(s => s.GetExpenses(Moq.It.IsAny <string>(), Moq.It.IsAny <int>(), Moq.It.IsAny <int>())).Returns(list);
// service
ExpenseService expenseService = new ExpenseService();
ExpenseService.Repository = mock.Object;
// Act
var resultList = expenseService.GetExpenses(searchTerm, pageIndex, pageSize);
ExpenseDTO result = resultList.FirstOrDefault();
// Assert
Assert.IsNotNull(result);
Assert.AreEqual(1, result.ExpenseId);
Assert.AreEqual(10, resultList.Count);
}
private void ValidateExpense(ExpenseDTO expense)
{
if (expense.To < expense.From)
{
throw new ArgumentOutOfRangeException("Starting date cannot be less than Finish date.");
}
}
public IActionResult Create([FromBody] ExpenseDTO expenseDTO)
{
Expense expense = _mapper.Map <Expense>(expenseDTO);
_expenseService.Create(expense);
return(StatusCode(201));
}
public async Task <int> InsertExpenseAsync(ExpenseDTO expense)
{
int id = 0;
using (var connection = new SqlConnection(_connectionString))
{
using (var cmd = new SqlCommand())
{
cmd.CommandType = System.Data.CommandType.StoredProcedure;
cmd.CommandText = "[dbo].[SpExpenseCreate]";
cmd.Parameters.AddWithValue("@buildingId", expense.BuildingId);
cmd.Parameters.AddWithValue("@categoryId", expense.CategoryId);
cmd.Parameters.AddWithValue("@from", expense.From);
cmd.Parameters.AddWithValue("@to", expense.To);
cmd.Parameters.AddWithValue("@amount", expense.Amount);
cmd.Parameters.AddWithValue("@name", expense.Name);
cmd.Connection = connection;
cmd.Connection.Open();
var result = await cmd.ExecuteScalarAsync();
id = Convert.ToInt32(result);
}
}
return(id);
}
public IActionResult Post([FromBody] ExpenseDTO expense)
{
//var newExpense = new Expense
//{
// Patient = (from p in _db.Users
// where p.FirstName == expense.FirstName && p.LastName == expense.LastName
// select p).FirstOrDefault(),
// ApptDate = expense.ApptDate,
// Cost = expense.Cost,
// Description = expense.Description,
// Physician = expense.Physician,
// Category = (from c in _db.Categories
// where c.CatType == expense.CategoryType
// select c).FirstOrDefault()
//};
//_db.Expenses.Add(newExpense);
//_db.SaveChanges();
if (ModelState.IsValid)
{
_expService.PostExpense(expense);
return(Ok(expense));
}
return(HttpBadRequest(ModelState));
}
public bool edit(ExpenseDTO rm)
{
string query = string.Empty;
query += "UPDATE expense SET [name] = @name, [kind] = @kind, [cost] = @cost, [date] = @date WHERE [ide] = @ide";
using (SqlConnection con = new SqlConnection(ConnectionString))
{
using (SqlCommand cmd = new SqlCommand())
{
cmd.Connection = con;
cmd.CommandType = System.Data.CommandType.Text;
cmd.CommandText = query;
cmd.Parameters.AddWithValue("@ide", rm.IDE);
cmd.Parameters.AddWithValue("@name", rm.NAME);
cmd.Parameters.AddWithValue("@kind", rm.KIND);
cmd.Parameters.AddWithValue("@date", rm.DATE);
cmd.Parameters.AddWithValue("@cost", rm.COST);
try
{
con.Open();
cmd.ExecuteNonQuery();
con.Close();
con.Dispose();
}
catch (Exception ex)
{
con.Close();
Console.WriteLine(ex);
throw;
}
}
}
return(true);
}
public ExpenseDTO GetExpense(int expenseId)
{
try
{
//Requires.NotNegative("expenseId", expenseId);
log.Debug("expenseId: " + expenseId + " ");
// get
R_Expense t = Repository.GetExpense(expenseId);
ExpenseDTO dto = new ExpenseDTO(t);
log.Debug(ExpenseDTO.FormatExpenseDTO(dto));
return(dto);
}
catch (System.Exception e)
{
// error
log.Error(e.ToString());
throw;
}
}
public int AddExpense(ExpenseDTO dto)
{
int id = 0;
try
{
log.Debug(ExpenseDTO.FormatExpenseDTO(dto));
R_Expense t = ExpenseDTO.ConvertDTOtoEntity(dto);
// add
id = Repository.AddExpense(t);
dto.ExpenseId = id;
log.Debug("result: 'success', id: " + id);
}
catch (System.Exception e)
{
// error
log.Error(e.ToString());
throw;
}
return(id);
}
public ExpenseVM(ExpenseDTO row)
{
this.Id = row.Id;
this.UserId = row.UserId;
this.Expense_Title = row.Expense_Title;
this.Expense_Quantitative = row.Expense_Quantitative;
}
public async Task <IEnumerable <ExpenseDTO> > GetExpensesAsync(int buildingId)
{
var result = new List <ExpenseDTO>();
using (var connection = new SqlConnection(_connectionString))
{
using (var cmd = new SqlCommand())
{
cmd.CommandType = System.Data.CommandType.StoredProcedure;
cmd.CommandText = "[dbo].[SpGetExpenses]";
cmd.Parameters.AddWithValue("@buildingId", buildingId);
cmd.Connection = connection;
cmd.Connection.Open();
using (var dataReader = await cmd.ExecuteReaderAsync())
{
while (await dataReader.ReadAsync())
{
var expenseDTO = new ExpenseDTO();
expenseDTO.Amount = Convert.ToDecimal(dataReader["Amount"]);
expenseDTO.ExpenseId = Convert.ToInt32(dataReader["ExpenseID"]);
expenseDTO.CategoryId = Convert.ToInt32(dataReader["CategoryID"]);
expenseDTO.From = Convert.ToDateTime(dataReader["From"]);
expenseDTO.To = Convert.ToDateTime(dataReader["To"]);
expenseDTO.Name = Convert.ToString(dataReader["Name"]);
expenseDTO.BuildingId = buildingId;
result.Add(expenseDTO);
}
}
}
}
return(result);
}
public List <ExpenseDTO> GetListOthersExpenseDTO(int ci, string d)
{
var cruiseId = ci;
DateTime?date = null;
try
{
date = DateTime.ParseExact(d, "dd/MM/yyyy", CultureInfo.InvariantCulture);
}
catch { }
var listExpense = BookingReportBLL.ExpenseGetAllByCriterion(cruiseId, date).Future().ToList();
var listOthersExpense = listExpense.Where(x => x.Type == "Others").ToList();
var listOthersExpenseDTO = new List <ExpenseDTO>();
listOthersExpense.ForEach(x =>
{
var guideExpenseDTO = new ExpenseDTO()
{
Id = x.Id,
Name = x.Name,
Phone = x.Phone,
Cost = x.Cost.ToString("#,##0.##"),
CruiseId = cruiseId,
Date = date.HasValue ? date.Value.ToString("dd/MM/yyyy") : "",
Operator_FullName = x.Operator != null ? x.Operator.FullName : "",
Operator_Phone = x.Operator != null ? x.Operator.Phone : "",
Operator_UserId = x.Operator != null ? x.Operator.Id : -1,
LockStatus = x.LockStatus,
};
listOthersExpenseDTO.Add(guideExpenseDTO);
});
return(listOthersExpenseDTO);
}
public void AddExpenseInvalidPaymentModeId(int paymentModeId)
{
var expenseDto = new ExpenseDTO {
PaymentModeId = paymentModeId
};
Assert.ThrowsAsync <ArgumentOutOfRangeException>(() => expenseWorker.AddExpense(expenseDto));
}
public void AddExpenseInvalidExpenseSubTypeId(int expenseSubTypeId)
{
var expenseDto = new ExpenseDTO {
ExpenseSubTypeId = expenseSubTypeId
};
Assert.ThrowsAsync <ArgumentOutOfRangeException>(() => expenseWorker.AddExpense(expenseDto));
}
public async Task AddExpenseAsync(ExpenseDTO expense)
{
ValidateExpense(expense);
var gateway = _gatewayFactory.CreateExpenseTableGateway();
var id = await gateway.InsertExpenseAsync(expense);
expense.ExpenseId = id;
}
public void AddExpenseInvalidUserAccountId(int userAccountId)
{
var expenseDto = new ExpenseDTO {
UserAccountId = userAccountId
};
Assert.ThrowsAsync <ArgumentOutOfRangeException>(() => expenseWorker.AddExpense(expenseDto));
}
public bool AddExpense(string expenseName, string expenseCost)
{
ExpenseDTO expenseToAdd = new ExpenseDTO();
expenseToAdd.Name = expenseName;
expenseToAdd.Cost = decimal.Parse(expenseCost);
return(cmLogicService.insertExpense(expenseToAdd));
}
public ExpenseDTO updateExpense(ExpenseDTO Expense)
{
var selectedExpense = uow.GetRepository <Expense>().Get(z => z.Id == Expense.Id);
selectedExpense = MapperFactory.CurrentMapper.Map(Expense, selectedExpense);
uow.GetRepository <Expense>().Update(selectedExpense);
uow.SaveChanges();
return(MapperFactory.CurrentMapper.Map <ExpenseDTO>(selectedExpense));
}
public void ShowExpenseEditView(ExpenseDTO expenseDTO, List <ExpenseTypeDTO> expenseTypeList)
{
expenseTypeComboBox.DataSource = expenseTypeList;
expenseTypeComboBox.DisplayMember = "ExpenseTypeName";
datePicker.Value = expenseDTO.Date;
costNumericPicker.Value = (decimal)expenseDTO.Cost;
ShowDialog();
}
