protected override bool ProcessRequestInternal(
RequestCache requestCache,
out string result_code)
{
bool success;
if (AccountQueries.VerifyCredentials(
requestCache.DatabaseContext,
m_username,
m_password,
out m_accountId,
out m_emailAddress,
out m_opsLevel,
out result_code))
{
CharacterQueries.GetCharacterIDList(requestCache.DatabaseContext, m_accountId, out m_characterIDs);
result_code = SuccessMessages.GENERAL_SUCCESS;
success = true;
}
else
{
m_characterIDs = new int[] {};
success = false;
}
return(success);
}
public AddressViewModel GetAddress(string addressText, int currentPage, int pageSize = AppSettings.PageSize)
{
var addressQueries = new AccountQueries(_context);
var tokenQueries = new TokenQueries(_context);
var account = addressQueries.QueryAccount(addressText);
if (account != null)
{
SoulRate = Explorer.GetSoulPrice();
var addressVm = AddressViewModel.FromAddress(account, tokenQueries.QueryTokens().ToList());
addressVm.Transactions = GetAddressTransactions(addressVm.Address, currentPage, pageSize);
foreach (var addressVmNativeBalance in addressVm.NativeBalances)
{
addressVmNativeBalance.TxnCount = GetTransactionCount(addressVm.Address);
}
CalculateAddressSoulValue(new List <AddressViewModel> {
addressVm
});
return(addressVm);
}
if (Address.IsValidAddress(addressText))
{
return(new AddressViewModel {
Address = addressText, Balance = 0, Name = "anonymous", Value = 0
});
}
return(null);
}
public static bool ValidateJSONRequestSessionHasAdminOpsLevel(
ISessionAdapter session,
out string error_code)
{
bool success = true;
int session_account_id = GetSessionAccountID(session);
DatabaseConstants.OpsLevel opsLevel =
AccountQueries.GetAccountOpsLevel(
ApplicationConstants.CONNECTION_STRING,
session_account_id,
out error_code);
if (opsLevel != DatabaseConstants.OpsLevel.invalid)
{
if (opsLevel >= DatabaseConstants.OpsLevel.admin)
{
error_code = SuccessMessages.GENERAL_SUCCESS;
success = true;
}
else
{
error_code = ErrorMessages.INSUFFICIENT_OPS_LEVEL;
}
}
return(success);
}
public async Task <ActionResult> Login(LoginModel model, string returnUrl)
{
if (User.Identity.IsAuthenticated)
{
return(RedirectToAction("Index", "Home"));
}
if (!ModelState.IsValid)
{
return(View(model));
}
var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, isPersistent : false, shouldLockout : false);
switch (result)
{
case SignInStatus.Success:
{
ApplicationUser user = AccountQueries.GetCurrentUser(model.Email);
CultureSetAttribute.SavePreferredCulture(HttpContext.Response, user.PreferredCulture);
if (Url.IsLocalUrl(returnUrl))
{
return(Redirect(returnUrl));
}
return(RedirectToAction("Login", "Account"));
}
case SignInStatus.Failure:
default:
{
ModelState.AddModelError("", "Invalid login");
return(View(model));
}
}
}
public IHttpActionResult Get()
{
List <Account> accounts = new List <Account>();
AccountQueries _accountQueries = new AccountQueries();
accounts = _accountQueries.GetAll();
List <AccountModel> accountModels = new List <AccountModel>();
foreach (var account in accounts)
{
AccountModel accountModel = new AccountModel();
accountModel.Id = account.Id;
accountModel.Name = account.Name;
foreach (var contact in account.Contacts)
{
ContactDetails contactDetails = new ContactDetails();
contactDetails.Id = contact.Id;
contactDetails.FirstName = contact.FirstName;
contactDetails.LastName = contact.LastName;
contactDetails.Email = contact.Email;
accountModel.Contacts.Add(contactDetails);
}
accountModels.Add(accountModel);
}
return(Ok(accountModels));
}
public List <BalanceViewModel> GetHolders(string symbol)
{
var accountQuery = new AccountQueries(_context);
var tokenQuery = new TokenQueries(_context);
var token = tokenQuery.QueryToken(symbol);
var balances = new List <BalanceViewModel>();
if (token == null)
{
return(balances);
}
if ((token.Flags & TokenFlags.Fungible) != 0)
{
foreach (var account in accountQuery.QueryRichList(30, symbol))
{
var accountTokenBalanceList = accountQuery.QueryAccountTokenBalanceList(account.Address, symbol);
foreach (var balance in accountTokenBalanceList)
{
var existingEntry = balances.SingleOrDefault(p => p.Address.Equals(account.Address));
if (existingEntry != null)
{
existingEntry.Balance += UnitConversion.ToDecimal(balance.Amount, (int)token.Decimals);
}
else
{
var vm = new BalanceViewModel
{
ChainName = balance.Chain,
Balance = UnitConversion.ToDecimal(balance.Amount, (int)token.Decimals),
Token = TokenViewModel.FromToken(token, AppSettings.MockLogoUrl),
Address = account.Address
};
balances.Add(vm);
}
}
}
}
else
{
var nftList = tokenQuery.QueryAllNonFungibleTokens(symbol);
foreach (var nonFungibleToken in nftList)
{
var vm = new BalanceViewModel
{
ChainName = nonFungibleToken.Chain,
Token = TokenViewModel.FromToken(token, AppSettings.MockLogoUrl),
Address = nonFungibleToken.AccountAddress
};
vm.Balance = nftList.Count(p => p.AccountAddress.Equals(vm.Address));
balances.Add(vm);
}
}
return(balances);
}
public IEnumerable <Account> GetAllAccounts()
{
AccountQueries accountQueries = new AccountQueries();
List <Account> accounts = new List <Account>();
accounts = accountQueries.GetAll();
return(accounts);
}
public ActionResult Index()
{
UserPageViewModel model = new UserPageViewModel();
model.VisitedBoards = AccountQueries.GetLastVisitedBoards(User.Identity.Name);
model.MyBoards = AccountQueries.GetMyBoards(User.Identity.Name);
return(View(model));
}
public IHttpActionResult Delete(int id)
{
AccountQueries _accountQueries = new AccountQueries();
Account account = _accountQueries.GetOneById(id);
_accountQueries.Delete(account);
return(Ok());
}
private List <TransactionViewModel> GetAddressTransactions(string address, int currentPage, int pageSize = AppSettings.PageSize, string chain = null)
{
var txQuery = new AccountQueries(_context);
var query = txQuery.QueryAddressTransactions(address, chain).Skip((currentPage - 1) * pageSize).Take(pageSize);
return(query.AsEnumerable().Select(TransactionViewModel.FromTransaction).ToList());
}
public void GetAllChildrenAndChildrenOfChildrenAccounts_When_No_Account_Exists()
{
var orgService = CreateTestingContext();
IAccountQueries queryEngine = new AccountQueries(orgService);
Assert.False(queryEngine.GetAllChildrenAndChildrenOfChildrenAccounts(new EntityReference(CrmObject.Account.EntityLogicalName, Guid.NewGuid())).Any());
}
public void GetChildAccountsForAnAccount_Throws_Error_On_Null_EntityReference()
{
var orgService = CreateTestingContext();
IAccountQueries queryEngine = new AccountQueries(orgService);
Assert.Throws <ArgumentNullException>(() => queryEngine.GetChildAccountsForAnAccount(null));
}
public List <AddressViewModel> GetSoulMasters(int currentPage, int pageSize = AppSettings.PageSize)
{
var addressQueries = new AccountQueries(_context);
var query = addressQueries.QuerySoulMasters().Skip((currentPage - 1) * pageSize).Take(pageSize);
return(query.AsEnumerable()
.Select(AddressViewModel.FromSoulMaster)
.ToList());
}
public ActionResult UserPreferences()
{
ApplicationUser user = AccountQueries.GetCurrentUser(User.Identity.Name);
PreferencesModel preferences = new PreferencesModel()
{
cultures = AccountQueries.GetCultures().ToList()
};
return(View(preferences));
}
public List <NftViewModel> GetNftListByAddress(string inputAddress) //todo redo this after rpc stuff
{
var accountQuery = new AccountQueries(_context);
var account = accountQuery.QueryAccount(inputAddress);
var nftList = new List <NftViewModel>();
var tokensQuery = new TokenQueries(_context);
var tokenList = tokensQuery.QueryTokens().ToList();
if (account != null)
{
foreach (var nfToken in account.NonFungibleTokens)
{
string viewerUrl = string.Empty, detailsUrl = string.Empty;
var tokenEntity = tokenList.SingleOrDefault(p => p.Symbol == nfToken.TokenSymbol);
if (tokenEntity.MetadataList.Count > 0)
{
viewerUrl = GetViewerUrl(tokenEntity);
detailsUrl = GetDetailsUrl(tokenEntity);
}
var existingVm = nftList.SingleOrDefault(vm => vm.Symbol == nfToken.TokenSymbol);
if (existingVm != null)
{
existingVm.InfoList.Add(new NftInfoViewModel
{
ViewerUrl = viewerUrl,
Id = nfToken.Id,
Info = detailsUrl
});
}
else
{
var newVm = new NftViewModel
{
Address = inputAddress,
Symbol = nfToken.TokenSymbol,
InfoList = new List <NftInfoViewModel>
{
new NftInfoViewModel
{
ViewerUrl = viewerUrl,
Id = nfToken.Id,
Info = detailsUrl
}
}
};
nftList.Add(newVm);
}
}
}
return(nftList);
}
public void InitalizeTables(
AsyncRPGDataContext dbContext,
Logger logger)
{
// Save the server constants into the DB
ConfigQueries.InitializeConfig(
dbContext,
m_config.APPLICATION_VERSION,
m_config.APPLICATION_WEB_URL,
m_config.APPLICATION_DEBUG_WEB_URL,
m_config.ACCOUNT_CLIENT_URL,
m_config.WEB_SERVICE_EMAIL_ADDRESS,
m_config.WEB_SERVICE_EMAIL_HOST,
m_config.WEB_SERVICE_EMAIL_PORT,
m_config.WEB_SERVICE_EMAIL_USERNAME,
m_config.WEB_SERVICE_EMAIL_PASSWORD,
m_config.DEFAULT_IRC_SERVER,
m_config.DEFAULT_IRC_PORT);
// Create test accounts
AccountQueries.CreateAccountNoEmailVerify(
dbContext,
"test",
AccountQueries.ClientPasswordHash("password"),
"*****@*****.**",
DatabaseConstants.OpsLevel.player);
AccountQueries.CreateAccountNoEmailVerify(
dbContext,
"test2",
AccountQueries.ClientPasswordHash("password"),
"*****@*****.**",
DatabaseConstants.OpsLevel.player);
// Re-import the mob type JSON data into the DB
{
MobTypeImporter importer = new MobTypeImporter(logger);
importer.ParseMobTypes(dbContext, m_config.MOBS_DIRECTORY + "/mob_types.json");
}
// Re-import the mob spawn tables JSON data into the DB (dependent on mob types)
{
MobSpawnTableImporter importer = new MobSpawnTableImporter(logger);
importer.ParseMobSpawnTables(dbContext, m_config.MOBS_DIRECTORY + "/mob_spawn_tables.json");
}
// Re-import the room template XML into the DB (dependent on mob types and spawn tables)
// This also does some import processing on the room templates (visibility, nav-mesh, etc).
{
RoomTemplateImporter importer = new RoomTemplateImporter(logger);
importer.ParseRoomTemplates(dbContext, m_config.MAPS_DIRECTORY);
}
}
public AccountCreatorServiceTests()
{
_testEncryptionUtility = new EncryptionUtility();
var testAccountOptions = new DbContextOptionsBuilder <AccountDbContext>()
.UseInMemoryDatabase("TestAccountCreatorDatabase")
.Options;
var testAccountDbContext = new AccountDbContext(testAccountOptions);
_testAccountQueries = new AccountQueries(testAccountDbContext);
_testAccountCreator = new AccountCreator(_testEncryptionUtility, _testAccountQueries);
}
public void GetAllChildrenAndChildrenOfChildrenAccounts_With_No_Children()
{
var orgService = CreateTestingContext();
IAccountQueries queryEngine = new AccountQueries(orgService);
var results =
queryEngine.GetAllChildrenAndChildrenOfChildrenAccounts(new EntityReference(CrmObject.Account.EntityLogicalName,
Guid.Parse("{66F541B7-2A0C-4668-B2D6-4E6C6F556946}")));
Assert.True(results.Count == 0);
}
public ActionResult UserPreferences(PreferencesModel model)
{
if (ModelState.IsValid)
{
string userName = User.Identity.Name;
string prefferedCulture = model.cultures.Where(x => x.Id == model.CultureIdentifier).Select(x => x.CultureTag).SingleOrDefault();
AccountQueries.ChangeLanguagePreference(userName, prefferedCulture);
CultureSetAttribute.SavePreferredCulture(HttpContext.Response, prefferedCulture);
}
return(View(model));
}
public void GetAllAccounts_Retrieves_All_Accounts()
{
var orgService = CreateTestingContext();
IAccountQueries queryEngine = new AccountQueries(orgService);
var results = queryEngine.GetAllAccounts();
Assert.True(results.Count == 9);
Assert.All(results, (x) => x.Contains(CrmObject.Account.Fields.AccountId));
Assert.All(results, x => x.Id.Equals(x.AccountId.Value));
}
public void GetChildAccountsForAnAccount_When_Account_Exists()
{
var orgService = CreateTestingContext();
IAccountQueries queryEngine = new AccountQueries(orgService);
var results =
queryEngine.GetChildAccountsForAnAccount(new EntityReference(CrmObject.Account.EntityLogicalName,
Guid.Parse("{FCFD0F00-B18A-45E8-9CF5-2A4C6BB6923D}")));
Assert.True(results.Count == 2);
Assert.True(results.Any(x => x.Id == Guid.Parse("{70446EE5-8591-4141-9429-632F231B02F6}")));
Assert.True(results.Any(x => x.Id == Guid.Parse("{E063D3AF-13E3-4A89-9E26-3FE9E88D491B}")));
}
public void GetAllChildrenAndChildrenOfChildrenAccounts_With_Children_And_A_Parent()
{
var orgService = CreateTestingContext();
IAccountQueries queryEngine = new AccountQueries(orgService);
var results =
queryEngine.GetAllChildrenAndChildrenOfChildrenAccounts(new EntityReference(CrmObject.Account.EntityLogicalName,
Guid.Parse("{E063D3AF-13E3-4A89-9E26-3FE9E88D491B}")));
Assert.True(results.Count == 2);
Assert.True(results.Any(x => x.Id == Guid.Parse("{66F541B7-2A0C-4668-B2D6-4E6C6F556946}")));
Assert.True(results.Any(x => x.Id == Guid.Parse("{7C4DB64C-0D80-4092-8F31-D6EB7558ED39}")));
}
public AccountQueriesTests()
{
var optionsBuilder = new DbContextOptionsBuilder <StoreASPContext>();
optionsBuilder.UseSqlServer(
@"Data Source=den1.mssql8.gear.host;Initial Catalog=storeasptests;User ID=storeasptests;Password=Sp3FG22Bkt_!");
var context = new StoreASPContext(optionsBuilder.Options);
_context = context;
_accountQueries = new AccountQueries(
context
);
}
public ActionResult DeleteBoard(int?id)
{
ApplicationUser user = AccountQueries.GetCurrentUser(User.Identity.Name);
bool success = BoardQueries.DeleteBoard(user, (int)id);
if (success)
{
string boardSuccesfullyDeleted = WebResources.BoardDeleteSuccess;
return(Json(new { success = true, message = boardSuccesfullyDeleted }));
}
string boardDeletionFailed = WebResources.BoardDeleteFailure;
return(Json(new { success = false, message = boardDeletionFailed }));
}
public ClaimsIdentityModel GetCurrentUser()
{
if (CurrentUser == null)
{
return(null);
}
Mapper.Initialize(cfg => {
cfg.CreateMap <ApplicationUser, ClaimsIdentityModel>();
cfg.CreateMap <RoleClaim, ClaimModel>();
});
ClaimsIdentityModel result = Mapper.Map <ClaimsIdentityModel>(CurrentUser);
result.Claims = AccountQueries.GetClaimsDictionaryByUser(CurrentUser, this.DbContext);
return(result);
}
/// <summary>
/// Sends the email.
/// </summary>
/// <param name="logOnView">The log on view.</param>
/// <returns></returns>
/// <exception cref="ApplicationException">Repository GetRegistrationByEmail</exception>
public IUserRegistration GetUserByEmail(string email)
{
try
{
using (
var dbContext = (PitalyticsEntities)dbContextFactory.GetDbContext())
{
var aRecord = AccountQueries.getRegistrationByEmail(dbContext, email);
return(aRecord);
}
}
catch (Exception e)
{
throw new ApplicationException("Repository GetRegistrationByEmail", e);
}
}
/// <summary>
/// Gets the registration by email.
/// </summary>
/// <param name="email">The email.</param>
/// <returns></returns>
/// <exception cref="System.ApplicationException">Repository GetRegistrationByEmail</exception>
public IAgentOfDeduction GetAgentOfDeductionId(int userId)
{
try
{
using (
var dbContext = (PitalyticsEntities)dbContextFactory.GetDbContext())
{
var aRecord = AccountQueries.GetAgentOfDeductionId(dbContext, userId);
return(aRecord);
}
}
catch (Exception e)
{
throw new ApplicationException("Repository AgentOfDeduction", e);
}
}
/// <summary>
/// Gets the user identifier.
/// </summary>
/// <param name="userId">The identifier.</param>
/// <returns></returns>
/// <exception cref="ApplicationException">CheckActivationCode</exception>
public IUserRegistration GetUserId(int userId)
{
try
{
using (
var dbContext = (PitalyticsEntities)dbContextFactory.GetDbContext())
{
var list = AccountQueries.getUserById(dbContext, userId);
return(list);
}
}
catch (Exception e)
{
throw new ApplicationException("CheckActivationCode", e);
}
}
/// <summary>
/// Gets the user registration.
/// </summary>
/// <returns></returns>
/// <exception cref="ApplicationException">Repository GetUserRegistration</exception>
public IList <IUserRegistration> GetUserRegistration()
{
try
{
using (
var dbContext = (PitalyticsEntities)dbContextFactory.GetDbContext())
{
var list = AccountQueries.GetUserRegistration(dbContext).ToList();
return(list);
}
}
catch (Exception e)
{
throw new ApplicationException("Repository GetUserRegistration", e);
}
}
/// <summary>
/// Gets the user role actions by identifier.
/// </summary>
/// <param name="email"></param>
/// <returns></returns>
/// <exception cref="ApplicationException">Repository GetUserRoleActionsById</exception>
public IList <int> GetUserRoleActionsById(string email)
{
try
{
using (
var dbContext = (PitalyticsEntities)dbContextFactory.GetDbContext())
{
var list = AccountQueries.GetUserRoleActionCollectionId(dbContext, email).ToList();
return(list);
}
}
catch (Exception e)
{
throw new ApplicationException("Repository GetUserRoleActionsById", e);
}
}
