// Main method begins execution of the app
    public static void Main( string[] args )
    {
        // constructors
        Account account1 = new Account(50.00M); //create Account object
        Account account2 = new Account(-7.53M);

        Console.WriteLine("Account1 balance: {0:C}\n", account1.Balance);
        Console.WriteLine("Account2 balance: {0:C}\n", account2.Balance);

        decimal depositAmount;

        Console.WriteLine("Enter deposit ammount for account1: ");
        depositAmount = Convert.ToDecimal(Console.ReadLine());
        Console.WriteLine("adding {0:C} to account1 balance\n", depositAmount);
        account1.Credit(depositAmount);

        Console.WriteLine("account1 balance: {0:C}\n", account1.Balance);
        Console.WriteLine("account2 balance: {0:C}", account2.Balance);

        Console.WriteLine("Enter deposit ammount for account2: ");
        depositAmount = Convert.ToDecimal(Console.ReadLine());
        Console.WriteLine("adding {0:C} to account2 balance\n", depositAmount);
        account2.Credit(depositAmount);

        Console.WriteLine("account1 balance: {0:C}\n", account1.Balance);
        Console.WriteLine("account2 balance: {0:C}", account2.Balance);
    }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="account"></param>
 /// <returns></returns>
 public bool CreateAccount(Account account)
 {
     int x = 0;
     var collection = MongoDb.Instance.GetCollection<Account>();
     var result = collection.Insert(account);
     return result.Ok;
 }

        public string Add(Account account)
        {
            account.Id = Regex.Replace(account.Name, @"\W+", string.Empty).ToLower();
            _accounts.Add(account);

            return account.Id;
        }

        public Account GetAccountByID(string sAccountID)
        {
            Account acct = new Account();
            acct.Id = new IdType { idDomain = idDomainEnum.QB, Value = sAccountID };

            return getDataService().FindById<Account>(acct) as Account;
        }

 public RenameAccountDialogViewModel(ShellViewModel shell, Account account, string currentName)
     : base(shell)
 {
     _account = account;
     _rename = new DelegateCommand(RenameAction);
     CurrentAccountName = currentName;
 }

 private void Init(Account modifiedAccount)
 {
     account = modifiedAccount;
     alert = new Alert();
     alert.AccountID = account.AccountID;
     alert.CreateDate = DateTime.Now;
 }

        public void MakeTransfer(Account creditAccount, Account debitAccount, decimal amount)
        {
            if (creditAccount == null)
            {
                throw new AccountServiceException("creditAccount null");
            }

            if (debitAccount == null)
            {
                throw new AccountServiceException("debitAccount null");
            }

            if (debitAccount.Balance < amount && debitAccount.AutorizeOverdraft == false)
            {
                throw new AccountServiceException("not enough money");
            }

            Operation creditOperation = new Operation() { Amount = amount, Direction = Direction.Credit};
            Operation debitOperation = new Operation() { Amount = amount, Direction = Direction.Debit };

            creditAccount.Operations.Add(creditOperation);
            debitAccount.Operations.Add(debitOperation);

            creditAccount.Balance += amount;
            debitAccount.Balance -= amount;

            _operationRepository.CreateOperation(creditOperation);
            _operationRepository.CreateOperation(debitOperation);

            _accountRepository.UpdateAccount(creditAccount);
            _accountRepository.UpdateAccount(debitAccount);
        }

 public GoldState(Account account)
     : base(account)
 {
     this.Interest = 0.05;
     this.LowerLimit = 1000.0;
     this.UpperLimit = double.MaxValue;
 }

		public override Task ShareItemAsync (Item item, Account account, CancellationToken cancellationToken)
		{
			Request req;

			if (item.Images.Count > 0) {
				req = CreateRequest ("POST", new Uri ("https://graph.facebook.com/me/photos"), account);
				item.Images.First ().AddToRequest (req, "source");

				var message = new StringBuilder ();
				message.Append (item.Text);
				foreach (var l in item.Links) {
					message.AppendLine ();
					message.Append (l.AbsoluteUri);
				}
				req.AddMultipartData ("message", message.ToString ());
			}
			else {
				req = CreateRequest ("POST", new Uri ("https://graph.facebook.com/me/feed"), account);
				req.Parameters["message"] = item.Text;
				if (item.Links.Count > 0) {
					req.Parameters["link"] = item.Links.First ().AbsoluteUri;
				}
			}

			return req.GetResponseAsync (cancellationToken).ContinueWith (reqTask => {
				var content = reqTask.Result.GetResponseText ();
				if (!content.Contains ("\"id\"")) {
					throw new SocialException ("Facebook returned an unrecognized response.");
				}
			});
		}

	public void TestTransferFundsToNullAccount()
	{
		Account source = new Account();
		source.Deposit(200.00F);
		Account dest = null;
		source.TransferFunds(dest, 100.00F);
	}

	public void TestDeposit()
	{
		Account acc = new Account();
		acc.Deposit(200.00F);
		float balance = acc.Balance;
		Assert.AreEqual(balance, 200F);
	}

	public void TestWithdrawNegative()
	{
		Account acc = new Account();
		acc.Withdraw(-3.14F);
		float balance = acc.Balance;
		Assert.AreEqual(balance, 1000F);
	}

	public void TestWithdraw()
	{
		Account acc = new Account();
		acc.Withdraw(138.56F);
		float balance = acc.Balance;
		Assert.AreEqual(balance, -138.56F);
	}

	public void TestDepositNegative()
	{
		Account acc = new Account();
		acc.Deposit(-150.30F);
		float balance = acc.Balance;
		Assert.AreEqual(balance, -150.30F);
	}

        public void NestedObjectTypeTest()
        {
            ClearConfig();
            var account = new Account();
            var settings = XmlSettings<Account>.Bind(account, CONFIG_FILE);
            var person = new Person();
            person.Age = 3;
            person.Name = "Sam";
            person.Happy = false;
            person.Birthdate = DateTime.Today;

            account.Person = person;
            account.Balance = 999;

            settings.Write();

            account = new Account();
            settings = XmlSettings<Account>.Bind(account, CONFIG_FILE);

            person = account.Person;
            Assert.AreEqual(account.Balance, 999);
            Assert.AreEqual(person.Age, 3);
            Assert.AreEqual(person.Name, "Sam");
            Assert.AreEqual(person.Happy, false);
            Assert.AreEqual(person.Birthdate, DateTime.Today);
        }

 public void Initialize()
 {
     _Clock = new Mock<IClock>();
     _TransactionRepository = new Mock<ITransactionRepository>();
     _StatementPrinter = new Mock<IStatementPrinter>();
     _Account = new Account(_TransactionRepository.Object, _StatementPrinter.Object, _Clock.Object);
 }

        public void When_Executing_Assign_Request_New_Owner_Should_Be_Assigned()
        {
            var oldOwner = new EntityReference("systemuser", Guid.NewGuid());
            var newOwner = new EntityReference("systemuser", Guid.NewGuid());

            var account = new Account
            {
                Id = Guid.NewGuid(),
                OwnerId = oldOwner
            };

            var context = new XrmFakedContext();
            var service = context.GetFakedOrganizationService();

            context.Initialize(new [] { account });

            var assignRequest = new AssignRequest
            {
                Target = account.ToEntityReference(),
                Assignee = newOwner
            };
            service.Execute(assignRequest);

            Assert.Equal(newOwner, account.OwnerId);
        }

 public void AddRange(Account[] value)
 {
     for (int i = 0;	i < value.Length; i++)
     {
         Add(value[i]);
     }
 }

 public static String GetBaseUrl(Account account)
 {
     if ((account != null) && (account.Type != AccountTypes.Regular)) {
         return string.Format(Uris.Base, Params.BaseApps + account.Domain);
     }
     return string.Format(Uris.Base, Params.Base);
 }

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