public async Task <ExpenseResponse> GetExpense(ExpenseRequest request)
{
var json = JsonConvert.SerializeObject(request);
var resp = await PostForString(new Uri(ApiUrl + "expenses/act"), json);
if (resp.IsSuccessfull)
{
try
{
return(JsonConvert.DeserializeObject <ExpenseResponse>(resp.Response));
}
catch (Exception ex)
{
LogHelper.Instance.LogException(ex, this);
return(new ExpenseResponse()
{
ErrorMessage = "Unserialisation failed for Description " + resp.Response
});
}
}
return(new ExpenseResponse()
{
ErrorMessage = resp.ErrorMessage
});
}
public async Task <Response <Expense> > UpdateItem(int id, ExpenseRequest expenseRequest)
{
try
{
if (id != expenseRequest.Id)
{
return(new Response <Expense>(false, "Failure: Id sent in body does not match object Id", null));
}
Expense expense = await _db.Expenses.FirstOrDefaultAsync(x => x.Id == id);;
if (expense == null)
{
return(new Response <Expense>(false, $"Failure: Unable to update expense. Because Id is invalid. ", null));
}
expense.UserId = expense.UserId;
expense.Name = expenseRequest.Name;
expense.BillType = expense.BillType;
expense.PaymentType = expenseRequest.PaymentType;
expense.EmployeeOrVender = expenseRequest.EmployeeOrVender;
expense.VoucherNo = expenseRequest.VoucherNo;
expense.Category = expenseRequest.Category;
expense.TotalBill = expenseRequest.TotalBill;
expense.TransactionDetail = expenseRequest.TransactionDetail;
await _db.SaveChangesAsync();
return(new Response <Expense>(true, "Success: Updated data.", expense));
}
catch (Exception exception)
{
return(new Response <Expense>(false, $"Server Failure: Unable to update data. Because {exception.Message}", null));
}
}
public async Task <Response <Expense> > InsertItem(ExpenseRequest expenseRequest)
{
try
{
User user = await _db.Users.FindAsync(expenseRequest.UserId);
if (user == null)
{
return(new Response <Expense>(false, "Failure: User belonging to this id does not exist.", null));
}
Expense expense = new Expense();
expense.UserId = expense.UserId;
expense.Name = expenseRequest.Name;
expense.BillType = expenseRequest.BillType;
expense.PaymentType = expenseRequest.PaymentType;
expense.EmployeeOrVender = expenseRequest.EmployeeOrVender;
expense.VoucherNo = expenseRequest.VoucherNo;
expense.Category = expenseRequest.Category;
expense.TotalBill = expenseRequest.TotalBill;
expense.TransactionDetail = expenseRequest.TransactionDetail;
expense.User = user;
await _db.Expenses.AddAsync(expense);
await _db.SaveChangesAsync();
return(new Response <Expense>(true, "Success: Inserted data.", expense));
}
catch (Exception exception)
{
return(new Response <Expense>(false, $"Server Failure: Unable to insert data. Because {exception.Message}", null));
}
}
public async Task <IActionResult> ModifyExpense([FromBody] ExpenseRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
ExpenseEntity expenseEntity = await _tripHelper.GetExpenseAsync(request.Id);
if (expenseEntity == null)
{
return(BadRequest("Expense doesn't exist"));
}
string picturePath = expenseEntity.PicturePath;
if (request.PictureArray != null && request.PictureArray.Length > 0)
{
picturePath = _imageHelper.UploadImage(request.PictureArray, "Expenses");
}
expenseEntity.Details = request.Details;
expenseEntity.Date = request.Date;
expenseEntity.Value = request.Value;
expenseEntity.PicturePath = picturePath;
_dataContext.Expenses.Update(expenseEntity);
await _dataContext.SaveChangesAsync();
ExpenseEntity expenseUpdated = await _tripHelper.GetExpenseAsync(request.Id);
return(Ok(_converterHelper.ToExpenseResponse(expenseUpdated)));
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
ExpenseRequest request = JsonConvert.DeserializeObject <ExpenseRequest>(File.ReadAllText(@"input/request.json"));
Console.WriteLine(request.expenses.Count);
}
public async Task ChangeExpenseAsync(int buildingId, int expenseId, ExpenseRequest newExpense)
{
var expense = newExpense.ToDTO();
expense.ExpenseId = expenseId;
expense.BuildingId = buildingId;
await _expenseManager.UpdateExpenseAsync(expense);
}
public async Task <int> CreateExpenseAsync(int buildingId, ExpenseRequest newExpense)
{
var expense = newExpense.ToDTO();
expense.BuildingId = buildingId;
await _expenseManager.AddExpenseAsync(expense);
return(expense.ExpenseId);
}
public async Task EditExpense(ExpenseRequest expenseRequest, long id)
{
var expenseToEdit = await _dbContext.Set <Expense>()
.Where(x => x.Id == id)
.FirstOrDefaultAsync();
_mapper.Map(expenseRequest, expenseToEdit);
await _dbContext.SaveChangesAsync();
}
public static ExpenseDTO ToDTO(this ExpenseRequest expense)
{
ExpenseDTO dto = new ExpenseDTO();
dto.CategoryId = expense.CategoryId;
dto.Amount = expense.Amount;
dto.From = expense.From;
dto.To = expense.To;
dto.Name = expense.Name;
return(dto);
}
public async Task CreateExpense(ExpenseRequest expenseRequest)
{
var expense = _mapper.Map <Expense>(expenseRequest);
var countOfExpenses = (await GetExpenses(expense.ExpenseDate.Month, expense.ExpenseDate.Year)).Count;
expense.ExpenseNo = $"{countOfExpenses + 1}/{expense.ExpenseDate.Month}/{expense.ExpenseDate.Year}";
await _dbContext.Set <Expense>().AddAsync(expense);
await _dbContext.SaveChangesAsync();
}
public ExpenseResponse SaveExpense(ExpenseRequest objExpenseRequest, bool isVerified)
{
ExpenseResponse objExpenseResponse = null;
try
{
objExpenseResponse = objExpenseBal.WriteExpense(objExpenseRequest, isVerified);
}
catch (Exception ex)
{
}
return(objExpenseResponse);
}
public async Task <ExpenseEntity> ToExpenseEntity(ExpenseRequest expenseRequest)
{
TripEntity tripEntity = await _tripHelper.GetTripAsync(expenseRequest.TripId);
return(new ExpenseEntity
{
Details = expenseRequest.Details,
Date = expenseRequest.Date,
Trip = tripEntity,
User = await _userHelper.GetUserAsync(tripEntity.User.Email),
Value = expenseRequest.Value,
ExpenseType = await _expenseHelper.GetExpenseTypeAsync(expenseRequest.ExpenseTypeId)
});
}
public ExpenseResponse WriteExpense(ExpenseRequest objExpenseRequest, bool isVerified)
{
ExpenseResponse objExpenseResponse = null;
try
{
objExpenseResponse = objExpenseDal.WriteExpense(objExpenseRequest, isVerified);
}
catch (Exception)
{
throw;
}
return(objExpenseResponse);
}
public async Task <IActionResult> AddExpense([FromBody] ExpenseRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_dataContext.Add(await _converterHelper.ToExpenseEntity(request));
await _dataContext.SaveChangesAsync();
TripEntity tripEntity = await _tripHelper.GetTripAsync(request.TripId);
return(Ok(_converterHelper.ToTripResponse(tripEntity)));
}
private (string Url, ExpenseRequest Body) CreateRequest(string rawText)
{
var ExpenseRequest = new ExpenseRequest
{
RawText = rawText
};
var request = new
{
Url = "/api/v1/payment/expense/import",
Body = ExpenseRequest
};
return(request.Url, request.Body);
}
public async Task <IActionResult> CreateExpense([FromBody] ExpenseRequest request)
{
var userId = User.Claims.FirstOrDefault(c => c.Type == "id").Value;
// check if user exists
var userExists = await _identityService.CheckIfUserExists(userId);
if (!userExists)
{
return(NotFound(new ErrorResponse(new ErrorModel {
Message = $"There is no user with id: {userId}"
})));
}
var budget = await _budgetService.GetBudgetAsync(request.BudgetId);
if (budget == null)
{
return(NotFound(new ErrorResponse(new ErrorModel {
Message = $"There is no budget with id: {request.BudgetId}"
})));
}
if (budget.UserId != userId)
{
return(Forbid());
}
var period = await _periodService.GetPeriodAsync(request.PeriodId);
if (period == null)
{
return(NotFound(new ErrorResponse(new ErrorModel {
Message = $"There is no Period with id: {request.PeriodId} in Budget with id: {request.BudgetId}"
})));
}
var expense = await _expenseService.NewExpenseAsync(request, userId);
if (expense == null)
{
return(BadRequest());
}
var locationUri = _uriService.GetExpenseUri(expense.Id);
return(Created(locationUri, new Response <ExpenseResponse>(_mapper.Map <ExpenseResponse>(expense))));
}
public async Task <Response> AddExpense(string urlBase,
string servicePrefix,
string controller,
string tokenType,
string accessToken,
ExpenseRequest expenseRequest)
{
try
{
string requestString = JsonConvert.SerializeObject(expenseRequest);
StringContent content = new StringContent(requestString, Encoding.UTF8, "application/json");
HttpClient client = new HttpClient
{
BaseAddress = new Uri(urlBase)
};
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(tokenType, accessToken);
string url = $"{servicePrefix}{controller}";
HttpResponseMessage response = await client.PostAsync(url, content);
string result = await response.Content.ReadAsStringAsync();
if (!response.IsSuccessStatusCode)
{
return(new Response
{
IsSuccess = false,
Message = result,
});
}
TripResponse tripResponse = JsonConvert.DeserializeObject <TripResponse>(result);
return(new Response
{
IsSuccess = true,
Result = tripResponse
});
}
catch (Exception ex)
{
return(new Response
{
IsSuccess = false,
Message = ex.Message
});
}
}
public AddExpensePageViewModel(INavigationService navigationService,
IApiService apiService,
IFilesHelper filesHelper) : base(navigationService)
{
_navigationService = navigationService;
_apiService = apiService;
_filesHelper = filesHelper;
Title = Languages.AddExpense;
Image = App.Current.Resources["UrlNoImage"].ToString();
IsRunning = false;
IsEnabled = true;
_user = JsonConvert.DeserializeObject <UserResponse>(Settings.User);
_trip = JsonConvert.DeserializeObject <TripResponse>(Settings.TripSelected);
ExpenseTypes = new ObservableCollection <ExpenseType>(CombosHelper.GetExpenseTypes());
Expense = new ExpenseRequest
{
Date = DateTime.UtcNow.ToLocalTime()
};
}
public async Task <Expense> NewExpenseAsync(ExpenseRequest request, string userId)
{
var expenseDto = new ExpenseDto
{
UserId = userId,
CreatedAt = DateTime.UtcNow,
ExpenseDate = request.ExpenseDate,
Name = request.Name,
Description = request.Description,
ExpenseValue = request.ExpenseValue,
CurrencyId = request.CurrencyId,
PeriodId = request.PeriodId
};
var expense = _mapper.Map <Expense>(expenseDto);
var created = await _baseRepository.CreateEntityAsync(expense);
return(created);
}
internal async Task <ExpensesResponse> EditExpense(ExpenseRequest userBudget)
{
var userId = userBudget.UserId;
var expenseId = Convert.ToInt32(userBudget.ExpenseId);
var expense =
_context.Expenses.Include(c => c.BudgetCategory).ThenInclude(c => c.UserBudget)
.FirstOrDefault(c => c.UId == expenseId && c.BudgetCategory.UserBudget.UserId == userId);
if (expense != null)
{
expense.Description = userBudget.Description;
expense.TransactionDate = userBudget.TransactionDate;
expense.Value = userBudget.ExpendedValue;
_context.Expenses.Update(expense);
await _context.SaveChangesAsync();
return(MapExpense(expense));
}
return(new ExpensesResponse {
ValidationMessage = Messages.CantEditExpense
});
}
internal async Task <ExpensesResponse> AddNewExpense(ExpenseRequest userBudget)
{
var userId = userBudget.UserId;
var budgetCategoryId = Convert.ToInt32(userBudget.CategoryId);
var budgetCategory = await
_context.BudgetDetail.Include(c => c.UserBudget).FirstOrDefaultAsync(c => c.UId == budgetCategoryId && c.UserBudget.UserId == userId);
if (budgetCategory != null)
{
var newExpense =
ExpensesTrackerFactory.CreateNewExpense(budgetCategory, userBudget.Description, userBudget.ExpendedValue, userBudget.TransactionDate);
_context.Expenses.Add(newExpense);
await _context.SaveChangesAsync();
return(MapExpense(newExpense));
}
else
{
return(new ExpensesResponse {
ValidationMessage = Messages.CannotAddExpenses
});
}
}
public async Task <IActionResult> AddExpense([FromRoute] int buildingId, [FromBody] ExpenseRequest expense)
{
var id = await _baseInfoApplicationService.CreateExpenseAsync(buildingId, expense);
return(Ok(id));
}
public async Task <ActionResult <ResponseBase> > Delete([FromRoute] ExpenseRequest userBudget)
{
var result = await _userBudgetAppService.DeleteExpense(userBudget.ExpenseId, userBudget.UserId);
return(Ok(result));
}
public ExpenseResponse WriteExpense(ExpenseRequest objExpenseRequest, bool isVerified)
{
ExpenseResponse objExpenseResponse = new ExpenseResponse();
try
{
SqlParameter[] sqlparams =
{
new SqlParameter("@ExpenseId", SqlDbType.Int)
{
Value = objExpenseRequest.ExpenseId
},
new SqlParameter("@ExpenseTypeId", SqlDbType.Int)
{
Value = objExpenseRequest.ExpenseTypeId
},
new SqlParameter("@Amount", SqlDbType.Decimal)
{
Value = objExpenseRequest.Amount
},
new SqlParameter("@ExpenseTo", SqlDbType.VarChar)
{
Value = objExpenseRequest.ExpenseTo
},
new SqlParameter("@ContactNumber", SqlDbType.VarChar)
{
Value = objExpenseRequest.ContactNumber
},
new SqlParameter("@DateOfExpense", SqlDbType.Date)
{
Value = objExpenseRequest.DateOfExpense
},
new SqlParameter("@Remarks", SqlDbType.VarChar)
{
Value = objExpenseRequest.Remarks
},
new SqlParameter("@EditRemarks", SqlDbType.VarChar)
{
Value = string.IsNullOrEmpty(objExpenseRequest.EditRemarks) ? (object)DBNull.Value : objExpenseRequest.EditRemarks
},
new SqlParameter("@CreatedBy", SqlDbType.Int)
{
Value = Convert.ToInt32(CommonMethods.URLKeyDecrypt(objExpenseRequest.CreatedBy))
},
new SqlParameter("@CounterId", SqlDbType.Int)
{
Value = Convert.ToInt32(CommonMethods.URLKeyDecrypt(objExpenseRequest.CounterId))
},
new SqlParameter("@IsVerified", SqlDbType.Bit)
{
Value = isVerified
},
};
SqlDataReader reader = SqlHelper.ExecuteReader(con, CommandType.StoredProcedure, "USP_WriteExpense", sqlparams);
while (reader.Read())
{
if (objExpenseResponse.objSaveResponse == null)
{
objExpenseResponse.objSaveResponse = new SaveRespone();
objExpenseResponse.objSaveResponse.StatusId = (int)reader["StatusId"];
if (objExpenseResponse.objSaveResponse.StatusId == 1)
{
objExpenseResponse.objSaveResponse.StatusMessage = "Expense added successfully.";
}
else if (objExpenseResponse.objSaveResponse.StatusId == 2)
{
objExpenseResponse.objSaveResponse.StatusMessage = "We found records similar to this entry.";
}
else if (objExpenseResponse.objSaveResponse.StatusId == 3)
{
objExpenseResponse.objSaveResponse.StatusMessage = "Date: " + objExpenseRequest.DateOfExpense + " expenses summary is closed, You can't enter expenses for the selected date.";
}
}
else if (objExpenseResponse.objSaveResponse.StatusId == 2)
{
objExpenseResponse.objExpenseRequest = new ExpenseRequest();
objExpenseResponse.objExpenseRequest.ExpenseId = Convert.ToInt32(reader["ExpenseId"]);
objExpenseResponse.objExpenseRequest.ExpenseTypeId = Convert.ToInt32(reader["ExpenseTypeId"]);
objExpenseResponse.objExpenseRequest.ExpenseType = Convert.ToString(reader["ExpenseType"]);
objExpenseResponse.objExpenseRequest.Amount = Convert.ToDecimal(reader["Amount"]);
objExpenseResponse.objExpenseRequest.Remarks = Convert.ToString(reader["Remarks"]);
}
reader.NextResult();
}
}
catch (Exception ex)
{
objExpenseResponse.objSaveResponse.StatusMessage = "oops something went wrong, please try again ";
//throw;
}
return(objExpenseResponse);
}
public async Task <ActionResult <ExpensesResponse> > Put(ExpenseRequest userBudget)
{
var result = await _userBudgetAppService.EditExpense(userBudget);
return(Ok(result));
}
public Task CreateExpense([FromBody] ExpenseRequest expense)
{
return(_expensesProvider.CreateExpense(expense));
}
public Task EditExpense([FromBody] ExpenseRequest expense, long id)
{
return(_expensesProvider.EditExpense(expense, id));
}
public async Task <IActionResult> ChangeExpense([FromRoute] int buildingId, [FromRoute] int expenseId, [FromBody] ExpenseRequest expense)
{
await _baseInfoApplicationService.ChangeExpenseAsync(buildingId, expenseId, expense);
return(Ok());
}
public Task <BooleanResponse> PostExpense(ExpenseRequest request)
{
var json = JsonConvert.SerializeObject(request);
return(PostForBoolean(new Uri(ApiUrl + "expenses/act"), json));
}
public async Task <ExpenseResponse> CreateExpense(ExpenseRequest request)
{
var response = new ExpenseResponse();
response.Request = request;
// Get all XML tags. If no XML tags, return error
logger.LogInformation <PaymentController>("Extracting XML tags");
var tags = await parser.GetXmlTagsAsync(request.RawText);
if (tags == null || !tags.Any())
{
response.ExecutionResult = new ExecutionResult
{
Status = Constants.FAILED,
Errors = new List <string> {
Constants.NO_XML_TAGS
}
};
return(response);
}
// Find "expense" tag. If no expense, return error
logger.LogInformation <PaymentController>("Finding Expense tag");
var expense = tags.FirstOrDefault(t => t.Length > 9 && t.Substring(0, 9) == Constants.EXPENSE_TAG);
if (string.IsNullOrWhiteSpace(expense))
{
response.ExecutionResult = new ExecutionResult
{
Status = Constants.FAILED,
Errors = new List <string> {
Constants.MISSING_EXPENSE
}
};
return(response);
}
// Validate XML for its format
logger.LogInformation <PaymentController>("Validating all XML tags");
var xmlValidator = await validator.ValidateXmlTags(tags);
if (!xmlValidator.IsValid)
{
response.ExecutionResult = new ExecutionResult
{
Status = Constants.FAILED,
Errors = new List <string>(xmlValidator.ErrorMessages)
};
return(response);
}
// Parse "expense"
logger.LogInformation <PaymentController>("Parsing Expense");
response = await parser.GetExpense(response, expense);
if (decimal.TryParse(configuration[Configuration.GST], out decimal gst))
{
response.TotalExcludingGST = Math.Round(response.Total - (response.Total * gst) / 100, Configuration.RoundingDecimals);
}
return(response);
}
