private void DestroyControllerInstance()
{
if (controllerInstance.Any())
{
controllerInstance.Single().Close();
}
controllerInstance = Maybe <DeviceController> .Empty;
}
public virtual void Saving(Maybe<Deal> deal)
{
if(deal.Any())
_logger.Info($"Saving : {deal}.");
else
_logger.Warn($" Try Saving : {deal}.");
}
private void EnsureControllerInstanceCreatedAndOpen()
{
if (!controllerInstance.Any())
{
CompositionRoot.BeginSessionScope();
var controller = CompositionRoot.Kernel.Get <DeviceController>();
controllerInstance = new Maybe <DeviceController>(controller);
}
var instance = controllerInstance.Single();
if (!instance.IsConnected)
{
instance.Open(performActionsOnOpen);
}
}
public async Task <List <Candle> > Candlestick(string symbol, string interval, Maybe <string> startTime, Maybe <string> endTime, Maybe <int> limit)
{
try
{
var queryParams = new Dictionary <string, string>
{
{ "symbol", symbol },
{ "interval", interval }
};
if (startTime.Any())
{
queryParams.Add("startTime", startTime.Single());
}
if (endTime.Any())
{
queryParams.Add("endTime", endTime.Single());
}
if (limit.Any())
{
queryParams.Add("limit", limit.Single().ToString());
}
var query = new FormUrlEncodedContent(queryParams);
var response = await _downloader.Get("klines", new Maybe <FormUrlEncodedContent>(query));
return(JsonConvert.DeserializeObject <List <Candle> >(response, new ArrayOfArraysConverter <Candle>()));
}
catch (Exception e)
{
throw e;
}
}
public async Task <List <Ticker> > BookTicker(Maybe <string> symbol)
{
try
{
Maybe <FormUrlEncodedContent> content;
if (!symbol.Any())
{
content = new Maybe <FormUrlEncodedContent>();
}
else
{
content = new Maybe <FormUrlEncodedContent>(new FormUrlEncodedContent(
new Dictionary <string, string>()
{
{ "symbol", symbol.Single() }
}
));
}
var response = await _downloader.Get("ticker/bookTicker", content);
return(JsonConvert.DeserializeObject <List <Ticker> >(response,
new SingleOrArrayConverter <Ticker>()));
}
catch (Exception e)
{
throw e;
}
}
public void MaybeWithValueHasValue(string input)
{
var actual = new Maybe <string>(input);
Assert.True(actual.HasValue);
Assert.True(actual.Any());
Assert.Equal(input, actual.Value);
}
public void MaybeWithNullHasNoValue()
{
var actual = new Maybe <string>(null);
Assert.False(actual.HasValue);
Assert.False(actual.Any());
Assert.Throws <EmptyMaybeException>(() => actual.Value);
}
public void AnyTest()
{
Func <Maybe <int> > j = () => Maybe.Just(1);
Func <Maybe <int> > n = () => Maybe.Nothing;
Assert.AreEqual(Maybe.Any(j, n), Maybe.Just(1));
Assert.AreEqual(Maybe.Any(n, j), Maybe.Just(1));
Assert.AreEqual(Maybe.Any(n), Maybe.Nothing);
}
public void Save(Maybe<Deal> deal)
{
if (deal.Any())
{
var value = deal.Single();
var path = GetFileName(value.Id).FullName;
var serializedDeal = _serializer.SerializeDeal(value);
File.WriteAllText(path, serializedDeal);
}
}
public CoinbasePro(Maybe <IDownloadData> downloader)
{
// If a downloader is not provided, create the default
if (!downloader.Any())
{
downloader = new Maybe <IDownloadData>(
new DownloadData(Constants.Endpoint, Constants.AbsolutePath)
);
}
_publicApi = new PublicMethods(downloader.Single());
}
public CryptoCompare(Maybe <IDownloadData> downloader)
{
// If a downloader is not provided, create the default
if (!downloader.Any())
{
downloader = new Maybe <IDownloadData>(
new DownloadData(Constants.Endpoint, Constants.AbsolutePath)
);
}
api = new Api(downloader.Single());
}
protected override Expression VisitMethodCall(MethodCallExpression node)
{
Maybe <Expression> f = Maybe.Nothing;
if (node.Arguments.Count == 1)
{
f = Maybe.Any(
() => ReplaceMethod(node, _contains, _contains2),
() => ReplaceMethod(node, _startsWith, _startsWith2),
() => ReplaceMethod(node, _endsWith, _endsWith2));
}
return(f.GetOrElse(() => base.VisitMethodCall(node)));
}
public HotBit(Maybe <IDownloadData> downloader)
{
// If a downloader is not provided, create the default
if (!downloader.Any())
{
downloader = new Maybe <IDownloadData>(
new DownloadData(Constants.Endpoint, Constants.AbsolutePath)
);
}
// We can call Single() safely because we are sure there is only one
// instance of IDownloadData inside the Maybe
_publicApi = new PublicMethods(downloader.Single());
}
public async Task <GenericResponse> HistoDay(string fromSymbol, string toSymbol,
Maybe <string> exchange,
Maybe <int> aggregate, Maybe <int> limit, Maybe <int> toTs, Maybe <string> allData)
{
try
{
var parameters = new Dictionary <string, string>()
{
{ "fsym", fromSymbol },
{ "tsym", toSymbol }
};
if (exchange.Any())
{
parameters.Add("e", exchange.Single());
}
if (aggregate.Any())
{
parameters.Add("aggregate", aggregate.Single().ToString());
}
if (limit.Any())
{
parameters.Add("limit", limit.Single().ToString());
}
if (toTs.Any())
{
parameters.Add("toTs", toTs.Single().ToString());
}
if (allData.Any())
{
parameters.Add("allData", allData.Single());
}
var content = new Maybe <FormUrlEncodedContent>(
new FormUrlEncodedContent(parameters));
var response = await downloader.Get("histoday", content);
return(JsonConvert.DeserializeObject <GenericResponse>(response));
}
catch (Exception e)
{
throw e;
}
}
public void UpsertBlockOrSkipWithStress()
{
BlobStorage.PutBlob(ContainerName, BlobName, 0);
var array = new Maybe <int> [8];
array = array
.AsParallel()
.Select(k => BlobStorage.UpsertBlobOrSkip <int>(ContainerName, BlobName, () => 1, i => i + 1))
.ToArray();
Assert.IsFalse(array.Any(x => !x.HasValue), "No skips");
var sorted = array.Select(m => m.Value)
.OrderBy(i => i)
.ToArray();
for (int i = 0; i < array.Length; i++)
{
Assert.AreEqual(i + 1, sorted[i], "Concurrency should be resolved, every call should increment by one.");
}
}
public async Task <List <Candle> > GetCandles(
string productId,
Maybe <string> startTime,
Maybe <string> endTime,
Maybe <string> granaularity)
{
try
{
var queryParams = new Dictionary <string, string>();
if (startTime.Any())
{
queryParams.Add("start", startTime.Single());
}
if (endTime.Any())
{
queryParams.Add("end", endTime.Single());
}
if (granaularity.Any())
{
queryParams.Add("granularity", granaularity.Single());
}
var query = new FormUrlEncodedContent(queryParams);
var req = await GetRequestMessage($"products/{productId}/candles", new Maybe <FormUrlEncodedContent>(query));
var result = await _downloadData.Send(req);
return(JsonConvert.DeserializeObject <List <Candle> >(result, new ArrayOfArraysConverter <Candle>()));
}
catch (Exception e)
{
throw e;
}
}
public void CreatedWithModestConstructorIsGenericallyEmpty(
[Modest] Maybe <T> sut)
{
Assert.False(sut.Any());
}
public void UpsertBlockOrSkipWithStress()
{
BlobStorage.PutBlob(ContainerName, BlobName, 0);
var array = new Maybe<int>[8];
array = array
.AsParallel()
.Select(k => BlobStorage.UpsertBlobOrSkip<int>(ContainerName, BlobName, () => 1, i => i + 1))
.ToArray();
Assert.IsFalse(array.Any(x => !x.HasValue), "No skips");
var sorted = array.Select(m => m.Value)
.OrderBy(i => i)
.ToArray();
for (int i = 0; i < array.Length; i++)
{
Assert.AreEqual(i + 1, sorted[i], "Concurrency should be resolved, every call should increment by one.");
}
}
private void DestroyControllerInstance()
{
if (controllerInstance.Any())
controllerInstance.Single().Close();
controllerInstance = Maybe<TelescopeController>.Empty;
}
