private bool ValidateAccountKafkaObject(dynamic source, KafkaMessage target,
bool isIncludeParentChild, DbAccount sourceAccountDetail)
{
var json = JObject.Parse(JsonConvert.SerializeObject(target.Message));
var eventMsg = JsonConvert.DeserializeObject <AccountEvent>(json.SelectToken("AccountEvent").ToString());
return(AccountTopic == target.Topic &&
source.CustomerUID.ToString() == target.Key &&
eventMsg.AccountName == source.CustomerName &&
eventMsg.AccountUID == source.CustomerUID &&
(new List <string> {
"Create", "Update"
}.Contains(eventMsg.Action)) &&
eventMsg.BSSID == source.BSSID &&
eventMsg.DealerAccountCode == source.DealerAccountCode &&
eventMsg.NetworkCustomerCode == source.NetworkCustomerCode &&
isIncludeParentChild
? (eventMsg.fk_ParentCustomerUID == sourceAccountDetail.fk_ParentCustomerUID &&
eventMsg.fk_ChildCustomerUID == sourceAccountDetail.fk_ChildCustomerUID)
: true);
}
public static Account FromDb(DbAccount acc)
{
return(new Account()
{
AccountId = acc.AccountId,
Name = acc.Name,
NameChosen = acc.NameChosen,
Converted = false,
Admin = acc.Admin,
VerifiedEmail = acc.Verified,
Credits = acc.Credits,
NextCharSlotPrice = 100,
BeginnerPackageTimeLeft = 0,
Vault = Vault.FromDb(acc, new DbVault(acc)),
Stats = Stats.FromDb(acc, new DbClassStats(acc)),
Guild = new Guild()
});
}
public void processRegisteredPayment(int id)
{
using (var db = new BankDBContext())
{
try
{
DbRegisteredPayment payment = db.RegisteredPayments.Find(id);
DbAccount customerAccount = db.Accounts.FirstOrDefault(
a => a.accountNumber.Equals(payment.customerAccountNumber));
DbAccount targetAccount = db.Accounts.FirstOrDefault(
a => a.accountNumber.Equals(payment.targetAccountNumber));
DbIssuedPayment ip = new DbIssuedPayment()
{
customerAccountNumber = payment.customerAccountNumber,
targetAccountNumber = payment.targetAccountNumber,
receiverName = payment.receiverName,
amount = payment.amount,
issuedDate = DateTime.Now,
customerAccountNumberFK = customerAccount
};
if (targetAccount != null)
{
ip.targetAccountNumberFK = targetAccount;
}
db.IssuedPayments.Add(ip);
DbRegisteredPayment test = db.RegisteredPayments.FirstOrDefault(rp => rp.id == payment.id);
db.RegisteredPayments.Remove(test);
customerAccount.balance += payment.amount;
db.Entry(customerAccount).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
}
catch (Exception e)
{
errorReport(e.ToString());
return;
}
}
}
public List <Account> deleteAccount(string accountNumber)
{
try
{
var db = new BankDBContext();
DbAccount account = db.Accounts.FirstOrDefault(a => a.accountNumber.Equals(accountNumber));
string nid = account.NID;
IEnumerable <DbRegisteredPayment> registeredPayments = db.RegisteredPayments.
Where(rp => rp.customerAccountNumber.Equals(account.accountNumber)).ToList();
foreach (DbRegisteredPayment rp in registeredPayments)
{
db.RegisteredPayments.Remove(rp);
}
IEnumerable <DbIssuedPayment> issuedPayments = db.IssuedPayments.
Where(ip => ip.customerAccountNumber.Equals(account.accountNumber)).ToList();
foreach (DbIssuedPayment ip in issuedPayments)
{
db.IssuedPayments.Remove(ip);
}
account.registeredPayments = null;
account.issuedPayments = null;
db.Accounts.Remove(account);
db.SaveChanges();
List <Account> remainingAccounts = db.Accounts.Where(a => a.NID.Equals(nid)).Select(a => new Account()
{
accountNumber = a.accountNumber,
balance = a.balance
})
.ToList();
return(remainingAccounts);
}
catch (Exception e)
{
BankCustomerDAL.errorReport(e.ToString());
return(null);
}
}
private void mfilesAccountProcessing(List <MfilesLogAccount> allaccount, DbAccount dbaccount)
{
var notfound = true;
foreach (MfilesLogAccount mfilesLogAccount in allaccount)
{
if (mfilesLogAccount.matched)
{
continue;
}
if (mfilesLogAccount.name == dbaccount.code)
{
checkUpdate(mfilesLogAccount, dbaccount);
mfilesLogAccount.matched = true;
notfound = false;
break;
}
}
if (notfound)//add new account
{
try
{
app.LoginAccountOperations.AddLoginAccount(
new LoginAccount
{
AccountType = MFLoginAccountType.MFLoginAccountTypeMFiles,
FullName = dbaccount.name,
Enabled = true,
LicenseType = MFLicenseType.MFLicenseTypeConcurrentUserLicense,
ServerRoles = MFLoginServerRole.MFLoginServerRoleLogIn,
UserName = dbaccount.code,
EmailAddress = dbaccount.email
}, "admin");
}
catch (Exception ex)
{
Trace.TraceError("AddLoginAccount error:" + dbaccount.name, ex);
}
}
}
public void TryLogin(DbAccount user, EAClient client)
{
//is someone else already logged in as this user?
var oldUser = Users.GetUserByName(user.Username);
if (oldUser != null)
{
oldUser.Connection.Close(); //should remove the old user.
Thread.Sleep(500);
}
var personas = new string[4];
for (int i = 0; i < user.Personas.Count; i++)
{
personas[i] = user.Personas[i];
}
//make a user object from DB user
var user2 = new User()
{
Connection = client,
ID = user.ID,
Personas = personas,
Username = user.Username,
IP = client.IP
};
Users.AddUser(user2);
client.User = user2;
client.SendMessage(new AuthOut()
{
TOS = user.ID.ToString(),
NAME = user.Username,
PERSONAS = string.Join(',', user.Personas)
});
Rooms.SendRooms(user2);
}
public Result CreateAccount(PostAccount postAccount)
{
Result result = new Result();
//walidacja pól
if (this.postAcocunt != null)
{
result = AccountValidate(this.postAcocunt);
if (!result.status)
{
return(result);
}
else
{
// sprawdzznie duplikatu
if (account.Get(postAcocunt.UserEmail) == null)
{
result.status = false;
result.value = "Konto " + postAcocunt.UserEmail + " już istnieje !";
return(result);
}
else
{
this.dbAccount = ModeltoDtoAccoutMapper.map(postAcocunt);
// mapowanie pól
if (dbAccount != null)
{
account.Add(dbAccount);
}
else
{
result.status = false;
result.value = "Błąd zapisu !";
}
}
}
}
return(result);
}
public static Stats FromDb(DbAccount acc, DbClassStats stats)
{
Stats ret = new Stats()
{
TotalFame = acc.TotalFame,
Fame = acc.Fame,
entries = new Dictionary <ushort, ClassStatsEntry>(),
BestCharFame = 0
};
foreach (var i in stats.AllKeys)
{
var objType = ushort.Parse(i);
var entry = ClassStatsEntry.FromDb(objType, stats[objType]);
if (entry.BestFame > ret.BestCharFame)
{
ret.BestCharFame = entry.BestFame;
}
ret.entries[objType] = entry;
}
return(ret);
}
public static Account FromDb(DbAccount acc)
{
return(new Account()
{
AccountId = acc.AccountId,
Name = acc.Name,
NameChosen = acc.NameChosen,
Admin = acc.Admin,
FirstDeath = acc.FirstDeath,
Credits = acc.Credits,
NextCharSlotPrice = Program.Resources.Settings.NewAccounts.SlotCost,
NextCharSlotCurrency = (int)Program.Resources.Settings.NewAccounts.SlotCurrency,
Vault = Vault.FromDb(acc, new DbVault(acc)),
Stats = Stats.FromDb(acc, new DbClassStats(acc)),
Guild = GuildIdentity.FromDb(acc, new DbGuild(acc)),
Skins = acc.Skins ?? new ushort[0],
});
}
public XElement ToXml(EmbeddedData data, DbAccount acc)
{
return
(new XElement("Chars",
new XAttribute("nextCharId", NextCharId),
new XAttribute("maxNumChars", MaxNumChars),
Characters.Select(x => x.ToXml()),
Account.ToXml(),
new XElement("News",
News.Select(x => x.ToXml())
),
new XElement("Servers",
Servers.Select(x => x.ToXml())
),
ClassAvailabilityList.ToXml(),
new XElement("OwnedSkins", Utils.GetCommaSepString(acc.OwnedSkins.ToArray())),
Lat == null ? null : new XElement("Lat", Lat),
Long == null ? null : new XElement("Long", Long),
MaxClassLevel.ToXml(data),
ItemCosts.ToXml()
));
}
public Account CreateAccount(string userName, string decryptedPassword)
{
if (string.IsNullOrWhiteSpace(userName))
{
throw new ArgumentException("Username was null or whitespace");
}
if (string.IsNullOrWhiteSpace(decryptedPassword))
{
throw new ArgumentException("Password was null or whitespace");
}
var dbKey = $"USER_{userName.ToLower()}";
//The account already exists
if (BankLedgerService.DataBase.ContainsKey(dbKey))
{
return(null);
}
var encryptedPasswordAndSalt = HashUtility.
ComputeHash(decryptedPassword);
var dbAccount = new DbAccount
{
User_Name = userName,
Encrypted_Password = encryptedPasswordAndSalt.Item1,
Salt = encryptedPasswordAndSalt.Item2,
Last_Login = DateTime.Now
};
var account = new Account(userName, encryptedPasswordAndSalt.Item1,
encryptedPasswordAndSalt.Item2, dbAccount.Last_Login);
BankLedgerService.DataBase[dbKey] = dbAccount;
return(account);
}
public void UpdateAccount_ValidPayload_TransactionSuccess(bool isParentNull, bool isChildNull)
{
//Arrange
var accountUid = Guid.NewGuid();
var accountDetail = new DbAccount
{
CustomerAccountID = 1,
fk_ChildCustomerUID = isChildNull ? (Guid?)null : Guid.NewGuid(),
fk_ParentCustomerUID = isParentNull ? (Guid?)null : Guid.NewGuid(),
CustomerAccountUID = accountUid
};
var updateEvent = new UpdateCustomerEvent
{
CustomerUID = accountUid,
BSSID = "BSS02",
CustomerName = "CUS02",
NetworkCustomerCode = "NCC02",
DealerAccountCode = "DAC02",
ActionUTC = DateTime.UtcNow,
ReceivedUTC = DateTime.UtcNow
};
transaction.Execute(Arg.Any <List <Action> >()).Returns(a =>
{
a.Arg <List <Action> >().ForEach(action => action.Invoke());
return(true);
});
//Act
var resultData = accountService.UpdateAccount(updateEvent, accountDetail);
//Assert
Assert.True(resultData);
transaction.Received(1).Upsert(
Arg.Is <DbAccount>(account => ValidateAccountObject(updateEvent, account, true, accountDetail)));
transaction.Received(1).Publish(
Arg.Is <KafkaMessage>(m => ValidateAccountKafkaObject(updateEvent, m, true, accountDetail)));
}
public XElement ToXml(XmlData data, DbAccount acc)
{
return
(new XElement("Chars",
new XAttribute("nextCharId", NextCharId),
new XAttribute("maxNumChars", MaxNumChars),
Characters.Select(x => x.ToXml()),
Account.ToXml(),
new XElement("News",
News.Select(x => x.ToXml())
),
new XElement("Servers",
Servers.Select(x => x.ToXml())
),
ClassAvailabilityList.ToXml(),
new XElement("OwnedSkins",
data.ObjectDescs.Values.Where(_ => _.Skin && !_.NoSkinSelect).Select(_ => _.ObjectType).ToArray().ToCommaSepString()),
//ItemCosts.ToXml(data),
Lat == null ? null : new XElement("Lat", Lat),
Long == null ? null : new XElement("Long", Long),
MaxClassLevel.ToXml(data)
));
}
public static Account FromDb(DbAccount acc)
{
return(new Account()
{
AccountId = acc.AccountId,
Name = acc.Name,
NameChosen = acc.NameChosen,
Converted = acc.Converted,
Admin = acc.AccType == AccountType.ULTIMATE_ACCOUNT,
MapEditor = acc.AccType == AccountType.LOESOFT_ACCOUNT,
VerifiedEmail = acc.Verified,
Credits = acc.Credits,
NextCharSlotPrice = 100, // need adjusts
BeginnerPackageTimeLeft = 604800,
Gifts = acc.Gifts,
PetYardType = acc.PetYardType,
FortuneTokens = acc.FortuneTokens,
IsAgeVerified = acc.IsAgeVerified,
Vault = Vault.FromDb(acc, new DbVault(acc)),
Stats = Stats.FromDb(acc, new DbClassStats(acc)),
Guild = new Guild()
});
}
public void GetAccount_ValidAccount_ReturnsResult()
{
//Arrange
var accountUid = Guid.NewGuid();
var account = new DbAccount
{
CustomerAccountID = 1,
CustomerAccountUID = accountUid,
BSSID = "BSS01",
AccountName = "ACC01",
NetworkCustomerCode = "NCC01",
DealerAccountCode = "DAC01",
fk_ParentCustomerUID = Guid.NewGuid(),
fk_ChildCustomerUID = Guid.NewGuid(),
RowUpdatedUTC = DateTime.UtcNow
};
var config = new ComparisonConfig
{
IgnoreObjectTypes = true,
MaxMillisecondsDateDifference = 500,
MaxDifferences = 0
};
var accountCompareLogic = new CompareLogic(config);
transaction.Get <DbAccount>(Arg.Any <string>()).Returns(new List <DbAccount> {
account
});
//Act
var resultData = accountService.GetAccount(accountUid);
//Arrange
Assert.NotNull(resultData);
ComparisonResult compareResult = accountCompareLogic.Compare(account, resultData);
Assert.True(compareResult.Differences.Count == 0);
}
public DbAccount GetLastBalances(IDbConnection db, ExchangeName ex)
{
using (var result = db.QueryMultiple(DbQueryStr.GetLastBalances, new { Exchange = (int)ex }))
{
var query1 = result.Read <DbAccount>().Single();
var query2 = result.Read <DbAccount>().SingleOrDefault();
var query3 = result.Read <DbAccount>().SingleOrDefault();
var query4 = result.Read <DbAccount>().SingleOrDefault();
var query5 = result.Read <DbAccount>().SingleOrDefault();
var query6 = result.Read <DbAccount>().Single();
var account = new DbAccount
{
CurrencyRate = query1.CurrencyRate,
InitUsdBalance = query6.InitUsdBalance,
UsdBalance = query1.UsdBalance,
Exchange = ex
};
if (query2 != null)
{
account.BtcBalance = query2.BtcBalance;
}
if (query3 != null)
{
account.BchBalance = query3.BchBalance;
}
if (query4 != null)
{
account.LtcBalance = query4.LtcBalance;
}
if (query5 != null)
{
account.EthBalance = query5.EthBalance;
}
return(account);
}
}
private bool Validate(DbAccount acc, int currency, int total)
{
switch ((Currency)currency)
{
case Currency.GOLD:
return(Credits(acc) >= total);
case Currency.FAME:
return(Fame(acc) >= total);
case Currency.GUILD_FAME:
return(GuildFame(acc) >= total);
case Currency.FORTUNE_TOKENS:
return(FortuneTokens(acc) >= total);
case Currency.EMPIRES_COIN:
return(EmpiresCoin(acc) >= total);
case Currency.INVALID:
default:
return(false);
}
}
public static Account FromDb(DbAccount acc)
{
return(new Account()
{
AccountId = acc.AccountId,
Name = acc.Name,
NameChosen = acc.NameChosen,
Converted = false,
Admin = acc.Admin,
Rank = acc.Rank,
VerifiedEmail = acc.Verified,
AgeVerified = acc.AgeVerified,
FirstDeath = acc.FirstDeath,
PetYardType = acc.PetYardType,
Credits = acc.Credits,
NextCharSlotPrice = Program.Resources.Settings.CharacterSlotCost,
CharSlotCurrency = Program.Resources.Settings.CharacterSlotCurrency,
MenuMusic = Program.Resources.Settings.MenuMusic,
DeadMusic = Program.Resources.Settings.DeadMusic,
MapMinRank = Program.Resources.Settings.MapMinRank,
SpriteMinRank = Program.Resources.Settings.SpriteMinRank,
BeginnerPackageTimeLeft = 0,
Vault = Vault.FromDb(acc, new DbVault(acc)),
Stats = Stats.FromDb(acc, new DbClassStats(acc)),
Guild = GuildIdentity.FromDb(acc, new DbGuild(acc)),
Skins = acc.Skins ?? new ushort[0],
Banned = acc.Banned,
BanReasons = acc.Notes,
BanLiftTime = acc.BanLiftTime,
LastSeen = acc.LastSeen
});
}
public bool TryConnect(Client client)
{
/**if (Clients.Count >= MaxClients)
* return false;
* else
* {
* client.Id = Interlocked.Increment(ref nextClientId);
* return Clients.TryAdd(client.Id.ToString(), client);
* }**/
DbAccount acc = client.Account;
if (Clients.Count >= MaxClients)
{
return(false);
}
client.Id = Interlocked.Increment(ref nextClientId);
Client dummy;
//if (Clients.ContainsKey(acc.AccountId))
// if (!Clients[acc.AccountId].Socket.Connected)
// Clients.TryRemove(acc.AccountId, out dummy);
bool ret = Clients.TryAdd(client.Id.ToString(), client);
return(ret);
}
public void DeleteAccountCustomerRelationShip_ValidPayload_TransactionSuccess()
{
//Arrange
var accountUid = Guid.NewGuid();
var parentUid = Guid.NewGuid();
var childUid = Guid.NewGuid();
var actionUTC = DateTime.UtcNow;
var accountDetail = new DbAccount
{
CustomerAccountID = 1,
CustomerAccountUID = accountUid,
AccountName = "ACC04",
BSSID = "BSS04",
DealerAccountCode = "DAC04",
NetworkCustomerCode = "NCC04",
};
transaction.Execute(Arg.Any <List <Action> >()).Returns(a =>
{
a.Arg <List <Action> >().ForEach(action => action.Invoke());
return(true);
});
//Act
var resultData = accountService.DeleteAccountCustomerRelationShip(
parentUid, childUid, accountDetail, actionUTC);
//Assert
Assert.True(resultData);
transaction.Received(1).Upsert(
Arg.Is <DbAccount>(account => ValidateCreateCustomerRelationshipAccountObject(
true, null, parentUid, childUid, account, accountDetail)));
transaction.Received(1).Publish(
Arg.Is <KafkaMessage>(message => ValidateCreateCustomerRelationshipAccountKafkaObject(
null, parentUid, childUid, message, accountDetail, actionUTC)));
}
/// <summary>
/// Add a new account the database
/// </summary>
/// <param name="account">Account that should be added</param>
public void AddAccount(DbAccount account)
{
_context.Accounts.Add(account);
_context.SaveChanges();
}
private int EmpiresCoin(DbAccount acc) => acc.EmpiresCoin;
private int FortuneTokens(DbAccount acc) => acc.FortuneTokens;
private int GuildFame(DbAccount acc) => acc.GuildFame;
private double Fame(DbAccount acc) => acc.Fame;
private int Credits(DbAccount acc) => acc.Credits;
public void SaveAndFindAccount()
{
var emptyGuid = Guid.Empty.ToString();
var key = new Dictionary <string, object>
{
["typ"] = "EC",
["crv"] = "P-256",
["x"] = 1,
["y"] = 2
};
var jwk = JsonConvert.SerializeObject(key);
var kid = Guid.NewGuid();
var dbAcct = new DbAccount
{
Jwk = jwk,
Details = new AccountDetails
{
Kid = kid.ToString(),
Payload = new Account
{
Id = BitConverter.ToString(kid.ToByteArray()),
Key = key,
Contact = new string[]
{
"*****@*****.**",
"*****@*****.**",
}
}
}
};
Assert.AreEqual(0, dbAcct.Id);
_repo.SaveAccount(dbAcct);
Assert.AreEqual(1, dbAcct.Id);
// Get by DB ID
var getAcct = _repo.GetAccount(dbAcct.Id);
AssertEqual(dbAcct, getAcct, "existing account by DB ID");
// Get by JWK
getAcct = _repo.GetAccountByJwk(jwk);
AssertEqual(dbAcct, getAcct, "existing account by JWK");
getAcct = _repo.GetAccountByJwk(kid.ToString());
Assert.IsNull(getAcct);
// Get by KID
getAcct = _repo.GetAccountByKid(kid.ToString());
AssertEqual(dbAcct, getAcct, "existing account by KID");
getAcct = _repo.GetAccountByKid(jwk);
Assert.IsNull(getAcct);
void AssertEqual(DbAccount exp, DbAccount act,
string message = null)
{
Assert.IsNotNull(getAcct, message);
Assert.AreEqual(dbAcct.Id, getAcct.Id, message);
Assert.AreEqual(dbAcct.Details.Kid, getAcct.Details.Kid, message);
Assert.AreEqual(dbAcct.Jwk, getAcct.Jwk, message);
CollectionAssert.AreEqual(
(Dictionary <string, object>)dbAcct.Details.Payload.Key,
(Dictionary <string, object>)getAcct.Details.Payload.Key, message);
CollectionAssert.AreEqual(
dbAcct.Details.Payload.Contact,
getAcct.Details.Payload.Contact, message);
}
}
public Account(DbAccount data)
{
_data = data;
}
public async Task <PkgPurchaseResult> Purchase(Database db, DbAccount acc)
{
var tran = db.Conn.CreateTransaction();
// handle quantity and max purchase checks
ConditionResult quantityResult = null;
ConditionResult maxPurchaseResult = null;
if (Quantity > -1)
{
quantityResult = tran.AddCondition(Condition.HashNotEqual(_key, "amountPurchased", Quantity));
}
tran.HashIncrementAsync(_key, "amountPurchased");
if (MaxPurchase > -1)
{
maxPurchaseResult = tran.AddCondition(Condition.HashNotEqual(_key, acc.AccountId, MaxPurchase));
}
tran.HashIncrementAsync(_key, acc.AccountId);
// deduct cost
switch (Cost.Currency)
{
case 0:
if (acc.Credits < Cost.Amount)
{
return(PkgPurchaseResult.NotEnoughGold);
}
db.UpdateCurrency(acc, -Cost.Amount, CurrencyType.Gold, tran);
break;
case 1:
if (acc.Fame < Cost.Amount)
{
return(PkgPurchaseResult.NotEnoughFame);
}
db.UpdateCurrency(acc, -Cost.Amount, CurrencyType.Fame, tran);
break;
default:
return(PkgPurchaseResult.InvalidCurrency);
}
// save gifts
var items = new List <ushort>();
foreach (var pkgItem in Contents.Items ?? new PackageItem[0])
{
items.AddRange(Enumerable.Repeat(pkgItem.Item, pkgItem.Count));
}
db.AddGifts(acc, items, tran);
// initiate transaction
var t1 = tran.ExecuteAsync();
// upon success add character slots / vault chests
var t2 = t1.ContinueWith(t =>
{
var success = !t.IsCanceled && t.Result;
if (!success)
{
if (quantityResult != null && !quantityResult.WasSatisfied)
{
return(PkgPurchaseResult.QuantityZero);
}
if (maxPurchaseResult != null && !maxPurchaseResult.WasSatisfied)
{
return(PkgPurchaseResult.MaxedPurchase);
}
return(PkgPurchaseResult.TransactionFailed);
}
if (Contents.CharacterSlots > 0)
{
acc.MaxCharSlot += Contents.CharacterSlots;
}
if (Contents.VaultChests > 0)
{
acc.VaultCount += Contents.VaultChests;
}
acc.FlushAsync();
return(PkgPurchaseResult.Success);
});
// await tasks
try
{
await Task.WhenAll(t1, t2);
}
catch (Exception e)
{
Log.Error(e);
return(PkgPurchaseResult.Error);
}
return(t2.Result);
}
public SaveAccountNotification(DbAccount account)
{
Account = account;
}
