public async Task <IActionResult> GetKeyAutocompleteList([FromRoute] string category,
[FromRoute] string name,
[FromQuery] string query = null,
[FromQuery] int offset = -1,
[FromQuery] int length = -1,
[FromQuery] long targetVersion = -1)
{
try
{
var range = QueryRange.Make(offset, length);
var identifier = new EnvironmentIdentifier(category, name);
var result = await _store.Environments.GetKeyAutoComplete(identifier, query, range, targetVersion);
return(Result(result));
}
catch (Exception e)
{
KnownMetrics.Exception.WithLabels(e.GetType().Name).Inc();
Logger.LogError(e, $"failed to export retrieve autocomplete-data (" +
$"{nameof(category)}: {category}; " +
$"{nameof(name)}: {name}; " +
$"{nameof(query)}: {query}; " +
$"{nameof(offset)}: {offset}; " +
$"{nameof(length)}: {length}; " +
$"{nameof(targetVersion)}: {targetVersion};)");
return(StatusCode(HttpStatusCode.InternalServerError, "failed to retrieve autocomplete-data"));
}
}
public string BuildSearchQueryString(int pageNumber)
{
var query = $"/search?q={SearchTerm}";
var paramz = new List <string>();
if (SearchResultsType != SearchResultsType.All)
{
paramz.Add("t=" + SearchResultsType.ToString().ToLower());
}
if (pageNumber > 1)
{
paramz.Add("p=" + pageNumber);
}
if (QuerySortBy != QuerySortBy.DateCreated)
{
paramz.Add("s=" + QuerySortBy.ToString().ToLower());
}
if (QueryRange != QueryRange.Forever)
{
paramz.Add("r=" + QueryRange.ToString().ToLower());
}
if (paramz.Count == 0)
{
return(query);
}
query += "&" + string.Join('&', paramz);
return(query);
}
/// <inheritdoc />
public async Task <IResult <IList <StructureIdentifier> > > GetAvailable(QueryRange range)
{
try
{
_logger.LogDebug("collecting available structures");
var listResult = await _domainObjectStore.ReplayObject <ConfigStructureList>();
if (listResult.IsError)
{
return(Result.Success <IList <StructureIdentifier> >(new List <StructureIdentifier>()));
}
var structures = listResult.Data.GetIdentifiers();
_logger.LogDebug($"got '{structures.Count}' structures, filtering / ordering now");
var result = structures.OrderBy(s => s.Name)
.ThenByDescending(s => s.Version)
.Skip(range.Offset)
.Take(range.Length)
.ToList();
return(Result.Success <IList <StructureIdentifier> >(result));
}
catch (Exception e)
{
_logger.LogError(e, "failed to retrieve structures");
return(Result.Error <IList <StructureIdentifier> >("failed to retrieve structures", ErrorCode.DbQueryError));
}
}
public async Task <IActionResult> GetAvailableStructures([FromQuery] int offset = -1,
[FromQuery] int length = -1)
{
try
{
var range = QueryRange.Make(offset, length);
var result = await _store.Structures.GetAvailable(range);
if (result.IsError)
{
return(ProviderError(result));
}
var sortedData = result.Data
.GroupBy(s => s.Name)
.ToDictionary(g => g.Key, g => g.Select(s => s.Version)
.ToArray());
return(Ok(sortedData));
}
catch (Exception e)
{
Logger.LogError(e, "failed to retrieve available structures");
return(StatusCode((int)HttpStatusCode.InternalServerError, "failed to retrieve available structures"));
}
}
/// <inheritdoc />
public async Task <IResult <IList <ConfigurationIdentifier> > > GetStale(QueryRange range)
{
try
{
_logger.LogDebug($"retrieving stale configurations, range={range}");
var list = await _domainObjectStore.ReplayObject <PreparedConfigurationList>();
if (list.IsError)
{
return(Result.Success <IList <ConfigurationIdentifier> >(new List <ConfigurationIdentifier>()));
}
var stale = list.Data.GetStale();
_logger.LogDebug($"got '{stale.Count}' stale configurations, filtering / ordering");
var identifiers = stale.OrderBy(id => id.Environment.Category)
.ThenBy(id => id.Environment.Name)
.ThenBy(id => id.Structure.Name)
.ThenByDescending(id => id.Structure.Version)
.Skip(range.Offset)
.Take(range.Length)
.ToList();
_logger.LogDebug($"collected '{identifiers.Count}' identifiers");
return(Result.Success <IList <ConfigurationIdentifier> >(identifiers));
}
catch (Exception e)
{
_logger.LogError(e, "failed to retrieve projected configurations");
return(Result.Error <IList <ConfigurationIdentifier> >("failed to retrieve projected configurations", ErrorCode.DbQueryError));
}
}
public async Task <IActionResult> GetVariables([FromRoute] string name,
[FromRoute] int structureVersion,
[FromQuery] int offset = -1,
[FromQuery] int length = -1)
{
if (string.IsNullOrWhiteSpace(name))
{
return(BadRequest("no name provided"));
}
if (structureVersion <= 0)
{
return(BadRequest($"invalid version provided '{structureVersion}'"));
}
var range = QueryRange.Make(offset, length);
var identifier = new StructureIdentifier(name, structureVersion);
try
{
var result = await _store.Structures.GetVariables(identifier, range);
return(Result(result));
}
catch (Exception e)
{
Logger.LogError(e, $"failed to retrieve structure-variables of ({nameof(name)}: {name}, {nameof(structureVersion)}: {structureVersion})");
return(StatusCode(HttpStatusCode.InternalServerError, "failed to retrieve structure"));
}
}
public async Task GetAutocompleteParametersForwarded(string category,
string name,
string query,
int offset,
int length,
long targetVersion)
{
_projectionStore.Setup(s => s.Environments.GetKeyAutoComplete(new EnvironmentIdentifier(category, name),
query,
QueryRange.Make(offset, length),
targetVersion))
.ReturnsAsync(() => Result.Success <IList <DtoConfigKeyCompletion> >(new List <DtoConfigKeyCompletion>
{
new DtoConfigKeyCompletion
{
FullPath = "Foo/Bar",
Completion = "Baz",
HasChildren = false
},
new DtoConfigKeyCompletion
{
FullPath = "Foo/Bar",
Completion = "Que",
HasChildren = true
}
}))
.Verifiable("autocomplete-data not searched");
await TestAction <OkObjectResult>(c => c.GetKeyAutocompleteList(category, name, query, offset, length, targetVersion));
_projectionStore.Verify();
}
public async Task <IActionResult> Get(string metric, string unit, int range)
{
_logger.LogInformation($"metric: {metric}; unit: {unit}; range: {range}");
QueryRange queryRange;
switch (unit)
{
case "hour":
queryRange = new QueryRange(range, RangeUnit.hour);
break;
case "day":
queryRange = new QueryRange(range, RangeUnit.day);
break;
default:
queryRange = new QueryRange(range, RangeUnit.minute);
break;
}
var data = await _reader.QueryAsync(metric, queryRange);
if (data != null)
{
return(Json(data));
}
else
{
return(NotFound());
}
}
public async Task <IActionResult> GetKeysWithMetadata([FromRoute] string category,
[FromRoute] string name,
[FromQuery] string filter,
[FromQuery] string preferExactMatch,
[FromQuery] string root,
[FromQuery] int offset = -1,
[FromQuery] int length = -1,
[FromQuery] long targetVersion = -1)
{
try
{
var range = QueryRange.Make(offset, length);
var identifier = new EnvironmentIdentifier(category, name);
var result = await _store.Environments.GetKeyObjects(new EnvironmentKeyQueryParameters
{
Environment = identifier,
Filter = filter,
PreferExactMatch = preferExactMatch,
Range = range,
RemoveRoot = root,
TargetVersion = targetVersion
});
if (result.IsError)
{
return(ProviderError(result));
}
foreach (var item in result.Data)
{
if (item.Description is null)
{
item.Description = string.Empty;
}
if (item.Type is null)
{
item.Type = string.Empty;
}
}
return(Ok(result.Data));
}
catch (Exception e)
{
KnownMetrics.Exception.WithLabels(e.GetType().Name).Inc();
Logger.LogError(e, "failed to retrieve Environment-Keys (" +
$"{nameof(category)}: {category}; " +
$"{nameof(name)}: {name}; " +
$"{nameof(filter)}: {filter}; " +
$"{nameof(preferExactMatch)}: {preferExactMatch}; " +
$"{nameof(root)}: {root}; " +
$"{nameof(offset)}: {offset}; " +
$"{nameof(length)}: {length}; " +
$"{nameof(targetVersion)}: {targetVersion})");
return(StatusCode(HttpStatusCode.InternalServerError, "failed to retrieve environment-keys"));
}
}
public void Equality(int offset, int length)
{
var left = new QueryRange(offset, length);
var right = new QueryRange(offset, length);
Assert.True(left.Equals(right));
Assert.True(left == right);
Assert.False(left != right);
}
public async Task GetKeysPaged()
{
var domainObjectStore = new Mock <IDomainObjectStore>(MockBehavior.Strict);
domainObjectStore.Setup(dos => dos.ReplayObject(It.IsAny <ConfigEnvironment>(), It.IsAny <string>()))
.ReturnsAsync((ConfigEnvironment str, string id) =>
{
str.ApplyEvent(new ReplayedEvent
{
DomainEvent = new EnvironmentCreated(new EnvironmentIdentifier("Foo", "Bar")),
UtcTime = DateTime.UtcNow,
Version = 4710
});
str.ApplyEvent(new ReplayedEvent
{
DomainEvent = new EnvironmentKeysImported(new EnvironmentIdentifier("Foo", "Bar"), new[]
{
ConfigKeyAction.Set("Foo", "FooValue"),
ConfigKeyAction.Set("Bar", "BarValue"),
ConfigKeyAction.Set("Baz", "BazValue")
}),
UtcTime = DateTime.UtcNow,
Version = 4711
});
return(Result.Success(str));
})
.Verifiable();
var eventStore = new Mock <IEventStore>(MockBehavior.Strict);
eventStore.Setup(es => es.ReplayEventsAsStream(
It.IsAny <Func <(StoredEvent StoredEvent, DomainEventMetadata Metadata), bool> >(),
It.IsAny <Func <(StoredEvent StoredEvent, DomainEvent DomainEvent), bool> >(),
It.IsAny <int>(),
It.IsAny <StreamDirection>(),
It.IsAny <long>()))
.Returns(Task.CompletedTask);
var store = new EnvironmentProjectionStore(eventStore.Object,
domainObjectStore.Object,
_logger,
new ICommandValidator[0]);
var result = await store.GetKeys(new EnvironmentKeyQueryParameters
{
Environment = new EnvironmentIdentifier("Foo", "Bar"),
Range = QueryRange.Make(1, 1)
});
Assert.Empty(result.Message);
Assert.False(result.IsError, "result.IsError");
Assert.Single(result.Data);
Assert.Equal(new KeyValuePair <string, string>("Baz", "BazValue"), result.Data.First());
domainObjectStore.Verify();
eventStore.Verify();
}
public async Task GetAvailablePaged()
{
var domainObjectStore = new Mock <IDomainObjectStore>(MockBehavior.Strict);
domainObjectStore.Setup(dos => dos.ReplayObject <ConfigEnvironmentList>(It.IsAny <long>()))
.ReturnsAsync((long v) =>
{
var list = new ConfigEnvironmentList();
list.ApplyEvent(new ReplayedEvent
{
DomainEvent = new EnvironmentCreated(new EnvironmentIdentifier("Foo", "Foo")),
UtcTime = DateTime.UtcNow,
Version = 4710
});
list.ApplyEvent(new ReplayedEvent
{
DomainEvent = new EnvironmentCreated(new EnvironmentIdentifier("Foo", "Bar")),
UtcTime = DateTime.UtcNow,
Version = 4711
});
list.ApplyEvent(new ReplayedEvent
{
DomainEvent = new EnvironmentCreated(new EnvironmentIdentifier("Foo", "Baz")),
UtcTime = DateTime.UtcNow,
Version = 4712
});
return(Result.Success(list));
})
.Verifiable();
var eventStore = new Mock <IEventStore>(MockBehavior.Strict);
eventStore.Setup(es => es.ReplayEventsAsStream(
It.IsAny <Func <(StoredEvent StoredEvent, DomainEventMetadata Metadata), bool> >(),
It.IsAny <Func <(StoredEvent StoredEvent, DomainEvent DomainEvent), bool> >(),
It.IsAny <int>(),
It.IsAny <StreamDirection>(),
It.IsAny <long>()))
.Returns(Task.CompletedTask);
var store = new EnvironmentProjectionStore(eventStore.Object,
domainObjectStore.Object,
_logger,
new ICommandValidator[0]);
var result = await store.GetAvailable(QueryRange.Make(1, 1));
Assert.Empty(result.Message);
Assert.False(result.IsError, "result.IsError");
Assert.Single(result.Data);
domainObjectStore.Verify();
eventStore.Verify();
}
public void GetHashCodeStable(int offset, int length)
{
var range = new QueryRange(offset, length);
var hashes = Enumerable.Range(0, 1000)
.Select(i => range.GetHashCode())
.ToList();
var example = range.GetHashCode();
Assert.True(hashes.All(h => h == example), "hashes.All(h => h == example)");
}
/// <inheritdoc />
public async Task <IResult <IDictionary <string, string> > > GetKeys(ConfigurationIdentifier identifier,
DateTime when,
QueryRange range)
{
var formattedParams = "(" +
$"{nameof(identifier.Environment)}{nameof(identifier.Environment.Category)}: {identifier.Environment.Category}; " +
$"{nameof(identifier.Environment)}{nameof(identifier.Environment.Name)}: {identifier.Environment.Name}; " +
$"{nameof(identifier.Structure)}{nameof(identifier.Structure.Name)}: {identifier.Structure.Name}; " +
$"{nameof(identifier.Structure)}{nameof(identifier.Structure.Version)}: {identifier.Structure.Version}" +
")";
try
{
_logger.LogDebug($"retrieving keys of '{identifier}' at {when:O}, range={range}");
var configuration = await _domainObjectStore.ReplayObject(new PreparedConfiguration(identifier), identifier.ToString());
if (configuration.IsError || !configuration.Data.Created)
{
return(Result.Error <IDictionary <string, string> >(
$"no configuration found with id: {formattedParams}",
ErrorCode.NotFound));
}
_logger.LogDebug($"compiling '{identifier}'");
await configuration.Data.Compile(_domainObjectStore, _compiler, _parser, _translator, _logger);
if (configuration.Data.Keys is null || !configuration.Data.Keys.Any())
{
return(Result.Error <IDictionary <string, string> >(
$"no data found for configuration with id: {formattedParams}",
ErrorCode.NotFound));
}
var result = configuration.Data
.Keys
.OrderBy(k => k.Key)
.Skip(range.Offset)
.Take(range.Length)
.ToImmutableSortedDictionary(k => k.Key, k => k.Value, StringComparer.OrdinalIgnoreCase);
_logger.LogDebug($"collected '{result.Count}' keys from '{identifier}'");
return(Result.Success <IDictionary <string, string> >(result));
}
catch (Exception e)
{
_logger.LogError(e, $"failed to retrieve projected configuration keys for id: {formattedParams}");
return(Result.Error <IDictionary <string, string> >($"failed to retrieve projected configuration keys for id: {formattedParams}",
ErrorCode.DbQueryError));
}
}
public async Task GetEnvironmentsParametersForwarded()
{
_projectionStoreMock.Setup(s => s.Environments.GetAvailable(QueryRange.Make(1, 2), 4711))
.ReturnsAsync(() => Result.Success <IList <EnvironmentIdentifier> >(new List <EnvironmentIdentifier>
{
new EnvironmentIdentifier("Foo", "Bar")
}))
.Verifiable("environments not queried");
await TestAction <OkObjectResult>(c => c.GetAvailableEnvironments(1, 2, 4711));
_projectionStoreMock.Verify();
}
public QueryRange <IContent> ExecuteQueryInternal(ApprovalQuery query)
{
var itemsToBeApproved = _approvalRepository.ListAsync(query);
var contentItemsToBeApproved = new List <IContent>();
var result = itemsToBeApproved.Result;
foreach (ContentApproval approval in result)
{
contentItemsToBeApproved.Add(_contentRepository.Get <IContent>(approval.ContentLink));
}
var items = new QueryRange <IContent>(contentItemsToBeApproved, new ItemRange());
return(items);
}
public async Task GetKeysPaged()
{
var domainObjectStore = new Mock <IDomainObjectStore>(MockBehavior.Strict);
domainObjectStore.Setup(dos => dos.ReplayObject(It.IsAny <ConfigStructure>(), It.IsAny <string>()))
.ReturnsAsync((ConfigStructure str, string id) =>
{
str.ApplyEvent(new ReplayedEvent
{
DomainEvent = new StructureCreated(new StructureIdentifier("Foo", 42),
new Dictionary <string, string>
{
{ "Bar", "BarValue" },
{ "Baz", "BazValue" },
{ "Foo", "FooValue" }
},
new Dictionary <string, string> {
{ "Bar", "Baz" }
}),
UtcTime = DateTime.UtcNow,
Version = 4710
});
return(Result.Success(str));
})
.Verifiable();
var eventStore = new Mock <IEventStore>(MockBehavior.Strict);
eventStore.Setup(es => es.ReplayEventsAsStream(
It.IsAny <Func <(StoredEvent StoredEvent, DomainEventMetadata Metadata), bool> >(),
It.IsAny <Func <(StoredEvent StoredEvent, DomainEvent DomainEvent), bool> >(),
It.IsAny <int>(),
It.IsAny <StreamDirection>(),
It.IsAny <long>()))
.Returns(Task.CompletedTask);
var store = new StructureProjectionStore(_logger,
domainObjectStore.Object,
eventStore.Object,
new ICommandValidator[0]);
var result = await store.GetKeys(new StructureIdentifier("Foo", 42), QueryRange.Make(1, 1));
Assert.False(result.IsError, "result.IsError");
Assert.Single(result.Data);
Assert.Equal(new KeyValuePair <string, string>("Baz", "BazValue"), result.Data.First());
domainObjectStore.Verify();
eventStore.Verify();
}
public async Task <IActionResult> GetConfiguration([FromRoute] string environmentCategory,
[FromRoute] string environmentName,
[FromRoute] string structureName,
[FromRoute] int structureVersion,
[FromQuery] DateTime when,
[FromQuery] int offset = -1,
[FromQuery] int length = -1)
{
try
{
var range = QueryRange.Make(offset, length);
var envIdentifier = new EnvironmentIdentifier(environmentCategory, environmentName);
var structureIdentifier = new StructureIdentifier(structureName, structureVersion);
var configId = new ConfigurationIdentifier(envIdentifier, structureIdentifier, default);
var result = await _store.Configurations.GetKeys(configId, when, range);
if (result.IsError)
{
return(ProviderError(result));
}
var version = await _store.Configurations.GetVersion(configId, when);
if (version.IsError)
{
return(ProviderError(version));
}
// add version to the response-headers
Response.Headers.Add("x-version", version.Data);
return(Result(result));
}
catch (Exception e)
{
KnownMetrics.Exception.WithLabels(e.GetType().Name).Inc();
Logger.LogError(e, "failed to add new environment at (" +
$"{nameof(environmentCategory)}: {environmentCategory}; " +
$"{nameof(environmentName)}: {environmentName}; " +
$"{nameof(structureName)}: {structureName}; " +
$"{nameof(structureVersion)}: {structureVersion}; " +
$"{nameof(when)}: {when}; " +
$"{nameof(offset)}: {offset}; " +
$"{nameof(length)}: {length})");
return(StatusCode(HttpStatusCode.InternalServerError, "failed to retrieve configuration"));
}
}
public string BuildTagQueryString(QueryRange queryRange)
{
var query = "?";
if (CurrentPage > 1)
{
query += "p=" + CurrentPage + "&";
}
if (QuerySortBy != QuerySortBy.DateCreated)
{
query += "s=" + QuerySortBy.ToString().ToLower() + "&";
}
query += "r=" + queryRange.ToString().ToLower();
return(query);
}
public async Task GetKeysParametersForwarded()
{
_projectionStoreMock.Setup(s => s.Environments.GetKeys(new EnvironmentKeyQueryParameters
{
Environment = new EnvironmentIdentifier("Foo", "Bar"),
Filter = "filter",
PreferExactMatch = "preferExactMatch",
Range = QueryRange.Make(1, 2),
RemoveRoot = "removeRoot",
TargetVersion = 4711
}))
.ReturnsAsync(() => Result.Success <IDictionary <string, string> >(new Dictionary <string, string>()))
.Verifiable("keys not queried");
await TestAction <OkObjectResult>(c => c.GetKeys("Foo", "Bar", "filter", "preferExactMatch", "removeRoot", 1, 2, 4711));
_projectionStoreMock.Verify();
}
public async Task <IActionResult> GetKeys([FromRoute] string category,
[FromRoute] string name,
[FromQuery] string filter,
[FromQuery] string preferExactMatch,
[FromQuery] string root,
[FromQuery] int offset = -1,
[FromQuery] int length = -1,
[FromQuery] long targetVersion = -1)
{
var range = QueryRange.Make(offset, length);
var identifier = new EnvironmentIdentifier(category, name);
try
{
var result = await _store.Environments.GetKeys(new EnvironmentKeyQueryParameters
{
Environment = identifier,
Filter = filter,
PreferExactMatch = preferExactMatch,
Range = range,
RemoveRoot = root,
TargetVersion = targetVersion
});
return(result.IsError
? ProviderError(result)
: Ok(result.Data.ToImmutableSortedDictionary()));
}
catch (Exception e)
{
KnownMetrics.Exception.WithLabels(e.GetType().Name).Inc();
Logger.LogError(e, "failed to retrieve Environment-Keys (" +
$"{nameof(category)}: {category}; " +
$"{nameof(name)}: {name}; " +
$"{nameof(filter)}: {filter}; " +
$"{nameof(preferExactMatch)}: {preferExactMatch}; " +
$"{nameof(root)}: {root}; " +
$"{nameof(offset)}: {offset}; " +
$"{nameof(length)}: {length}; " +
$"{nameof(targetVersion)}: {targetVersion})");
return(StatusCode(HttpStatusCode.InternalServerError, "failed to retrieve environment-keys"));
}
}
public async Task <IActionResult> GetStaleConfigurations([FromQuery] int offset = -1,
[FromQuery] int length = -1)
{
try
{
var range = QueryRange.Make(offset, length);
var result = await _store.Configurations.GetStale(range);
return(Result(result));
}
catch (Exception e)
{
KnownMetrics.Exception.WithLabels(e.GetType().Name).Inc();
Logger.LogError(e, "failed to add new environment at (" +
$"{nameof(offset)}: {offset}; " +
$"{nameof(length)}: {length})");
return(StatusCode(HttpStatusCode.InternalServerError, "failed to retrieve stale configurations"));
}
}
public string BuildSearchQueryString(QueryRange queryRange)
{
var query = $"/search?q={SearchTerm}";
if (SearchResultsType != SearchResultsType.All)
{
query += $"&t={SearchResultsType.ToString().ToLower()}";
}
if (CurrentPage > 1)
{
query += "&p=" + CurrentPage;
}
if (QuerySortBy != QuerySortBy.DateCreated)
{
query += "&s=" + QuerySortBy.ToString().ToLower();
}
query += "&r=" + queryRange.ToString().ToLower();
return(query);
}
public async Task <IActionResult> GetAvailableEnvironments([FromQuery] int offset = -1,
[FromQuery] int length = -1,
[FromQuery] long targetVersion = -1)
{
var range = QueryRange.Make(offset, length);
try
{
var result = await _store.Environments.GetAvailable(range, targetVersion);
return(Result(result));
}
catch (Exception e)
{
KnownMetrics.Exception.WithLabels(e.GetType().Name).Inc();
Logger.LogError(e, "failed to retrieve available Environments (" +
$"{nameof(offset)}: {offset}; " +
$"{nameof(length)}: {length}; " +
$"{nameof(targetVersion)}: {targetVersion})");
return(StatusCode(HttpStatusCode.InternalServerError, "failed to retrieve available environments"));
}
}
public async Task <IActionResult> GetUsedKeys([FromRoute] string environmentCategory,
[FromRoute] string environmentName,
[FromRoute] string structureName,
[FromRoute] int structureVersion,
[FromQuery] DateTime when,
[FromQuery] int offset = -1,
[FromQuery] int length = -1)
{
try
{
var range = QueryRange.Make(offset, length);
var envIdentifier = new EnvironmentIdentifier(environmentCategory, environmentName);
var structureIdentifier = new StructureIdentifier(structureName, structureVersion);
var result = await _store.Configurations.GetUsedConfigurationKeys(
new ConfigurationIdentifier(
envIdentifier,
structureIdentifier,
default),
when,
range);
return(Result(result));
}
catch (Exception e)
{
KnownMetrics.Exception.WithLabels(e.GetType().Name).Inc();
Logger.LogError(e, "failed to add new environment at (" +
$"{nameof(environmentCategory)}: {environmentCategory}; " +
$"{nameof(environmentName)}: {environmentName}; " +
$"{nameof(structureName)}: {structureName}; " +
$"{nameof(structureVersion)}: {structureVersion}; " +
$"{nameof(when)}: {when}; " +
$"{nameof(offset)}: {offset}; " +
$"{nameof(length)}: {length})");
return(StatusCode(HttpStatusCode.InternalServerError, "failed to retrieve used keys in configuration"));
}
}
/// <inheritdoc />
public async Task <IResult <IList <EnvironmentIdentifier> > > GetAvailable(QueryRange range, long version)
{
try
{
_logger.LogDebug($"collecting available environments, range={range}");
var envList = await(version <= 0
? _domainObjectStore.ReplayObject <ConfigEnvironmentList>()
: _domainObjectStore.ReplayObject <ConfigEnvironmentList>(version));
List <EnvironmentIdentifier> identifiers;
if (envList.IsError)
{
identifiers = new List <EnvironmentIdentifier>();
_logger.LogInformation($"could not build EnvironmentList to collect environments: {envList.Code}; {envList.Message}");
}
else
{
identifiers = envList.Data
.GetIdentifiers()
.OrderBy(e => e.Category)
.ThenBy(e => e.Name)
.Skip(range.Offset)
.Take(range.Length)
.ToList();
_logger.LogDebug($"collected '{identifiers.Count}' identifiers");
}
return(Result.Success <IList <EnvironmentIdentifier> >(identifiers));
}
catch (Exception e)
{
_logger.LogError(e, "failed to retrieve environments");
return(Result.Error <IList <EnvironmentIdentifier> >("failed to retrieve environments", ErrorCode.DbQueryError));
}
}
private void rbtDone_CheckedChanged(object sender, EventArgs e)
{
if (this.rbtDone.Checked)
{
this.queryDrugRange = QueryRange.Druged;
if (this.QueryDrugRange == ucQueryDrugList.QueryRange.NoneDrug)
{
this.neuPanel6.Visible = false;
}
else
{
this.neuPanel6.Visible = true;
}
if (this.tvSelectType.SelectedNode.ToolTipText == "摆药单")
{
this.QueryDrugList();
}
else
{
this.ClearData();
}
}
}
/// <inheritdoc />
public async Task <IResult <IList <int> > > GetAvailableVersions(string name, QueryRange range)
{
try
{
_logger.LogDebug($"collecting available versions of structure '{name}'");
var listResult = await _domainObjectStore.ReplayObject <ConfigStructureList>();
if (listResult.IsError)
{
return(Result.Success <IList <int> >(new List <int>()));
}
var structures = listResult.Data.GetIdentifiers();
_logger.LogDebug($"got '{structures.Count}' structures, filtering / ordering now");
var result = structures.Where(s => s.Name.Equals(name, StringComparison.OrdinalIgnoreCase))
.OrderByDescending(s => s.Version)
.Skip(range.Offset)
.Take(range.Length)
.Select(s => s.Version)
.ToList();
return(Result.Success <IList <int> >(result));
}
catch (Exception e)
{
_logger.LogError(e, "failed to retrieve structures");
return(Result.Error <IList <int> >("failed to retrieve structures", ErrorCode.DbQueryError));
}
}
/// <inheritdoc />
public async Task <IResult <IDictionary <string, string> > > GetVariables(StructureIdentifier identifier, QueryRange range)
{
try
{
_logger.LogDebug($"retrieving variables of structure '{identifier}'");
var structResult = await _domainObjectStore.ReplayObject(new ConfigStructure(identifier), identifier.ToString());
if (structResult.IsError)
{
return(Result.Error <IDictionary <string, string> >("no structure found with (" +
$"{nameof(identifier.Name)}: {identifier.Name}; " +
$"{nameof(identifier.Version)}: {identifier.Version}" +
")",
ErrorCode.NotFound));
}
var structure = structResult.Data;
_logger.LogDebug($"got structure at version '{structure.CurrentVersion}' / {structure.MetaVersion}");
var result = structure.Variables
.OrderBy(v => v.Key)
.Skip(range.Offset)
.Take(range.Length)
.ToImmutableSortedDictionary(k => k.Key,
k => k.Value,
StringComparer.OrdinalIgnoreCase);
return(Result.Success <IDictionary <string, string> >(result));
}
catch (Exception e)
{
_logger.LogError("failed to retrieve variables for structure " +
$"({nameof(identifier.Name)}: {identifier.Name}; {nameof(identifier.Version)}: {identifier.Version}): {e}");
return(Result.Error <IDictionary <string, string> >(
"failed to retrieve variables for structure " +
$"({nameof(identifier.Name)}: {identifier.Name}; {nameof(identifier.Version)}: {identifier.Version})",
ErrorCode.DbQueryError));
}
}
public static bool GetDatesOfRange(QueryRange range, DateTime?start, DateTime?end, out DateTime dtUTCStart, out DateTime dtUTCEnd)
{
dtUTCStart = DateTime.UtcNow;
dtUTCEnd = DateTime.UtcNow.AddDays(-1);
//custom range
if (range == QueryRange.CUSTOM)
{
if (start.HasValue)
{
dtUTCStart = start.Value.Date;
}
if (end.HasValue)
{
dtUTCEnd = end.Value.Date.AddHours(23).AddMinutes(59).AddSeconds(59).AddMilliseconds(999);
}
}
else
{
switch (range)
{
case QueryRange.CURRENTHOUR:
dtUTCEnd = DateTime.UtcNow;
dtUTCStart = new DateTime(dtUTCEnd.Year, dtUTCEnd.Month, dtUTCEnd.Day, dtUTCEnd.Hour, 0, 0);
break;
case QueryRange.CURRENTDAY:
dtUTCEnd = DateTime.UtcNow;
dtUTCStart = dtUTCEnd.Date;
break;
case QueryRange.CURRENTWEEK:
dtUTCEnd = DateTime.UtcNow;
dtUTCStart = dtUTCEnd.Date.StartOfWeek(DayOfWeek.Monday).Date;
break;
case QueryRange.CURRENTMONTH:
dtUTCEnd = DateTime.UtcNow;
dtUTCStart = new DateTime(dtUTCEnd.Year, dtUTCEnd.Month, 1).Date;
break;
case QueryRange.CURRENTYEAR:
dtUTCEnd = DateTime.UtcNow;
dtUTCStart = new DateTime(dtUTCEnd.Year, 1, 1).Date;
break;
case QueryRange.LIVE:
dtUTCEnd = DateTime.UtcNow;
dtUTCStart = dtUTCEnd.AddSeconds(-300);
break;
case QueryRange.LAST60MINUTES:
dtUTCEnd = DateTime.UtcNow;
dtUTCStart = dtUTCEnd.AddMinutes(-60);
break;
case QueryRange.LAST24HOURS:
dtUTCEnd = DateTime.UtcNow;
dtUTCStart = dtUTCEnd.AddHours(-24);
break;
case QueryRange.LAST7DAYS:
dtUTCEnd = DateTime.UtcNow;
dtUTCStart = dtUTCEnd.AddDays(-7);
break;
case QueryRange.LAST30DAYS:
dtUTCEnd = DateTime.UtcNow;
dtUTCStart = dtUTCEnd.AddDays(-30);
break;
case QueryRange.LAST365DAYS:
dtUTCEnd = DateTime.UtcNow;
dtUTCStart = dtUTCEnd.AddDays(-365);
break;
default:
throw new Exception($"Unknown Range: {range.ToString()}");
}
}
return(true);
}
internal StackRegion(QueryRange bounds)
{
this.bounds = bounds;
this.stackPtr = bounds.start - 1;
}
