private async Task DoTimer(ITimerTrigger timer, TimerTriggeredHandlerArgs args, CancellationToken ct)
{
var balance = await _b2C2RestClient.BalanceAsync(ct);
using (var context = CreateContext())
{
var ts = DateTime.UtcNow;
var items = new List <BalanceEntity>();
foreach (var assetBalance in balance)
{
var assetName = assetBalance.Key;
foreach (var assetMapping in _assetMappings)
{
assetName = assetName.Replace(assetMapping.Key, assetMapping.Value);
}
var item = new BalanceEntity
{
Asset = assetName,
Timestamp = ts,
Balance = assetBalance.Value
};
items.Add(item);
}
context.Balances.AddRange(items);
await context.SaveChangesAsync(ct);
}
}
public int AddClient(ClientRegistrationInfo clientInfo)
{
if (validator.ValidateClientInfo(clientInfo))
{
var clientToAdd = new ClientEntity()
{
ClientFirstName = clientInfo.FirstName,
ClientLastName = clientInfo.LastName,
PhoneNumber = clientInfo.PhoneNumber
};
clientsRepository.Add(clientToAdd);
clientsRepository.SaveChanges();
var balance = new BalanceEntity()
{
ClientID = clientToAdd.ClientID,
ClientBalance = 0
};
balanceRepository.Add(balance);
balanceRepository.SaveChanges();
return(clientToAdd.ClientID);
}
return(-1);
}
public string CreateBalance(BalanceInfo args)
{
int balancesCount;
try
{
List <BalanceEntity> userBalanceEntities = this.balanceTableRepository.GetAll(args.UserID);
balancesCount = userBalanceEntities.Count;
}
catch
{
throw new ArgumentException($"Can't count balances for this user {args.UserID}. It might be not exists");
}
var entityToAdd = new BalanceEntity()
{
CreatedAt = DateTime.Now,
UserID = args.UserID,
BalanceID = args.UserID.ToString() + "0" + balancesCount.ToString(),
Balance = args.Balance,
StockID = args.StockID,
StockAmount = args.StockAmount,
};
if (this.balanceTableRepository.Contains(entityToAdd))
{
throw new ArgumentException("Balance with that number is already exists. Can't continue");
}
this.balanceTableRepository.Add(entityToAdd);
this.balanceTableRepository.SaveChanges();
return(entityToAdd.BalanceID);
}
public void ShouldChangeBalanceAmount()
{
// Arrange
SalesService salesService = new SalesService(
this.operationTableRepository,
this.balanceTableRepository,
this.blockedMoneyTableRepository,
this.sharesNumberTableRepository,
this.blockedSharesNumberTableRepository);
var testBalance = new BalanceEntity()
{
Id = 10,
Amount = 30000.00M,
Client = new ClientEntity()
{
Id = 10
},
Status = true
};
decimal newAmount = 35000.00M;
// Act
bool flag = salesService.ChangeBalance(testBalance, newAmount);
// Assert
this.balanceTableRepository.Received(1).ChangeAmount(testBalance.Id, newAmount);
this.balanceTableRepository.Received(1).SaveChanges();
if (!flag)
{
throw new ArgumentException("The flag is false");
}
}
/// <summary>
/// 余额
/// </summary>
/// <param name="dto"></param>
/// <param name="roleId"></param>
private void Balance(CustomerDto dto, UserType roleId)
{
var b = new BalanceEntity
{
UserId = dto.Id,
OperatorId = dto.Operator,
BeforeValue = 0,
Value = _configuration.GetValue("giftNumber", 20),
ModifyDate = DateTime.Now,
SalesMan = dto.SalesMan,
Remark = "赠送"
};
_balanceRepository.ChangeBalance(b);
var orgId = _staffRepository.GetOrgId(dto.SalesMan).OrgId;
var dataInOrg = new DataInOrgEntity
{
DataId = dto.Id,//客户id
DataType = (int)DataType.Balance,
OrgId = orgId,
RoleId = ((int)roleId).ToString()
};
_dataInOrgRepository.Inserts(dataInOrg);
}
public int RegisterNewBalance(BalanceRegistrationInfo args)
{
if (args.Amount <= 0)
{
throw new ArgumentException("Invalid BalanceRegistrationInfo. Can't continue.");
}
var entityToAdd = new BalanceEntity()
{
Client = args.Client,
Amount = args.Amount,
Status = true
};
if (this.tableRepository.Contains(entityToAdd))
{
throw new ArgumentException("Balance for this client has been registered. Can't continue.");
}
this.tableRepository.Add(entityToAdd);
this.tableRepository.SaveChanges();
return(entityToAdd.Id);
}
public void ShouldCheckPermissionToSell()
{
//Arrange
var balanceTableRepository = Substitute.For <IBalanceTableRepository>();
ValidationOfTransactionService validationService = new ValidationOfTransactionService(balanceTableRepository);
var args = new BalanceInfo();
args.Balance = 100;
args.UserID = 22;
BalanceEntity balanceEntity = new BalanceEntity()
{
Balance = 1000,
BalanceID = "2201",
CreatedAt = DateTime.Now,
StockID = 2,
StockAmount = 2,
UserID = 22
};
balanceTableRepository.GetAll(22).Returns(new List <BalanceEntity>()
{
balanceEntity
});
//Act
validationService.CheckPermissionToSell(args.UserID);
//Average
balanceTableRepository.Received(1).GetAll(Arg.Is <int>(args.UserID));
balanceTableRepository.Received(1);
}
/* 'Balance' methods
*/
public bool ChangeBalance(BalanceEntity balance, decimal newAmount)
{
this.balanceTableRepository.ChangeAmount(balance.Id, newAmount);
this.balanceTableRepository.SaveChanges();
return(true);
}
public void Change(BalanceEntity entity)
{
var oldEntity = this.dbContext.Balances.Find(entity.BalanceID);
this.dbContext.Balances.Remove(oldEntity);
this.dbContext.SaveChanges();
this.dbContext.Balances.Add(entity);
}
public BalanceDto MapFromBalanceEntityToBalanceDto(BalanceEntity entity)
{
return(new BalanceDto()
{
BalanceId = entity.BalanceId,
Balance = entity.Balance,
CardId = entity.CardId
});
}
public void MakeSell(TransactionInfo args, StockEntity stock)
{
BalanceEntity sellerOldBalance = this.balanceTableRepository.Get(args.SellerBalanceID);
sellerOldBalance.StockAmount -= args.StockAmount;
sellerOldBalance.Balance += args.StockAmount * stock.Price;
this.balanceTableRepository.Change(sellerOldBalance);
this.balanceTableRepository.SaveChanges();
}
public void MakeBuy(TransactionInfo args, StockEntity stock)
{
BalanceEntity buyerOldBalance = this.balanceTableRepository.Get(args.BuyerBalanceID);
buyerOldBalance.StockAmount += args.StockAmount;
buyerOldBalance.Balance -= args.StockAmount * stock.Price;
this.balanceTableRepository.Change(buyerOldBalance);
this.balanceTableRepository.SaveChanges();
}
public static BalanceOutDto EntityToOutDto(BalanceEntity balanceEntity)
{
return(new BalanceOutDto()
{
BalanceAmount = AmountOutDto.EntityToOutDto(balanceEntity.BalanceAmount),
BalanceType = balanceEntity.BalanceType,
CreditLimitIncluded = balanceEntity.CreditLimitIncluded,
LastChangeDateTime = balanceEntity.LastChangeDateTime,
LastCommittedTransaction = balanceEntity.LastCommittedTransaction
});
}
public Task <bool> CreateIfNotExistsAsync(
string address)
{
var(partitionKey, rowKey) = GetKeys(address);
var entity = new BalanceEntity
{
PartitionKey = partitionKey,
RowKey = rowKey
};
return(_balances.CreateIfNotExistsAsync(entity));
}
public void ShouldChangeBalanceOfTheSeller()
{
//Arrange
historyTableRepository = Substitute.For <IHistoryTableRepository>();
balanceTableRepository = Substitute.For <IBalanceTableRepository>();
stockTableRepository = Substitute.For <IStockTableRepository>();
TransactionService transactionService = new TransactionService(this.historyTableRepository, this.balanceTableRepository, this.stockTableRepository);
var args = new TransactionInfo();
args.SellerID = 22;
args.SellerBalanceID = "2201";
args.BuyerID = 7;
args.BuyerBalanceID = "701";
args.StockAmount = 2;
args.StockID = 5;
args.dateTime = DateTime.Now;
var stock = new StockEntity();
stock.ID = 5;
stock.Price = 200;
stock.Type = "StockTypeA";
stockTableRepository.Get(5).Returns(stock);
var sellerBalance = new BalanceEntity();
sellerBalance.BalanceID = "2201";
sellerBalance.Balance = 1000;
sellerBalance.StockID = 3;
sellerBalance.StockAmount = 2;
sellerBalance.UserID = 22;
sellerBalance.CreatedAt = DateTime.Now;
balanceTableRepository.Get("2201").Returns(sellerBalance);
//Act
transactionService.MakeSell(args, stock);
//Assert
balanceTableRepository.Received(1).Change(Arg.Is <BalanceEntity>(w =>
w.Balance == sellerBalance.Balance &&
w.BalanceID == sellerBalance.BalanceID &&
w.CreatedAt == sellerBalance.CreatedAt &&
w.StockID == sellerBalance.StockID &&
w.StockAmount == sellerBalance.StockAmount &&
w.UserID == sellerBalance.UserID));
balanceTableRepository.Received(1).SaveChanges();
}
public BalanceEntity SearchBalanceByClientId(int clientId)
{
BalanceEntity balanceEntity = this.balanceTableRepository.SearchBalanceByClientId(clientId);
if (balanceEntity == null)
{
throw new ArgumentException("Can't find client balance by Id");
}
if (balanceEntity.Status == false)
{
throw new ArgumentException("Operations on this balance have been blocked.");
}
return(balanceEntity);
}
public void ShouldThrowExceptionIfCantFindBalanceByClientId()
{
// Arrange
int testClientId = 65;
BalanceEntity testNullBalance = null;
this.balanceTableRepository.SearchBalanceByClientId(Arg.Is(testClientId)).Returns(testNullBalance);
SalesService salesService = new SalesService(
this.operationTableRepository,
this.balanceTableRepository,
this.blockedMoneyTableRepository,
this.sharesNumberTableRepository,
this.blockedSharesNumberTableRepository);
// Act
var balance = salesService.SearchBalanceByClientId(testClientId);
// Assert
}
// Private API
// GetBalance
public async Task <Balance> GetBalance(string currency)
{
using (var client = new HttpClient())
{
// create the URL string.
string endpoint = "api/private/getbalance";
// JSON POST parameters
JObject jObject = new JObject();
jObject["Currency"] = currency;
string postParams = jObject.ToString(Formatting.None, null);
// Http Client params
SetHttpClientPropertiesPrivate(client, endpoint, postParams);
// make the request
var content = new StringContent(postParams, Encoding.UTF8, "application/json");
var response = await client.PostAsync(endpoint, content);
// parse the response and return the data.
var jsonResponseString = await response.Content.ReadAsStringAsync();
BalanceEntity balanceEntity = new BalanceEntity();
try
{
balanceEntity = JsonConvert.DeserializeObject <BalanceEntity>(jsonResponseString);
}
catch (Exception e)
{
throw new Exception(_ParseError, e);
}
// Check success message from server
if (balanceEntity.Success == false)
{
throw new Exception(_SuccessError);
}
return(balanceEntity.Result);
}
}
public List <BalanceEntity> ContextInitializer(List <UserEntity> users, List <StockEntity> stocks)
{
Random r = new Random();
List <BalanceEntity> Balances = new List <BalanceEntity>();
int stockID = r.Next(1, 10);
int stockAmount = r.Next(1, 5);
StockEntity stock = stocks.Where(f => f.ID == stockID).First();
foreach (UserEntity user in users)
{
BalanceEntity balance = new BalanceEntity();
balance.UserID = user.ID;
balance.Balance = stock.Price * stockAmount;
balance.StockID = stock.ID;
balance.StockAmount = stockAmount;
balance.CreatedAt = DateTime.Now;
Balances.Add(balance);
}
return(Balances);
}
private async Task Balance(AppDto appInfo)
{
await UnitOfWorkService.Execute(async() =>
{
var entity = new BalanceEntity
{
UserId = appInfo.UserId,
Value = -1,
Remark = "计费程序",
SalesMan = appInfo.SalesMan
};
await _balanceRepository.ChangeBalance(entity);
var orgId = _staffRepository.GetOrgId(appInfo.SalesMan).OrgId;
var dataInOrg = new DataInOrgEntity
{
DataId = appInfo.UserId,
DataType = (int)DataType.Balance,
OrgId = orgId,
RoleId = ((int)UserType.Admin).ToString()
};
_dataInOrgRepository.Inserts(dataInOrg);
});
}
public void Add(BalanceEntity entity)
{
this.dBContext.Balances.Add(entity);
}
public async Task <Result> UpdateBalance_NewCredit(CreditTransactionEntity newCreditTransaction)
{
try
{
var dateTimeNow = DateTimeOffset.UtcNow;
var foundAccountResult = await GetEntity(newCreditTransaction.AssociatedAccountId);
AccountDetailEntity foundAccount;
switch (foundAccountResult)
{
case BadRequestTypedResult <AccountDetailEntity> badRequestTypedResult:
return(new FailedResult(new Exception(badRequestTypedResult.Problem.Message)));
case FailedTypedResult <AccountDetailEntity> failedTypedResult:
return(new FailedResult(failedTypedResult.Error));
case NotFoundTypedResult <AccountDetailEntity> notFoundTypedResult:
return(new FailedResult(new Exception("Account Not Found")));
case SuccessfulTypedResult <AccountDetailEntity> successfulTypedResult:
foundAccount = successfulTypedResult.Value;
break;
default:
return(new FailedResult(new ArgumentOutOfRangeException(nameof(foundAccountResult))));
}
var balances = foundAccount.Balances.ToList();
var closingBookedBalance = balances.First(b => b.BalanceType == BalanceTypeEnum.closingBooked);
var expectedBalance = balances.FirstOrDefault(b => b.BalanceType == BalanceTypeEnum.expected);
if (expectedBalance == null)
{
expectedBalance = new BalanceEntity()
{
BalanceType = BalanceTypeEnum.expected,
BalanceAmount = closingBookedBalance.BalanceAmount.RealCopy(),
CreditLimitIncluded = false,
};
balances.Add(expectedBalance);
}
expectedBalance.BalanceAmount = expectedBalance.BalanceAmount.Add(newCreditTransaction.TransactionAmount);
expectedBalance.LastChangeDateTime = dateTimeNow;
expectedBalance.LastCommittedTransaction = newCreditTransaction.TransactionId;
if (foundAccount.AuthorizedLimit != null)
{
var authorizedBalance = balances.FirstOrDefault(b => b.BalanceType == BalanceTypeEnum.authorised);
if (authorizedBalance == null)
{
authorizedBalance = new BalanceEntity()
{
BalanceType = BalanceTypeEnum.authorised,
CreditLimitIncluded = true,
};
balances.Add(authorizedBalance);
}
authorizedBalance.BalanceAmount = expectedBalance.BalanceAmount.Add(foundAccount.AuthorizedLimit);
authorizedBalance.LastChangeDateTime = dateTimeNow;
authorizedBalance.LastCommittedTransaction = newCreditTransaction.TransactionId;
}
foundAccount.Balances = balances;
foundAccount.LastModifiedDate = dateTimeNow;
_accounts.FindOneAndReplace(a => a.ResourceId == foundAccount.ResourceId, foundAccount);
return(new SuccessResult());
}
catch (Exception e)
{
return(new FailedResult(e));
}
}
/* Sale
* 0. Get info about purchase from program (Customer, Number of Shares, Total (money))
* 1. Create empty operation
* 2.1 Get Customer balance info
* 2.2 - Customer balance amount
* 3. Create blocked money
* 4.1 Get Seller shares number info
* 4.2 - Seller shares number
* 5. Create blocked shares number // after that action purchase can't cancel
* 6.1 Get Seller balance info
* 6.2 + Seller balance amount
* 7.1 Get Customer shares number info
* 7.2 + Customer shares number
* 8. Fill operation columns
* 9. Remove blocked money
* 10. Remove blocked shares number
*/
public void Deal(int customerId, int sellerId, int shareId, int requiredSharesNumber)
{
OperationEntity operation = null;
SharesNumberEntity customerSharesNumber = null;
SharesNumberEntity sellerSharesNumber = null;
ClientEntity customer = null;
//ClientEntity seller = null;
BalanceEntity customerBalance = null;
BalanceEntity sellerBalance = null;
ShareEntity share = null;
BlockedMoneyEntity blockedMoney = null;
bool blockedMoneyFlag = false;
BlockedSharesNumberEntity blockedSharesNumber = null;
bool blockedSharesNumberFlag = false;
decimal customerBalanceAmount = 0M;
decimal total = 0M;
int sellerSharesNumberNumber = 0;
operation = CreateOperation();
try
{
sellerSharesNumber = SearchSharesNumberForBuy(shareId, requiredSharesNumber); // search required shares on stock exchange
//seller = sellerSharesNumber.Client;
//share = sellerSharesNumber.Share;
share = GetShare(shareId);
customerBalance = SearchBalanceByClientId(customerId);
customer = customerBalance.Client;
//sellerBalance = SearchBalanceByClientId(seller.Id);
sellerBalance = SearchBalanceByClientId(sellerId);
// get total
CheckShareAndShareTypeStatuses(share);
total = share.Type.Cost * requiredSharesNumber;
// Blocked money
customerBalanceAmount = customerBalance.Amount;
if (customerBalanceAmount < total)
{
throw new ArgumentException("Customer don't have enough money.");
}
blockedMoneyFlag = ChangeBalance(customerBalance, customerBalanceAmount - total);
blockedMoney = CreateBlockedMoney(new BlockedMoneyRegistrationInfo()
{
Operation = operation,
ClientBalance = customerBalance,
Total = total
});
// Blocked shares Number
sellerSharesNumberNumber = sellerSharesNumber.Number;
blockedSharesNumberFlag = ChangeSharesNumber(sellerSharesNumber, sellerSharesNumberNumber - requiredSharesNumber);
blockedSharesNumber = CreateBlockedSharesNumber(new BlockedSharesNumberRegistrationInfo()
{
ClientSharesNumber = sellerSharesNumber,
Operation = operation,
//Share = sellerSharesNumber.Share,
//ShareTypeName = sellerSharesNumber.Share.Type.Name,
//Cost = sellerSharesNumber.Share.Type.Cost,
Number = requiredSharesNumber
});
}
catch
{
RemoveOperation(operation);
if (blockedMoneyFlag)
{
ChangeBalance(customerBalance, customerBalanceAmount + total);
if (blockedMoney != null)
{
RemoveBlockedMoney(blockedMoney);
}
}
if (blockedSharesNumberFlag)
{
ChangeSharesNumber(sellerSharesNumber, sellerSharesNumberNumber + requiredSharesNumber);
if (blockedSharesNumber != null)
{
RemoveBlockedSharesNumber(blockedSharesNumber);
}
}
// throw new ArgumentException($"Deal was broken cause: {e.Message}");
throw;
}
if (sellerSharesNumber.Number == 0)
{
RemoveSharesNumber(sellerSharesNumber);
}
ChangeBalance(sellerBalance, sellerBalance.Amount + total);
customerSharesNumber = SearchOrCreateSharesNumberForAddition(customer, share);
ChangeSharesNumber(customerSharesNumber, customerSharesNumber.Number + requiredSharesNumber);
FillOperationColumns(blockedMoney, blockedSharesNumber);
RemoveBlockedMoney(blockedMoney);
RemoveBlockedSharesNumber(blockedSharesNumber);
}
public void UpdateBalance(BalanceEntity entity)
{
var dao = mapper.MapFromBalanceEntityToBalanceDto(entity);
balanceRepository.Update(dao);
}
public void Update(BalanceEntity balance)
{
var balanceOld = LoadBalanceByID(balance.ClientID);
dbContext.Entry(balanceOld).CurrentValues.SetValues(balance);
}
public void Add(BalanceEntity balanceEntity)
{
this.dbContext.Balances.Add(balanceEntity);
}
public bool Contains(BalanceEntity entity)
{
return(this.dBContext.Balances.Any(b =>
b.Client == entity.Client));
}
public bool Contains(BalanceEntity entity)
{
return(this.dbContext.Balances.Any(f =>
f.BalanceID == entity.BalanceID));
}
public void Add(BalanceEntity balance)
{
dbContext.Balances.Add(balance);
}
