public async Task <IActionResult> Get(
[FromQuery] string address,
[FromQuery] string unit,
[FromQuery] string state,
[FromQuery] string city,
[FromQuery] string zipcode
)
{
//validate url parameters
var lookups = new Lookup(HttpContext.Request.Query)
.ToList();
if (RequestValidator.ValuesMissing(lookups))
{
return(BadRequest(
new ErrorResponse(ResponseMessages.GetResponseMessage(400), 400)
));
}
try
{
var data = await _propertyService
.GetPropertyData(lookups.FirstOrDefault(), _options.BaseUri);
return(Ok(data.GetSewerResponse()));
}
catch (System.Exception ex)
{
_logger.LogError(ex.Message);
return(StatusCode(StatusCodes.Status500InternalServerError,
new ErrorResponse(ex.Message, 500)
));
}
}
public IActionResult Post([FromBody] ShapesRequest request)
{
var response = new SingleResponse <ShapesDTO>();
try
{
if (request == null)
{
response.Messages = ResponseMessages.BadRequest();
return(NotFound(response));
}
if (!ModelState.IsValid)
{
response.Messages = ResponseMessages.ModelValidate(ModelState);
return(UnprocessableEntity(response));
}
var result = _shapesLogic.AddShape(request);
response.Messages = ResponseMessages.Created();
response.Model = result;
return(CreatedAtRoute("GetShapeByid",
new { id = result.ShapeId },
response));
}
catch (Exception exception)
{
response.Messages = ResponseMessages.InternalServerError(exception.ToString());
return(StatusCode(500, response));
}
}
public async Task <ActionResult <PlayerModel> > UpdatePlayer([FromBody] PlayerModel dto, [FromRoute] string username)
{
if (dto == null)
{
return(BadRequest(ResponseMessages.PutNullObjectErrorMessage));
}
try
{
Player player = await _service.GetPlayerByUsernameAsync(username);
if (player == null)
{
return(BadRequest(ResponseMessages.PlayerDoesNotExistMessage(username)));
}
player = await _service.UpdatePlayerAsync(player, dto);
PlayerModel playerModel = (PlayerModel)player;
return(Ok(playerModel));
}
catch (Exception)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, ResponseMessages.InternalServerErrorMessage));
}
}
public IActionResult Get()
{
var response = new ListResponse <ShapesDTO>();
try
{
var result = _shapesLogic.GetAllShapes();
//throw new Exception();
if (result == null)
{
response.Messages = ResponseMessages.NotFound();
return(NotFound(response));
}
response.Messages = ResponseMessages.Success();
response.Model = result.ToList();
return(Ok(response));
}
catch (Exception exception)
{
response.Messages = ResponseMessages.InternalServerError(exception.ToString());
return(StatusCode(500, response));
}
}
public async Task <IActionResult> Get(int id)
{
var response = new EmployeeResponse()
{
Result = null
};
try
{
var result = await _employeeService.GetEmployeesById(id);
if (result == null)
{
response.Messages = ResponseMessages.NotFound();
return(NotFound(response));
}
response.Messages = ResponseMessages.Success();
response.Result = result;
return(Ok(response));
}
catch (Exception exception)
{
response.Messages = ResponseMessages.InternalServerError(exception.ToString());
return(StatusCode(500, response));
}
}
private void MessageReceiver()
{
while (true)
{
byte[] data = _NetworkComms.GetMessage();
if (data == null)
{
Thread.Sleep(50);
continue;
}
Message msg = JsonSerializer.Deserialize <Message>(data);
if (msg != null)
{
//Ignore our own message
if (msg.Sender != _UniqueID)
{
switch (msg.MsgType)
{
case MessageType.TurnInfo:
HandleTurnInfoMessage(JsonSerializer.Deserialize <TurnInfoMessage>(data));
break;
case MessageType.Response:
ResponseMessage responseMessage = JsonSerializer.Deserialize <ResponseMessage>(data);
//Only add message to queue if we are receiver
if (responseMessage.Receiver == _UniqueID)
{
ResponseMessages.Enqueue(responseMessage);
}
break;
case MessageType.AdvertiseLobby:
AdvertiseLobbyMessages.Enqueue(JsonSerializer.Deserialize <AdvertiseLobbyMessage>(data));
break;
case MessageType.JoinLobby:
JoinLobbyMessage joinLobbyMessage = JsonSerializer.Deserialize <JoinLobbyMessage>(data);
//Only add message to queue if we are receiver
if (joinLobbyMessage.Receiver == _UniqueID)
{
JoinLobbyMessages.Enqueue(joinLobbyMessage);
}
break;
default:
Debug.WriteLine("Unknown message type: " + msg.MsgType);
Debug.WriteLine(BitConverter.ToString(data));
break;
}
}
}
}
}
public override void WritePropertiesData(DataWriter writer)
{
writer.WriteStartObject(Name);
base.WritePropertiesData(writer);
if (Status == Core.Process.ProcessStatus.Inactive)
{
writer.WriteFinishObject();
return;
}
if (Page != null)
{
if (Page.GetType().IsSerializable ||
Page.GetType().GetInterface("ISerializable") != null)
{
writer.WriteSerializableObjectValue("Page", Page, null);
}
}
if (!HasMapping("Icon"))
{
writer.WriteValue("Icon", Icon, null);
}
if (!HasMapping("Buttons"))
{
writer.WriteValue("Buttons", Buttons, null);
}
if (!HasMapping("WindowCaption"))
{
writer.WriteValue("WindowCaption", WindowCaption, null);
}
if (!HasMapping("MessageText"))
{
writer.WriteValue("MessageText", MessageText, null);
}
if (ResponseMessages != null)
{
if (ResponseMessages.GetType().IsSerializable ||
ResponseMessages.GetType().GetInterface("ISerializable") != null)
{
writer.WriteSerializableObjectValue("ResponseMessages", ResponseMessages, null);
}
}
if (!HasMapping("ProcessInstanceId"))
{
writer.WriteValue("ProcessInstanceId", ProcessInstanceId, null);
}
if (PageParameters != null)
{
if (PageParameters.GetType().IsSerializable ||
PageParameters.GetType().GetInterface("ISerializable") != null)
{
writer.WriteSerializableObjectValue("PageParameters", PageParameters, null);
}
}
writer.WriteFinishObject();
}
protected Response <TT> DecodeError(Stream responseBody, Client client)
{
var errorResponse = (new ErrorResponseDecoder()).Decode(responseBody);
var message = this.ReadError(errorResponse.Error);
var messages = new ResponseMessages(new[] { message });
var response = new Response <TT>(client, new List <TT>(), new ResponseDictionary(client), messages);
return(response);
}
public void PassivateUser(string email)
{
User user = this.userRepository.GetSingleWithEmail(email);
if (user.Status == StatusType.NotAvailable)
{
throw new Exception(ResponseMessages.Get(ServiceResponseCode.RM0000.ToString(), ""));
}
user.Passivate();
this.userRepository.Update(user);
}
///<inheritdoc/>
public HttpClient CreateClient(string name)
{
Mock <HttpMessageHandler> mockHttpMessageHandler = new Mock <HttpMessageHandler>();
mockHttpMessageHandler.Protected()
.Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>())
.Callback <HttpRequestMessage, CancellationToken>((message, token) => RequestMessages.Push(message))
.ReturnsAsync(ResponseMessages.Pop());
HttpClient client = new HttpClient(mockHttpMessageHandler.Object)
{
BaseAddress = new System.Uri(BaseAddress)
};
return(client);
}
private void TextMsgRecived(TdsToken token)
{
var msg = (TextMessageToken)token;
if (msg.Severity > 10)
{
_logger?.LogError($"Server error: {msg.GetMessage()}");
ResponseMessages.Add(msg);
ResponseIsError = true;
}
else
{
_logger?.LogInformation($"Server info: {msg.GetMessage()}");
ResponseMessages.Add(msg);
}
}
private object GetReturnDto(IInvocation invocation, string errorCode, string responseMessage)
{
if (invocation.Method.ReturnType == typeof(void))
{
return(null);
}
var returnValue = Activator.CreateInstance(invocation.Method.ReturnType);
BaseResponseDTO dto = returnValue as BaseResponseDTO;
if (dto != null)
{
dto.Header.ResponseCode = errorCode;
dto.Header.Message = ResponseMessages.Get(errorCode, this.GetLanguageCode(invocation));
}
return(returnValue);
}
public async Task <ActionResult> RemovePlayer([FromRoute] string username)
{
try
{
var oldPlayer = await _service.GetPlayerByUsernameAsync(username);
if (oldPlayer == null)
{
return(BadRequest(ResponseMessages.PlayerDoesNotExistMessage(username)));
}
await _service.RemovePlayerAsync(oldPlayer);
return(Ok($"Player '{oldPlayer.Username}' was removed from the database"));
}
catch (Exception)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, ResponseMessages.InternalServerErrorMessage));
}
}
public DomainUserResponseDTO CreateUser(DomainUserRequestDTO requestDto)
{
User user = this.userRepository.GetSingleWithEmail(requestDto.Email);
if (user != null)
{
throw new Exception("User already exists.");
}
user = new User(requestDto.Email, requestDto.NewPassword);
user = this.userRepository.Add(user);
DomainUserResponseDTO response = new DomainUserResponseDTO()
{
ResponseCode = ServiceResponseCode.RM0000.ToString(),
Status = 0,
Message = ResponseMessages.Get(ServiceResponseCode.RM0000.ToString(), requestDto.LanguageCode),
User = user
};
return(response);
}
public IActionResult Get(int id)
{
var response = new SingleResponse <ShapesDTO>();
try
{
var result = _shapesLogic.GetShapeById(id);
if (result == null)
{
response.Messages = ResponseMessages.NotFound();
return(NotFound(response));
}
response.Messages = ResponseMessages.Success();
response.Model = result;
return(Ok(response));
}
catch (Exception exception)
{
response.Messages = ResponseMessages.InternalServerError(exception.ToString());
return(StatusCode(500, response));
}
}
public async Task <IActionResult> Post([FromBody] IEnumerable <Lookup> lookups)
{
if (RequestValidator.ValuesMissing(lookups))
{
return(BadRequest(
new ErrorResponse(ResponseMessages.GetResponseMessage(400), 400)
));
}
try
{
var data = await _propertyService.GetPropertyData(lookups, _options.BaseUri);
return(Ok(data.GetSewerResponse()));
}
catch (System.Exception ex)
{
_logger.LogError(ex.Message);
return(StatusCode(StatusCodes.Status500InternalServerError,
new ErrorResponse(ex.Message, 500)
));
}
}
public IActionResult CreatePDF([FromQuery] int?[] ids)
{
var response = new ListResponse <ShapesDTO>();
try
{
IEnumerable <ShapesDTO> result = null;
result = ids.Length > 0 ? _shapesLogic.GetShapesByIds(ids.Cast <int>().ToArray()) : _shapesLogic.GetAllShapes();
var fileList = new List <string>();
var zipFileName = Path.Combine(Directory.GetCurrentDirectory(),
@"PDF\" + DateTime.Now.ToFileTime() + ".zip");
if (result.Count() == 0)
{
response.Messages = ResponseMessages.NotFound();
return(NotFound(response));
}
foreach (var shapesDto in result)
{
var fileName = Path.Combine(Directory.GetCurrentDirectory(),
@"PDF\" + DateTime.Now.ToFileTime() + ".pdf");
CreatePDFFileWithZip(shapesDto, fileName);
fileList.Add(fileName);
}
CreateZipFile(zipFileName, fileList);
response.Messages = ResponseMessages.CreatedPDF("File has been created at this URL = " + zipFileName);
response.Model = result.ToList();
return(Ok(response));
}
catch (Exception exception)
{
response.Messages = ResponseMessages.InternalServerError(exception.ToString());
return(StatusCode(500, response));
}
}
public async Task <IActionResult> Post([FromBody] EmployeeRequestDTO model)
{
var response = new EmployeeResponse()
{
Result = null
};
try
{
if (model == null)
{
response.Messages = ResponseMessages.BadRequest();
return(NotFound(response));
}
var res = new EmployeeValidator();
if (!ModelState.IsValid)
{
response.Messages = ResponseMessages.ModelValidate(ModelState);
return(UnprocessableEntity(response));
}
var result = await _employeeService.AddEmployee(model);
response.Messages = ResponseMessages.Created();
response.Result = result;
return(CreatedAtRoute("GetEmployees",
new { id = result.EmployeeId },
response));
}
catch (Exception exception)
{
response.Messages = ResponseMessages.InternalServerError(exception.ToString());
return(StatusCode(500, response));
}
}
private bool ProcessMarketDataResponse(IBSocket socket, ResponseMessages message, ServerVersions version)
{
switch (message)
{
case ResponseMessages.TickPrice:
{
// http://www.interactivebrokers.com/en/software/api/apiguide/java/tickprice.htm
ReadTickPrice(socket, version);
return true;
}
case ResponseMessages.TickVolume:
{
// http://www.interactivebrokers.com/en/software/api/apiguide/java/ticksize.htm
ReadTickVolume(socket);
return true;
}
case ResponseMessages.TickOptionComputation:
{
// http://www.interactivebrokers.com/en/software/api/apiguide/java/tickoptioncomputation.htm
ReadTickOptionComputation(socket, version);
return true;
}
case ResponseMessages.TickGeneric:
{
// http://www.interactivebrokers.com/en/software/api/apiguide/java/tickgeneric.htm
ReadTickGeneric(socket);
return true;
}
case ResponseMessages.TickString:
{
// http://www.interactivebrokers.com/en/software/api/apiguide/java/tickstring.htm
ReadTickString(socket);
return true;
}
case ResponseMessages.TickEfp:
{
// http://www.interactivebrokers.com/en/software/api/apiguide/java/tickefp.htm
ReadTickEfp(socket);
return true;
}
case ResponseMessages.ScannerData:
{
ReadScannerData(socket, version);
return true;
}
case ResponseMessages.SecurityInfo:
{
ReadSecurityInfo(socket, version);
return true;
}
case ResponseMessages.BondInfo:
{
// http://www.interactivebrokers.com/en/software/api/apiguide/java/bondcontractdetails.htm
ReadBondInfo(socket, version);
return true;
}
case ResponseMessages.MarketDepth:
case ResponseMessages.MarketDepthL2:
{
// http://www.interactivebrokers.com/en/software/api/apiguide/java/updatemktdepth.htm
// http://www.interactivebrokers.com/en/software/api/apiguide/java/updatemktdepthl2.htm
ReadMarketDepth(socket, message);
return true;
}
case ResponseMessages.NewsBulletins:
{
// http://www.interactivebrokers.com/en/software/api/apiguide/java/updatenewsbulletin.htm
ReadNewsBulletins(socket);
return true;
}
case ResponseMessages.FinancialAdvice:
{
ReadFinancialAdvice(socket);
return true;
}
case ResponseMessages.HistoricalData:
{
// http://www.interactivebrokers.com/en/software/api/apiguide/java/historicaldata.htm
ReadHistoricalData(socket, version);
return true;
}
case ResponseMessages.ScannerParameters:
{
// http://www.interactivebrokers.com/en/software/api/apiguide/java/scannerparameters.htm
ReadScannerParameters(socket);
return true;
}
case ResponseMessages.RealTimeBars:
{
// http://www.interactivebrokers.com/en/software/api/apiguide/java/realtimebar.htm
ReadRealTimeBars(socket);
return true;
}
case ResponseMessages.FundamentalData:
{
// http://www.interactivebrokers.com/en/software/api/apiguide/java/fundamentaldata.htm
ReadFundamentalData(socket);
return true;
}
case ResponseMessages.SecurityInfoEnd:
{
ReadSecurityInfoEnd(socket);
return true;
}
case ResponseMessages.DeltaNuetralValidation:
{
ReadDeltaNuetralValidation(socket);
return true;
}
case ResponseMessages.TickSnapshotEnd:
{
// http://www.interactivebrokers.com/en/software/api/apiguide/java/ticksnapshotend.htm
ReadTickSnapshotEnd(socket);
return true;
}
case ResponseMessages.MarketDataType:
{
// http://www.interactivebrokers.com/en/software/api/apiguide/java/marketdatatype.htm
ReadMarketDataType(socket);
return true;
}
default:
return false;
}
}
private void ReadMarketDepth(IBSocket socket, ResponseMessages message)
{
var requestId = socket.ReadInt();
var secId = GetSecurityId(requestId);
/* position */
var pos = socket.ReadInt();
if (message == ResponseMessages.MarketDepthL2)
{
/* marketMaker */
secId.BoardCode = socket.ReadBoardCode();
}
var operation = socket.ReadInt();
var side = socket.ReadBool() ? Sides.Buy : Sides.Sell;
var price = socket.ReadDecimal();
var volume = socket.ReadInt();
var prevQuotes = _depths.SafeAdd(secId, key =>
Tuple.Create(new SortedDictionary<decimal, decimal>(new BackwardComparer<decimal>()), new SortedDictionary<decimal, decimal>()));
var quotes = side == Sides.Buy ? prevQuotes.Item1 : prevQuotes.Item2;
this.AddDebugLog("MD {0} {1} POS {2} PRICE {3} VOL {4}", secId, operation, pos, price, volume);
switch (operation)
{
case 0: // insert
{
if (!CollectionHelper.TryAdd(quotes, price, volume))
quotes[price] += volume;
break;
}
case 1: // update
{
if (quotes.Count > (pos + 1))
{
var sign = side == Sides.Buy ? 1 : -1;
if (quotes[pos + 1] * sign >= price * sign)
{
for (var i = quotes.Count - 1; i >= pos + 1; i--)
quotes.Remove(quotes[quotes.Keys.ElementAt(i)]);
}
}
if (quotes.Count > pos)
{
//if (quotes[quotes.Keys.ElementAt(pos)] == price)
// quotes[price] = volume;
//else
//{
// depth.Remove(quotes[pos]);
// depth.AddQuote(quote);
//}
quotes[price] = volume;
}
else
{
if (!CollectionHelper.TryAdd(quotes, price, volume))
quotes[price] += volume;
}
break;
}
case 2: // delete
{
if (quotes.Count > pos)
quotes.Remove(quotes.Keys.ElementAt(pos));
break;
}
}
SendOutMessage(new QuoteChangeMessage
{
SecurityId = secId,
Bids = prevQuotes.Item1.Select(p => new QuoteChange(Sides.Buy, p.Key, p.Value)).ToArray(),
Asks = prevQuotes.Item2.Select(p => new QuoteChange(Sides.Sell, p.Key, p.Value)).ToArray(),
ServerTime = this.CurrentTime.Convert(TimeZoneInfo.Utc),
});
}
public OrderItemController(IOrderItemService iOrderItemService, OrderItemQueries orderItemQueries, IResponseMessages responsMessages)
{
IOrderItemService = iOrderItemService;
OrderItemQueries = orderItemQueries;
ResponsMessages = responsMessages as ResponseMessages;
}
public void EndTurn()
{
_logger.Log("Ending turn...");
TurnInfo turnInfo = _GameState.GetTurn();
if (turnInfo == null)
{
Debug.WriteLine("Received null turnInfo from GameState");
return;
}
//Use same ID for all turnInfo messages for this turn
string msgID = _TurnInfoMessageID;
_TurnInfoMessageNumber++;
TurnInfoMessage turnInfoMsg = new TurnInfoMessage {
TurnInfo = turnInfo, Sender = _UniqueID, MsgID = msgID
};
byte[] turnInfoMsgBytes = JsonSerializer.SerializeToUtf8Bytes(turnInfoMsg);
bool turnApproved = false;
List <int> ApprovedPlayers = new List <int>(); //Players who have approved this turn
int requiredNumberOfPlayerApprovals = _LobbyInfo.Players.Count - 1; //-1 because player does not approve local turn
//TODO, implement some time here? now sends turn max 10 times then fails
for (int i = 0; i < 10; i++)
{
_NetworkComms.SendMessage(turnInfoMsgBytes);
//Sleep a bit to give others time to check turn and response
Thread.Sleep(500);
bool responseAvailable;
do
{
responseAvailable = ResponseMessages.TryDequeue(out ResponseMessage response);
if (responseAvailable == false)
{
continue;
}
//Check if response is to our message
if (response.Receiver != _UniqueID)
{
Debug.WriteLine("Receive msg error: response was to some other message"); continue;
}
//Check if response is to same message as we sent
if (response.ReceivedMsgID != msgID)
{
Debug.WriteLine("Receive msg error: message ID did not match"); continue;
}
//Log message
_logger.Log("Received response to turn info message from " + response.Sender);
//Check if this player is in lobby
if (IsThisPlayerInLobby(response.Sender) == false)
{
Debug.WriteLine("Receive msg error: player not in lobby"); continue;
}
//Check if turn was approved
if (response.Approve == false)
{
Debug.WriteLine("Receive msg error: player did not approve turn, reason: " + response.ErrorString); continue;
}
//Check if this player has already approved turn
if (ApprovedPlayers.Contains(response.Sender) == true)
{
Debug.WriteLine("Error: player has already approved turn"); continue;
}
_logger.Log("Other player approved turn, PlayerID: " + response.Sender);
ApprovedPlayers.Add(response.Sender);
//Check if it was last required approvement
if (ApprovedPlayers.Count == requiredNumberOfPlayerApprovals)
{
break;
}
} while (responseAvailable);
if (ApprovedPlayers.Count == requiredNumberOfPlayerApprovals)
{
turnApproved = true;
break;
}
}
if (turnApproved)
{
//All good
_logger.Log("Turn ended successfully");
//Clear unnessary responses
ResponseMessages.Clear();
}
else
{
_logger.Log("Ending turn FAILED, did not receive approvement from other players");
}
}
public static KeyValuePair <int, string> Message(Code code)
{
return(ResponseMessages.First(d => d.Key == code.Value()));
}
private void StartRequest()
{
ResponseMessages.Clear();
ResponseIsError = false;
ResponseAtEnd = false;
}
public EmployeeController(IEmployeeService iEmployeeService, EmployeeQueries employeeQueries, IResponseMessages responsMessages)
{
IEmployeeService = iEmployeeService;
EmployeeQueries = employeeQueries;
ResponsMessages = responsMessages as ResponseMessages;
}
public EmployeeQueries(IMapper mapper, UnitOfWork unitOfWork, IResponseMessages responsMessages)
{
_mapper = mapper;
_responsMessages = responsMessages as ResponseMessages;
_unitOfWork = unitOfWork;
}
public CategoryController(ICategoryService iCategoryService, CategoryQueries categoryQueries, IResponseMessages responsMessages)
{
ICategoryService = iCategoryService;
CategoryQueries = categoryQueries;
ResponsMessages = responsMessages as ResponseMessages;
}
public CategoryService(IMapper mapper, UnitOfWork unitOfWork, IResponseMessages responsMessages)
{
_mapper = mapper;
_responsMessages = responsMessages as ResponseMessages;
_unitOfWork = unitOfWork;
}
private bool ProcessTransactionResponse(IBSocket socket, ResponseMessages message, ServerVersions version)
{
switch (message)
{
case ResponseMessages.OrderStatus:
{
// http://www.interactivebrokers.com/en/software/api/apiguide/java/orderstatus.htm
ReadOrderStatus(socket, version);
return true;
}
case ResponseMessages.Portfolio:
{
// http://www.interactivebrokers.com/en/software/api/apiguide/java/updateaccountvalue.htm
ReadPortfolio(socket, version);
return true;
}
case ResponseMessages.PortfolioPosition:
{
// http://www.interactivebrokers.com/en/software/api/apiguide/java/updateportfolio.htm
ReadPortfolioPosition(socket, version);
return true;
}
case ResponseMessages.PortfolioUpdateTime:
{
ReadPortfolioUpdateTime(socket);
return true;
}
case ResponseMessages.OpenOrder:
{
// http://www.interactivebrokers.com/en/software/api/apiguide/java/openorder.htm
ReadOpenOrder(socket, version);
return true;
}
case ResponseMessages.NextOrderId:
{
ReadNextOrderId(socket);
return true;
}
case ResponseMessages.MyTrade:
{
// http://www.interactivebrokers.com/en/software/api/apiguide/java/execdetails.htm
ReadMyTrade(socket, version);
return true;
}
case ResponseMessages.ManagedAccounts:
{
// http://www.interactivebrokers.com/en/software/api/apiguide/java/managedaccounts.htm
ReadManagedAccounts(socket);
return true;
}
case ResponseMessages.OpenOrderEnd:
{
//openOrderEnd(socket);
return true;
}
case ResponseMessages.AccountDownloadEnd:
{
ReadPortfolioName(socket);
return true;
}
case ResponseMessages.MyTradeEnd:
{
// http://www.interactivebrokers.com/en/software/api/apiguide/java/execdetailsend.htm
ReadMyTradeEnd(socket);
return true;
}
case ResponseMessages.CommissionReport:
{
ReadCommissionReport(socket);
return true;
}
case ResponseMessages.Position:
{
ReadPosition(socket, version);
return true;
}
case ResponseMessages.PositionEnd:
{
ReadPositionEnd(socket);
return true;
}
case ResponseMessages.AccountSummary:
{
ReadAccountSummary(socket);
return true;
}
case ResponseMessages.AccountSummaryEnd:
{
ReadAccountSummaryEnd(socket);
return true;
}
default:
return false;
}
}
public ItemController(IItemService iItemService, ItemQueries itemQueries, IResponseMessages responsMessages)
{
IItemService = iItemService;
ItemQueries = itemQueries;
ResponsMessages = responsMessages as ResponseMessages;
}
