/// <summary>
/// Erstellt ein Photo und läd es auf den webserver hoch.
/// </summary>
private string TakeAndUpload(Dictionary<string, string> parameter)
{
string response; // Beinhaltet später den response des Servers.
// Überprüft ob der Parameter uploadurl vom Server mitgeteilt wurde.
if (!parameter.ContainsKey("uploadurl"))
{
_browser.Navigate(new Uri("javascript:Krypsis.Device.Photo.Error.takeandupload({code : 5})"));
// MessageBox.Show("Device.TakeAndUpload > [Parameter uploadurl nicht vorhanden]");
return "";
}
// Überprüft ob der Parameter parametername vom Server mitgeteilt wurde.
if (!parameter.ContainsKey("parametername"))
{
_browser.Navigate(new Uri("javascript:Krypsis.Device.Photo.Error.takeandupload({code : 5})"));
// MessageBox.Show("Device.TakeAndUpload > [Parameter parametername nicht vorhanden]");
return "";
}
// Überprüft ob der Parameter filename vom Server mitgeteilt wurde und wenn ja, dann wid dieser
// als Name für das Bild verwendet.
if (parameter.ContainsKey("filename"))
{
// Wenn der "filename" Parameter übergeben wurde wird dieser alls Photoname benutzt
DeviceAgent dataAgent = new DeviceAgent();
string path = dataAgent.MakePhoto(parameter["filename"]);
response = NetCom.UploadFileToRemoteUrl(path, parameter["uploadurl"], parameter["parametername"]);
// MessageBox.Show("Device.TakeAndUpload > Bilderpfad: ["+path+"]");
return "";
}
// Wurde der Parameter filename nicht mitgeteilt wird ein Name aus Pic_ und dem Datum für das Bild erstelt.
else
{
// Wenn kein "filename" Paramter übergeben wurde wird ein Name aus "Pic" und einem Zeitstempel ergeugt.
SecurityProvider securityProvider = new SecurityProvider();
DeviceAgent dataAgent = new DeviceAgent();
string path = dataAgent.MakePhoto("Pic_" + securityProvider.Timestamp());
response = NetCom.UploadFileToRemoteUrl(path, parameter["uploadurl"], parameter["parametername"]);
// MessageBox.Show("Device.TakeAndUpload > Bilderpfad: [" + path + "]");
return "";
}
if (response != null && response != "")
{
_browser.Navigate(new Uri("javascript:Krypsis.Device.Photo.Success.takeandupload({response : '" + response + "'})"));
// MessageBox.Show("Device.TakeAndUpload > [Bild wurde hoch geladen!]");
return "";
}
else
{
_browser.Navigate(new Uri("javascript:Krypsis.Device.Photo.Error.takeandupload({code : 5})"));
return "";
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
private string GetID()
{
string path = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().GetName().CodeBase);
CfgFile cfg = new CfgFile(path + "\\confini.ci");
string id = cfg.getValue("DATA", "uniqueid", true);
if (id == "")
{
SecurityProvider sp = new SecurityProvider();
id = sp.GetUniqueIDWithTimestamp(32);
cfg.setValue("DATA", "uniqueid", id, true);
cfg.Save();
}
return id;
}
public void InitializeBrokerage()
{
InteractiveBrokersGatewayRunner.Start(Config.Get("ib-controller-dir"),
Config.Get("ib-tws-dir"),
Config.Get("ib-user-name"),
Config.Get("ib-password"),
Config.Get("ib-trading-mode"),
Config.GetBool("ib-use-tws")
);
// grabs account info from configuration
var securityProvider = new SecurityProvider();
securityProvider[Symbols.USDJPY] = new Security(SecurityExchangeHours.AlwaysOpen(TimeZones.NewYork),
new SubscriptionDataConfig(typeof(TradeBar), Symbols.USDJPY, Resolution.Minute, TimeZones.NewYork, TimeZones.NewYork, false, false, false),
new Cash(CashBook.AccountCurrency, 0, 1m), SymbolProperties.GetDefault(CashBook.AccountCurrency));
_interactiveBrokersBrokerage = new InteractiveBrokersBrokerage(new OrderProvider(_orders), securityProvider);
_interactiveBrokersBrokerage.Connect();
}
public static KeyedHashAlgorithm GetInstance(SecurityProvider provider)
{
switch (provider)
{
case SecurityProvider.HMACMD5:
return new HMACMD5();
case SecurityProvider.HMACRIPEMD160:
return new HMACRIPEMD160();
case SecurityProvider.HMACSHA1:
return new HMACSHA1();
case SecurityProvider.HMACSHA256:
return new HMACSHA256();
case SecurityProvider.HAMCSHA384:
return new HMACSHA384();
case SecurityProvider.HMACSHA512:
return new HMACSHA512();
default:
return new HMACMD5();
}
}
public ActionsController(SecurityProvider securityProvider)
{
this.securityProvider = securityProvider;
}
private void ReceivePacketData(NetworkPacket packet)
{
switch (packet.Command)
{
#region Connected, Send Client Version.
case 0x7E:
{
if (RequiresVersion)
{
var format = new ClientVersion();
Send(format);
RequiresVersion = false;
}
}
break;
#endregion
#region Receive Encryption Information.
case 0x00:
{
_reader = new NetworkPacketReader();
_reader.Packet = packet;
{
_reader.Position--;
}
byte type = _reader.ReadByte();
if (type == 0)
{
var serverTableCrc = _reader.ReadUInt32();
var seed = _reader.ReadByte();
var salt = _reader.ReadBytes(_reader.ReadByte());
_encryption = new SecurityProvider(
new SecurityParameters(seed, salt));
Send(new EncryptionReceived(0));
}
} break;
#endregion
#region Received Server Table Data.
case 0x56:
{
_encryption.Transform(packet);
_reader = new NetworkPacketReader();
_reader.Packet = packet;
}
break;
#endregion
#region Received Redirect Information.
case 0x03:
{
_reader = new NetworkPacketReader();
_reader.Packet = packet;
{
_reader.Position--;
}
var address = _reader.ReadBytes(4);
var port = _reader.ReadUInt16();
_reader.Position++;
var seed = _reader.ReadByte();
var key = _reader.ReadStringA();
var name = _reader.ReadStringA();
var socketid = _reader.ReadUInt32();
_encryption = new SecurityProvider(new SecurityParameters(seed, Encoding.ASCII.GetBytes(key)));
{
Array.Reverse(address);
}
_socket.Close();
Connect(address, port);
State = ServerState.Login;
Send(new RedirectRequest(seed, key, name, socketid));
} break;
#endregion
#region Request Login
case 0x60:
{
if (State == ServerState.Login)
{
Send(new Login(User, Pass));
State = ServerState.World;
}
} break;
#endregion
#region Login Response
case 0x02:
{
_encryption.Transform(packet);
_reader = new NetworkPacketReader();
_reader.Packet = packet;
} break;
#endregion
case 0x05:
Connections++;
break;
default: break;
}
}
/// <summary>
/// Update the enrollment under test such that it forces it to reprovision to the hubs within <paramref name="iotHubsToReprovisionTo"/>
/// </summary>
private async Task UpdateEnrollmentToForceReprovision(EnrollmentType?enrollmentType, ProvisioningServiceClient provisioningServiceClient, ICollection <String> iotHubsToReprovisionTo, SecurityProvider security, string groupId)
{
if (enrollmentType == EnrollmentType.Individual)
{
IndividualEnrollment individualEnrollment = await provisioningServiceClient.GetIndividualEnrollmentAsync(security.GetRegistrationID()).ConfigureAwait(false);
individualEnrollment.IotHubs = iotHubsToReprovisionTo;
IndividualEnrollment individualEnrollmentResult = await provisioningServiceClient.CreateOrUpdateIndividualEnrollmentAsync(individualEnrollment).ConfigureAwait(false);
}
else
{
EnrollmentGroup enrollmentGroup = await provisioningServiceClient.GetEnrollmentGroupAsync(groupId).ConfigureAwait(false);
enrollmentGroup.IotHubs = iotHubsToReprovisionTo;
EnrollmentGroup enrollmentGroupResult = await provisioningServiceClient.CreateOrUpdateEnrollmentGroupAsync(enrollmentGroup).ConfigureAwait(false);
}
}
protected virtual void DestroySecurity()
{
SecurityProvider.Destroy();
}
public EmployeesController(SecurityProvider securityProvider)
{
this.securityProvider = securityProvider;
objectSpace = securityProvider.ObjectSpaceProvider.CreateObjectSpace();
}
public ContainerDeviceSimulator(ProvisioningDeviceClient provisioningDeviceClient, SecurityProvider security)
{
provClient = provisioningDeviceClient;
this.security = security;
}
protected void DemandPermissions()
{
SecurityProvider.DemandPermission();
}
public RoleController(SecurityProvider securityProvider, IMapper mapper)
{
this.securityProvider = securityProvider;
this.mapper = mapper;
}
public ProvisioningDeviceLogic(ProvisioningDeviceClient provisioningDeviceClient, SecurityProvider security)
{
_provClient = provisioningDeviceClient;
_security = security;
}
public AccountController(XpoDataStoreProviderService xpoDataStoreProviderService, IConfiguration config, SecurityProvider securityHelper)
: base(xpoDataStoreProviderService, config, securityHelper)
{
}
public EncryptionHelper(SecurityProvider securityProvider)
{
this.securityProvider = securityProvider;
this.salt = this.securityProvider.pwsalt;
}
public AuthorizationFilter(SecurityProvider securityProvider)
{
this.securityProvider = securityProvider;
}
public ActionResult LogOff()
{
SecurityProvider.Logout();
return(RedirectToAction("Index"));
}
public ProvisioningDeviceClient(Microsoft.Azure.Devices.Provisioning.Client.ProvisioningDeviceClient provisioningDeviceClient, SecurityProvider security)
{
_provClient = provisioningDeviceClient;
_security = security;
}
private void Build()
{
var socketFactory = new SocketFactory();
var perfCountersManager = CreatePerfCountersManager();
var localSocketFactory = new LocalSocketFactory();
var routerLocalSocket = localSocketFactory.Create <IMessage>();
var internalRoutingTable = new InternalRoutingTable();
var externalRoutingTable = new ExternalRoutingTable(logger);
var scaleOutConfigurationManager = new ScaleOutConfigurationManager(configurationProvider.GetRouterConfiguration(),
configurationProvider.GetScaleOutConfiguration());
var rendezvousConfigurationStorage = new RendezvousClusterConfigurationReadonlyStorage(configurationProvider.GetRendezvousEndpointsConfiguration());
var rendezvousCluster = new RendezvousCluster(rendezvousConfigurationStorage);
var securityProider = new SecurityProvider(() => HMAC.Create("HMACMD5"),
domainScopeResolver,
domainPrivateKeyProvider);
var autoDiscoverSender = new AutoDiscoverySender(rendezvousCluster,
scaleOutConfigurationManager,
socketFactory,
perfCountersManager,
securityProider,
logger);
var autoDiscoverListener = new AutoDiscoveryListener(rendezvousCluster,
socketFactory,
scaleOutConfigurationManager,
autoDiscoverSender,
configurationProvider.GetClusterMembershipConfiguration(),
perfCountersManager,
securityProider,
routerLocalSocket,
logger);
var routeDiscovery = new RouteDiscovery(autoDiscoverSender,
scaleOutConfigurationManager,
configurationProvider.GetClusterMembershipConfiguration(),
securityProider,
logger);
var heartBeatSenderConfigurationManager = new HeartBeatSenderConfigurationManager(configurationProvider.GetHeartBeatSenderConfiguration());
var clusterConnectivity = new ClusterConnectivity(configurationProvider.GetClusterMembershipConfiguration(),
scaleOutConfigurationManager,
autoDiscoverSender,
autoDiscoverListener,
routeDiscovery,
socketFactory,
routerLocalSocket,
scaleOutConfigurationManager,
securityProider,
perfCountersManager,
logger,
heartBeatSenderConfigurationManager,
localSocketFactory,
configurationProvider.GetClusterHealthMonitorConfiguration());
var internalRegistrationsSocket = localSocketFactory.Create <InternalRouteRegistration>();
var internalRegistrationsHandler = new InternalMessageRouteRegistrationHandler(clusterConnectivity,
internalRoutingTable,
securityProider,
logger);
messageRouter = new MessageRouter(socketFactory,
internalRoutingTable,
externalRoutingTable,
scaleOutConfigurationManager,
clusterConnectivity,
CreateServiceMessageHandlers(clusterConnectivity,
externalRoutingTable,
internalRoutingTable,
securityProider),
perfCountersManager,
securityProider,
routerLocalSocket,
internalRegistrationsSocket,
internalRegistrationsHandler,
logger);
actorHostManager = new ActorHostManager(securityProider,
perfCountersManager,
routerLocalSocket,
internalRegistrationsSocket,
localSocketFactory,
logger);
var callbackHandlerStack = new CallbackHandlerStack();
messageHub = new MessageHub(callbackHandlerStack,
perfCountersManager,
routerLocalSocket,
internalRegistrationsSocket,
localSocketFactory,
logger,
false);
}
public bool HavePermission()
{
return(SecurityProvider.HavePermission());
}
private async Task CommunicationEngineLoopAsync(CancellationToken token)
{
_Logger.EnteringMethodAzure(nameof(CommunicationContext));
SecurityProvider security = null;
DeviceClient deviceClient = null;
string assignedHub = String.Empty;
try
{
security = new SecurityProviderSymmetricKey(_azureDeviceParameters.AzureDeviceId, _azureDeviceParameters.AzurePrimaryKey, _azureDeviceParameters.AzureSecondaryKey);
while (!_disconnectRequest)
{
token.ThrowIfCancellationRequested();
_Logger.EnteringState(_currentState.ToString());
switch (_currentState)
{
case MachineState.UnassignedState:
DeviceRegistrationResult provisioningResult = await RegisterAsync(security, token);
switch (provisioningResult.Status)
{
case ProvisioningRegistrationStatusType.Unassigned:
_Logger.UnexpectedProvisioningResultStatus($"{nameof(ProvisioningRegistrationStatusType.Unassigned)}", $"{provisioningResult.ErrorMessage}");
await Task.Delay(_delayAfterFailure, token); //No transition
break;
case ProvisioningRegistrationStatusType.Assigning:
_Logger.UnexpectedProvisioningResultStatus($"{nameof(ProvisioningRegistrationStatusType.Assigning)}", $"{provisioningResult.ErrorMessage}");
await Task.Delay(_delayAfterFailure, token); //No transition
break;
case ProvisioningRegistrationStatusType.Assigned:
assignedHub = provisioningResult.AssignedHub;
TransitionTo(MachineState.AssigneddState);
break;
case ProvisioningRegistrationStatusType.Failed:
_Logger.UnexpectedProvisioningResultStatus($"{nameof(ProvisioningRegistrationStatusType.Failed)}", $"{provisioningResult.ErrorMessage}");
await Task.Delay(_delayAfterFailure, token); //No transition
break;
case ProvisioningRegistrationStatusType.Disabled:
_Logger.UnexpectedProvisioningResultStatus($"{nameof(ProvisioningRegistrationStatusType.Disabled)}", $"{provisioningResult.ErrorMessage}");
await Task.Delay(_delayAfterFailure, token); //No transition
break;
}
break;
case MachineState.AssigneddState:
deviceClient = await ConnectAsync(assignedHub, security, token);
if (deviceClient != null)
{
security.Dispose();
security = null;
TransitionTo(MachineState.DataTransferingState);
}
else
{
_Logger.AzureConnectionFailure(nameof(CommunicationContext), nameof(CommunicationEngineLoopAsync), $"Failed to connect.");
await Task.Delay(_delayAfterFailure, token);
}
break;
case MachineState.DataTransferingState:
_Logger.StartingTimeDelay(_azureDeviceParameters.PublishingInterval().ToString());
await Task.Delay(_azureDeviceParameters.PublishingInterval(), token);
await DataTransfer(deviceClient, token);
break;
}
}
}
catch (Exception ex)
{
_Logger.LogException(nameof(CommunicationContext), ex);
}
finally
{
_Logger.DisposingObject(nameof(DeviceClient), nameof(DeviceClient.CloseAsync));
deviceClient?.CloseAsync();
_Logger.DisposingObject(nameof(SecurityProvider), nameof(SecurityProvider.Dispose));
security?.Dispose();
_disconnectRequest = false;
_running = false;
}
}
public WorkspaceController(SecurityProvider securityProvider)
{
this.securityProvider = securityProvider;
}
public DepartmentsController(XpoDataStoreProviderService xpoDataStoreProviderService, IConfiguration config, SecurityProvider securityHelper, IHttpContextAccessor contextAccessor)
: base(xpoDataStoreProviderService, config, securityHelper, contextAccessor)
{
}
public DepartmentsController(SecurityProvider securityProvider)
{
this.securityProvider = securityProvider;
objectSpace = securityProvider.ObjectSpaceProvider.CreateObjectSpace();
}
protected NetworkClient()
{
Reader = new NetworkPacketReader();
Writer = new NetworkPacketWriter();
Encryption = new SecurityProvider();
}
void WebEvents_OnLoadRequestedPath(HandleFlag handled)
{
if (handled.Handled)
{
return;
}
switch (SprocketPath.Value)
{
case "activate/fix":
{
bool failed = false;
if (!WebAuthentication.IsLoggedIn)
{
failed = true;
}
else if (!SecurityProvider.CurrentUser.HasPermission(PermissionType.AdministrativeAccess))
{
failed = true;
}
if (failed)
{
HttpContext.Current.Response.Write("<html><body><p>Access denied. Administrative access required.</p></body></html>");
handled.Set();
return;
}
else
{
try
{
int k;
using (TransactionScope scope = new TransactionScope())
{
DatabaseManager.DatabaseEngine.GetConnection();
List <User> users = SecurityProvider.DataLayer.FilterUsers(null, null, null, null, null, null, false, out k);
foreach (User user in users)
{
SecurityProvider.RequestUserActivation(user.UserID, user.Email);
}
scope.Complete();
}
HttpContext.Current.Response.Write("<html><body><p>" + k + " activation requests created.</p></body></html>");
handled.Set();
return;
}
finally
{
DatabaseManager.DatabaseEngine.ReleaseConnection();
}
}
}
default:
switch (SprocketPath.Sections[0])
{
case "_captcha":
RenderCAPTCHAImage();
break;
case "activate":
if (SprocketPath.Sections.Length == 2)
{
string activationCode = SprocketPath.Sections[1];
long userID;
Result r = SecurityProvider.DataLayer.ActivateUser(activationCode, out userID);
if (r.Succeeded)
{
User user = null;
if (WebAuthentication.IsLoggedIn)
{
if (SecurityProvider.CurrentUser.UserID == userID)
{
user = SecurityProvider.CurrentUser;
user.Activated = true;
}
}
if (user == null)
{
user = SecurityProvider.DataLayer.SelectUser(userID);
}
if (OnUserActivated != null)
{
OnUserActivated(user, handled);
}
if (!handled.Handled)
{
HttpContext.Current.Response.Write("<html><body><p>The user has been successfully activated.</p></body></html>");
handled.Set();
}
}
else
{
if (OnUserActivationError != null)
{
OnUserActivationError(r, handled);
}
if (!handled.Handled)
{
HttpContext.Current.Response.Write("<html><body><p>" + r.Message + "</p></body></html>");
handled.Set();
}
}
}
break;
}
break;
}
}
public bool HavePermission(string operation)
{
return(SecurityProvider.HavePermission(operation));
}
public PokemonController(PokemonDatabase database, Pokedex pokedex, SecurityProvider securityProvider)
{
this.database = database;
this.pokedex = pokedex;
this.securityProvider = securityProvider;
}
protected void DemandPermissions(string operation)
{
SecurityProvider.DemandPermission(operation);
}
public HomeController(IOwinContext context, SecurityProvider securityProvider)
{
this.owinContext = context;
this.securityProvider = securityProvider;
}
protected override void Cleanup()
{
SecurityProvider.Cleanup();
}
/// <summary>
/// Places a new order and assigns a new broker ID to the order
/// </summary>
/// <param name="order">The order to be placed</param>
/// <returns>True if the request for a new order has been placed, false otherwise</returns>
public override bool PlaceOrder(Order order)
{
var requestParams = new Dictionary <string, string>
{
{ "instrument", SymbolMapper.GetBrokerageSymbol(order.Symbol) },
{ "units", Convert.ToInt32(order.AbsoluteQuantity).ToString() }
};
PopulateOrderRequestParameters(order, requestParams);
var postOrderResponse = PostOrderAsync(requestParams);
if (postOrderResponse == null)
{
return(false);
}
// if market order, find fill quantity and price
var marketOrderFillPrice = 0m;
if (order.Type == OrderType.Market)
{
marketOrderFillPrice = Convert.ToDecimal(postOrderResponse.price);
}
var marketOrderFillQuantity = 0;
if (postOrderResponse.tradeOpened != null && postOrderResponse.tradeOpened.id > 0)
{
if (order.Type == OrderType.Market)
{
marketOrderFillQuantity = postOrderResponse.tradeOpened.units;
}
else
{
order.BrokerId.Add(postOrderResponse.tradeOpened.id.ToString());
}
}
if (postOrderResponse.tradeReduced != null && postOrderResponse.tradeReduced.id > 0)
{
if (order.Type == OrderType.Market)
{
marketOrderFillQuantity = postOrderResponse.tradeReduced.units;
}
else
{
order.BrokerId.Add(postOrderResponse.tradeReduced.id.ToString());
}
}
if (postOrderResponse.orderOpened != null && postOrderResponse.orderOpened.id > 0)
{
if (order.Type != OrderType.Market)
{
order.BrokerId.Add(postOrderResponse.orderOpened.id.ToString());
}
}
if (postOrderResponse.tradesClosed != null && postOrderResponse.tradesClosed.Count > 0)
{
marketOrderFillQuantity += postOrderResponse.tradesClosed
.Where(trade => order.Type == OrderType.Market)
.Sum(trade => trade.units);
}
// send Submitted order event
const int orderFee = 0;
order.PriceCurrency = SecurityProvider.GetSecurity(order.Symbol).SymbolProperties.QuoteCurrency;
OnOrderEvent(new OrderEvent(order, DateTime.UtcNow, orderFee)
{
Status = OrderStatus.Submitted
});
if (order.Type == OrderType.Market)
{
// if market order, also send Filled order event
OnOrderEvent(new OrderEvent(order, DateTime.UtcNow, orderFee)
{
Status = OrderStatus.Filled,
FillPrice = marketOrderFillPrice,
FillQuantity = marketOrderFillQuantity * Math.Sign(order.Quantity)
});
}
return(true);
}
/// <summary>
/// Places a new order and assigns a new broker ID to the order
/// </summary>
/// <param name="order">The order to be placed</param>
/// <returns>True if the request for a new order has been placed, false otherwise</returns>
public override bool PlaceOrder(Order order)
{
var requestParams = new Dictionary <string, string>
{
{ "instrument", SymbolMapper.GetBrokerageSymbol(order.Symbol) },
{ "units", order.AbsoluteQuantity.ConvertInvariant <int>().ToStringInvariant() }
};
var orderFee = OrderFee.Zero;
var marketOrderFillQuantity = 0;
var marketOrderRemainingQuantity = 0;
decimal marketOrderFillPrice;
var marketOrderStatus = OrderStatus.Filled;
order.PriceCurrency = SecurityProvider.GetSecurity(order.Symbol).SymbolProperties.QuoteCurrency;
PopulateOrderRequestParameters(order, requestParams);
lock (Locker)
{
var postOrderResponse = PostOrderAsync(requestParams);
if (postOrderResponse == null)
{
return(false);
}
// Market orders are special, due to the callback not being triggered always, if the order was filled,
// find fill quantity and price and inform the user
if (postOrderResponse.tradeOpened != null && postOrderResponse.tradeOpened.id > 0)
{
if (order.Type == OrderType.Market)
{
marketOrderFillQuantity = postOrderResponse.tradeOpened.units;
}
else
{
order.BrokerId.Add(postOrderResponse.tradeOpened.id.ToStringInvariant());
}
}
if (postOrderResponse.tradeReduced != null && postOrderResponse.tradeReduced.id > 0)
{
if (order.Type == OrderType.Market)
{
marketOrderFillQuantity = postOrderResponse.tradeReduced.units;
}
else
{
order.BrokerId.Add(postOrderResponse.tradeReduced.id.ToStringInvariant());
}
}
if (postOrderResponse.orderOpened != null && postOrderResponse.orderOpened.id > 0)
{
if (order.Type != OrderType.Market)
{
order.BrokerId.Add(postOrderResponse.orderOpened.id.ToStringInvariant());
}
}
if (postOrderResponse.tradesClosed != null && postOrderResponse.tradesClosed.Count > 0)
{
marketOrderFillQuantity += postOrderResponse.tradesClosed
.Where(trade => order.Type == OrderType.Market)
.Sum(trade => trade.units);
}
marketOrderFillPrice = postOrderResponse.price.ConvertInvariant <decimal>();
marketOrderRemainingQuantity = Convert.ToInt32(order.AbsoluteQuantity - Math.Abs(marketOrderFillQuantity));
if (marketOrderRemainingQuantity > 0)
{
marketOrderStatus = OrderStatus.PartiallyFilled;
// The order was not fully filled lets save it so the callback can inform the user
PendingFilledMarketOrders[order.Id] = marketOrderStatus;
}
}
OnOrderEvent(new OrderEvent(order, DateTime.UtcNow, orderFee)
{
Status = OrderStatus.Submitted
});
// If 'marketOrderRemainingQuantity < order.AbsoluteQuantity' is false it means the order was not even PartiallyFilled, wait for callback
if (order.Type == OrderType.Market && marketOrderRemainingQuantity < order.AbsoluteQuantity)
{
OnOrderEvent(new OrderEvent(order, DateTime.UtcNow, orderFee)
{
Status = marketOrderStatus,
FillPrice = marketOrderFillPrice,
FillQuantity = marketOrderFillQuantity * Math.Sign(order.Quantity)
});
}
return(true);
}
public ProvisioningDeviceTpmClient(ProvisioningDeviceClient provisioningDeviceClient, SecurityProvider security, string skipTest)
{
_provClient = provisioningDeviceClient;
_security = security;
_skipTest = skipTest;
}
