public static List<AccountDetails> GetAccountDetails(string companyCode)
{
List<AccountDetails> result = new List<AccountDetails>();
try
{
DataTable dtTable = XBDataProvider.RptSalesQuote.GetAllActiveAcoountNo(companyCode);
//Session["BPDetails"] = dtTable;
for (int i = 0; i < dtTable.Rows.Count; i++)
{
AccountDetails AccountDetails = new AccountDetails();
AccountDetails.AccountNo = dtTable.Rows[i]["AccountNo"].ToString();
AccountDetails.name = dtTable.Rows[i]["Name"].ToString();
AccountDetails.Branch = dtTable.Rows[i]["Branch"].ToString();
AccountDetails.BankCode = dtTable.Rows[i]["BankCode"].ToString();
AccountDetails.AccountType = dtTable.Rows[i]["AccountType"].ToString();
AccountDetails.IBAN = dtTable.Rows[i]["IBAN"].ToString();
AccountDetails.IFSC = dtTable.Rows[i]["IFSC"].ToString();
AccountDetails.SWIFT = dtTable.Rows[i]["SWIFT"].ToString();
AccountDetails.MICR = dtTable.Rows[i]["MICR"].ToString();
AccountDetails.BankName = dtTable.Rows[i]["BankName"].ToString();
AccountDetails.CompanyCode = dtTable.Rows[i]["CompanyCode"].ToString();
result.Add(AccountDetails);
}
}
catch (Exception e)
{
}
return result;
}
public static DataSet getAccountDetails(ICustomerAccount account)
{
AccountDetails details = new AccountDetails(account);
DataSet ds = DataSetBuilder.CreateDataSetFromBusinessObjectList(
new AccountDetails[] { details },
"AccountNumber, VermogensBeheer, TegenRekening, TegenRekeningBank,TegenRekeningTNV, TegenRekeningPlaats, ModelPortfolio, PLastName, SLastName, PVoorLetters, SVoorLetters, PTussenVoegsels, STussenVoegsels, PGeslacht, SGeslacht, PGeboortedatum, SGeboortedatum, PNationaliteit, SNationaliteit, PBSN, SBSN, PostalAdres1, PostalCode, WoonPlaats, PLegitimatie, SLegitimatie, PLegitimatieNummer, SLegitimatieNummer, PLegitimatieExpiry, SLegitimatieExpiry, PTelefoon, STelefoon, PMobiel, SMobiel, PEmail, SEmail",
"AccountDetail");
return ds;
}
public bool Equals(AccountDetails other)
{
if (ReferenceEquals(null, other)) return false;
if (ReferenceEquals(this, other)) return true;
return other._accountId == _accountId &&
Equals(other._username, _username) &&
Equals(other._currency, _currency) &&
Equals(other._legalEntity, _legalEntity) &&
Equals(other._displayLocale, _displayLocale) &&
other._fundingAllowed.Equals(_fundingAllowed);
}
void OnAccountRegistered(string OwnerName, string AccountNumber, string AccountId)
{
var detail = new AccountDetails
{
Id = AccountId,
AccountNumber = AccountNumber,
OwnerName = OwnerName,
Balance = 0
};
Details.Add(AccountId, detail);
Clients.AddAccountDetails(detail);
}
public void Should_not_throw_on_missing_headers()
{
IWebResponseDetails details = MockRepository.GenerateMock<IWebResponseDetails>(null);
details.Expect(d => d.Headers).Return(new Dictionary<string,string>());
Assert.DoesNotThrow(() =>
{
accountDetailsParser.BuildFromWebResponse(details);
});
Assert.NotNull(accountDetailsParser.Data);
accountDetails = accountDetailsParser.Data;
Assert.Equal(accountDetails.BytesUsed, 0);
Assert.Equal(accountDetails.ContainerCount, 0);
Assert.Equal(accountDetails.ObjectsCount, 0);
}
public void Should_throw_on_incorrect_headers()
{
Dictionary<string, string> wrongHeaders = new Dictionary<string, string>();
wrongHeaders.Add(AccountDetailsParser.HEADER_BYTES_USED, "wrong_header_value");
IWebResponseDetails details = MockRepository.GenerateMock<IWebResponseDetails>(null);
details.Expect(d => d.Headers).Return(wrongHeaders);
Assert.Throws(typeof(FormatException),()=>{
accountDetailsParser.BuildFromWebResponse(details);
});
Assert.NotNull(accountDetailsParser.Data);
accountDetails = accountDetailsParser.Data;
Assert.Equal(accountDetails.BytesUsed, 0);
}
private async Task ResolveAccount(AcmeClient acme)
{
_account = await _stateStore.GetAccountDetailsAsync();
if (_account == null)
{
var contacts = _options.AccountContactEmails.Select(x => $"mailto:{x}");
_logger.LogInformation("Creating ACME Account");
var accountDetails = await acme.CreateAccountAsync(
contacts : contacts,
termsOfServiceAgreed : _options.AcceptTermsOfService);
_account = accountDetails;
await _stateStore.SaveAccountDetailsAsync(_account);
_logger.LogInformation($"account {JsonSerializer.Serialize(_account)}");
}
acme.SetAccount(_account);
}
public void Should_throw_on_incorrect_headers()
{
Dictionary <string, string> wrongHeaders = new Dictionary <string, string>();
wrongHeaders.Add(AccountDetailsParser.HEADER_BYTES_USED, "wrong_header_value");
IWebResponseDetails details = MockRepository.GenerateMock <IWebResponseDetails>(null);
details.Expect(d => d.Headers).Return(wrongHeaders);
Assert.Throws(typeof(FormatException), () => {
accountDetailsParser.BuildFromWebResponse(details);
});
Assert.NotNull(accountDetailsParser.Data);
accountDetails = accountDetailsParser.Data;
Assert.Equal(accountDetails.BytesUsed, 0);
}
public AccountDetails Details()
{
// if we want to know which user is logged in or which roles he has
// apart from [Authorize] attribute...
// we have User.Identity.IsAuthenticated
// User.IsInRole("admin")
// User.Identity.Name
if (!User.Identity.IsAuthenticated)
{
return(null);
}
var details = new AccountDetails
{
Username = User.Identity.Name,
Roles = User.Claims.Where(c => c.Type == ClaimTypes.Role)
.Select(c => c.Value)
};
return(details);
}
private void DisplayTransactions()
{
AccountDetails.Clear();
AccountSummaries.Clear();
var transactions = Dao.Query(GetCurrentRange(x => x.AccountId == SelectedAccount.Id)).OrderBy(x => x.Date);
AccountDetails.AddRange(transactions.Select(x => new AccountDetailViewModel(x)));
if (FilterType != Resources.All)
{
var pastDebit = Dao.Sum(x => x.Debit, GetPastRange(x => x.AccountId == SelectedAccount.Id));
var pastCredit = Dao.Sum(x => x.Credit, GetPastRange(x => x.AccountId == SelectedAccount.Id));
if (pastCredit > 0 || pastDebit > 0)
{
AccountSummaries.Add(new AccountSummaryViewModel(Resources.Total, AccountDetails.Sum(x => x.Debit), AccountDetails.Sum(x => x.Credit)));
var detailValue =
new AccountDetailViewModel(new AccountTransactionValue
{
Name = Resources.PastTransactions,
Credit = pastCredit,
Debit = pastDebit
});
AccountDetails.Insert(0, detailValue);
detailValue.IsBold = true;
}
}
AccountSummaries.Add(new AccountSummaryViewModel(Resources.GrandTotal, AccountDetails.Sum(x => x.Debit), AccountDetails.Sum(x => x.Credit)));
for (var i = 0; i < AccountDetails.Count; i++)
{
AccountDetails[i].Balance = (AccountDetails[i].Debit - AccountDetails[i].Credit);
if (i > 0)
{
(AccountDetails[i].Balance) += (AccountDetails[i - 1].Balance);
}
}
RaisePropertyChanged(() => TotalBalance);
}
// ############################################################
// New account details action/method
// Uses a new AccountDetails view model class
// GET: /Account/Details
public ActionResult Details()
{
// Create a view model object
var accountDetails = new AccountDetails();
// Identity object "name" (i.e. not the claim)
accountDetails.UserName = User.Identity.Name;
// Work with the current User in claims-compatible mode
var identity = User.Identity as ClaimsIdentity;
// Now, go through the claims...
// Get the name, if present
var name = identity.FindFirst(ClaimTypes.Name);
accountDetails.ClaimsName = name == null ? "(none)" : name.Value;
// Get the given name, if present
var givenName = identity.FindFirst(ClaimTypes.GivenName);
accountDetails.ClaimsGivenName = givenName == null ? "(none)" : givenName.Value;
// Get the surname, if present
var surname = identity.FindFirst(ClaimTypes.Surname);
accountDetails.ClaimsSurname = surname == null ? "(none)" : surname.Value;
// Get the email, if present
var email = identity.FindFirst(ClaimTypes.Email);
accountDetails.ClaimsEmail = email == null ? "(none)" : email.Value;
// Get the roles, if present
var roles = identity.FindAll(ClaimTypes.Role).Select(rn => rn.Value).ToArray();
accountDetails.ClaimsRoles = roles.Count() == 0 ? "(none)" : string.Join(", ", roles);
return(View(accountDetails));
}
public async Task Handle(EventReceived <Withdrawal> @event, CancellationToken cancellationToken)
{
_logger.LogInformation("processing withdrawal of {Amount} on account {AggregateId} ...", @event.Event.Amount, @event.Event.AggregateId);
var accountId = @event.Event.AggregateId;
var partitionKey = new PartitionKey(accountId.ToString());
var response = await _customerDetailsContainer.ReadItemAsync <AccountDetails>(
accountId.ToString(),
partitionKey,
null, cancellationToken);
var account = response.Resource;
var newBalance = account.Balance.Subtract(@event.Event.Amount.Value);
var updatedAccount = new AccountDetails(account.Id,
account.OwnerId, account.OwnerFirstName, account.OwnerLastName,
newBalance);
await _accountsContainer.UpsertItemAsync(updatedAccount, partitionKey, null, cancellationToken);
_logger.LogInformation("withdrawn {Amount} from account {AggregateId} ...", @event.Event.Amount, @event.Event.AggregateId);
}
private decimal Interest(AccountDetails accountDetails)
{
double interest = 0;
if (IsAccountStartedAfterBonusAge(accountDetails))
{
if (Age <= accountDetails.Age)
{
//interest = (PrincipalAmount * DurationInYears * AnnualInterestRate) / 100
interest = (double)accountDetails.Balance
* DurationSinceStartDateInYears(accountDetails.StartDate) * SeniorPercent / 100;
}
else
{
interest = (double)accountDetails.Balance
* DurationSinceStartDateInYears(accountDetails.StartDate) * InterestPercent / 100;
}
}
return((decimal)interest);
}
public void GetAccountDetailsTest()
{
var testJObject = new JObject()
{
new JProperty("statusCode", "0"),
new JProperty("message", "Success"),
};
var messageHandler = new FakeHttpMessageHandler(new HttpResponseMessage()
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(JsonConvert.SerializeObject(testJObject), Encoding.UTF8, "application/json")
});
var mockServiceClient = new MockServiceClient(messageHandler);
var mockGraphService = new MockGraphService();
var mockB2CGraphService = new MockB2CGraphService();
var serviceId = new ServiceId(mockGraphService, mockB2CGraphService, _mockServiceClientServiceId);
var accountDetails = new AccountDetails(serviceId, mockServiceClient);
var input = new JObject()
{
new JProperty("token", "abc123"),
new JProperty("serviceUrl", ServiceUrl.Url)
};
var expectedOutput = new JObject()
{
new JProperty("statusCode", "0"),
new JProperty("message", "Success")
};
var response = accountDetails.GetAccountDetails(input);
var responseObj = JObject.Parse(response);
foreach (var item in responseObj)
{
Assert.True(expectedOutput.ContainsKey(item.Key));
var value = expectedOutput.GetValue(item.Key);
Assert.Equal(value, item.Value);
}
}
// GET: Tracks/Create
public ActionResult Create()
{
// Create a view model object
var accountDetails = new AccountDetails();
// Identity object "name" (i.e. not the claim)
accountDetails.UserName = HttpContext.User.Identity.Name;
// Work with the current User in claims-compatible mode
var identity = User.Identity as ClaimsIdentity;
// Now, go through the claims...
// Get the name, if present
//var name = identity.FindFirst(ClaimTypes.Name);
//accountDetails.ClaimsName = name == null ? "(none)" : name.Value;
// Get the given name, if present
var givenName = identity.FindFirst(ClaimTypes.GivenName);
accountDetails.ClaimsGivenName = givenName == null ? "(none)" : givenName.Value;
// Get the surname, if present
var surname = identity.FindFirst(ClaimTypes.Surname);
accountDetails.ClaimsSurname = surname == null ? "(none)" : surname.Value;
// Get the email, if present
// var email = identity.FindFirst(ClaimTypes.Email);
//accountDetails.ClaimsEmail = email == null ? "(none)" : email.Value;
TrackAddForm form = new TrackAddForm();
form.Clerk = givenName.Value + " " + surname.Value;
form.GenreList = new SelectList(m.GenreGetAll(), "Name", "Name");
form.AlbumList = new MultiSelectList(m.AlbumGetAll(), dataValueField: "Id", dataTextField: "Name");
return(View(form));
}
public ActionResult ImpersonateAccount()
{
if (Session["SysAdminDetails"] != null)
{
TempData["SelectedMenu"] = "AccImpersontation";
var adminUser = (User)Session["SysAdminDetails"];
var userObj = CCUserRepository.GetUserByEmailAddress(adminUser.Email);
Session["user"] = userObj;
//Session["account"] = "";
//Session["timeZone"] = "";
var accountObj = CCAccRepository.Accounts.FirstOrDefault(x => x.ID == userObj.AccountID);
Session["account"] = accountObj;
var timeZone = CCAccRepository.Accounts.Where(aid => aid.ID == userObj.AccountID).FirstOrDefault().TimeZone;
Session["timeZone"] = timeZone;
ImpersonateAccountsSysAdminModel model = new ImpersonateAccountsSysAdminModel();
var AccountsList = CCAccRepository.Accounts.ToList();
foreach (var acc in AccountsList)
{
try
{
AccountDetails AD = new AccountDetails();
AD.AccountID = acc.ID;
AD.AccountGUID = acc.AccountGUID;
AD.AccountName = acc.AccountName;
AD.DateCreated = "Coming Soon...";
AD.Email = CCUserRepository.Users.FirstOrDefault(u => u.AccountID == acc.ID).Email;
AD.Usgae = "Coming Soon...";
model.listOfAccounts.Add(AD);
}
catch (Exception ex) { }
}
return View(model);
}
else
{
return RedirectToAction("Login", "Login");
}
}
protected static Account GetAccountFromAccountDetails(AccountDetails details)
{
if (details == null)
throw new Exception("ArticleDetails record is null!");
Account account = new Account(details.AccountID, details.Name, details.BSB, details.Number, details.StartAmount, new Bank(details.BankID));
return account;
}
public static bool UpdateAccount(int id, Bank bank, string name,
string bsb, string accountNumber, double startAmount)
{
name = ConvertNullToEmptyString(name);
bsb = ConvertNullToEmptyString(bsb);
accountNumber = ConvertNullToEmptyString(accountNumber);
AccountDetails details = new AccountDetails(id, bank.ID, name, bsb, accountNumber, startAmount);
bool result = SiteProvider.Accounts.UpdateAccount(details);
return result;
}
public static int InsertAccount(Bank bank, string name, string bsb, string accountNumber, double startAmount)
{
name = ConvertNullToEmptyString(name);
bsb = ConvertNullToEmptyString(bsb);
accountNumber = ConvertNullToEmptyString(accountNumber);
AccountDetails details = new AccountDetails(0, bank.ID, name, bsb, accountNumber, startAmount);
int id = SiteProvider.Accounts.InsertAccount(details);
return id;
}
/// <summary>
/// There are no comments for AccountDetails in the schema.
/// </summary>
public void AddToAccountDetails(AccountDetails accountDetails)
{
base.AddObject("AccountDetails", accountDetails);
}
/// <summary>
/// Create a new AccountDetails object.
/// </summary>
/// <param name="accountDetailsID">Initial value of AccountDetailsID.</param>
public static AccountDetails CreateAccountDetails(int accountDetailsID)
{
AccountDetails accountDetails = new AccountDetails();
accountDetails.AccountDetailsID = accountDetailsID;
return accountDetails;
}
private void getsavedsalesinvoiceparameters(string hdncompanyCode)
{
DataTable dtTable = XBDataProvider.RptSalesQuote.GetSalesQuoteParameters(hdncompanyCode);
for (int i = 0; i < dtTable.Rows.Count; i++)
{
Header.Text = dtTable.Rows[i]["HeaderText"].ToString();
Declaration.Text = dtTable.Rows[i]["DeclarationText"].ToString();
Footer.Text = dtTable.Rows[i]["FooterText"].ToString();
NoOfCopies.Text = dtTable.Rows[i]["Copies"].ToString();
AccountDetails objAccountDetails = new AccountDetails();
txtAccNoid.Text = dtTable.Rows[i]["AccountNo"].ToString();
objAccountDetails.AccountNo = dtTable.Rows[i]["AccountNo"].ToString();
objAccountDetails.name = dtTable.Rows[i]["AccountName"].ToString();
objAccountDetails.BankCode = dtTable.Rows[i]["BankCode"].ToString();
objAccountDetails.BankName = dtTable.Rows[i]["BankName"].ToString();
objAccountDetails.Branch = dtTable.Rows[i]["Branch"].ToString();
objAccountDetails.IFSC = dtTable.Rows[i]["IFSC"].ToString();
objAccountDetails.IBAN = dtTable.Rows[i]["IBAN"].ToString();
lblBankCode.InnerText = dtTable.Rows[i]["BankCode"].ToString();
if (dtTable.Rows[i]["Header"].ToString() == "True")
{
HeaderCB.Checked = true;
Header.ReadOnly = false;
}
else
{
HeaderCB.Checked = false;
Header.ReadOnly = true;
}
if (dtTable.Rows[i]["Declaration"].ToString() == "True")
{
DeclarationCB.Checked = true;
Declaration.ReadOnly = false;
}
else
{
DeclarationCB.Checked = false;
Declaration.ReadOnly = true;
}
if (dtTable.Rows[i]["Footer"].ToString() == "True")
{
FooterCB.Checked = true;
Footer.ReadOnly = false;
}
else
{
FooterCB.Checked = false;
Footer.ReadOnly = true;
}
if (BankCB.Checked == true)
{
txtAccNoid.ReadOnly = false;
}
else
{
txtAccNoid.ReadOnly = true;
}
}
}
private void saveAccount(bool forceClosedStatus)
{
try
{
string message;
bool valid = false;
bool askConfirmation = false;
AccountDetails saveValue = new AccountDetails()
{
AccountNrID = AccountId,
AccountNumber = String.Empty,
AssetManagerKey = int.MinValue,
Modelid = int.MinValue,
LifecycleId = int.MinValue,
AccountShortName = string.Empty,
AccountFullName = string.Empty,
PandHouderID = int.MinValue,
CounterAccountID = int.MinValue,
CreationDate = DateTime.MinValue,
LastUpDated = DateTime.MinValue,
LastDateStatusChanged = DateTime.MinValue,
FirstManagementStartDate = DateTime.MinValue,
FinalManagementEndDate = DateTime.MinValue,
DateTradeabilityStatusChanged = DateTime.MinValue,
ExitFeePayingAccountID = int.MinValue,
VerpandSoortID = int.MinValue,
RelatedEmployeeID = int.MinValue
};
if (ddlVerpandSoort.Items.Count > 0 && int.Parse(ddlVerpandSoort.SelectedValue) >= 0)
rfvPandhouder.Enabled = true;
if (ddlPandhouder.Items.Count > 0 && int.Parse(ddlPandhouder.SelectedValue) >= 0)
rfvVerpandSoort.Enabled = true;
Page.Validate();
valid = Page.IsValid;
if (valid)
{
saveValue.AccountNrID = Convert.ToInt32(AccountId);
saveValue.AssetManagerKey = Convert.ToInt32(hfAssetMAnagerID.Value);
saveValue.IsJointAccount = chkIsJointAccount.Checked;
if (pnlLifecycle.Visible)
saveValue.LifecycleId = Utility.GetKeyFromDropDownList(ddlLifecycle);
saveValue.Modelid = int.Parse(ddlModelPortfolio.SelectedValue);
saveValue.IsExecOnlyCustomer = chkIsExecOnlyCustomer.Checked;
saveValue.AccountShortName = tbShortName.Text;
saveValue.AccountFullName = tbFullName.Text;
saveValue.FamilyID = Utility.GetKeyFromDropDownList(ddlAccountFamily);
saveValue.PandHouderID = int.Parse(ddlPandhouder.SelectedValue);
if (int.Parse(ddlVerpandSoort.SelectedValue) != int.MinValue)
saveValue.VerpandSoortID = int.Parse(ddlVerpandSoort.SelectedValue);
saveValue.CounterAccountID = int.Parse(ddlCounterAccount.SelectedValue);
saveValue.Status = (AccountStati)int.Parse(ddlStatus.SelectedValue);
saveValue.TradeableStatus = (Tradeability)int.Parse(ddlTradeability.SelectedValue);
if (dpFirstManagementStartDate.SelectedDate > DateTime.MinValue)
saveValue.FirstManagementStartDate = dpFirstManagementStartDate.SelectedDate;
saveValue.FinalManagementEndDate = dpFinalManagementEndDate.SelectedDate;
if (pnlExitFeePayer.Visible)
saveValue.ExitFeePayingAccountID = int.Parse(ddlExitFeePayer.SelectedValue);
if (ddlRemisierEmployee.Items.Count > 0 && ddlRemisierEmployee.SelectedIndex != -1)
saveValue.RemisierEmployeeID = Convert.ToInt32(ddlRemisierEmployee.SelectedValue);
saveValue.UseManagementFee = chkUseManagementFee.Checked;
saveValue.UseKickBack = chkUseKickBack.Checked;
saveValue.KickBack = dbKickbackPercentage.Value;
saveValue.IntroductionFee = dbIntroductionFee.Value;
saveValue.IntroductionFeeReduction = dbIntroductionFeeReduction.Value;
saveValue.SubsequentDepositFee = dbSubsequentDepositFee.Value;
saveValue.SubsequentDepositFeeReduction = dbSubsequentDepositFeeReduction.Value;
saveValue.EmployerRelationship = (AccountEmployerRelationship)int.Parse(ddlEmployerRelationship.SelectedValue);
if (pnlRelatedEmployee.Visible)
saveValue.RelatedEmployeeID = int.Parse(ddlRelatedEmployee.SelectedValue);
saveValue.FirstPromisedDeposit = dbFirstDeposit.Value;
AccountEditAdapter.SaveCustomerAccount(saveValue, forceClosedStatus, out askConfirmation, out message);
if (message != null && message.Length > 0)
Session["messagesavingaccount"] = message;
if (askConfirmation)
mvwAccountSave.ActiveViewIndex = 1;
else
{
//Session["accountnrid"] = AccountId;
Utility.NavigateToPrevPageSessionIfAnyWithQueryString("?accountnumber=" + saveValue.AccountNumber);
Response.Redirect("Account.aspx");
}
}
}
catch (Exception ex)
{
pnlErrorMess.Visible = true;
lblMess.Text = Utility.GetCompleteExceptionMessage(ex);
}
}
