public XHRResponse <_Receipt> Create(string userId, _ReceiptCreate data)
{
XHRResponse <_Receipt> result = new XHRResponse <_Receipt>();
try
{
Receipt receipt = Mapper.Map <Receipt>(data);
receipt.AccountId = userId;
receipt.CreatedDate = DateTime.Now;
receipt.ModifiedDate = DateTime.Now;
_receiptRepository.Insert(receipt);
_receiptRepository.Save();
_receiptRepository.Load(receipt, nameof(Category));
_receiptRepository.Load(receipt, nameof(Payment));
result.Data = Mapper.Map <_Receipt>(receipt);
result.Succeeded = true;
}
catch (Exception ex)
{
result.Message = "Unable to create receipt.";
result.Succeeded = false;
}
return(result);
}
public XHRResponse <_Receipt> Update(string userId, _ReceiptUpdate data)
{
XHRResponse <_Receipt> result = new XHRResponse <_Receipt>();
try
{
Receipt receipt = _receiptRepository.GetById(data.ReceiptId);
ThrowExceptionIfIsInvalidReceipt(receipt, userId);
receipt.TransactionDate = data.TransactionDate;
receipt.Amount = data.Amount;
receipt.CategoryId = data.CategoryId;
receipt.Title = data.Title;
receipt.PaymentId = data.PaymentId;
receipt.Description = data.Description;
_receiptRepository.Update(receipt);
_receiptRepository.Save();
_receiptRepository.Load(receipt, nameof(Category));
_receiptRepository.Load(receipt, nameof(Payment));
result.Data = Mapper.Map <_Receipt>(receipt);
result.Succeeded = true;
}
catch (Exception ex)
{
result.Message = "Unable to update receipt.";
result.Succeeded = false;
}
return(result);
}
public XHRResponse <List <_Category> > ReadAllByType(int typeId)
{
XHRResponse <List <_Category> > result = new XHRResponse <List <_Category> >();
try
{
List <Category> categories = _categoryRepository.GetAll(x => x.TypeId == typeId);
result.Data = Mapper.Map <List <_Category> >(categories);
result.Succeeded = true;
}
catch (Exception ex)
{
result.Message = "Unable to get categories.";
result.Succeeded = false;
}
return(result);
}
public XHRResponse <List <_Receipt> > ReadAllByDate(string userId, DateTime date)
{
XHRResponse <List <_Receipt> > result = new XHRResponse <List <_Receipt> >();
try
{
List <Receipt> receipts = _receiptRepository.GetAll(x => x.AccountId == userId && date.Date == x.TransactionDate.Date);
result.Data = Mapper.Map <List <_Receipt> >(receipts);
result.Succeeded = true;
}
catch (Exception ex)
{
result.Message = "Unable to get receipts.";
result.Succeeded = false;
}
return(result);
}
public XHRResponse <_Account> Read(string userId)
{
XHRResponse <_Account> result = new XHRResponse <_Account>();
try
{
Account account = _accountRepository.GetById(userId);
result.Data = Mapper.Map <_Account>(account);
result.Succeeded = true;
}
catch (Exception ex)
{
result.Message = "Unable to get user.";
result.Succeeded = false;
}
return(result);
}
public XHRResponse <List <_Payment> > ReadAll()
{
XHRResponse <List <_Payment> > result = new XHRResponse <List <_Payment> >();
try
{
List <Payment> payments = _paymentRepository.GetAll();
result.Data = Mapper.Map <List <_Payment> >(payments);
result.Succeeded = true;
}
catch (Exception ex)
{
result.Message = "Unable to get payments.";
result.Succeeded = false;
}
return(result);
}
public XHRResponse <_Receipt> Read(string userId, int receiptId)
{
XHRResponse <_Receipt> result = new XHRResponse <_Receipt>();
try
{
Receipt receipt = _receiptRepository.GetById(receiptId, userId);
ThrowExceptionIfReceiptDoesntExists(receipt);
result.Data = Mapper.Map <_Receipt>(receipt);
result.Succeeded = true;
}
catch (Exception ex)
{
result.Message = "Unable to get receipt.";
result.Succeeded = false;
}
return(result);
}
public XHRResponse <_Analysis> ReadByTypeForAnalysis(string userId, int year, int month, int typeId)
{
XHRResponse <_Analysis> result = new XHRResponse <_Analysis>();
try
{
List <Receipt> receipts = _receiptRepository
.GetAll(x => x.AccountId == userId &&
x.TransactionDate.Year == year &&
x.TransactionDate.Month == month &&
x.Category.TypeId == typeId);
var groups = from Receipt receipt in receipts
group receipt by receipt.Category
into items
select new
{
Category = items.Key,
Receipts = items
};
foreach (var group in groups)
{
result.Data.Summary.Add(new _CategorySummary
{
Category = Mapper.Map <_Category>(group.Category),
Amount = group.Receipts.Sum(x => x.Amount)
});
}
result.Data.Summary = result.Data.Summary.OrderByDescending(x => x.Amount).ToList();
result.Succeeded = true;
}
catch (Exception ex)
{
result.Message = "Unable to get analysis.";
result.Succeeded = false;
}
return(result);
}
public XHRResponse <_Token> Login(_Credentials data)
{
XHRResponse <_Token> result = new XHRResponse <_Token>();
try
{
using (HttpClient client = new HttpClient())
{
client.BaseAddress = new Uri($"https://{_configuration["Auth0:Domain"]}/");
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
using (HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, "oauth/token"))
{
var body = new
{
client_id = _configuration["Auth0:ClientId"],
client_secret = _configuration["Auth0:ClientSecret"],
grant_type = "password",
scope = "openid profile email",
username = data.Username,
password = data.Password
};
request.Content = new StringContent(JsonConvert.SerializeObject(body), Encoding.UTF8, "application/json");
HttpResponseMessage response = client.SendAsync(request).Result;
ThrowExceptionIfHasInvalidCredentials(response.IsSuccessStatusCode);
result.Data = response.Content.ReadAsAsync <_Token>().Result;
result.Succeeded = true;
}
}
}
catch (Exception ex)
{
result.Message = "Unable to authenticate user.";
result.Succeeded = false;
}
return(result);
}
public XHRResponse <List <_Receipt> > ReadAllBySearch(string userId, string title)
{
XHRResponse <List <_Receipt> > result = new XHRResponse <List <_Receipt> >();
try
{
List <Receipt> receipts = _receiptRepository
.GetAll(x => x.AccountId == userId && x.Title.Contains(title))
.OrderByDescending(x => x.TransactionDate)
.ToList();
result.Data = Mapper.Map <List <_Receipt> >(receipts);
result.Succeeded = true;
}
catch (Exception ex)
{
result.Message = "Unable to get receipts.";
result.Succeeded = false;
}
return(result);
}
public XHRResponse <_Balance> ReadBalance(string userId, int year, int month)
{
XHRResponse <_Balance> result = new XHRResponse <_Balance>();
try
{
List <Receipt> receipts = _accountRepository.GetReceipts(x => x.AccountId == userId &&
x.TransactionDate.Month == month &&
x.TransactionDate.Year == year);
var groups = from Receipt receipt in receipts
group receipt by receipt.TransactionDate.Date
into items
select new
{
Date = items.Key,
Receipts = items
};
foreach (var group in groups)
{
result.Data.Summary.Add(new _DateSummary
{
Date = group.Date,
Deposit = group.Receipts.Where(x => x.Category.TypeId == (int)PlutusCategoryType.Income).Sum(x => x.Amount),
Withdrawal = group.Receipts.Where(x => x.Category.TypeId == (int)PlutusCategoryType.Expense).Sum(x => x.Amount)
});
}
result.Succeeded = true;
}
catch (Exception ex)
{
result.Message = "Unable to get balance.";
result.Succeeded = false;
}
return(result);
}
public XHRResponse <bool> Delete(string userId, int receiptId)
{
XHRResponse <bool> result = new XHRResponse <bool>();
try
{
Receipt receipt = _receiptRepository.GetById(receiptId, userId);
ThrowExceptionIfReceiptDoesntExists(receipt);
_receiptRepository.Delete(receipt);
_receiptRepository.Save();
result.Data = true;
result.Succeeded = true;
}
catch (Exception ex)
{
result.Message = "Unable to delete receipt.";
result.Succeeded = false;
}
return(result);
}
