public void ValidateCustomer(ICustomer customer, String message)
 {
     if (customer == null)
     {
         throw new ArgumentException(message);
     }
 }

 public AddAppointmentDialog(ICustomer icustomer, CreateCustomerDialog createCustomerDialog, List<IAppointment> appointments)
 {
     this.iCustomer = icustomer;
     this.ccd = createCustomerDialog;
     this.appointments = appointments;
     InitializeComponent();
 }

        /// <summary>
        /// Creates a Braintree <see cref="Customer"/> from a Merchello <see cref="ICustomer"/>
        /// </summary>
        /// <param name="customer">
        /// The customer.
        /// </param>
        /// <param name="paymentMethodNonce">
        /// The "nonce-from-the-client"
        /// </param>
        /// <param name="billingAddress">
        /// The billing address
        /// </param>
        /// <param name="shippingAddress">
        /// The shipping Address.
        /// </param>
        /// <returns>
        /// The <see cref="Attempt{Customer}"/>.
        /// </returns>
        public Attempt<Customer> Create(ICustomer customer, string paymentMethodNonce = "", IAddress billingAddress = null, IAddress shippingAddress = null)
        {
            if (Exists(customer)) return Attempt.Succeed(GetBraintreeCustomer(customer));

            var request = RequestFactory.CreateCustomerRequest(customer, paymentMethodNonce, billingAddress);

            Creating.RaiseEvent(new Core.Events.NewEventArgs<CustomerRequest>(request), this);

            // attempt the API call
            var attempt = TryGetApiResult(() => BraintreeGateway.Customer.Create(request));

            if (!attempt.Success) return Attempt<Customer>.Fail(attempt.Exception);

            var result = attempt.Result;

            if (result.IsSuccess())
            {
                Created.RaiseEvent(new Core.Events.NewEventArgs<Customer>(result.Target), this);

                return Attempt.Succeed((Customer)RuntimeCache.GetCacheItem(MakeCustomerCacheKey(customer), () => result.Target));
            }

            var error = new BraintreeApiException(result.Errors);
            LogHelper.Error<BraintreeCustomerApiService>("Braintree API Customer Create return a failure", error);

            return Attempt<Customer>.Fail(error);
        }

 public Commerce(IBillingProcessor billingProcessor, ICustomer customer, INotifier notifier, ILogger logger)
 {
     _BillingProcessor = billingProcessor;
     _Customer = customer;
     _Notifier = notifier;
     _Logger = logger;
 }

 public Deposit(ICustomer customer, float amount, DateTime endDate)
 {
     Amount = amount;
     EndDate = endDate;
     Customer = customer;
     History = new List<IOperationHistory>();
 }

 private void FullyRegister(ISet behaviour, ICustomer customer)
 {
     Debug.WriteLine("Perform full customer registration");
     behaviour.Perform()
         .Given(customer.Register);
         //.And(customer...)
 }

 public IBooking CreateBooking(ISupplier supplier, ICustomer customer, string sale, int bookingNumber,
     DateTime StartDate, DateTime EndDate)
 {
     //Calls Bookingcollection class for create
     return bookingCollection.Create((Supplier)supplier, (Customer)customer, sale, bookingNumber, StartDate,
         EndDate);
 }

 public Account(int id, ICustomer customer, decimal balance, decimal interestRate, DateTime creatDate)
     : this(id, customer, creatDate)
 {
     this.Balance = balance;
     this.InterestRate = interestRate;
     this.CreatedOn = DateTime.Now;
 }

       protected BankAccount(ICustomer customer,decimal balance,decimal monthlyInterestRate)
       {
           this.Customer = customer;
           this.Balance = balance;
           this.MonthlyInterestRate = monthlyInterestRate;

       }

 public static bool Update(ICustomer customer)
 {
     List<ICustomer> customers = LoadAllCustomers();
     ICustomer customerToBeUpdated = null;
     for (int i = 0; i < customers.Count; i++)
     {
         ICustomer customerLoaded = customers[i];
         if (customer.Id == customerLoaded.Id)
         {
             customerToBeUpdated = customerLoaded;
             break;
         }
     }
     if (customerToBeUpdated != null)
     {
         customers.Remove(customerToBeUpdated);
         customers.Add(customer);
         SaveAllCustomers(customers);
         return true;
     }
     else
     {
         return false;
     }
 }

		public IEnumerable<IFinancingEligibilityRule> GetRules(ICustomer customer)
		{
			yield return new IsOldEnoughRule(customer.Age);
			yield return new LivesInFinancingStateRule(customer.BillingStateAbbreviation);
			yield return new HasNoDelinquenciesOnFileRule(customerId: customer.CustomerId, financingRepository: _financingRepository);
			yield return new HasTopTierCreditScoreRule(ssn: customer.SSN, dateOfBirth: customer.DateOfBirth, financingRepository: _financingRepository);
		}

        public int Compare(ICustomer x, ICustomer y)
        {
            if (x.ArrivalTime != y.ArrivalTime) return x.ArrivalTime.CompareTo(y.ArrivalTime);
            if (x.CartCount != y.CartCount) return x.CartCount.CompareTo(y.CartCount);

            return x.CustomerType.CompareTo(y.CustomerType);
        }

        protected TradeAction(ICustomer customer, ISeller seller)
        {
            ThrowNewArgumentNullException(customer, seller);

            _customer = customer;
            _seller = seller;
        }

 public Account(ICustomer owner, decimal balance, decimal interestRate)
 {
     this.Owner = owner;
     this.Balance = balance;
     this.InterestRate = interestRate;
     this.openDate = DateTime.Now;
 }

 ///TODO: We need to talk about the contstructor.  An empty address does not make a lot of sense.
 internal CustomerAddress(ICustomer customer, string label)
 {
     Mandate.ParameterNotNull(customer, "customer");
     Mandate.ParameterNotNull(label, "label");
     _customerKey = customer.Key;
     _label = label;
 }

 public Commerce2(IBillingProcessorFactory billingProcessorFactory, ICustomer customer, INotifier notifier, ILogger logger)
 {
     _BillingProcessorFactory = billingProcessorFactory;
     _Customer = customer;
     _Notifier = notifier;
     _Logger = logger;
 }

        protected Account(double interestRate, decimal balance, ICustomer customer, DateTime dateCreated)
        {
            this.InterestRate = interestRate;
            this.Balance = balance;
            this.CreatonDate = dateCreated;

            this.customer = customer;
        }

 IOrder GetOrder(Random rand, ICustomer customer, int counter, ITypeInfo ordersTypeInfo) {
     var order = (IOrder)ReflectionHelper.CreateObject(ordersTypeInfo.Type, new object[] { _objectSpace.Session });
     order.Customer = customer;
     order.OrderDate = DateTime.Now.AddDays((-rand.Next(365 * 3)));
     order.Reference = String.Format("ORD{0}", counter + 1000);
     order.Total = 0F;
     return order;
 }

 public List<IAppointment> AddAllCustomerAppointmentsToList(ICustomer icustomer, List<IAppointment> iappointmentsList)
 {
     for (int i = 0; i < icustomer.Appointments.Count; i++)
     {
         iappointmentsList.Add(icustomer.Appointments[i]);
     }
     return iappointmentsList;
 }

        public IBooking CreateBooking(ISupplier supplier, ICustomer customer, string sale, int bookingNumber, 
            DateTime startDate, DateTime endDate)
        {
            BookingEntity booking = new BookingEntity(supplier, customer, sale, bookingNumber, startDate, endDate);
            bookings.Add(booking);

            return booking;
        }