public async Task <ActionResult <LoanItem> > PostTodoItem(LoanItem item)
{
_context.LoanItems.Add(item);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetLoanItem), new { id = item.Id }, item));
}
public async Task <ActionResult <LoanItem> > PostLoanItem(LoanItem loanItem)
{
_context.LoanItems.Add(loanItem);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetLoanItem", new { id = loanItem.id }, loanItem));
}
public async Task <IActionResult> PutLoanItem(int id, LoanItem loanItem)
{
if (id != loanItem.Id)
{
return(BadRequest());
}
_context.Entry(loanItem).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!LoanItemExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
//bata is wondering what the person of having a static method
private static LoanItemDTO LoanToDTO(LoanItem LoanItem) =>
new LoanItemDTO
{
Balance = LoanItem.Balance,
MonthLeft = LoanItem.MonthLeft,
Rate = LoanItem.Rate
};
private void loanPaymentPlanner(LoanItem loanItem)
{
int monthsLeft = loanItem.MonthLeft;
decimal interestRate = loanItem.Rate;
decimal originalBalance = loanItem.Balance;
decimal remainingBalance = originalBalance;
decimal totalMonthlyPayment = getTotalMonthlyPayment(originalBalance, interestRate, monthsLeft); // equal amount is paid every month
List <PaymentPlanItem> ppiList = new List <PaymentPlanItem>();
//loops through all months given to repay loanItem and creates a full repayment plan.
for (int month = 0; month < monthsLeft; month++)
{
decimal interestPayment = getInterestPayment(remainingBalance, interestRate);
decimal principalPayment = getPrincipalPayment(totalMonthlyPayment, interestPayment);
//above this line is previous remainingBalance
remainingBalance = getRemainingBalance(remainingBalance, principalPayment);
PaymentPlanItem ppi = new PaymentPlanItem(loanItem.Id, month + 1, interestPayment, principalPayment, remainingBalance);
ppiList.Add(ppi);
}
_context.PaymentPlanItems.AddRange(ppiList);
_context.SaveChanges();
}
public static async Task ReturnItem(LoanItem item)
{
item.ReturnedAt = DateTime.Now;
item.IsReturned = true;
//To avoid conflicts
item.Item = null;
await LoanTable.UpdateAsync(item);
}
public static LoanItem CreateLoanItem(string loanItemId, int gracePeriodDays, int loanDays)
{
LoanItem loanItem = new LoanItem();
loanItem.LoanItemId = loanItemId;
loanItem.GracePeriodDays = gracePeriodDays;
loanItem.LoanDays = loanDays;
return(loanItem);
}
public ActionResult Create(LoanItem loanItem)
{
if (!ModelState.IsValid)
{
return(View("Create", loanItem));
}
_itemRepository.Add(loanItem);
return(RedirectToAction("Index"));
}
public IActionResult PutLoanItem(String id, LoanItem loanItem)
{
var loan = _loanService.Get(id);
if (loan == null)
{
return(NotFound());
}
_loanService.Update(id, loan);
return(NoContent());
}
public async Task <IActionResult> PutLoanItem(int id, LoanItem loanItem)
{
if (id != loanItem.id)
{
return(BadRequest());
}
_context.Entry(loanItem).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(NoContent());
}
public void Add_GivenLoanItem_ShouldAddItCatalogue()
{
//---------------Set up test pack-------------------
using (var dbContext = GetContext())
{
var itemRepository = CreateItemRepository(dbContext);
var loanItem = new LoanItem {
Name = "Strat"
};
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
itemRepository.Add(loanItem);
//---------------Test Result -----------------------
var addedItem = dbContext.LoanItems.Single(i => i.Name == "Strat");
Assert.AreEqual(loanItem, addedItem);
}
}
public void GetItems_GivenOneItemInCatalogue_ShouldReturnThatItem()
{
//---------------Set up test pack-------------------
using (var dbContext = GetContext())
{
var loanItem = new LoanItem {
Name = "Chair"
};
AddItem(dbContext, loanItem);
var itemRepository = CreateItemRepository(dbContext);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var loanItems = itemRepository.GetItems();
//---------------Test Result -----------------------
CollectionAssert.AreEquivalent(new[] { loanItem }, loanItems);
}
}
public void FindByName_GivenMatchingItemName_ShouldReturnLoanItem()
{
//---------------Set up test pack-------------------
using (var dbContext = GetContext())
{
var loanItem = new LoanItem {
Name = "Lamp"
};
AddItem(dbContext, loanItem);
var itemRepository = CreateItemRepository(dbContext);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var foundItem = itemRepository.FindByName("Lamp");
//---------------Test Result -----------------------
Assert.AreEqual(loanItem, foundItem);
}
}
public void FindById_GivenMatchingNoItemId_ShouldReturnNull()
{
//---------------Set up test pack-------------------
using (var dbContext = GetContext())
{
var loanItem = new LoanItem {
Name = "Lamp"
};
AddItem(dbContext, loanItem);
var itemRepository = CreateItemRepository(dbContext);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var foundItem = itemRepository.FindById(777);
//---------------Test Result -----------------------
Assert.IsNull(foundItem);
}
}
public void Delete_GivenMatchingNoItemId_ShouldNotDeleteAnyItems()
{
//---------------Set up test pack-------------------
using (var dbContext = GetContext())
{
var loanItem = new LoanItem {
Name = "Lamp"
};
AddItem(dbContext, loanItem);
var itemRepository = CreateItemRepository(dbContext);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
itemRepository.Delete(777);
//---------------Test Result -----------------------
var loanItems = dbContext.LoanItems;
CollectionAssert.AreEquivalent(new[] { loanItem }, loanItems);
}
}
public void Delete_GivenMatchingItemId_ShouldNotDeleteLoanItems()
{
//---------------Set up test pack-------------------
using (var dbContext = GetContext())
{
var loanItem = new LoanItem {
Name = "Lamp"
};
AddItem(dbContext, loanItem);
var id = dbContext.LoanItems.Single(i => i.Name == "Lamp").Id;
var itemRepository = CreateItemRepository(dbContext);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
itemRepository.Delete(id);
//---------------Test Result -----------------------
var loanItems = dbContext.LoanItems;
CollectionAssert.IsEmpty(loanItems);
}
}
public async Task <ActionResult <LoanItemDTO> > CreateLoanItem(LoanItemDTO loanItemDTO)
{
//Console.WriteLine("POST new loan item");
var loanItem = new LoanItem {
Balance = loanItemDTO.Balance,
MonthLeft = loanItemDTO.MonthLeft,
Rate = loanItemDTO.Rate
};
_context.LoanItems.Add(loanItem);
await _context.SaveChangesAsync();
loanPaymentPlanner(loanItem);
return(CreatedAtAction(
nameof(GetLoanItem),
new { id = loanItem.Id },
LoanToDTO(loanItem)));
}
public void SaveChanges_GivenNewItem_ShouldPersistChanges()
{
//---------------Set up test pack-------------------
using (var dbContext = GetContext())
{
var loanItem = new LoanItem {
Name = "Strat"
};
dbContext.LoanItems.Add(loanItem);
//---------------Assert Precondition----------------
var itemBeforeSave = dbContext.LoanItems.SingleOrDefault(i => i.Name == "Strat");
Assert.IsNull(itemBeforeSave);
//---------------Execute Test ----------------------
dbContext.SaveChanges();
//---------------Test Result -----------------------
var addedItem = dbContext.LoanItems.Single(i => i.Name == "Strat");
Assert.AreEqual(loanItem, addedItem);
}
}
public static async void CreateLoan(string username, IEnumerable <string> hardWareItemList)
{
var availableItems = await HardwareRepository.GetHardwareItems();
foreach (var hwItem in hardWareItemList)
{
var newLoan = new LoanItem
{
IsReturned = false,
LoanedAt = DateTime.Now,
LoanedBy = username
};
var hardwareItems = availableItems as HardwareItem[] ?? availableItems.ToArray();
if (hardwareItems.Select(x => x.Name.ToLower()).Contains(hwItem.ToLower()))
{
newLoan.ItemId = hardwareItems.FirstOrDefault(x => string.Equals(x.Name, hwItem, StringComparison.CurrentCultureIgnoreCase)).Id;
}
else
{
var newItem = new HardwareItem
{
Category = "",
ImageUrl = "",
Name = hwItem
};
await HardwareRepository.AddItem(newItem);
newLoan.ItemId = newItem.Id;
}
try
{
await LoanTable.InsertAsync(newLoan);
}
catch (Exception e)
{
//Item allready exist, create duplicate
newLoan.Item.Id = Guid.NewGuid().ToString();
await LoanTable.InsertAsync(newLoan);
}
}
}
public LoanItem Create(LoanItem loan)
{
_loan.InsertOne(loan);
return(loan);
}
private static void AddItem(WimsDbContext dbContext, LoanItem loanItem)
{
dbContext.LoanItems.Add(loanItem);
dbContext.SaveChanges();
}
public void Add(LoanItem loanItem)
{
_itemModels.Add(loanItem);
}
public ActionResult <LoanItem> PostLoanItem(LoanItem loanItem)
{
_loanService.Create(loanItem);
return(CreatedAtRoute("GetLoanItem", new { id = loanItem.Id.ToString() }, loanItem));
}
public void Add(LoanItem loanItem)
{
_dbContext.LoanItems.Add(loanItem);
_dbContext.SaveChanges();
}
public static async Task AddLoan(LoanItem loanItem)
{
await LoanTable.InsertAsync(loanItem);
}
public void Remove(LoanItem loanIn)
{
_loan.DeleteOne(LoanItem => LoanItem.Id == loanIn.Id);
}
public JObject addLoan(JObject request)
{
//Get arguments
request.TryGetValue("productId", out JToken requestProductId);
request.TryGetValue("start", out JToken requestStart);
request.TryGetValue("end", out JToken requestEnd);
// Verify the arguments
List <string> failedVerifications = new List <string>();
if (requestProductId == null || requestProductId.Type != JTokenType.String)
{
failedVerifications.Add("productID");
}
if (requestStart == null || !(requestStart.Type == JTokenType.String || requestStart.Type == JTokenType.Date))
{
failedVerifications.Add("start");
}
if (requestEnd == null || !(requestEnd.Type == JTokenType.String || requestEnd.Type == JTokenType.Date))
{
failedVerifications.Add("end");
}
if (failedVerifications.Any())
{
return(Templates.InvalidArguments(failedVerifications.ToArray()));
}
// Parse arguments
DateTime start;
DateTime end;
string productId = requestProductId.ToString();
try { start = DateTime.Parse(requestStart.ToString()); }
catch (Exception) { return(Templates.InvalidArgument("Unable to parse 'start'")); }
try { end = DateTime.Parse(requestEnd.ToString()); }
catch (Exception) { return(Templates.InvalidArgument("Unable to parse 'end'")); }
if (end < start)
{
return(Templates.InvalidArguments("'end' must come after 'start'"));
}
var newLoanSpan = new DateTimeSpan(start, end);
if (newLoanSpan.Start < DateTime.Now.Date)
{
return(Templates.InvalidArgument("'start' may not be set earlier than today."));
}
if (newLoanSpan.Duration > MaxLoanDuration)
{
return(Templates.InvalidArgument($"Duration of the loan may not exceed {MaxLoanDuration.Days} days."));
}
// Get an unreserved product item
ProductItem item;
try {
item = Core_GetUnreservedItems(productId, newLoanSpan).FirstOrDefault();
} catch (Exception) {
return(Templates.NoItemsForProduct(productId));
}
if (item == null)
{
return(Templates.NoItemsForProduct($"Product '{productId}' has no items available during this time."));
}
var loan = new LoanItem(null, CurrentUser.Username, item.Id.Value, start, end);
Connection.Upload(loan);
//Create response
JObject response = new JObject()
{
{ "reason", null },
{ "responseData", new JObject()
{
{ "loanId", loan.Id },
{ "productItem", item.Id }
} }
};
return(response);
}
public void Update(string id, LoanItem loanIn)
{
var docId = new ObjectId(id);
_loan.ReplaceOne(LoanItem => LoanItem.Id == docId, loanIn);
}
public JObject resizeLoan(JObject request)
{
//Get arguments
request.TryGetValue("loanId", out JToken loanItemID);
request.TryGetValue("start", out JToken requestStart);
request.TryGetValue("end", out JToken requestEnd);
// Verify the arguments
List <string> failedVerifications = new List <string>();
if (loanItemID == null || loanItemID.Type != JTokenType.Integer)
{
failedVerifications.Add("loanId");
}
if (requestStart == null || !(requestStart.Type == JTokenType.String || requestStart.Type == JTokenType.Date))
{
failedVerifications.Add("start");
}
if (requestEnd == null || !(requestEnd.Type == JTokenType.String || requestEnd.Type == JTokenType.Date))
{
failedVerifications.Add("end");
}
if (failedVerifications.Any())
{
return(Templates.InvalidArguments(failedVerifications.ToArray()));
}
// Parse arguments
DateTime start;
DateTime end;
string loanID = loanItemID.ToString();
try { start = DateTime.Parse(requestStart.ToString()); } catch (Exception) { return(Templates.InvalidArgument("Unable to parse 'start'")); }
try { end = DateTime.Parse(requestEnd.ToString()); } catch (Exception) { return(Templates.InvalidArgument("Unable to parse 'end'")); }
if (end < start)
{
return(Templates.InvalidArguments("'end' must come after 'start'"));
}
DateTimeSpan newLoanSpan = new DateTimeSpan(start, end);
if (newLoanSpan.Start < DateTime.Now.Date)
{
return(Templates.InvalidArgument("'start' may not be set earlier than today."));
}
if (newLoanSpan.Duration > MaxLoanDuration)
{
return(Templates.InvalidArgument($"Duration of the loan may not exceed {MaxLoanDuration.Days} days."));
}
// Build a condition to get the specific loan
var condition = new MySqlConditionBuilder();
// Automatically limit results to current user only if their permission is User
if (CurrentUser.Permission <= UserPermission.User)
{
condition.And().Column("user").Equals(CurrentUser.Username, MySqlDbType.String);
}
condition.And().Column("id").Equals(loanID, MySqlDbType.Int32);
//Get the specified loanItem if it exists. If it doesn't, throw an error.
LoanItem oldLoan = Connection.Select <LoanItem>(condition).FirstOrDefault();
if (oldLoan == null)
{
return(Templates.NoSuchLoan(loanID));
}
// Return a loanExpired template if the loan has already ended
if (oldLoan.End < DateTime.Now)
{
return(Templates.LoanExpired());
}
if (oldLoan.Start < DateTime.Now && oldLoan.Start != start)
{
return(Templates.LoanAlreadyStarted());
}
// Build condition
condition = new MySqlConditionBuilder()
.Column("product_item")
.Equals(oldLoan.ProductItem, MySqlDbType.Int32);
// Select only relevant loans
condition.And().Column("end").GreaterThanOrEqual().Operand(start, MySqlDbType.DateTime);
condition.And().Column("start").LessThanOrEqual().Operand(end, MySqlDbType.DateTime);
//Get all loanItems for this loan's product_item.
var loans = Connection.Select <LoanItem>(condition).ToList();
//Check for conflicting loanItems
bool canResize = true;
foreach (var loan in loans)
{
var loanSpan = new DateTimeSpan(loan.Start, loan.End);
if (newLoanSpan.Overlaps(loanSpan))
{
canResize = false;
break;
}
}
//Create response
var responseData = new JObject();
JObject response = new JObject()
{
{ "reason", null },
{ "responseData", responseData }
};
if (canResize)
{
// Update loan
oldLoan.Start = start;
oldLoan.End = end;
Connection.Update(oldLoan);
}
else if (oldLoan.IsAcquired && !canResize) // If loan is not eligible for a item reassignment
{
return(Templates.LoanResizeFailed());
}
else // If the loan is eligible for an item reassignment
{
// Try to retrieve a list of unreserved equivalent products
var unreservedAlts = Core_GetUnreservedItems(oldLoan.GetProductItem(Connection).ProductId, newLoanSpan);
if (unreservedAlts == null) // Normally this value should not be able to be null. This block is just a failsafe that adds context.
{
throw new InvalidOperationException("Expected type of 'unreservedAlts' is List, but nullreference was found.");
}
if (!unreservedAlts.Any())
{
Log.Error("Failed at line 107");
return(Templates.LoanResizeFailed());
}
// Update loan
oldLoan.ProductItem = unreservedAlts.First().Id.Value;
oldLoan.Start = start;
oldLoan.End = end;
Connection.Update(oldLoan);
// Return new data in response and add message for context
responseData["product_item"] = oldLoan.ProductItem;
response["message"] = "Loan has been reassigned.";
}
return(response);
}
/// <summary>
/// 打印
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ViewResult Print(string id)
{
Item result = ExpenseReimbursementBll.GetExpenseReimbursementObjById(inn, id);
//拆解数据
ExpenseReimbursementModel model = new ExpenseReimbursementModel();
model.Id = result.getProperty("id");
model.b_RecordNo = result.getProperty("b_recordno");
model.b_CompanyCode = result.getProperty("b_companycode");
model.b_ReimbursementPlace = result.getProperty("b_reimbursementplace");
model.b_IsBudgetary = result.getProperty("b_isbudgetary") == "1" ? true : false;
model.b_Preparer = result.getProperty("b_preparer");
model.b_PreparerNo = result.getProperty("b_preparerno");
model.b_ApplicationDate = DateTime.Parse(result.getProperty("b_applicationdate")).ToString("yyyy-MM-dd");
model.b_Employee = result.getProperty("b_employee");
model.b_StaffNo = result.getProperty("b_staffno");
model.b_Position = result.getProperty("b_position");
model.b_Dept = result.getProperty("b_dept");
model.b_CostCenter = result.getProperty("b_costcenter");
model.b_Tel = result.getProperty("b_tel");
model.b_AdvancedAmount = !string.IsNullOrEmpty(result.getProperty("b_advancedamount")) ? decimal.Parse(result.getProperty("b_advancedamount")) : 0;
model.b_TotalExpense = !string.IsNullOrEmpty(result.getProperty("b_totalexpense")) ? decimal.Parse(result.getProperty("b_totalexpense")) : 0;
model.b_DueCompany = result.getProperty("b_duecompany");
model.b_IsHangUp = result.getProperty("b_ishangup") == "1" ? true : false;
model.b_AmountInWords = result.getProperty("b_amountinwords");
model.b_TotalAmount = !string.IsNullOrEmpty(result.getProperty("b_totalamount")) ? decimal.Parse(result.getProperty("b_totalamount")) : 0;
model.b_Type = result.getProperty("b_type");
model.b_AttachmentsQuantity = !string.IsNullOrEmpty(result.getProperty("b_attachmentsquantity")) ? int.Parse(result.getProperty("b_attachmentsquantity")) : 0;
model.b_LineLeader = result.getProperty("b_lineleader");
model.b_DepartmentLeader = result.getProperty("b_departmentleader");
model.b_DivisionVP = result.getProperty("b_divisionvp");
model.OldRemark = result.getProperty("b_remark");
//报销明细
Item Relation = result.getRelationships("R_ReimbursementItem");
if (Relation.getItemCount() > 0)
{
model.ReimbursementItems = new List <ReimbursementItem>();
for (int i = 0; i < Relation.getItemCount(); i++)
{
Item ItemObJ = Relation.getItemByIndex(i).getRelatedItem();
ReimbursementItem itemModel = new ReimbursementItem();
itemModel.Id = ItemObJ.getProperty("id");
itemModel.b_Date = !string.IsNullOrEmpty(ItemObJ.getProperty("b_date")) ? DateTime.Parse(ItemObJ.getProperty("b_date")).ToString("yyyy-MM-dd") : "";
itemModel.b_CategoryNumber = ItemObJ.getProperty("b_categorynumber");
itemModel.b_ProjectName = ItemObJ.getProperty("b_projectname");
itemModel.b_BudgetNumber = ItemObJ.getProperty("b_budgetnumber");
itemModel.b_Currency = ItemObJ.getProperty("b_currency");
itemModel.b_Rate = !string.IsNullOrEmpty(ItemObJ.getProperty("b_rate")) ? float.Parse(ItemObJ.getProperty("b_rate")) : 0;
itemModel.b_OriginalCurrency = !string.IsNullOrEmpty(ItemObJ.getProperty("b_originalcurrency")) ? decimal.Parse(ItemObJ.getProperty("b_originalcurrency")) : 0;
itemModel.b_Count = !string.IsNullOrEmpty(ItemObJ.getProperty("b_count")) ? int.Parse(ItemObJ.getProperty("b_count")) : 0;
itemModel.b_TaxRate = !string.IsNullOrEmpty(ItemObJ.getProperty("b_taxrate")) ? float.Parse(ItemObJ.getProperty("b_taxrate")) : 0;
itemModel.b_Tax = !string.IsNullOrEmpty(ItemObJ.getProperty("b_tax")) ? decimal.Parse(ItemObJ.getProperty("b_tax")) : 0;
itemModel.b_TaxFreeAmount = !string.IsNullOrEmpty(ItemObJ.getProperty("b_taxfreeamount")) ? decimal.Parse(ItemObJ.getProperty("b_taxfreeamount")) : 0;
itemModel.b_CNYSubtotal = !string.IsNullOrEmpty(ItemObJ.getProperty("b_cnysubtotal")) ? decimal.Parse(ItemObJ.getProperty("b_cnysubtotal")) : 0;
model.ReimbursementItems.Add(itemModel);
}
}
//借款明细
Item loanItemRelation = result.getRelationships("R_LoanItem");
if (loanItemRelation.getItemCount() > 0)
{
model.LoanItems = new List <LoanItem>();
for (int i = 0; i < loanItemRelation.getItemCount(); i++)
{
Item ItemObJ = loanItemRelation.getItemByIndex(i).getRelatedItem();
LoanItem item = new LoanItem();
item.id = ItemObJ.getProperty("id");
item.b_LoanOrderNo = ItemObJ.getProperty("b_loanorderno");
item.b_Date = !string.IsNullOrEmpty(ItemObJ.getProperty("b_date")) ? DateTime.Parse(ItemObJ.getProperty("b_date")).ToString("yyyy-MM-dd") : "";
item.b_Borrower = ItemObJ.getProperty("b_borrower");
item.b_LoanAmount = !string.IsNullOrEmpty(ItemObJ.getProperty("b_loanamount")) ? decimal.Parse(ItemObJ.getProperty("b_loanamount")) : 0;
item.b_LoanReason = ItemObJ.getProperty("b_loanreason");
model.LoanItems.Add(item);
}
}
//日志信息
model.HistoryList = GetExpenseReimbursementHistoryList(id);
foreach (var item in model.HistoryList)
{
item.Created_on = item.Create_onStr.GetValueOrDefault().ToString("yyyy-MM-dd HH:mm:ss");
}
return(View("~/Views/ExpenseReimbursement/PrintExpenseReimbursement.cshtml", model));
}
