private async Task <object> ResolveCkAttributesQuery(IResolveConnectionContext <object> arg)
{
Logger.Debug("GraphQL query handling of contruction kit attributes started");
var graphQlUserContext = (GraphQLUserContext)arg.UserContext;
using var session = await graphQlUserContext.TenantContext.Repository.StartSessionAsync();
session.StartTransaction();
int?offset = arg.GetOffset();
DataQueryOperation dataQueryOperation = arg.GetDataQueryOperation();
arg.TryGetArgument(Statics.AttributeIdArg, out string key);
arg.TryGetArgument(Statics.AttributeIdsArg, new List <string>(), out IEnumerable <string> keys);
var keysList = keys.ToList();
if (!keysList.Any() && key != null)
{
keysList.Add(key);
}
var resultSet =
await graphQlUserContext.TenantContext.Repository.GetCkAttributesAsync(session, keysList, dataQueryOperation, offset, arg.First);
await session.CommitTransactionAsync();
Logger.Debug("GraphQL query handling returning data for contruction kit attributes");
return(ConnectionUtils.ToConnection(resultSet.Result.Select(CkAttributeDtoType.CreateCkAttributeDto), arg,
resultSet.TotalCount > 0 ? offset.GetValueOrDefault(0) : 0, (int)resultSet.TotalCount));
}
private async Task <object> ResolveRtEntitiesQuery(IResolveConnectionContext <RtEntityDto> ctx)
{
var graphQlContext = (GraphQLUserContext)ctx.UserContext;
using var session = await graphQlContext.TenantContext.Repository.StartSessionAsync();
session.StartTransaction();
var ckId = (string)ctx.FieldDefinition.Metadata[Statics.CkId];
var roleId = (string)ctx.FieldDefinition.Metadata[Statics.RoleId];
var graphDirections = (GraphDirections)ctx.FieldDefinition.Metadata[Statics.GraphDirection];
int?offset = ctx.GetOffset();
DataQueryOperation dataQueryOperation = ctx.GetDataQueryOperation();
if (ctx.Source.RtId != null)
{
var resultSet = await graphQlContext.TenantContext.Repository.GetRtAssociationTargetsAsync(session,
ctx.Source.RtId.Value.ToObjectId(), roleId, ckId,
graphDirections, dataQueryOperation, offset, ctx.First);
return(ConnectionUtils.ToConnection(resultSet.Result.Select(RtEntityDtoType.CreateRtEntityDto), ctx,
resultSet.TotalCount > 0 ? offset.GetValueOrDefault(0) : 0, (int)resultSet.TotalCount));
}
await session.CommitTransactionAsync();
return(ConnectionUtils.ToConnection(new RtEntityDto[] { }, ctx, 0, 0));
}
private async Task <object> ResolveGenericRtEntitiesQuery(IResolveConnectionContext <object> arg)
{
Logger.Debug("GraphQL query handling for generic runtime entity started");
var graphQlUserContext = (GraphQLUserContext)arg.UserContext;
var ckId = arg.GetArgument <string>(Statics.CkIdArg);
using var session = await graphQlUserContext.TenantContext.Repository.StartSessionAsync();
session.StartTransaction();
int?offset = arg.GetOffset();
DataQueryOperation dataQueryOperation = arg.GetDataQueryOperation();
arg.TryGetArgument(Statics.RtIdArg, out OspObjectId? key);
arg.TryGetArgument(Statics.RtIdsArg, new List <ObjectId>(), out IEnumerable <ObjectId> keys);
var keysList = keys.ToList();
if (keysList.Any())
{
var resultSetIds =
await graphQlUserContext.TenantContext.Repository.GetRtEntitiesByIdAsync(session, ckId, keysList, dataQueryOperation,
offset, arg.First);
Logger.Debug("GraphQL query handling returning data by keys");
return(ConnectionUtils.ToConnection(resultSetIds.Result.Select(RtEntityDtoType.CreateRtEntityDto), arg,
resultSetIds.TotalCount > 0 ? offset.GetValueOrDefault(0) : 0, (int)resultSetIds.TotalCount));
}
if (key.HasValue)
{
var result = await graphQlUserContext.TenantContext.Repository.GetRtEntityAsync(session, new RtEntityId(ckId, key.Value));
var resultList = new List <RtEntityDto>();
if (result != null)
{
resultList.Add(RtEntityDtoType.CreateRtEntityDto(result));
}
Logger.Debug("GraphQL query handling returning data by key");
return(ConnectionUtils.ToConnection(resultList, arg));
}
var resultSet =
await graphQlUserContext.TenantContext.Repository.GetRtEntitiesByTypeAsync(session, ckId, dataQueryOperation, offset,
arg.First);
await session.CommitTransactionAsync();
Logger.Debug("GraphQL query handling returning data");
return(ConnectionUtils.ToConnection(resultSet.Result.Select(RtEntityDtoType.CreateRtEntityDto), arg,
resultSet.TotalCount > 0 ? offset.GetValueOrDefault(0) : 0, (int)resultSet.TotalCount));
}
public static bool FeatureSelector(IFeature feature, string prop, DataQueryOperation operation, object param)
{
if (operation == DataQueryOperation.Equals)
{
return(feature.Properties.ContainsKey(prop) && ((param.IsNumber() && feature[prop].TryParseToDouble() == Convert.ToDouble(param)) || (feature[prop] == param.ToString())));
}
else if (operation == DataQueryOperation.NotEquals)
{
return(feature.Properties.ContainsKey(prop) && ((param.IsNumber() && feature[prop].TryParseToDouble() != Convert.ToDouble(param)) || (feature[prop] != param.ToString())));
}
else if (operation == DataQueryOperation.GreaterThan)
{
return(feature.Properties.ContainsKey(prop) && (param.IsNumber() && feature[prop].TryParseToDouble() > Convert.ToDouble(param)));
}
else if (operation == DataQueryOperation.LessThan)
{
return(feature.Properties.ContainsKey(prop) && (param.IsNumber() && feature[prop].TryParseToDouble() < Convert.ToDouble(param)));
}
return(false);
}
public async Task Export(IOspSession session, OspObjectId queryId, string filePath, CancellationToken?cancellationToken)
{
var query = await _tenantContext.Repository.GetRtEntityAsync(session, new RtEntityId(Constants.SystemQueryCkId, queryId));
if (CheckCancellation(cancellationToken))
{
throw new OperationCanceledException();
}
if (query == null)
{
throw new ModelExportException($"Query '{queryId}‘ does not exist.");
}
DataQueryOperation dataQueryOperation = new DataQueryOperation();
var sortingDtoList =
JsonConvert.DeserializeObject <ICollection <SortDto> >(query.GetAttributeStringValueOrDefault("Sorting"));
dataQueryOperation.SortOrders = sortingDtoList.Select(dto =>
new SortOrderItem(dto.AttributeName.ToPascalCase(), (SortOrders)dto.SortOrder));
var fieldFilterDtoList =
JsonConvert.DeserializeObject <ICollection <FieldFilterDto> >(
query.GetAttributeStringValueOrDefault("FieldFilter"));
dataQueryOperation.FieldFilters = fieldFilterDtoList.Select(dto =>
new FieldFilter(TransformAttributeName(dto.AttributeName), (FieldFilterOperator)dto.Operator,
dto.ComparisonValue));
var ckId = query.GetAttributeStringValueOrDefault("QueryCkId");
var resultSet = await _tenantContext.Repository.GetRtEntitiesByTypeAsync(session, ckId, dataQueryOperation);
var entityCacheItem = _tenantContext.CkCache.GetEntityCacheItem(ckId);
RtModelRoot model = new RtModelRoot();
model.RtEntities.AddRange(resultSet.Result.Select(entity =>
{
var exEntity = new RtEntity
{
Id = entity.RtId.ToOspObjectId(),
WellKnownName = entity.WellKnownName,
CkId = entity.CkId,
};
exEntity.Attributes.AddRange(entity.Attributes.Select(pair =>
{
var attributeCacheItem = entityCacheItem.Attributes[pair.Key];
return(new RtAttribute
{
Id = attributeCacheItem.AttributeId,
Value = pair.Value
});
}));
return(exEntity);
}));
await using StreamWriter streamWriter = new StreamWriter(filePath);
RtSerializer.Serialize(streamWriter, model);
await session.CommitTransactionAsync();
}
public static IEnumerable <IFeature> QueryFeatures(this ILayer layer, string prop, DataQueryOperation operation, object param)
{
return(layer.Features.Where(f => MapQueryServices.FeatureSelector(f, prop, operation, param)).ToList());
}
public async Task Run(string dataSource, IJobCancellationToken cancellationToken)
{
try
{
DateTime startDateTime = DateTime.Now;
var dataSourceContext = await _systemContext.CreateOrGetTenantContext(dataSource);
using var session = await dataSourceContext.Repository.StartSessionAsync();
session.StartTransaction();
var dataQueryQueryOperation = new DataQueryOperation
{
FieldFilters = new[] { new FieldFilter(Constants.EnabledAttribute, FieldFilterOperator.Equals, true), }
};
var serviceHookResultSet =
await dataSourceContext.Repository.GetRtEntitiesByTypeAsync <RtSystemServiceHook>(session, dataQueryQueryOperation);
foreach (var serviceHook in serviceHookResultSet.Result)
{
var targetCkId = serviceHook.GetAttributeStringValueOrDefault(Constants.QueryCkIdAttribute);
var serviceHookBaseUri = serviceHook.GetAttributeStringValueOrDefault(Constants.ServiceHookBaseUriAttribute);
var serviceHookAction = serviceHook.GetAttributeStringValueOrDefault(Constants.ServiceHookActionAttribute);
var dataQueryOperation = new DataQueryOperation
{
FieldFilters = JsonConvert
.DeserializeObject <FieldFilterDto[]>(
serviceHook.GetAttributeStringValueOrDefault(Constants.FieldFilterAttribute))
.Select(f =>
new FieldFilter(TransformAttributeName(f.AttributeName), (FieldFilterOperator)f.Operator, f.ComparisonValue))
};
if (CheckCancellation(cancellationToken.ShutdownToken))
{
return;
}
var result =
await dataSourceContext.Repository.GetRtEntitiesByTypeAsync(session, targetCkId, dataQueryOperation, 0, 500);
Logger.Info(
$"Processing '{result.TotalCount}' entities of type '{targetCkId}' at '{startDateTime}");
try
{
await CallServiceHook(serviceHookBaseUri, serviceHookAction, result.Result,
cancellationToken.ShutdownToken);
}
catch (Exception e)
{
Logger.Error(e);
// Ignore the error because the job is recurring
}
Logger.Info($"Processing done (start was at '{startDateTime}')");
}
await session.CommitTransactionAsync();
}
catch (Exception e)
{
Logger.Error(e);
throw;
}
}
