Files
WMS/HHWMS.Web/Areas/Hub/StockTicker.cs
T
2024-03-07 22:59:43 +08:00

192 lines
5.3 KiB
C#

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Reactive.Linq;
using System.Reactive.Subjects;
using System.Threading;
using System.Threading.Tasks;
using IoTClient.Clients.PLC;
using IoTClient.Common.Enums;
using IoTClient.Enums;
using Microsoft.AspNetCore.SignalR;
namespace HHWMS.Web
{
public class StockTicker
{
private readonly SemaphoreSlim _marketStateLock = new SemaphoreSlim(1, 1);
private readonly SemaphoreSlim _updateStockPricesLock = new SemaphoreSlim(1, 1);
private readonly ConcurrentDictionary<string, Stock> _stocks = new ConcurrentDictionary<string, Stock>();
private readonly Subject<Stock> _subject = new Subject<Stock>();
// Stock can go up or down by a percentage of this factor on each change
private readonly double _rangePercent = 0.002;
private readonly TimeSpan _updateInterval = TimeSpan.FromSeconds(10);
private readonly Random _updateOrNotRandom = new Random();
private Timer _timer;
private volatile bool _updatingStockPrices;
private volatile MarketState _marketState;
public StockTicker(IHubContext<StockTickerHub> hub)
{
Hub = hub;
LoadDefaultStocks();
}
private IHubContext<StockTickerHub> Hub
{
get;
set;
}
public MarketState MarketState
{
get { return _marketState; }
private set { _marketState = value; }
}
public IEnumerable<Stock> GetAllStocks()
{
return _stocks.Values;
}
public IObservable<Stock> StreamStocks()
{
return _subject;
}
public async Task OpenMarket()
{
await _marketStateLock.WaitAsync();
try
{
//if (MarketState != MarketState.Open)
//{
_timer = new Timer(UpdateStockPrices, null, _updateInterval, _updateInterval);
MarketState = MarketState.Open;
await BroadcastMarketStateChange(MarketState.Open);
//}
}
finally
{
_marketStateLock.Release();
}
}
public async Task CloseMarket()
{
await _marketStateLock.WaitAsync();
try
{
if (MarketState == MarketState.Open)
{
if (_timer != null)
{
_timer.Dispose();
}
MarketState = MarketState.Closed;
await BroadcastMarketStateChange(MarketState.Closed);
}
}
finally
{
_marketStateLock.Release();
}
}
public async Task Reset()
{
await _marketStateLock.WaitAsync();
try
{
if (MarketState != MarketState.Closed)
{
throw new InvalidOperationException("Market must be closed before it can be reset.");
}
LoadDefaultStocks();
await BroadcastMarketReset();
}
finally
{
_marketStateLock.Release();
}
}
private void LoadDefaultStocks()
{
_stocks.Clear();
var stocks = new List<Stock>
{
new Stock { DbName = "V2207", DbValue = 1.0 },
new Stock { DbName = "V2307", DbValue = 2.0 },
new Stock { DbName = "V2407", DbValue = 3.0 }
};
stocks.ForEach(stock => _stocks.TryAdd(stock.DbName, stock));
}
private async void UpdateStockPrices(object state)
{
// This function must be re-entrant as it's running as a timer interval handler
await _updateStockPricesLock.WaitAsync();
try
{
if (!_updatingStockPrices)
{
_updatingStockPrices = true;
foreach (var stock in _stocks.Values)
{
SiemensClient client = new SiemensClient(SiemensVersion.S7_1500, "127.0.0.1", 102);
stock.DbValue = client.ReadFloat(stock.DbName).Value;
_subject.OnNext(stock);
}
_updatingStockPrices = false;
}
}
finally
{
_updateStockPricesLock.Release();
}
}
private async Task BroadcastMarketStateChange(MarketState marketState)
{
switch (marketState)
{
case MarketState.Open:
await Hub.Clients.All.SendAsync("marketOpened");
break;
case MarketState.Closed:
await Hub.Clients.All.SendAsync("marketClosed");
break;
default:
break;
}
}
private async Task BroadcastMarketReset()
{
await Hub.Clients.All.SendAsync("marketReset");
}
}
public enum MarketState
{
Closed,
Open
}
}