// ReSharper disable once UnusedMethodReturnValue.Local
private bool TryHandleOutboundAssoc(RtEntity rtEntity, EntityCacheItem entityCacheItem, KeyValuePair <string, object> item, List <AssociationUpdateInfo> associations)
{
var assocName = item.Key;
var associationCacheItem = entityCacheItem.OutboundAssociations.Values.SelectMany(x => x).FirstOrDefault(a => a.Name == assocName);
if (associationCacheItem == null)
{
return(false);
}
var rtAssociationInputDtos = (IEnumerable <object>)item.Value;
foreach (RtAssociationInputDto rtAssociationDto in rtAssociationInputDtos)
{
var assocInfo = new AssociationUpdateInfo(
rtEntity.ToRtEntityId(),
rtAssociationDto.Target,
associationCacheItem.RoleId,
rtAssociationDto.ModOption ?? AssociationModOptionsDto.Create);
associations.Add(assocInfo);
}
return(true);
}
private RtEntityAttributeDto CreateRtEntityAttributeDto(RtEntity rtEntity,
AttributeCacheItem attributeCacheItem)
{
var attributeDto = new RtEntityAttributeDto
{
AttributeName = attributeCacheItem.AttributeName.ToCamelCase(),
Value = rtEntity.GetAttributeValueOrDefault(attributeCacheItem.AttributeName),
UserContext = attributeCacheItem
};
return(attributeDto);
}
internal static RtEntityDto CreateRtEntityDto(RtEntity rtEntity)
{
var rtEntityDto = new RtEntityDto
{
RtId = rtEntity.RtId.ToOspObjectId(),
CkId = rtEntity.CkId,
WellKnownName = rtEntity.WellKnownName,
UserContext = rtEntity
};
return(rtEntityDto);
}
private async Task <object> ResolveDelete(IResolveFieldContext <object> arg)
{
var graphQlUserContext = (GraphQLUserContext)arg.UserContext;
var ckId = arg.FieldDefinition.GetMetadata <string>(Statics.CkId);
var inputObjects = arg.GetArgument <List <MutationDto <object> > >(Statics.EntitiesArg);
using var session = await graphQlUserContext.TenantContext.Repository.StartSessionAsync();
session.StartTransaction();
try
{
var entityUpdateInfos = new List <EntityUpdateInfo>();
foreach (var mutationDto in inputObjects)
{
var document = new RtEntity
{
RtId = mutationDto.RtId.ToObjectId(),
CkId = ckId
};
entityUpdateInfos.Add(new EntityUpdateInfo(document, EntityModOptions.Delete));
}
await graphQlUserContext.TenantContext.Repository.ApplyChanges(session, entityUpdateInfos);
await session.CommitTransactionAsync();
return(true);
}
catch (OperationFailedException e)
{
await session.AbortTransactionAsync();
arg.Errors.Add(new ExecutionError(e.Message, e)
{
Code = CommonConstants.GraphQLErrorDataStore
});
return(false);
}
catch (Exception e)
{
await session.AbortTransactionAsync();
arg.Errors.Add(new ExecutionError("A general error occurred", e)
{
Code = CommonConstants.GraphQLErrorCommon
});
return(false);
}
}
private bool TryHandleAttribute(RtEntity rtEntity, EntityCacheItem entityCacheItem, KeyValuePair <string, object> item)
{
var attributeName = item.Key;
var attributeCacheItem = entityCacheItem.Attributes.Values.FirstOrDefault(a => a.AttributeName == attributeName);
if (attributeCacheItem == null)
{
return(false);
}
rtEntity.SetAttributeValue(attributeCacheItem.AttributeName, attributeCacheItem.AttributeValueType, item.Value);
return(true);
}
private void RtEntityFromInputObject(RtEntity rtEntity, RtEntityDto rtEntityDto, List <AssociationUpdateInfo> associations)
{
var metaEntityCacheItem = _ckCache.GetEntityCacheItem(rtEntity.CkId);
rtEntity.WellKnownName = rtEntityDto.WellKnownName;
if (rtEntityDto.Properties != null)
{
foreach (var item in rtEntityDto.Properties)
{
if (TryHandleAttribute(rtEntity, metaEntityCacheItem, item))
{
continue;
}
if (TryHandleInboundAssoc(rtEntity, metaEntityCacheItem, item, associations))
{
continue;
}
TryHandleOutboundAssoc(rtEntity, metaEntityCacheItem, item, associations);
}
}
}
public EntityUpdateInfo(RtEntity rtEntity, EntityModOptions modOption)
{
RtEntity = rtEntity;
ModOption = modOption;
}
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();
}
