public ActionResult Create(Customer entry)
{
bool hasPermissions = sectionRpstry.GetPermission(sectionName, loggedUser.UserId, canCreate);
if (hasPermissions)
{
try
{
entry.dateCreated = DateTime.Now;
entry.dateModified = DateTime.Now;
entry.priority = rpstry.GetMaxPriority() + 1;
rpstry.Add(entry);
rpstry.Save();
var customerServicesArray = !string.IsNullOrEmpty(Request["CustomerServices"]) ? Request["CustomerServices"].ToString().Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries) : new string[0];
rpstry.ManageServices(entry, customerServicesArray);
return(RedirectToAction("Index", new { thisid = entry.id }));
}
catch (Exception e)
{
ViewBag.Types = new SelectList(rpstryType.GetAll(), "id", "name");
ModelState.AddModelError("", "");
return(View("details", entry));
}
}
else
{
return(View("Error", "You do not have Orders to access this section."));
}
}
public void Delete_Should_Delete_The_Customer_And_Should_Return_All_Count_As_One()
{
var customer1 = new Domain.Customer("Caner Tosuner", "IST", DateTime.Today.AddYears(28));
var customer2 = new Domain.Customer("Caner Tosuner", "IST", DateTime.Today.AddYears(28));
var options = new DbContextOptionsBuilder <CustomerDbContext>()
.UseInMemoryDatabase("customer_db")
.Options;
using (var context = new CustomerDbContext(options))
{
var repository = new CustomerRepository(context);
repository.Save(customer1);
repository.Save(customer2);
context.SaveChanges();
}
using (var context = new CustomerDbContext(options))
{
var repository = new CustomerRepository(context);
repository.Delete(customer1.Id);
context.SaveChanges();
}
using (var context = new CustomerDbContext(options))
{
var repository = new CustomerRepository(context);
repository.All().Count().Should().Be(1);
}
}
public void Find_Should_Fid_The_Customer_And_Should_Return_All_Count_As_One()
{
var customer1 = new Domain.Customer("Caner Tosuner", "IST", DateTime.Today.AddYears(28));
var customer2 = new Domain.Customer("Caner Tosuner", "IZM", DateTime.Today.AddYears(28));
var options = new DbContextOptionsBuilder <CustomerDbContext>()
.UseInMemoryDatabase("customer_db")
.Options;
using (var context = new CustomerDbContext(options))
{
var repository = new CustomerRepository(context);
repository.Save(customer1);
repository.Save(customer2);
context.SaveChanges();
}
using (var context = new CustomerDbContext(options))
{
var repository = new CustomerRepository(context);
var result = repository.Find(c => c.CityCode == customer1.CityCode);
result.Should().NotBeNull();
result.Count().Should().Be(1);
}
}
public ActionResult UpdateCart(string Operator, int Id)
{
var userId = Convert.ToInt32(Session["UserId"]);
//var filterCart = db.Carts.Where(c => c.FoodId == Id && c.UserId == userId).SingleOrDefault();
//var filterFood = db.Food.Where(f => f.FoodId == Id).SingleOrDefault();
var filterCart = customerRepo.CheckCart(userId, Id);
var filterFood = customerRepo.CheckFood(Id);
if (Operator == "+")
{
filterCart.FoodQuantity++;
filterCart.TotalAmount = filterCart.FoodQuantity * filterFood.FoodPrice;
//db.SaveChanges();
customerRepo.Save();
return(Json(JsonRequestBehavior.AllowGet));
}
else
{
if (filterCart.FoodQuantity == 1)
{
filterCart.FoodQuantity = 1;
}
else
{
filterCart.FoodQuantity--;
filterCart.TotalAmount = filterCart.FoodQuantity * filterFood.FoodPrice;
//db.SaveChanges();
customerRepo.Save();
}
return(Json(JsonRequestBehavior.AllowGet));
}
}
public void can_select_all_customers()
{
CustomerRepository <Custommer <int>, int> cr = new CustomerRepository <Custommer <int>, int>();
Custommer <int> customer1 = new Custommer <int>();
customer1.Id = 1;
cr.Save(customer1);
Custommer <int> customer2 = new Custommer <int>();
customer2.Id = 2;
cr.Save(customer2);
Custommer <int> customer3 = new Custommer <int>();
customer3.Id = 3;
cr.Save(customer3);
int count = 0;
foreach (var item in cr.GetAll())
{
count++;
}
Assert.IsTrue(count == 3, "The respository does not return all customers");
}
public void DeleteCustomer_AddTwoCustomerAndDeleteOne_ReturnCustomersCountAsOne()
{
var customer1 = new Domain.Customer("ali", "ist", DateTime.Today.AddYears(-30));
var customer2 = new Domain.Customer("veli", "ank", DateTime.Today.AddYears(-25));
var options = CreateNewContextOptions();
using (var context = new CustomerDbContext(options))
{
var repository = new CustomerRepository(context);
repository.Save(customer1);
repository.Save(customer2);
context.SaveChanges();
}
using (var context = new CustomerDbContext(options))
{
var repository = new CustomerRepository(context);
var customerToBeDelete = repository.All().First();
repository.Delete(customerToBeDelete.Id);
context.SaveChanges();
}
using (var context = new CustomerDbContext(options))
{
var repository = new CustomerRepository(context);
var customerCount = repository.All().Count();
customerCount.Should().Be(1);
}
}
public void It_should_update_and_insert()
{
// Given
var repo = new CustomerRepository(Config.ConnectionString);
var customer = RandomCustomer();
repo.Save(customer);
// When
customer.Name = RandomString();
customer.Orders.Add(new Order
{
Id = Guid.NewGuid(),
CreatedAt = DateTimeOffset.UtcNow,
Items = new List <OrderItem>
{
new OrderItem
{
Id = Guid.NewGuid(),
Product = RandomString(),
Cost = RandomInt()
}
}
});
repo.Save(customer);
// Then
var actual = repo.Load(customer.Id);
actual.Should().BeEquivalentTo(customer, Options);
}
public void FindCustomer_ByCityCode_ReturnValidCustomer()
{
var customer1 = new Domain.Customer("ali", "ist", DateTime.Today.AddYears(-30));
var customer2 = new Domain.Customer("veli", "ank", DateTime.Today.AddYears(-25));
var options = CreateNewContextOptions();
using (var context = new CustomerDbContext(options))
{
var repository = new CustomerRepository(context);
repository.Save(customer1);
repository.Save(customer2);
context.SaveChanges();
}
using (var context = new CustomerDbContext(options))
{
var repository = new CustomerRepository(context);
var customers = repository.Find(c => c.CityCode == "ist");
customers.Should().NotBeNull();
customers.Count().Should().Be(1);
}
}
public void GetByNameWorks()
{
List <Customers> inserted = new List <Customers>();
string name = "Test";
string nameWrong = "Name";
int id = 0;
// arrange (use the context directly - we assume that works)
var options = new DbContextOptionsBuilder <Project1Context>()
.UseInMemoryDatabase("db_customer_test_getByName_List").Options;
using (var db = new Project1Context(options));
// act (for act, only use the repo, to test it)
using (var db = new Project1Context(options))
{
var repo = new CustomerRepository(db);
Customers customer = new Customers {
FirstName = "First Test", LastName = "Last"
};
repo.Save(customer);
inserted.Add(customer);
customer = new Customers {
FirstName = "First", LastName = "Last Test"
};
repo.Save(customer);
inserted.Add(customer);
customer = new Customers {
FirstName = "First Name", LastName = "Last Name"
};
repo.Save(customer);
inserted.Add(customer);
repo.SaveChanges();
}
// assert (for assert, once again use the context directly for verify.)
using (var db = new Project1Context(options))
{
var repo = new CustomerRepository(db);
List <Customers> list = (List <Customers>)repo.GetByName(name);
Assert.Equal(2, list.Count);
foreach (Customers customer in list)
{
Assert.NotEqual(0, customer.Id);
Assert.DoesNotContain(nameWrong, customer.FirstName);
Assert.DoesNotContain(nameWrong, customer.LastName);
//Assert if the string searched is contained in FirstName OR LastName
bool contains = customer.FirstName.Contains(name) || customer.LastName.Contains(name);
Assert.True(contains);
}
}
}
public async Task <IActionResult> Create([Bind("CustomerId,FullName,Username,Password")] Customers customers)
{
if (ModelState.IsValid)
{
custRepo.Add(customers);
custRepo.Save();
return(RedirectToAction(nameof(Index)));
}
return(View(customers));
}
public void Add(CustomerViewModels client)
{
Customer customer = new Customer();
customer.Customer_ID = Guid.NewGuid();
Repository.Add(Mapper.ModelToData(customer, client));
Repository.Save();
}
public ActionResult <int> AddCustomer(Customer customer)
{
_customerRepository.Add(customer);
var result = _customerRepository.Save();
if (result == 0)
{
return(StatusCode(500));
}
return(new OkObjectResult(customer.Id));
}
public void AddCustomer(CustomerDTO customerDTO)
{
Customer customer = _mapper.Mapper().Map <Customer>(customerDTO);
customer.IsDeleted = false;
customer.CityId = customerDTO.CityDTOId;
customer.City = _cityRepository.GetById(customer.CityId);
_customerRepository.InsertEntity(customer);
_customerRepository.Save();
}
public Customer Create(Customer toCreate)
{
try {
rep.Create(toCreate);
rep.Save();
return(toCreate);
}
catch (Exception) {
return(null);
}
}
public IActionResult Create(Customer customer)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
db.Create(customer);
db.Save();
return(Ok(customer));
}
public IHttpActionResult InsertCustomerToList([FromBody] Customer customer)
{
Customer addCustomer = custRepositoryObj.InsertCustomer(customer);
custRepositoryObj.Save();
try
{
return(Ok("Customer Added Successfully"));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public void GetByIdWorks()
{
int id = 0;
// arrange (use the context directly - we assume that works)
var options = new DbContextOptionsBuilder <Project1Context>()
.UseInMemoryDatabase("db_customer_test_getById").Options;
using (var db = new Project1Context(options));
// act (for act, only use the repo, to test it)
using (var db = new Project1Context(options))
{
var repo = new CustomerRepository(db);
Customers customer = new Customers {
FirstName = "First Name", LastName = "Last Name"
};
repo.Save(customer);
repo.SaveChanges();
id = customer.Id;
}
// assert (for assert, once again use the context directly for verify.)
using (var db = new Project1Context(options))
{
var repo = new CustomerRepository(db);
Customers customer = (Customers)repo.GetById(id);
Assert.Equal("First Name", customer.FirstName);
Assert.Equal("Last Name", customer.LastName);
Assert.NotEqual(0, customer.Id); // should get some generated ID
}
}
public void GetAllAddress()
{
List <Addresses> listAddresses = new List <Addresses>();
// arrange (use the context directly - we assume that works)
var options = new DbContextOptionsBuilder <Project1Context>()
.UseInMemoryDatabase("db_customer_test_create_address").Options;
using (var db = new Project1Context(options));
// act (for act, only use the repo, to test it)
using (var db = new Project1Context(options))
{
var repo = new CustomerRepository(db);
Customers customer = new Customers {
FirstName = "First Name", LastName = "Last Name"
};
Addresses address = new Addresses {
CustomerId = customer.Id, Address1 = "Address 1", City = "City 1", State = "S1", Zipcode = 12345
};
customer.Addresses.Add(address);
listAddresses.Add(address);
address = new Addresses {
CustomerId = customer.Id, Address1 = "Address 2", City = "City 2", State = "S2", Zipcode = 12345
};
customer.Addresses.Add(address);
listAddresses.Add(address);
address = new Addresses {
CustomerId = customer.Id, Address1 = "Address 3", City = "City 3", State = "S3", Zipcode = 12345
};
customer.Addresses.Add(address);
listAddresses.Add(address);
repo.Save(customer);
repo.SaveChanges();
}
// assert (for assert, once again use the context directly for verify.)
using (var db = new Project1Context(options))
{
Customers customer = db.Customers.Include(m => m.Addresses).First(m => m.FirstName == "First Name" && m.LastName == "Last Name");
List <Addresses> addresses = customer.Addresses.ToList();
Assert.Equal(listAddresses.Count, addresses.Count);
for (int i = 0; i < addresses.Count; i++)
{
Assert.NotEqual(0, addresses[i].Id);
Assert.Equal(customer.Id, addresses[i].CustomerId);
Assert.Equal(listAddresses[i].Address1, addresses[i].Address1);
Assert.Equal(listAddresses[i].Address2, addresses[i].Address2);
Assert.Equal(listAddresses[i].City, addresses[i].City);
Assert.Equal(listAddresses[i].State, addresses[i].State);
Assert.Equal(listAddresses[i].Zipcode, addresses[i].Zipcode);
}
}
}
public void Save_DoesNotHaveChanges_ReturnsTrue()
{
var customer = new Customer(1)
{
FirstName = "Test First",
LastName = "Test Last",
EmailAddress = "*****@*****.**",
AddressList = new List <Address>()
{
new Address()
{
StreetLine1 = "1233 Street",
AddressType = "Work",
City = "Houston",
State = "Texas",
Country = "US",
PostalCode = "99999"
}
}
};
var customerRepository = new CustomerRepository();
var expected = true;
var actual = customerRepository.Save(customer);
Assert.AreEqual(expected, actual);
}
public void generateData()
{
using (ICustomerRepository _repo = new CustomerRepository(ApplicationDbContext.Create()))
{
_repo.Insert(new Customer()
{
Company = "It-Minds",
Address = "Trommesalen 5",
Email = "*****@*****.**",
PhoneNumber = "11111111",
Tasks = "test",
ContactPerson = "Mads"
});
_repo.Save();
}
using (IEmployeeRepository _empolyeeRepo = new EmployeeRepository(ApplicationDbContext.Create()))
{
_empolyeeRepo.Insert(new Employee()
{
Name = "Mads",
Address = "Mågevej 46",
Email = "*****@*****.**",
PhoneNumber = "22222222"
});
_empolyeeRepo.Save();
}
}
public void SaveCustomer_ValidParameters_EqualProps()
{
var customer = new Domain.Customer("Celalettin Altıntaş", "IST", DateTime.Today.AddYears(-1));
var options = CreateNewContextOptions();
Guid newCustomerId;
using (var context = new CustomerDbContext(options))
{
var repository = new CustomerRepository(context);
newCustomerId = repository.Save(customer);
context.SaveChanges();
}
Domain.Customer insertedCustomer;
using (var context = new CustomerDbContext(options))
{
var repository = new CustomerRepository(context);
insertedCustomer = repository.Get(newCustomerId);
}
Assert.Equal(customer.FullName, insertedCustomer.FullName);
Assert.Equal(customer.CityCode, insertedCustomer.CityCode);
Assert.Equal(customer.BirthDate, insertedCustomer.BirthDate);
}
static void Main(string[] args)
{
Console.WriteLine("CRM Example!");
//create Customer
Customer c1 = new Customer(1);
CustomerRepository cr = new CustomerRepository();
//Add Customer
cr.Save(c1);
//Customer Information
Customer c2 = cr.Retrieve(1);
Console.WriteLine(c2.CustomerId + " " + c2.EmailAddress + " Fullname:+" + c2.FullName);
//Address Information
AddressRepository ad = new AddressRepository();
var addresslist = new List <Address>();
int id = c2.CustomerId;
//addresslist = ad.RetrieveByCustomerId(id);
//Order History
/* OrderRepository or = new OrderRepository();
* OrderDisplay od = or.RetrieveOrderDisplay(10);
* Console.WriteLine(od.FirstName + " " + od.LastName);
*/
OrderRepository o = new OrderRepository();
Order o1 = o.Retrieve(10);
Console.WriteLine(o1.OrderDate);
}
public HttpResponseMessage Create(CreateCustomerModel model)
{
try
{
ValidateName(model.Name);
ValidateEmail(model.PrimaryEmail, "Primary email");
if (model.SecondaryEmail != null)
{
ValidateEmail(model.SecondaryEmail, "Secondary email");
}
Industry industry = _industryRepository.GetByName(model.Industry);
if (industry == null)
{
throw new BusinessException("Industry name is invalid: " + model.Industry);
}
var customer = new Customer(model.Name, model.PrimaryEmail, model.SecondaryEmail, industry);
_customerRepository.Save(customer);
_unitOfWork.Commit();
return(Request.CreateResponse(HttpStatusCode.OK, Envelope.Ok()));
}
catch (BusinessException ex)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, Envelope.Error(ex.Message)));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, Envelope.Error(ex.Message)));
}
}
public void Update_Should_Update_The_Customer()
{
var customer = new Domain.Customer("Caner Tosuner", "IST", DateTime.Today.AddYears(28));
var options = new DbContextOptionsBuilder <CustomerDbContext>()
.UseInMemoryDatabase("customer_db")
.Options;
using (var context = new CustomerDbContext(options))
{
var repository = new CustomerRepository(context);
repository.Save(customer);
context.SaveChanges();
}
customer.SetFields("Caner T", "IZM", customer.BirthDate);
using (var context = new CustomerDbContext(options))
{
var repository = new CustomerRepository(context);
repository.Update(customer);
context.SaveChanges();
}
using (var context = new CustomerDbContext(options))
{
var repository = new CustomerRepository(context);
var result = repository.Get(customer.Id);
result.Should().NotBe(null);
result.FullName.Should().Be(customer.FullName);
result.CityCode.Should().Be(customer.CityCode);
result.BirthDate.Should().Be(customer.BirthDate);
}
}
//[ExpectedException(
public void TestNoKey()
{
ICustomerRepository repository = new CustomerRepository(_dbContext);
var bip = new Customer(_validator);
bip.CustomerId = 10;
bip.CustomerId = 20;
var customer = CreateCustomer(repository);
_dbContext.Customers.Attach(bip);
bip.CustomerId = 30;
Debug.WriteLine(_dbContext.Entry(bip).State);
var newContext = new EntityContext();
var repository2 = new CustomerRepository(newContext);
Debug.WriteLine(newContext.Entry(customer).State);
customer.Address = "555";
Debug.WriteLine(newContext.Entry(customer).State);
//newContext.Entry(customer).State = System.Data.EntityState.Modified;
Debug.WriteLine(newContext.Entry(customer).State);
newContext.Customers.Attach(customer);
customer.CustomerId = 0;
newContext.SaveChanges();
repository2.Update(customer);
repository2.Save();
customer.Address = "556";
Debug.WriteLine(newContext.Entry(customer).State);
}
public async Task <IActionResult> Registration(RegistrationViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = _userRepository.Get(model.Login);
if (user != null)
{
ModelState.AddModelError(nameof(RegistrationViewModel.Login),
"Пользователь с таким именем уже существует");
return(View(model));
}
//Готов регистрировать
var newUser = _mapper.Map <User>(model);
_userRepository.Save(newUser);
await HttpContext.SignInAsync(_userService.GetPrincipal(newUser));
var company = _companyRepository.Get(model.Company) ?? new Company {
Name = model.Company
};
var newCustomer = new Customer {
Profile = newUser, Company = company
};
_customerRepository.Save(newCustomer);
return(RedirectToAction("Profile", "Customer"));
}
public void SaveWithAddressValidTest()
{
//Arrange
var addressRepository = new AddressRepository();
var customerRepository = new CustomerRepository(addressRepository);
var address = new Address()
{
StreetLine1 = "Awesome 5 street", City = "Awesome Town", StateOrRegion = "AS", Country = "United Satetes of Awesomeness", Code = "12492", Type = AddressType.Home
};
addressRepository.Save(address);
var customer = new Customer()
{
FirstName = "Volodymyr", LastName = "Yablonskyi", Email = "*****@*****.**"
};
customer.Addresses.Add(address);
//Act
var result = customerRepository.Save(customer);
//Assert
Assert.True(result);
}
public void GetAllAddressWithNoAddressShouldReturnNull()
{
// arrange (use the context directly - we assume that works)
var options = new DbContextOptionsBuilder <Project1Context>()
.UseInMemoryDatabase("db_customer_test_create_address_2").Options;
using (var db = new Project1Context(options));
// act (for act, only use the repo, to test it)
using (var db = new Project1Context(options))
{
var repo = new CustomerRepository(db);
Customers customer = new Customers {
FirstName = "First Name", LastName = "Last Name"
};
repo.Save(customer);
repo.SaveChanges();
}
// assert (for assert, once again use the context directly for verify.)
using (var db = new Project1Context(options))
{
Customers customer = db.Customers.Include(m => m.Addresses).First(m => m.FirstName == "First Name" && m.LastName == "Last Name");
List <Addresses> addresses = customer.Addresses.ToList();
Assert.Empty(addresses);
}
}
public void InsertAndLoadCustomer()
{
//Add to context just to show its state prior to save
Customer customerNew = new Customer(_validator);
customerNew.FirstName = "Mary";
customerNew.LastName = "Doe";
_dbContext.Customers.Attach(customerNew);
//State is 'unchanged' no errors raised by simply adding it.
Debug.WriteLine(_dbContext.Entry(customerNew).State);
//Insert via repository
ICustomerRepository repository = new CustomerRepository(_dbContext);
//creates and saves it
var customer = CreateCustomer(repository);
//Get its state from the context - should be unchanged (as its saved)
Debug.WriteLine(_dbContext.Entry(customer).State);
//Saving again does nothing to the database (see profiler)
repository.Update(customer);
repository.Save();
//update the first name.
customer.FirstName = "John";
//Get its state from the context
Debug.WriteLine(_dbContext.Entry(customer).State);
//saving again notice only the first name is updated.
repository.Update(customer);
repository.Save();
Customer insertCustomer = new Customer(_validator);
insertCustomer.FirstName = "Jane";
insertCustomer.LastName = "Doe";
insertCustomer.Address = "555 main st";
insertCustomer.City = "Orlando";
insertCustomer.Zip = "33400";
insertCustomer.State = "FL";
Debug.WriteLine(insertCustomer.CustomerId);
_dbContext.Customers.Add(insertCustomer);
Debug.WriteLine(_dbContext.Entry(insertCustomer).State);
_dbContext.SaveChanges();
//Note the primary key is automatically updated.
Debug.WriteLine(insertCustomer.CustomerId);
Debug.WriteLine(_dbContext.Entry(insertCustomer).State);
}
/// Save Customer details in database
/// </summary>
/// <param name="shopSettingDetails">Customer object to be saved</param>
/// <returns>returns integer value as identity value for the new customer record entered in database</returns>
/// <summary>
int ICustomerService.SaveCustomerDetail(CustomerDTO customerDetails)
{
customer customerEntity = new customer();
ObjectMapper.Map(customerDetails, customerEntity);
CustomerRepository.Save(customerEntity);
return(customerEntity.id);
}
public static void Wrong()
{
var repository = new CustomerRepository();
Customer customer = new Customer()
{
Name = "Michael L Perry",
PhoneNumber = "222-9999"
};
repository.Save(customer);
}
public static void Right()
{
var repository = new CustomerRepository();
Customer customer = new Customer()
{
Name = "Michael L Perry",
PhoneNumber = "(214) 222-9999"
};
if (!customer.Validate())
Console.WriteLine("Invalid customer");
else
repository.Save(customer);
}
public void Should_Use_Two_Transactions_In_One_TransactionScope()
{
string test_name = Guid.NewGuid().ToString();
using (IUnitOfWork unitOfWork = new UnitOfWork(Singleton.SessionFactoryProvider))
{
ICustomerRepository customerRepository = new CustomerRepository(unitOfWork);
var customer = customerRepository.AsQueryable(f => f.Name == test_name).FirstOrDefault();
Assert.IsNull(customer);
}
using (new TransactionScope(TransactionScopeOption.Required))
{
using (IUnitOfWork unitOfWork = new UnitOfWork(Singleton.SessionFactoryProvider))
{
unitOfWork.BeginTransaction();
ICustomerRepository customerRepository = new CustomerRepository(unitOfWork);
customerRepository.Save(
new Customer
{
Code = "test_code",
Name = test_name,
Type = CustomerType.LoyalCustomers,
CreatedOn = DateTime.Now,
DeletedOn = null
});
unitOfWork.Commit();
}
using (IUnitOfWork unitOfWork = new UnitOfWork(Singleton.SessionFactoryProvider))
{
unitOfWork.BeginTransaction();
ICustomerRepository customerRepository = new CustomerRepository(unitOfWork);
var customer = customerRepository.AsQueryable(f => f.Name == test_name).FirstOrDefault();
Assert.IsNotNull(customer);
unitOfWork.Commit();
}
}
}
public void Save_Customer_Succeed()
{
using (var context = new ManagementContext())
{
//Arrange
var customer = context.Customers.First();
customer.Name = "Cliente modificado";
var unitOfWork = new DatabaseUnitOfWork(context);
var customerRepository = new CustomerRepository(unitOfWork);
//Act
customerRepository.Save(customer);
unitOfWork.Save();
//Assert
Assert.Pass();
}
}
public void Save_NewCustomer_Succeed()
{
using (var context = new ManagementContext())
{
//Arrange
var customer = new Customer()
{
Name = "Nuevo cliente"
};
var unitOfWork = new DatabaseUnitOfWork(context);
var customerRepository = new CustomerRepository(unitOfWork);
//Act
customerRepository.Save(customer);
unitOfWork.Save();
//Assert
Assert.Pass();
}
}
private void CreateCustomer(string name)
{
using (IUnitOfWork unitOfWork = new UnitOfWork(Singleton.SessionFactoryProvider))
{
unitOfWork.BeginTransaction();
ICustomerRepository customerRepository = new CustomerRepository(unitOfWork);
customerRepository.Save(
new Customer
{
Code = "test_code",
Name = name,
Type = CustomerType.LoyalCustomers,
CreatedOn = DateTime.Now,
DeletedOn = null
});
unitOfWork.Commit();
}
}
/// <summary>
/// Process Order
/// </summary>
/// <param name="customerId"></param>
/// <param name="salesOrderId"></param>
public void ProcessOrder(Guid customerId, Guid salesOrderId)
{
var customerRepository = new CustomerRepository();
var salesOrderRepository = new SalesOrderRepository();
// Get the Sales Order
logger.WriteLine("Get SalesOrder ID={0}", salesOrderId);
var salesOrder = salesOrderRepository.GetById(salesOrderId);
// Get the Current Customer
logger.WriteLine("Get Customer ID={0}", customerId);
var currentCustomer = customerRepository.GetById(customerId);
// Business Rules
if(currentCustomer.CreditScore < 500)
{
logger.WriteLine("RequestApprovalForLowCreditScore");
salesOrder.Status = SalesOrderStatus.Pending;
emailServer.Send(currentCustomer.ApprovalManagerEmail, "Request Approval for low credit score");
}
else if( salesOrder.Total >= 1000D )
{
logger.WriteLine("RequestApprovalForLargeOrder");
salesOrder.Status = SalesOrderStatus.LargeOrder;
emailServer.Send(currentCustomer.ApprovalManagerEmail, "Request Approval for large order");
}
else
{
logger.WriteLine("CompleteOrder");
salesOrder.Status = SalesOrderStatus.Completed;
emailServer.Send(currentCustomer.EmailAddress, "Your order has been shipped");
}
// Save the sales order and customer
customerRepository.Save(currentCustomer);
salesOrderRepository.Save(salesOrder);
}