public void GetListOfAddedCustomersAndCHeckAreEqualLikeModels()
{
//Arrange
Customer customer1 = new Customer()
{
Id = 66,
Name = "test",
NIP = "unit"
};
Customer customer2 = new Customer()
{
Id = 67,
Name = "test1",
NIP = "unit1"
};
var options = new DbContextOptionsBuilder <Context>()
.UseInMemoryDatabase(databaseName: "UsersDirectoryMVC")
.Options;
using (var context = new Context(options))
{
//Act
var customerRepository = new CustomerRepository(context);
customerRepository.AddCustomer(customer1);
customerRepository.AddCustomer(customer2);
var listOfCustomers = customerRepository.GetAllActiveCustomers();
//Assert
listOfCustomers.FirstOrDefault(e => e.Id == 66).Should().Equals(customer1);
listOfCustomers.FirstOrDefault(e => e.Id == 67).Should().Equals(customer2);
}
}
public void AddCustomerFails_With_Invalid_Data()
{
CustomerRepository repo = new CustomerRepository();
Customer customerNoName = new Customer()
{
Id = 999, Name = ""
};
Customer customerInvalidId = new Customer()
{
Id = -1, Name = "Fred"
};
Customer customerExistingId = new Customer()
{
Id = 1, Name = "Fred"
};
KeyValuePair <string, Customer> noNameResult = repo.AddCustomer(customerNoName);
KeyValuePair <string, Customer> invalidIdResult = repo.AddCustomer(customerInvalidId);
KeyValuePair <string, Customer> existingIdResult = repo.AddCustomer(customerExistingId);
Assert.That(!string.IsNullOrEmpty(noNameResult.Key) && noNameResult.Value == customerNoName);
Assert.That(!string.IsNullOrEmpty(invalidIdResult.Key) && invalidIdResult.Value == customerInvalidId);
Assert.That(!string.IsNullOrEmpty(existingIdResult.Key) && existingIdResult.Value == customerExistingId);
}
private void AddCustomer()
{
Console.Clear();
var customer = new Customer();
Console.WriteLine("Enter your first name:");
customer.FirstName = Console.ReadLine();
Console.WriteLine("Enter your last name:");
customer.LastName = Console.ReadLine();
Console.WriteLine("Select a customer status: \n" +
"1.) Potential\n" +
"2.) Current\n" +
"3.) Past");
string customerStatusString = Console.ReadLine();
switch (customerStatusString)
{
case "1":
customer.TypeOfCustomer = CustomerType.Potential;
break;
case "2":
customer.TypeOfCustomer = CustomerType.Current;
break;
case "3":
customer.TypeOfCustomer = CustomerType.Past;
break;
}
_customerRepo.AddCustomer(customer);
}
public void Repo_RemoveCustomer_ShouldRemoveObjectFromList()
{
//-- Arrange
CustomerRepository _repo = new CustomerRepository();
Customer customer1 = new Customer
{
FirstName = "David",
LastName = "Caldwell",
Type = "Current"
};
Customer customer2 = new Customer
{
FirstName = "John",
LastName = "Smith",
Type = "Potential"
};
_repo.AddCustomer(customer1);
_repo.AddCustomer(customer2);
var list = _repo.GetCustomers();
//-- Act
_repo.RemoveCustomer(customer1);
int actual = list.Count;
int expected = 1;
//-- Assert
Assert.AreEqual(expected, actual);
}
public void CheckCustomerExistAfterDelete()
{
//Arrange
Customer customer1 = new Customer()
{
Id = 66,
Name = "test",
NIP = "unit"
};
Customer customer2 = new Customer()
{
Id = 77,
Name = "test",
NIP = "unit"
};
var options = new DbContextOptionsBuilder <Context>()
.UseInMemoryDatabase(databaseName: "UsersDirectoryMVC")
.Options;
using (var context = new Context(options))
{
//Act
var customerRepository = new CustomerRepository(context);
customerRepository.AddCustomer(customer1);
customerRepository.AddCustomer(customer2);
customerRepository.DeleteCustomer(66);
var gerEmployer1 = customerRepository.GetCustomer(66);
var gerEmployer2 = customerRepository.GetCustomer(77);
//Assert
gerEmployer1.Should().BeNull();
gerEmployer2.Should().Equals(customer2);
}
}
public void Arrange()
{
_customerRepo = new CustomerRepository();
_customer1 = new Customer("Bluth", "Michael", CustomerType.Past);
_customerRepo.AddCustomer(_customer1);
_customer2 = new Customer("Funke", "Lindsay", CustomerType.Past);
_customerRepo.AddCustomer(_customer2);
}
public void ClaimsRepository_AddCustomer_ShouldReturnCorrectCount()
{
//Arrange
_customerRepoTest.AddCustomer("James", "Walker", 1);
List <Customer> _customerList = _customerRepoTest.GetList();
//Act
var actual = _customerList.Count;
var expected = 1;
//Assert
Assert.AreEqual(actual, expected);
}
public void Seed()
{
customer1 = new Customer("John", "Smith", 1, CustomerType.Current);
customer2 = new Customer("Jane", "Smith", 2, CustomerType.Past);
customer3 = new Customer("Dave", "Alvarez", 3, CustomerType.Potential);
customer4 = new Customer("Bob", "Wilson", 4, CustomerType.Current);
_repo = new CustomerRepository();
_repo.AddCustomer(customer1);
_repo.AddCustomer(customer2);
_repo.AddCustomer(customer3);
_repo.AddCustomer(customer4);
}
static void FeedDatabase(List <Customer> customers)
{
lock (_locker)
{
customers.ForEach(c => _repository.AddCustomer(c));
}
//wh.WaitOne();
//customers.ForEach(c => _repository.AddCustomer(c));
//wh.Set();
//customers.ForEach(c => _repository.AddCustomer(c));
//while (true)
//{
//if (customers[0].Id == 1)
//{
// customers.ForEach(c => _repository.AddCustomer(c));
// Thread.Sleep(300);//Imitation of lont time work
// _currentMax = customers.Last().Id;
// return;
//}
//if (customers[0].Id - 1 == _currentMax)
//{
// customers.ForEach(c => _repository.AddCustomer(c));
// //Thread.Sleep(300);//Imitation of lont time work
// _currentMax = customers.Last().Id;
// return;
//}
//wh.WaitOne();
//}
}
public ActionResult AddCustomer(Customer c)
{
var repo = new CustomerRepository();
repo.AddCustomer(c);
return(Redirect("/Customers/AllCustomers"));
}
public IActionResult CreateCustomer(AddCustomer newCustomer)
{
if (!ModelState.IsValid)
{
_eventLogger.LogInformation("Failed: Failed to add customer");
return(BadRequest(ModelState));
}
else
{
string concatinatedForValidation = newCustomer.FirstName + newCustomer.LastName + newCustomer.Gender + newCustomer.Email + newCustomer.Age;
if (concatinatedForValidation.Contains(","))
{
_eventLogger.LogInformation("Failed: Failed to add customer due to illegal character");
return(BadRequest($"Your data contains an illegal character (,)"));
}
else
{
var currentCustomers = GetCustomerList();
int newId = (currentCustomers.Count() + 1);
var customerToAdd = new Customer {
FirstName = CapitalizeFirstLetterAccordingToWritingRules(newCustomer.FirstName), LastName = CapitalizeFirstLetterAccordingToWritingRules(newCustomer.LastName), Gender = CapitalizeFirstLetterAccordingToWritingRules(newCustomer.Gender), Email = newCustomer.Email, Age = newCustomer.Age, DateCreated = DateTime.Now
};
customerRepository.AddCustomer(customerToAdd, databaseContext);
_eventLogger.LogInformation("Command: Created a new customer");
return(Ok($"Added {customerToAdd.FirstName} {customerToAdd.LastName}."));
}
}
}
private void DataLoadPool(object item)
{
int tryNumber = 0;
while (tryNumber < _settings.CountTries)
{
try
{
using DatabaseContext dbContext = new DatabaseContext(_settings);
CustomersPool cp = (CustomersPool)item;
CustomerRepository customerRepository = new CustomerRepository(dbContext);
foreach (Customer customer in cp.Customers)
{
customerRepository.AddCustomer(customer);
}
dbContext.SaveChanges();
AutoResetEvent autoResetEvent = (AutoResetEvent)cp.WaitHandle;
autoResetEvent.Set();
tryNumber = _settings.CountTries;
}
catch (Exception ex)
{
Console.WriteLine($"Try number {tryNumber + 1} for ManagedThreadId={Thread.CurrentThread.ManagedThreadId} has fail");
Console.WriteLine($"{ex.Message}");
tryNumber++;
}
}
}
public void AddCustomer_IntegrationTest()
{
CustomerRepository myCustomerRepo = new CustomerRepository();
List <Customer> myCustomers = new List <Customer>();
myCustomers = myCustomerRepo.GetAllCustomers();
Random myRandom = new Random();
var myRandomInt = myRandom.Next(1, myCustomers.Count);
Customer myNewCustomer = new Customer();
myNewCustomer.Id = myCustomers.Count() + 1;
myNewCustomer.FirstName = "Test";
myNewCustomer.MiddleName = "Demo";
myNewCustomer.LastName = "User" + myNewCustomer.Id;
myNewCustomer.Email = "test" + myNewCustomer.Id + "@email.com";
myNewCustomer.Phone = "1234567890";
myNewCustomer.Address = myNewCustomer.Id + " Some Test Adress";
bool result = myCustomerRepo.AddCustomer(myNewCustomer);
Customer myReturnCustomer = myCustomerRepo.GetCustomer(myNewCustomer.Id);
Assert.AreEqual(result, true);
Assert.IsNotNull(myReturnCustomer);
Assert.AreEqual(myNewCustomer.Id, myReturnCustomer.Id);
}
public ActionResult Payment(RegisterModel model, Order order)
{
if (ModelState.IsValid)
{
Customer customer = new Customer();
customer.Name = model.Name;
customer.LastName = model.LastName;
customer.DateOfBirth = model.DateOfBirth;
customer.EmailAddress = model.EmailAddres;
order = (Order)Session["Orders"];
order.OrderTime = DateTime.Now;
order.PaymentMethod = model.PaymentMethod.ToString();
if (customer != null && order != null)
{
FormsAuthentication.SetAuthCookie(customer.EmailAddress, false);
order.Paid = true;
customerRepository.AddCustomer(customer);
order.Customer_Id = customer.Id;
orderRepository.AddNewOrder(order);
return(RedirectToAction("Final", "Order"));
}
else
{
ModelState.AddModelError("register-error", "the username or password provided is incorrect");
}
}
return(View(model));
}
public void CRUD_CreateUpdateReadAndDeleteAnUser_CheckSuccess()
{
ICustomerRepository customerRepo = new CustomerRepository();
ICustomer toCreatedCustomer = GetCustomer();
customerRepo.AddCustomer(toCreatedCustomer);
ICustomer createdCustomer = GetCustomerByEmail(toCreatedCustomer);
var expectedWebsite = "www.lafi.ch";
createdCustomer.Website = expectedWebsite;
customerRepo.UpdateCustomer(createdCustomer);
ICustomer updatedCustomer = GetCustomerByEmail(createdCustomer);
var isDeleted = customerRepo.DeleteCustomer(updatedCustomer);
ICustomer deletedCustomer = GetCustomerByEmail(updatedCustomer);
Assert.AreEqual(toCreatedCustomer.Firstname, createdCustomer.Firstname);
Assert.AreEqual(expectedWebsite, updatedCustomer.Website);
Assert.IsTrue(isDeleted);
Assert.IsNull(deletedCustomer);
}
public IActionResult Create(CustomerViewModel model)
{
var mapModel = _mapper.Map <Customer>(model);
_customer.AddCustomer(mapModel);
return(RedirectToAction("Index"));
}
public void AddCustomerTest()
{
Customer customer5 = new Customer();
bool wasAdded = _repo.AddCustomer(customer5);
Assert.IsTrue(wasAdded);
}
static void AddCustomer(string firstName, string lastName, long bankId)
{
Customer customer = new Customer(firstName, lastName, bankId);
CustomerRepository customerRepository = new CustomerRepository();
customerRepository.AddCustomer(customer);
}
//creates a customer object, validates and saves to DB if it's valid
private void SaveCustomer(object sender, EventArgs e)
{
Customer customer = new Customer()
{
IsCompany = (bool)IsCompany.IsChecked,
ContactPerson = ContactPersonInput.Text,
CompanyName = CompanyNameInput.Text,
Address = AddressInput.Text,
PostalCode = PostalCodeInput.Text,
Area = AreaInput.Text,
DateOfBirth = DateOfBirthInput.SelectedDate,
Email = EmailInput.Text,
Phone = PhoneInput.Text,
WantsNewsletter = (bool)WantsNewsLetterInput.IsChecked,
Notes = NotesInput.Text
};
if (Validate(customer))
{
CustomerRepository.AddCustomer(customer);
_customers.Clear();
CustomerRepository.GetRecentCustomers().ForEach(x => _customers.Add(x));
ClearTextBoxes(RegistryWindow);
}
}
public IActionResult Create(AddCustomerCommand newCustomer)
{
var repo = new CustomerRepository();
newCustomer.FirebaseUid = UserId;
return(Ok(repo.AddCustomer(newCustomer)));
}
public ActionResult Test()
{
var customer = new Customer();
var equip = new CustEquip();
customer.CustomerID = 30;
customer.Name = "Barb Cena";
customer.Address = "3484 urhgieurhge";
customer.CellPhoneNum = "6666666666";
customer.Notes = "CATS ARE CATS ARE CATS";
equip.CustomerID = customer.CustomerID;
equip.ModelNum = "gerugheriug";
equip.Diagnostics = "diagnorteirhjg";
CustomerRepository.AddCustomer(customer);
var custs = CustomerRepository.GetCustomers();
return(Json(custs, JsonRequestBehavior.AllowGet));
}
public async Task <IActionResult> Post(CustomerDto dto)
{
try
{
if (dto == null)
{
_logger.LogError("Customer object sent from client is null.");
return(BadRequest("Customer object is null"));
}
if (!ModelState.IsValid)
{
_logger.LogError("Invalid Customer object sent from client.");
return(BadRequest("Invalid model object"));
}
bool customerExists = _repo.DoesCustomerAlreadyExists(dto);
if (!customerExists)
{
var result = await _repo.AddCustomer(dto);
return(CreatedAtRoute("GetCustomerById", new { id = result.Id }, dto));
}
else
{
return(StatusCode(200, $"customer already exists with the given First Name : {dto.FirstName} and Last Name : {dto.LastName}"));
}
}
catch (Exception ex)
{
_logger.LogError($"Something went wrong inside Add Customer action: {ex.Message}");
return(StatusCode(500, "Internal server error :" + ex.Message));
}
}
public ActionResult JQAjaxAddCustomerDB(CustomerMaster cm)
{
try
{
if (ModelState.IsValid)
{
CustomerRepository cmRepo = new CustomerRepository();
if (cmRepo.AddCustomer(cm))
{
return(Json(new
{
msg = "Successfully added " + cm.CompanyName
}));
//ViewBag.Message = "Customer details added successfully";
}
return(RedirectToAction("Index"));
}
else
{
return(View("Index"));
}
}
catch (Exception ex)
{
throw ex;
}
}
private void ButtonCreateCustomer_Click(object sender, RoutedEventArgs e)
{
Domain.Customer customer = new Domain.Customer();
WindowShowDialog wsd = new WindowShowDialog();
customer.CompanyName = TextBoxCompanyName.Text.ToString();
if (TextBoxCustomerAddress != null && TextBoxCustomerTelephone != null && TextBoxCustomerZip != null && TextBoxCustomerTelephone != null && TextBoxCustomerEmail != null)
{
customer.CompanyName = TextBoxCompanyName.Text;
customer.CustomerEmail = TextBoxCustomerEmail.Text;
customer.CustomerAddress = TextBoxCustomerAddress.Text;
customer.CustomerTelephone = TextBoxCustomerTelephone.Text;
customer.CustomerZip = TextBoxCustomerZip.Text;
customer.CustomerTown = TextBoxCustomerTown.Text;
customerRepository.AddCustomer(customer);
wsd.LabelShowDialog.Content = "Kunden blev tilføjet";
wsd.ShowDialog();
this.Close();
}
else
{
wsd.LabelShowDialog.Content = "Muligvis tommefelter";
wsd.ShowDialog();
}
}
static void CustomerRepo()
{
var _repository = new CustomerRepository();
var aCustomer = new Customer {
Name = "ABC Rentals"
};
var aRetrievedCustomer = _repository.GetCustomerByNameAsync(aCustomer.Name).Result;
if (aRetrievedCustomer == null)
{
var aKey = _repository.AddCustomer(aCustomer);
var aSavedCustomer = _repository.GetCustomer(aKey);
Console.WriteLine(aSavedCustomer.Id == aKey
? "Customer was saved and retrieved successfully!"
: $"Saved customer key was {aSavedCustomer.Id} and new customer key was {aKey}");
}
else
{
var aSavedCustomer = _repository.GetCustomer(aRetrievedCustomer.Id);
Console.WriteLine(aSavedCustomer.Id == aRetrievedCustomer.Id
? "Customer was already in the database and retrieved successfully!"
: $"Saved customer key was {aSavedCustomer.Id} and new customer key was {aRetrievedCustomer.Id}");
}
}
public async Task InsertNewCustomer()
{
//arrange
CustomerEntity cust = new CustomerEntity {
CustomerAge = 10,
CustomerId = Guid.NewGuid(),
CustomerIncome = 10000,
CustomerName = "Ritesh"
};
Mock <DbSet <CustomerEntity> > dbs = new Mock <DbSet <CustomerEntity> >();
Mock <CustomerDbContext> context = new Mock <CustomerDbContext>();
context.Setup(x => x.customers).Returns(dbs.Object);
//Act
ICustomerRepository _repo = new CustomerRepository(context.Object);
CustomerEntity custResult = await _repo.AddCustomer(cust);
//Assert
dbs.Verify(a => a.AddAsync(cust, CancellationToken.None), Times.Once);
context.Verify(b => b.SaveChangesAsync(CancellationToken.None), Times.Once);
Assert.Equal(10, custResult.CustomerAge);
await Task.CompletedTask;
}
public ActionResult AddCustomer(Customer customer)
{
bool success = true;
CustomerRepository.AddCustomer(customer);
return(Json(success, JsonRequestBehavior.AllowGet));
}
public void TestCreateCustomer()
{
CustomerRepository c = new CustomerRepository();
Customer cust = c.CreateCustomer(1, "test", "testaddress", "1234", "testtown", "12344567");
c.AddCustomer(cust);
Assert.AreEqual(cust, c.GetCustomer("1"));
}
public Customer WriteToDb(Customer addCustomer)
{
CustomerRepository repo = new CustomerRepository();
var newestCustomerId = repo.AddCustomer(addCustomer);
return(repo.GetCustomerById(newestCustomerId));
//IsComplete = true; // Seems a little hacky, but I have to do this to break out of the while look.
}
//[ValidateAntiForgeryToken]
public ActionResult Create_customer([Bind] Customer cust)
{
if (ModelState.IsValid)
{
objCustomer.AddCustomer(cust);
return(RedirectToAction("Index"));
}
return(View(objCustomer));
}
public void TestAddCustomer_PassNull_ShouldThrowArgumentNullException()
{
var dbSetMock = new Mock<DbSet<Customer>>();
var mockedContext = new Mock<NorthwindEntities>();
mockedContext.SetupGet(x => x.Customers).Returns(dbSetMock.Object);
var repository = new CustomerRepository(mockedContext.Object);
Assert.Throws<ArgumentNullException>(() => repository.AddCustomer(null));
}
public void TestAddCustomer_PassValidCustomer_ShouldAddToCollection()
{
var dbSetMock = new Mock<DbSet<Customer>>();
var mockedContext = new Mock<NorthwindEntities>();
mockedContext.SetupGet(x => x.Customers).Returns(dbSetMock.Object);
var repository = new CustomerRepository(mockedContext.Object);
var customer = new Mock<Customer>().Object;
repository.AddCustomer(customer);
mockedContext.Verify(x => x.Customers, Times.Once);
}
