public ICollection <IInstruction> Deserialize(byte[] delta) { var instructions = new List <IInstruction>(); using (MemoryStream stream = new MemoryStream(delta)) using (BinaryReader reader = new BinaryReader(stream)) { while (reader.BaseStream.Position < reader.BaseStream.Length) { InstructionTypes instructionType = (InstructionTypes)reader.ReadByte(); switch (instructionType) { case InstructionTypes.Add: var add = new Add(); add.Index = reader.ReadInt32(); int length = reader.ReadInt32(); add.Data = reader.ReadBytes(length); instructions.Add(add); break; case InstructionTypes.Copy: var copy = new Copy(); copy.Index = reader.ReadInt32(); copy.Length = reader.ReadInt32(); instructions.Add(copy); break; case InstructionTypes.Run: var run = new Run(); run.Length = reader.ReadInt32(); run.Value = reader.ReadByte(); instructions.Add(run); break; default: throw new FormatException(); } } } return(instructions); }
internal static bool rebalanceAccount(int accountId, InstructionTypes instructionType, OrderActionTypes actionType, bool noCharges, decimal depositCashPositionDiff, bool includePrevCash) { bool success = false; Money diff = null; IDalSession session = NHSessionFactory.CreateSession(); IAccountTypeCustomer account = (IAccountTypeCustomer)AccountMapper.GetAccount(session, accountId); if (account.ActiveRebalanceInstructions != null && account.ActiveRebalanceInstructions.Count > 0) throw new ApplicationException(string.Format("The account {0} already has an active rebalance instruction.", account.Number)); IList<IJournalEntryLine> cashTransfers = JournalEntryMapper.GetUnProcessedCashTransfers(session, account); if (cashTransfers == null || cashTransfers.Count == 0) throw new ApplicationException("It is not possible to do this rebalance without cash transfers"); else diff = new Money(depositCashPositionDiff, cashTransfers[0].Currency); if (account.ModelPortfolio == null) throw new ApplicationException(string.Format("The account {0} does not have a model attached.", account.Number)); IInstruction instruction = account.CreateInstruction(instructionType, actionType, DateTime.Now.Date, noCharges, cashTransfers); if (instruction != null) { // check total value of the transfers if (instructionType == InstructionTypes.BuyModel) { IBuyModelInstruction bmi = (IBuyModelInstruction)instruction; if (!(bmi.CashTransfers.TotalTransferAmount.IsGreaterThanZero && account.TotalCash.IsGreaterThanZero)) throw new ApplicationException("It is not possible to do this rebalance with a zero/negative cash transfer amount"); if (!(account.ActiveWithdrawalInstructions.Count == 0 && account.ActiveMoneyTransferOrders.Count == 0)) throw new ApplicationException(string.Format("It is not possible to do a buy model for account {0} since there are active money transfers/withdrawals.", account.Number)); if (account.OpenOrdersForAccount.NewCollection(x => x.Side == Side.Sell).Count > 0) throw new ApplicationException(string.Format("It is not possible to do a buy model for account {0} since ther are sell orders.", account.Number)); if (account.OpenOrdersForAccount.Count > 0) { if (diff.IsLessThanZero) throw new ApplicationException(string.Format("It is not possible to do a buy model for account {0} since the cash difference is negative.", account.Number)); if (account.TotalCash - account.OpenOrderAmount() < bmi.CashTransfers.TotalTransferAmount) throw new ApplicationException(string.Format("It is not possible to do a buy model for account {0} since the cash is already spent.", account.Number)); } else { if (diff != null && diff.IsNotZero) { // When there is a cash difference (max 15% of the deposit) -> clear it away if (includePrevCash) { if ((bmi.CashTransfers.TotalTransferAmount + diff).IsLessThanZero) throw new ApplicationException(string.Format("It is not possible to do a buy model for account {0} since there is not enough cash.", account.Number)); bmi.DepositCashPositionDifference = diff; } } } } ICurrency underlying = account.AccountOwner.StichtingDetails.BaseCurrency; InstructionEngineParameters engineParams = InstructionEngineParametersMapper.GetParameters(session); InstructionEngine engine = new InstructionEngine(engineParams); if (engine.ProcessInstruction(instruction)) { session.BeginTransaction(); AccountMapper.Update(session, account); if (instruction.UpdateableOrders != null && instruction.UpdateableOrders.Count > 0) OrderMapper.Insert(session, instruction.UpdateableOrders); success = session.CommitTransaction(); } } session.Close(); return success; }
public Instruction(InstructionTypes toggleInsType, int value) { InstructionType = toggleInsType; Value = value; }
private Instruction(InstructionTypes type, int first, int second) { InstructionType = type; First = first; Second = second; }
private Stream getStateTable(InstructionTypes instructionType) { Assembly assembly = Assembly.GetExecutingAssembly(); string assemblyname = assembly.ToString().Substring(0, assembly.ToString().IndexOf(",")); const string subPath = ".Instructions.Engine.StateMachineSchemas."; Stream stateTable = null; switch (instructionType) { case InstructionTypes.Rebalance: stateTable = assembly.GetManifestResourceStream(assemblyname + subPath + "RebalanceInstructionStates.xml"); break; case InstructionTypes.BuyModel: stateTable = assembly.GetManifestResourceStream(assemblyname + subPath + "BuyModelInstructionStates.xml"); break; case InstructionTypes.CashWithdrawal: stateTable = assembly.GetManifestResourceStream(assemblyname + subPath + "CashWithdrawalInstructionStates.xml"); break; case InstructionTypes.ClientDeparture: stateTable = assembly.GetManifestResourceStream(assemblyname + subPath + "ClientDepartureInstructionStates.xml"); break; } return stateTable; }
/// <summary> /// This is the method where a new rebalance instruction is created for the account. /// </summary> /// <param name="instructionType">The type of instruction, currently we only support rebalance instructions</param> /// <param name="orderActionType">The type of instruction that is placed on the orders</param> /// <param name="executionDate">The date that the rebalance should be executed</param> /// <param name="doNotChargeCommission">Determines whether commission should be charged</param> /// <param name="cashTransfers">The cash transfers involved</param> /// <returns>A new <see cref="T:B4F.TotalGiro.Accounts.Instructions.Instruction">instruction</see></returns> public IInstructionTypeRebalance CreateInstruction(InstructionTypes instructionType, OrderActionTypes orderActionType, DateTime executionDate, bool doNotChargeCommission, IList<IJournalEntryLine> cashTransfers) { IInstructionTypeRebalance instruct = null; switch (instructionType) { case InstructionTypes.Rebalance: instruct = new RebalanceInstruction(this, executionDate, orderActionType, doNotChargeCommission, cashTransfers); break; case InstructionTypes.BuyModel: instruct = new BuyModelInstruction(this, executionDate, orderActionType, doNotChargeCommission, cashTransfers); break; default: throw new ApplicationException("Wrong instruction type for this method"); } if (instruct != null) { AccountInstructions.Add(instruct); ActiveAccountInstructions.Add(instruct); } return instruct; }
/// <summary> /// This is the method where a new rebalance instruction is created for the account. /// </summary> /// <param name="instructionType">The type of instruction, currently we only support rebalance instructions</param> /// <param name="orderActionType">The type of instruction that is placed on the orders</param> /// <param name="executionDate">The date that the rebalance should be executed</param> /// <returns>A new <see cref="T:B4F.TotalGiro.Accounts.Instructions.Instruction">instruction</see></returns> public IInstructionTypeRebalance CreateInstruction(InstructionTypes instructionType, OrderActionTypes orderActionType, DateTime executionDate, bool doNotChargeCommission) { return CreateInstruction(instructionType, orderActionType, executionDate, doNotChargeCommission, null); }