public void CreateCustomer(Customer customer)
        {
            using (TransactionScope scope = new TransactionScope())
            {
                try
                {
                    Log.Info($"Criando um novo usuário com o CPF {customer.CPF}");

                    if (this.ExistsCustomer(customer))
                        throw new Exception($"CPF {customer.CPF} já cadastrado");

                    var userId = Guid.NewGuid();
                    customer.Id = userId;
                    customer.Password = Infra.Utils.SecurityUtils.HashSHA1(customer.Password);

                    this.customerRepository.Save(customer);

                    if (!this.Login(customer.Email, customer.Password, true, false))
                        throw new Exception("Usuário não cadastrado, por favor tente mais tarde");

                }
                catch (Exception ex)
                {
                    Log.Error(ex.Message, ex);
                    this.LogOut();
                    throw;
                }
                finally
                {
                    Log.Info($"Finalizando a criação de um novo usuário com o CPF {customer.CPF}");
                    scope.Complete();
                }
            }
        }

 private void ShowCustomerDetails(Customer customer)
 {
     hidCustomerID.Value = customer.ID;
     lblCustomerID.Text = customer.ID;
     txtCompanyName.Text = customer.CompanyName;
     txtContactName.Text = customer.ContactName;
 }

 public void Serialize(SerializedData data, Customer customer)
 {
     foreach (var formatter in _formatters)
     {
         formatter.Serialize(data, customer);
     }
 }

        public void InsertCustomer(Customer customer)
        {
            using (SqlConnection conn = CreateConnection())
            {
                try
                {
                    SqlCommand cmd = new SqlCommand("dbo.usp_createKund",conn);
                    cmd.CommandType = System.Data.CommandType.StoredProcedure;

                    cmd.Parameters.Add("@Personnummer",SqlDbType.VarChar, 15).Value = customer.PersonalNumber;
                    cmd.Parameters.Add("@Förnamn",SqlDbType.VarChar,15).Value = customer.FirstName;
                    cmd.Parameters.Add("@Efternamn",SqlDbType.VarChar,40).Value = customer.LastName;
                    cmd.Parameters.Add("@Adress",SqlDbType.VarChar,6).Value = customer.PostalCode;
                    cmd.Parameters.Add("@Ort",SqlDbType.VarChar,20).Value = customer.Town;
                    cmd.Parameters.Add("@Epost",SqlDbType.VarChar,30).Value = customer.Email;

                    cmd.Parameters.Add("@KundID",SqlDbType.Int,4).Direction = ParameterDirection.Output;
                    conn.Open();
                    cmd.ExecuteNonQuery();
                    customer.CustomerID = (int)cmd.Parameters["@KundID"].Value;
                }
                catch
                {
                    throw new ApplicationException("Något gick fel när du försökte lägga till en ny kund");
                }
            }
        }

 //Update
 public static void Update(Customer customer, string lastName, string firstName, string telephone, string emailAddress)
 {
     customer.FirstName = firstName;
     customer.LastName = lastName;
     customer.TelephoneNumber = telephone;
     customer.EmailAddress = emailAddress;
 }

        public void RegisterCustomer(string name, CustomerType customerType)
        {            
            try
            {
                using (var transaction = new TransactionScope())
                {
                    Customer customer = new Customer();
                    customer.Name = name;
                    customer.Type = customerType;

                    customer.Agreements.Add(
                        new Agreement
                            {
                                Number = agreementManagementService.GenerateAgreementNumber(),
                                CreatedOn = DateTime.Now,
                                Customer = customer
                            });

                    repository.Save(customer);
                    repository.Commit();

                    transaction.Complete();
                }
            }
            catch (Exception ex)
            {                
                throw new RegistrationException(string.Format("Failed to register customer with name '{0}' and type {1}.", name, customerType), ex);
            }                                
        }

 public ActionResult Create(Customer cs, FormCollection collection)
 {
     IFormatProvider iFP = new System.Globalization.CultureInfo("vi-VN", true);
     cs.CreateDate = DateTime.Parse(collection["CreateDate"], iFP);
     var result = CustomerBusiness.Insert(cs);
     return PartialView(cs);
 }

 protected Account(Customer customer, decimal balance, decimal interestRate, uint validityInMonths = 6)
 {
     this.Customer = customer;
     this.Balance = balance;
     this.InterestRate = interestRate;
     this.ValidityInMonths = validityInMonths;
 }

        public void Should_Return_The_Last_Inserted_Ids()
        {
            // Arrange
            const string sql = @"
CREATE TABLE IF NOT EXISTS Customer
(
    CustomerId      INTEGER         NOT NULL    PRIMARY KEY     AUTOINCREMENT,
    FirstName       NVARCHAR(120)   NOT NULL,
    LastName        NVARCHAR(120)   NOT NULL,
    DateOfBirth     DATETIME        NOT NULL
);";
            var dbConnection = Sequelocity.CreateDbConnection( ConnectionStringsNames.SqliteInMemoryDatabaseConnectionString );

            new DatabaseCommand( dbConnection )
                .SetCommandText( sql )
                .ExecuteNonQuery( true );

            var customer1 = new Customer { FirstName = "Clark", LastName = "Kent", DateOfBirth = DateTime.Parse( "06/18/1938" ) };
            var customer2 = new Customer { FirstName = "Bruce", LastName = "Wayne", DateOfBirth = DateTime.Parse( "05/27/1939" ) };
            var customer3 = new Customer { FirstName = "Peter", LastName = "Parker", DateOfBirth = DateTime.Parse( "08/18/1962" ) };
            var list = new List<Customer> { customer1, customer2, customer3 };
            
            // Act
            var customerIds = new DatabaseCommand( dbConnection )
                .GenerateInsertsForSQLite( list )
                .ExecuteToList<long>();

            // Assert
            Assert.That( customerIds.Count == 3 );
            Assert.That( customerIds[0] == 1 );
            Assert.That( customerIds[1] == 2 );
            Assert.That( customerIds[2] == 3 );
        }

    static void Main()
    {
        Customer examplePerson = new Customer("Example Person", CustomerType.Individual);
        Customer exampleCompany = new Customer("Example Company", CustomerType.Company);

        DepositAccount deposit = new DepositAccount(examplePerson, 1200, (decimal)0.02);
        int period = 2;
        Console.WriteLine("Interest for: {0}, account type: {1}, balance: {2}, period: {3} months, interest rate: {4}%\n{5}%",
            deposit.Customer, deposit.GetType(), deposit.Balance, period, deposit.IntrestRate, deposit.CalcInterestAmount(period));

        deposit.Withdraw(300);
        Console.WriteLine("Interest for: {0}, account type: {1}, balance: {2}, period: {3} months, interest rate: {4}%\n{5}%",
            deposit.Customer, deposit.GetType(), deposit.Balance, period, deposit.IntrestRate, deposit.CalcInterestAmount(period));

        deposit.Deposit(1000);
        Console.WriteLine("Test depositing money balance: {0}", deposit.Balance);

        period = 3;
        Loan loan = new Loan(examplePerson, 1200, (decimal)0.02);
        Console.WriteLine("Interest for: {0}, account type: {1}, balance: {2}, period: {3} months, interest rate: {4}%\n{5}%",
            loan.Customer, loan.GetType(), loan.Balance, period, loan.IntrestRate, loan.CalcInterestAmount(period));

        period = 4;
        Console.WriteLine("Interest for: {0}, account type: {1}, balance: {2}, period: {3} months, interest rate: {4}%\n{5}%",
            loan.Customer, loan.GetType(), loan.Balance, period, loan.IntrestRate, loan.CalcInterestAmount(period));

        loan.Deposit(1200);
        Console.WriteLine("After repaying the loan the balance is: {0}", loan.Balance);

        //invalid period test
        //Console.WriteLine(loan.CalcInterestAmount(-3));
    }

        public void can_commit_multiple_db_operations()
        {
            var customer = new Customer { FirstName = "John", LastName = "Doe" };
            var salesPerson = new SalesPerson { FirstName = "Jane", LastName = "Doe", SalesQuota = 2000 };

            using (var scope = new UnitOfWorkScope())
            {
                new EFRepository<Customer>().Add(customer);
                new EFRepository<SalesPerson>().Add(salesPerson);
                scope.Commit();
            }

            using (var ordersTestData = new EFTestData(OrdersContextProvider()))
            using (var hrTestData = new EFTestData(HRContextProvider()))
            {
                Customer savedCustomer = null;
                SalesPerson savedSalesPerson = null;
                ordersTestData.Batch(action => savedCustomer = action.GetCustomerById(customer.CustomerID));
                hrTestData.Batch(action => savedSalesPerson = action.GetSalesPersonById(salesPerson.Id));

                Assert.That(savedCustomer, Is.Not.Null);
                Assert.That(savedSalesPerson, Is.Not.Null);
                Assert.That(savedCustomer.CustomerID, Is.EqualTo(customer.CustomerID));
                Assert.That(savedSalesPerson.Id, Is.EqualTo(salesPerson.Id));
            }
        }

        public static bool Charge(Customer customer, CreditCard creditCard, decimal amount)
        {
            var chargeDetails = new StripeChargeCreateOptions();
            chargeDetails.Amount = (int)amount * 100;
            chargeDetails.Currency = "usd";

            chargeDetails.Source = new StripeSourceOptions
            {
                Object = "card",
                Number = creditCard.CcNumber,
                ExpirationMonth = creditCard.ExpireDate.Month.ToString(),
                ExpirationYear = creditCard.ExpireDate.Year.ToString(),
                Cvc = creditCard.CVCCode
            };

            var chargeService = new StripeChargeService(stripeApiKey);

            var response = chargeService.Create(chargeDetails);

            if(response.Paid == false)
            {
                throw new Exception(response.FailureMessage);
            }

            return response.Paid;
        }

 public void testThreeAcounts()
 {
     Customer oscar = new Customer("Oscar")
             .openAccount(new Account(Account.SAVINGS));
     oscar.openAccount(new Account(Account.CHECKING));
     Assert.AreEqual(3, oscar.getNumberOfAccounts());
 }

        public void testAppWithTransfer()
        {
            Account checkingAccount = new Account(Account.CHECKING);
            Account savingsAccount = new Account(Account.SAVINGS);

            Customer henry = new Customer("Henry").openAccount(checkingAccount).openAccount(savingsAccount);

            checkingAccount.deposit(100.0, false);
            savingsAccount.deposit(4000.0, false);
            savingsAccount.withdraw(200.0, false);
            henry.transfer(savingsAccount, checkingAccount, 400);

            Assert.AreEqual("Statement for Henry\n" +
                    "\n" +
                    "Checking Account\n" +
                    "  deposit $100.00\n" +
                    "  transfer to $400.00\n" +
                    "Total $500.00\n" +
                    "\n" +
                    "Savings Account\n" +
                    "  deposit $4,000.00\n" +
                    "  withdrawal $200.00\n" +
                    "  transfer from $400.00\n" +
                    "Total $3,400.00\n" +
                    "\n" +
                    "Total In All Accounts $3,900.00", henry.getStatement());
        }

    private Customer AddCustomer()
    {
        Customer customer = new Customer()
        {
            Address = BillingAddressControl.Address,
            CellPhone = CellPhoneTextBox.Text,
            City = BillingAddressControl.City,
            Company = ComapnyTextBox.Text,
            CountryID = BillingAddressControl.CountryID,
            DateCreated = DateTime.Now,
            DateUpdated = DateTime.Now,
            DayPhone = DayPhoneTextBox.Text,
            Email = EmailTextBox.Text,
            EveningPhone = EveningPhoneTextBox.Text,
            Fax = FaxTextBox.Text,
            StateID = BillingAddressControl.StateID,
            FirstName = FirstNameTextBox.Text,
            LastName = LastNameTextBox.Text,
            ProvinceID = BillingAddressControl.ProvinceID,
            Zipcode = BillingAddressControl.Zipcode,
            Active = true
        };

        return CustomerManager.AddCustomer(customer);
    }

        public void AddThreeItems_RemoveMiddleItem_CheckConsistency()
        {
            string path = AppDomain.CurrentDomain.BaseDirectory;
            BackingUnknownSize<Customer, string> backingFile = new BackingUnknownSize<Customer, string>(path, 100);
            MMFDictionary<Customer, string> dict = new MMFDictionary<Customer, string>(path, 1000);

            Customer c1 = new Customer {Name = "Mikael"};
            Customer c2 = new Customer {Name = "Svenson"};
            Customer c3 = new Customer {Name = "Boss"};

            dict.Add(c1, "test");
            dict.Add(c2, "test2");
            dict.Add(c3, "test3");

            var result = dict.Remove(c2);
            Assert.IsTrue(result);
            result = dict.Remove(c2);
            Assert.IsFalse(result);
            dict.Add(c2, "test2");
            result = dict.Remove(c2);
            Assert.IsTrue(result);

            var res2 = dict[c3];
            Assert.AreEqual("test3", res2);
        }

 public Deposit(Customer customer, decimal balance, decimal interestRate, byte months)
 {
     this.Customer = customer;
     this.Balance = balance;
     this.InterestRate = interestRate;
     this.Months = months;
 }

		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}");

			}
		}

 protected void btnAdd_Click(object sender, EventArgs e)
 {
     MealPlan mp = new MealPlan();
     mp.find("PlanID = '" + this.ddlMealPlan.Text + "'");
     this.customer = (Customer)ViewState["customer"];
     this.tbCurrentMeals.Text = (this.customer.CurrentMeals + mp.MealsPerWeek).ToString();
 }

        public async Task<ActionResult> Register() {

            var pcats = CURTAPI.GetParentCategoriesAsync();
            await Task.WhenAll(new Task[] { pcats });
            ViewBag.parent_cats = await pcats;

            List<Country> countries = UDF.GetCountries();

            Customer cust = new Customer();
            Address billing = new Address();
            Address shipping = new Address();
            bool same = true;
            try {
                cust = (Customer)TempData["customer"];
                billing = (Address)TempData["billing"];
                shipping = (Address)TempData["customer"];
                same = (bool)TempData["same"];
            } catch (Exception) { }

            ViewBag.cust = cust;
            ViewBag.billing = billing;
            ViewBag.shipping = shipping;
            ViewBag.same = same;
            ViewBag.countries = countries;
            ViewBag.error = TempData["error"];
            return View();
        }