private bool saveTransaction(Guid currencyId, decimal value)
{
var currencyExchange = getExchangeRateFromForeignId(currencyId);
var surcharge = Surcharges.FirstOrDefault(c => c.CurrencyId == currencyId);
ICompletedTransaction transaction = new CompletedTransaction();
transaction.ExchangeRateId = currencyExchange.Id;
transaction.LocalValue = CalculateLocalOwedAmount(currencyId, value);
transaction.ForeignValue = value;
transaction.ExchangeRateValue = currencyExchange.Value;
transaction.SurchargeId = surcharge.Id;
transaction.SurchargePercent = surcharge.Value;
transaction.SurchargeValue = value * (1 + surcharge.Value);
if (discount.HasValue)
{
transaction.Discount = discount.Value;
}
if (discount.HasValue)
{
transaction.LocalValue = transaction.LocalValue / (1 + discount.Value);
}
CompletedTransactionDataAccessor completedTransactionAccessor = new CompletedTransactionDataAccessor(baseUri);
var saveResult = completedTransactionAccessor.Insert(transaction);
return(saveResult);
}
public void InsertCompletedTrans(CompletedTransaction _completedTransaction)
{
var col = ChainDB.GetCollection <CompletedTransaction>("CompleteTransaction");
col.EnsureIndex(x => x.TransactionId, true);
col.Insert(_completedTransaction);
}
public IHttpActionResult SaveCompletedTransaction([FromBody] CompletedTransaction model)
{
if (!(model is CompletedTransaction))
{
return(base.BadRequest());
}
var completedTransactionAccess = new CompletedTransactionAccess();
var result = completedTransactionAccess.Insert(model);
return(base.Ok());
}
public void TransferShares(string _fromAddress,
string _privateKey,
string _toAddress,
double _amount)
{
IList <Share> PostingShares;
PostingShares = CollectActiveShares(_fromAddress, _amount); //Get the transactions
if (PostingShares != null)
{
//Now start building the transaction
CompletedTrans = BuildTransaction(PostingShares, _fromAddress, _privateKey, _toAddress, _amount);
if (CompletedTrans != null) //If the transaction has been completed, broadcast it
{
//Now broadcast
}
}
}
public bool ExecuteTransaction(
Transaction transaction,
bool allowNegativeCapital,
out CompletedTransaction completedTransaction,
out string error,
bool forcibly = false)
{
error = string.Empty;
completedTransaction = null;
if (transaction.Action == TradingAction.OpenLong)
{
var charge = transaction.Price * transaction.Volume + transaction.Commission;
// try to allocate capital
bool isFirstPosition = !ExistsPosition(transaction.Code);
if (!_capitalManager.AllocateCapital(charge, isFirstPosition, allowNegativeCapital))
{
error = "No enough capital for the transaction";
return(false);
}
var position = new Position(transaction);
AddPosition(position);
return(true);
}
if (transaction.Action == TradingAction.CloseLong)
{
var code = transaction.Code;
if (!ExistsPosition(code))
{
error = string.Format("There is no position for trading object {0}", code);
return(false);
}
var positions = _activePositions[code].ToArray();
var positionsToBeSold = IdentifyPositionToBeSold(positions, transaction).ToArray();
if (positionsToBeSold.Count() == 0)
{
return(true);
}
// check if position is still frozen if transaction is not executed forcibly
if (!forcibly)
{
foreach (var ptbs in positionsToBeSold)
{
var span = transaction.ExecutionTime.Date - positions[ptbs.Index].BuyTime.Date;
if (span.Days < _positionFrozenDays)
{
error = string.Format("position is still frozen");
return(false);
}
}
}
// note: the position could be sold partially and we need to consider the situation
// everywhere in the code
var buyCost = 0.0;
var buyCommission = 0.0;
foreach (var ptbs in positionsToBeSold)
{
buyCost += positions[ptbs.Index].BuyPrice * ptbs.Volume;
buyCommission += positions[ptbs.Index].BuyCommission
* ptbs.Volume / positions[ptbs.Index].Volume;
}
foreach (var ptbs in positionsToBeSold)
{
var position = positions[ptbs.Index];
if (position == null)
{
throw new InvalidOperationException();
}
// for partial selling, we need to split position firstly.
Position newPosition = null;
if (ptbs.Volume < position.Volume)
{
newPosition = position.Split(ptbs.Volume);
}
// close the position
var newTransaction = new Transaction
{
Action = transaction.Action,
Code = transaction.Code,
Name = transaction.Name,
Comments = transaction.Comments,
Commission = transaction.Commission / transaction.Volume * position.Volume,
Error = transaction.Error,
ExecutionTime = transaction.ExecutionTime,
InstructionId = transaction.InstructionId,
ObservedMetricValues = transaction.ObservedMetricValues,
Price = transaction.Price,
RelatedObjects = transaction.RelatedObjects,
SubmissionTime = transaction.SubmissionTime,
Succeeded = transaction.Succeeded,
Volume = position.Volume
};
position.Close(newTransaction);
// move closed position to history
_closedPositions.Add(position);
// use new position to replace old position.
positions[ptbs.Index] = newPosition;
// free capital
var earn = newTransaction.Price * newTransaction.Volume - newTransaction.Commission;
_capitalManager.FreeCapital(earn, ptbs.Index == 0);
}
// update positions for given code
var remainingPositions = positions.Where(e => e != null).ToList();
if (remainingPositions == null || remainingPositions.Count == 0)
{
_activePositions.Remove(code);
}
else
{
_activePositions[code] = remainingPositions;
}
// create completed transaction object
completedTransaction = new CompletedTransaction
{
Code = code,
Name = transaction.Name,
ExecutionTime = transaction.ExecutionTime,
Volume = transaction.Volume,
BuyCost = buyCost,
AverageBuyPrice = buyCost / transaction.Volume,
SoldPrice = transaction.Price,
SoldGain = transaction.Price * transaction.Volume,
Commission = transaction.Commission + buyCommission,
};
return(true);
}
throw new InvalidOperationException(
string.Format("unsupported action {0}", transaction.Action));
}
public void AddCompletedTransaction(CompletedTransaction completedTransaction)
{
_completedTransactionHistory.Add(completedTransaction);
}
