public void SavingsAccount_InterestCalc_LastDebitLessThanThirty()
{
decimal initalBalance = 100;
decimal expected = 100;
PrivateCustomer pc = new PrivateCustomer()
{
CustomerID = Guid.NewGuid(),
ContactInformation = new Contact()
{
FirstName = "test",
LastName = "test",
Address = "test",
Email = "test",
PhoneNumbers = new List <string>()
{
"123-122"
}
}
};
BonusSavingsAccount ba = new BonusSavingsAccount(new List <PrivateCustomer>()
{
pc
}, initalBalance);
ba.CalculateInterest();
decimal actual = ba.Balance;
Assert.AreEqual(expected, actual);
}
public void OverdraftAccount_Debit_ExceedLimit()
{
decimal debitAmount = 250;
decimal initalBalance = 100;
decimal expected = 100;
decimal overdraftLimit = 100;
PrivateCustomer pc = new PrivateCustomer()
{
CustomerID = Guid.NewGuid(),
ContactInformation = new Contact()
{
FirstName = "test",
LastName = "test",
Address = "test",
Email = "test",
PhoneNumbers = new List <string>()
{
"123-122"
}
}
};
OverdraftAccount ba = new OverdraftAccount(initalBalance, new List <PrivateCustomer>()
{
pc
}, overdraftLimit);
ba.Debit(debitAmount);
decimal actual = ba.Balance;
Assert.AreEqual(expected, actual);
}
public ActionResult Create([Bind(Include = "FullName,Address,Phone,Email,Vat,Note,Description")] PrivateCustomer privateCustomer)
{
if (ModelState.IsValid)
{
privateCustomer.PrivateCustomerID = Guid.NewGuid();
privateCustomer.DateCreated = DateTime.Now;
privateCustomer.DateModified = privateCustomer.DateCreated;
privateCustomer.CreatedBy = Guid.Parse(User.Identity.GetUserId());
privateCustomer.ModifiedBy = privateCustomer.CreatedBy;
db.PrivateCustomer.Add(privateCustomer);
db.SaveChanges();
Customers customers = new Customers();
customers.CustomerID = Guid.NewGuid();
customers.DateCreated = privateCustomer.DateCreated;
customers.DateModified = privateCustomer.DateModified;
customers.CreatedBy = privateCustomer.CreatedBy;
customers.ModifiedBy = privateCustomer.ModifiedBy;
customers.PrivateCustomerID = privateCustomer.PrivateCustomerID;
db.Customers.Add(customers);
db.SaveChanges();
return(RedirectToAction("Index", "Customers"));
}
return(View(privateCustomer));
}
public void SavingsAccount_Debit_InvalidAmount()
{
decimal debitAmount = -5;
decimal initalBalance = 100;
decimal expected = 100;
PrivateCustomer pc = new PrivateCustomer()
{
CustomerID = Guid.NewGuid(),
ContactInformation = new Contact()
{
FirstName = "test",
LastName = "test",
Address = "test",
Email = "test",
PhoneNumbers = new List <string>()
{
"123-122"
}
}
};
SavingsAccount ba = new SavingsAccount(new List <PrivateCustomer>()
{
pc
}, initalBalance);
ba.Debit(debitAmount);
decimal actual = ba.Balance;
Assert.AreEqual(expected, actual);
}
public void PrivateCustomer()
{
Customers.PrivateCustomer privateCustomer = new PrivateCustomer(new TestingCustomers.TestPrivateCustomer());
// Testing get
Assert.AreEqual(true, privateCustomer.Active);
Assert.AreEqual("testAltPhoneNo", privateCustomer.AltPhoneNo);
Assert.AreEqual("testEmail", privateCustomer.Email);
Assert.AreEqual("testHomeAddress", privateCustomer.HomeAddress);
Assert.AreEqual("testName", privateCustomer.Name);
Assert.AreEqual("testPhoneNo", privateCustomer.PhoneNo);
Assert.AreEqual(new TestingCustomers.PostNumberTest().Id, privateCustomer.PostNo.Id);
Assert.AreEqual(1, privateCustomer.PrivateCustomersNo);
Assert.AreEqual("testName", privateCustomer.Name);
// Testing set
privateCustomer.Active = false;
Assert.AreEqual(false, privateCustomer.Active);
privateCustomer.AltPhoneNo = "NewTestAltPhoneNo";
Assert.AreEqual("NewTestAltPhoneNo", privateCustomer.AltPhoneNo);
privateCustomer.Email = "newTestEamil";
Assert.AreEqual("newTestEamil", privateCustomer.Email);
privateCustomer.HomeAddress = "newTestHomeAddress";
Assert.AreEqual("newTestHomeAddress", privateCustomer.HomeAddress);
privateCustomer.Name = "newTestName";
Assert.AreEqual("newTestName", privateCustomer.Name);
privateCustomer.PhoneNo = "newTestPhoneNo";
Assert.AreEqual("newTestPhoneNo", privateCustomer.PhoneNo);
privateCustomer.PostNo = new TestingCustomers.PostNumberTest();
Assert.AreEqual(new TestingCustomers.PostNumberTest().Id, privateCustomer.PostNo.Id);
privateCustomer.Name = "newTestName";
Assert.AreEqual("newTestName", privateCustomer.Name);
}
public void OverdraftAccount_InterestCalc_Overdraft()
{
decimal initalBalance = -100;
decimal expected = -103.25M;
decimal overdraftLimit = 10000;
PrivateCustomer pc = new PrivateCustomer()
{
CustomerID = Guid.NewGuid(),
ContactInformation = new Contact()
{
FirstName = "test",
LastName = "test",
Address = "test",
Email = "test",
PhoneNumbers = new List <string>()
{
"123-122"
}
}
};
OverdraftAccount ba = new OverdraftAccount(initalBalance, new List <PrivateCustomer>()
{
pc
}, overdraftLimit);
ba.CalculateInterest();
decimal actual = ba.Balance;
Assert.AreEqual(expected, actual);
}
public async Task <IActionResult> EditPrivateCustomer(PrivateCustomer privateCustomer)
{
if (ModelState.IsValid)
{
string endPointGetPrivateCustomer = $"PrivateCustomer?id={privateCustomer.PrivateCustomerID}";
string baseUrl = configuration.GetValue <string>("Urls:CustomerBaseUrl");
int statusCode = await PrivateCustomerHandler.PutHttp(privateCustomer, baseUrl, endPointGetPrivateCustomer);
if (statusCode == StatusCodes.Status204NoContent)
{
return(RedirectToAction("GetPrivateCustomers"));
}
string endPointGetCompanyCustomer = $"PrivateCustomer/{privateCustomer.PrivateCustomerID}";
var updatedCustomer = await PrivateCustomerHandler.CallHttpGetByID(baseUrl, endPointGetCompanyCustomer);
PrivateCustomerEditViewModel privateCustomerEditViewModel = new();
privateCustomerEditViewModel.PrivateCustomer = updatedCustomer;
var ErrorMessageForConflict = "Nogen har sandsynligvis lavet ændringer i mellemtiden. Nyeste version er nu hentet.";
privateCustomerEditViewModel.ErrorMessage = $"Fejlede med statuskode {statusCode}. {(statusCode == 409 ? ErrorMessageForConflict : "")}";
ModelState.Clear();
return(View("EditPrivateCustomer", privateCustomerEditViewModel));
}
return(View());
}
public static void Main(string[] args)
{
// initialise new private customer and all types of accounts with it
var privateGosho = new PrivateCustomer("Gosho", "Ubawetsa", "9005062452", "P0001620");
var newDepositPrivate = new Deposit("DP00001", 1m, privateGosho);
var newLoanPrivate = new Loan("LP00001", 20m, privateGosho);
var newMortPrivate = new Mortgage("MP00001", 15m, privateGosho);
// initialise ne corporate customer and all types of accounts with it
var corporatePesho = new CorporateCustomer("Kurti ltd", "BG130607427", "C00012368");
var newDepositCorp = new Deposit("DC00001", 0.5m, corporatePesho);
var newLoanCorp = new Loan("LC00001", 30m, corporatePesho);
var newMortCorp = new Mortgage("MC00001", 25, corporatePesho);
// prit the corporate deposit account to ches the ToStrig() overriding
Console.WriteLine(newDepositCorp);
// deposit money to the corporatie deposit
newDepositCorp.DepositMoney(2000m);
// newDepositCorp.Withdraw(200m); // Shoud throw exeption (insufficient money)
// prints the interest for 5 monts
Console.WriteLine();
Console.WriteLine(newDepositCorp.CalculateIntersetAmount(5));
// deposit money to private loan
newLoanPrivate.DepositMoney(100m);
// print interest fow 2 monts for private loan
Console.WriteLine();
Console.WriteLine(newLoanPrivate.CalculateIntersetAmount(2));
// and so on..
}
public void SavingsAccount_ResetDebit()
{
decimal initalBalance = 100;
DateTime expected = default(DateTime);
PrivateCustomer pc = new PrivateCustomer()
{
CustomerID = Guid.NewGuid(),
ContactInformation = new Contact()
{
FirstName = "test",
LastName = "test",
Address = "test",
Email = "test",
PhoneNumbers = new List <string>()
{
"123-122"
}
}
};
BonusSavingsAccount ba = new BonusSavingsAccount(new List <PrivateCustomer>()
{
pc
}, initalBalance);
ba.ResetDebitCounter();
DateTime actual = ba.LastDebit;
Assert.AreEqual(expected, actual);
}
public PrivateCustomerView(PrivateCustomer model)
{
Mapper.CreateMap<PrivateCustomer, PrivateCustomerView>();
Mapper.Map<PrivateCustomer, PrivateCustomerView>(model, this);
this.created = model.created.ToString().Replace('T', ' ');
this.updated = model.updated.ToString().Replace('T', ' ');
}
public ActionResult DeleteConfirmed(int id)
{
PrivateCustomer privateCustomer = db.Customers.Find(id) as PrivateCustomer;//had to add "as PrivateCustomer"
db.Customers.Remove(privateCustomer);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public PrivateCustomerView(PrivateCustomer model)
{
Mapper.CreateMap <PrivateCustomer, PrivateCustomerView>();
Mapper.Map <PrivateCustomer, PrivateCustomerView>(model, this);
this.created = model.created.ToString().Replace('T', ' ');
this.updated = model.updated.ToString().Replace('T', ' ');
}
public ActionResult DeleteConfirmed(Guid id)
{
PrivateCustomer privateCustomer = db.PrivateCustomer.Find(id);
db.PrivateCustomer.Remove(privateCustomer);
db.SaveChanges();
return(RedirectToAction("Index", "Customers"));
}
public PrivateCustomer getModel()
{
var model = new PrivateCustomer();
Mapper.CreateMap<PrivateCustomerView, PrivateCustomer>().ForSourceMember(x => x.type, y => y.Ignore());
Mapper.Map<PrivateCustomerView, PrivateCustomer>(this, model);
return model;
}
public IActionResult NewPrivate(PrivateCustomer customer)
{
//Get bank object from file, add customer to bank object, then save!
var bank = Utility.Utility.GetBankData(_env.WebRootPath);
bank.PrivateCustomers.Add(customer);
Utility.Utility.SaveBankData(_env.WebRootPath, bank);
return(RedirectToAction("Index", "Home", new { message = Message.CreatePrivateCustomerSuccess }));
}
public PrivateCustomer getModel()
{
var model = new PrivateCustomer();
Mapper.CreateMap <PrivateCustomerView, PrivateCustomer>().ForSourceMember(x => x.type, y => y.Ignore());
Mapper.Map <PrivateCustomerView, PrivateCustomer>(this, model);
return(model);
}
public async Task <PrivateCustomer> Create(PrivateCustomer privateCustomer)
{
using (var context = _contextFactory.CreateDbContext())
{
context.PrivateCustomers.Add(privateCustomer);
await context.SaveChangesAsync();
return(privateCustomer);
}
}
public ActionResult Edit([Bind(Include = "CustomerID,Firstname,Lastname,MailAdress,StreetAdress,City,ZipCode,MobileNumber")] PrivateCustomer privateCustomer)
{
if (ModelState.IsValid)
{
db.Entry(privateCustomer).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(privateCustomer));
}
public ActionResult Create([Bind(Include = "CustomerID,Firstname,Lastname,MailAdress,StreetAdress,City,ZipCode,MobileNumber")] PrivateCustomer privateCustomer)
{
if (ModelState.IsValid)
{
db.Customers.Add(privateCustomer);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(privateCustomer));
}
public async Task <ActionResult> PutPrivateCustomer(int id, [FromBody] PrivateCustomer privateCustomer)
{
if (id != privateCustomer.PrivateCustomerID)
{
return(BadRequest());
}
var statuscode = await _privateCustomerRepository.Update(privateCustomer);
return(StatusCode(statuscode));
}
public async Task <IActionResult> CreatePrivateCustomer([Bind("FirstName, LastName, CPR, LandlinePhoneNumber, MobilePhoneNumber, Addresse, PostalCode, City, Email, PrimaryDelpinDepartment")] PrivateCustomer privateCustomer)
{
if (ModelState.IsValid)
{
string endPointGetCompanyCustomer = "PrivateCustomer";
string baseUrl = configuration.GetValue <string>("Urls:CustomerBaseUrl");
await PrivateCustomerHandler.PostHttp(privateCustomer, baseUrl, endPointGetCompanyCustomer);
return(RedirectToAction("GetPrivateCustomers"));
}
return(View());
}
public Customer GetCustomer(string type)
{
Customer c = null;
switch (type)
{
case "Privatperson": c = new PrivateCustomer(); break;
case "Firma": c = new Company(); break;
}
return(c);
}
// GET: PrivateCustomer/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
PrivateCustomer privateCustomer = db.Customers.Find(id) as PrivateCustomer;//had to add "as PrivateCustomer"
if (privateCustomer == null)
{
return(HttpNotFound());
}
return(View(privateCustomer));
}
public IActionResult Private(string id)
{
try
{
if (!ModelState.IsValid)
{
return(StatusCode(StatusCodes.Status500InternalServerError, new Response
{
Status = "Error",
Messages = new Message[] {
new Message {
Lang_id = 1,
MessageLang = "Model state isn't valid!"
},
new Message {
Lang_id = 2,
MessageLang = "Состояние модели недействительно!"
},
new Message {
Lang_id = 3,
MessageLang = "Model vəziyyəti etibarsızdır!"
}
}
}));
}
AppUser appUser = _userDbContext.Users.Where(u => u.Id == id)
.Include(u => u.City).ThenInclude(c => c.CityNameTranslates)
.Include(u => u.Balance)
.Include(u => u.Office).ThenInclude(o => o.OfficeNameTranlates).FirstOrDefault();
if (appUser == null)
{
return(StatusCode(StatusCodes.Status404NotFound));
}
PrivateCustomer customer = _privateContext.GetWithCamexId(appUser.CamexId);
if (customer == null)
{
return(StatusCode(StatusCodes.Status404NotFound));
}
return(Ok(
new PrivateUserAdmin
{
User = appUser,
PrivateCustomer = customer
}));
}
catch (Exception e)
{
return(StatusCode(StatusCodes.Status500InternalServerError, e.Message));
}
}
// GET: PrivateCustomers/Edit/5
public ActionResult Edit(Guid?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
PrivateCustomer privateCustomer = db.PrivateCustomer.Find(id);
if (privateCustomer == null)
{
return(HttpNotFound());
}
return(View(privateCustomer));
}
private void CreatePrivateCustomer(PrivateCustomer privateCustomer)
{
string query = Utility.ReadSQLQueryFromFile("CreatePrivateCustomer.txt");
SQLQuery sQLQuery = new SQLQuery(query);
sQLQuery.AddParameter("@customerID", privateCustomer.customerID.ToString(), SqlDbType.Int);
SQLQueryResult sQLQueryResult = SQLDatabaseConnector.QueryDatabase(sQLQuery);
if (sQLQueryResult.code != 0)
{
throw new CantCreateCustomer("", sQLQueryResult.exception);
}
}
public IActionResult NewPrivate()
{
//empty form
PrivateCustomer customer = new PrivateCustomer()
{
CustomerID = Guid.NewGuid(), //just generate new guid at this time!
ContactInformation = new Contact()
};
List <string> phoneNumbers = new List <string>();
for (int i = 0; i < 3; i++)
{
phoneNumbers.Add(string.Empty);
}
customer.ContactInformation.PhoneNumbers = phoneNumbers;
return(View(customer));
}
public async Task <int> Update(PrivateCustomer privateCustomer)
{
using (var context = _contextFactory.CreateDbContext())
{
context.Entry(privateCustomer).State = EntityState.Modified;
try
{
await context.SaveChangesAsync();
return(204);
}
catch (DbUpdateConcurrencyException)
{
return(409);
}
}
}
public async Task <IActionResult> Get()
{
try
{
AppUser user = _user.Users
.Where(u => u.UserName == User.Identity.Name)
.Include(u => u.Balance)
.Include(u => u.Receipts).FirstOrDefault();
var roles = await _userManager.GetRolesAsync(user);
foreach (var role in roles)
{
if (role == Helper.Roles.PrivateCustomer.ToString())
{
PrivateCustomer customer = _privateContext.GetWithCamexId(user.CamexId);
UserVm userVm = new UserVm
{
User = user,
PrivateCustomer = customer,
BusinessCustomer = null
};
return(Ok(userVm));
}
else if (role == Helper.Roles.BusinessCustomer.ToString())
{
BusinessCustomer customer = _businesContext.GetWithCamexId(user.CamexId);
UserVm userVm = new UserVm
{
User = user,
PrivateCustomer = null,
BusinessCustomer = customer
};
return(Ok(userVm));
}
}
return(NotFound());
}
catch (Exception e)
{
return(StatusCode(StatusCodes.Status500InternalServerError, e.Message));
}
}
public Customer CreateCustomer(Customer customer)
{
SqlConnection con = new SqlConnection(Utility.connectionString);
string query = Utility.ReadSQLQueryFromFile("CreateCustomer.txt");
SQLQuery sQLQuery = new SQLQuery(query);
sQLQuery.AddParameter("@phone", customer.phone.ToString(), SqlDbType.VarChar);
sQLQuery.AddParameter("@name", customer.name.ToString(), SqlDbType.VarChar);
sQLQuery.AddParameter("@address", customer.address.ToString(), SqlDbType.VarChar);
sQLQuery.AddParameter("@email", customer.email.ToString(), SqlDbType.VarChar);
SQLQueryResult sQLQueryResult = SQLDatabaseConnector.QueryDatabase(sQLQuery);
if (sQLQueryResult.code != 0)
{
throw new CantCreateCustomer("", sQLQueryResult.exception);
}
int customerID = (int)sQLQueryResult.dataTable.Rows[0]["CustomerID"];
customer.UpdateID(customerID);
if (customer.GetType() == typeof(BusinessCustomer))
{
//der laves en BusinessCustomer som castes til customer
BusinessCustomer businessCustomer = (BusinessCustomer)customer;
CreateBusinessCustomer(businessCustomer);
}
if (customer.GetType() == typeof(PrivateCustomer))
{
//der laves en PrivateCustomer som castes til customer
PrivateCustomer privateCustomer = (PrivateCustomer)customer;
CreatePrivateCustomer(privateCustomer);
}
return(customer);
}
public ActionResult DeleteConfirmed(Guid id)
{
Customers customers = db.Customers.Find(id);
if (customers.CompanyID != null)
{
Company company = db.Company.Find(customers.CompanyID);
db.Company.Remove(company);
}
if (customers.PrivateCustomerID != null)
{
PrivateCustomer privateCustomer = db.PrivateCustomer.Find(customers.PrivateCustomerID);
db.PrivateCustomer.Remove(privateCustomer);
}
db.Customers.Remove(customers);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public IActionResult GetUser()
{
string UserName = User.Identity.Name;
List <string> Roles = User.FindAll(ClaimTypes.Role).Select(c => c.Value.ToString()).ToList();
AppUser user = _userDbContext.Users
.Where(u => u.UserName == UserName)
.Include(u => u.Balance)
.FirstOrDefault();
foreach (string role in Roles)
{
if (role == Helper.Roles.BusinessCustomer.ToString())
{
BusinessCustomer businessCustomer = _businessContext.GetWithCamexId(user.CamexId);
UserNavVM userNav = new UserNavVM
{
CompanyName = businessCustomer.CompanyName,
UserBalance = user.Balance.UserBalance,
Roles = Roles,
Image = user.Image
};
return(Ok(userNav));
}
else if (role == Helper.Roles.PrivateCustomer.ToString())
{
PrivateCustomer privateCustomer = _privateContext.GetWithCamexId(user.CamexId);
UserNavVM userNav = new UserNavVM
{
Name = privateCustomer.Name,
Surname = privateCustomer.Surname,
UserBalance = user.Balance.UserBalance,
Roles = Roles,
Image = user.Image
};
return(Ok(userNav));
}
}
return(NotFound());
}
public PrivateCustomer createPrivateCustomer(PrivateCustomer model)
{
db.privateCustomers.Add(model);
db.SaveChanges();
return model;
}
