private IApiNode AddAsChildOf(ApiNode parent)
{
var newMember = parent.AddMember(m_Signature, (parent.Namespace + "." + m_Name).TrimStart('.'), m_SymbolAccessibility, m_SymbolKind, m_Name);
AddMembersAsChildrenOf(newMember);
return(newMember);
}
/// <summary>
/// Initializes a new instance of the <see cref="Database"/> class.
/// </summary>
/// <param name="connectionString">The connection string.</param>
public Database(string connectionString)
{
_node = new ApiNode(connectionString);
_node.Run();
_node.WaitUntilFirstNodeListMessage();
}
public Node EnableRoomEncryption(EnableRoomEncryptionRequest request)
{
_client.Executor.CheckApiServerVersion();
#region Parameter Validation
request.MustNotNull(nameof(request));
request.DataRoomRescueKeyPassword.MustNotNullOrEmptyOrWhitespace(nameof(request.DataRoomRescueKeyPassword), true);
request.Id.MustPositive(nameof(request.Id));
#endregion
ApiUserKeyPair apiDataRoomRescueKey = null;
if (request.DataRoomRescueKeyPassword != null)
{
try {
UserKeyPair cryptoPair = Crypto.Sdk.Crypto.GenerateUserKeyPair(request.DataRoomRescueKeyPassword);
apiDataRoomRescueKey = UserMapper.ToApiUserKeyPair(cryptoPair);
} catch (CryptoException ce) {
DracoonClient.Log.Debug(Logtag, $"Generation of user key pair failed with '{ce.Message}'!");
throw new DracoonCryptoException(CryptoErrorMapper.ParseCause(ce), ce);
}
}
ApiEnableRoomEncryptionRequest apiEnableRoomEncryptionRequest =
RoomMapper.ToApiEnableRoomEncryptionRequest(request, apiDataRoomRescueKey);
IRestRequest restRequest = _client.Builder.PutEnableRoomEncryption(request.Id, apiEnableRoomEncryptionRequest);
ApiNode result = _client.Executor.DoSyncApiCall <ApiNode>(restRequest, RequestType.PutEnableRoomEncryption);
return(NodeMapper.FromApiNode(result));
}
private void AddMembers(ApiNode parent, ISymbol symbol, CancellationToken cancellationToken)
{
foreach (var childSymbol in symbol.GetApiAffectingMembers())
{
var childNode = CreateApiNode(parent, childSymbol, cancellationToken);
}
}
private void AddMembersAsChildrenOf(ApiNode newMember)
{
foreach (var member in m_Members)
{
member.AddAsChildOf(newMember);
}
}
public ApiNode Build()
{
var topLevel = new ApiNode(m_Signature, "", m_SymbolAccessibility, m_SymbolKind, m_Name);
AddMembersAsChildrenOf(topLevel);
return(topLevel);
}
private void AddMembersAsChildrenOf(ApiNode newMember)
{
foreach (var member in m_Members)
{
member.AddAsChildOf(newMember);
}
}
private async Task <ApiNode> CreateAssemblyNode(CancellationToken token, Project project)
{
var assemblyNode = ApiNode.CreateAssemblyRoot(project.AssemblyName);
await AddTypes(project, assemblyNode, token);
return(assemblyNode);
}
private ApiNode CreateApiNode(ApiNode parentNode, ISymbol symbol, CancellationToken cancellationToken)
{
var symbolNamespace = symbol.ContainingNamespace.Name;
string signature = symbol.GetSignature();
var memberImportance = symbol.GetImportance();
var presentedAccessibility = GetPresentedAccessibility(symbol);
var attributes = symbol.GetAttributes().ToLookup(a => a.AttributeClass.Name, a => string.Join(", ", a.ConstructorArguments.Select(x => x.Value.ToString())));
var apiNode = parentNode.AddMember(signature, symbolNamespace, presentedAccessibility, GetPresentedKind(symbol), symbol.Name, attributes, memberImportance);
AddMembers(apiNode, symbol, cancellationToken);
return apiNode;
}
private ApiNode CreateApiNode(ApiNode parentNode, ISymbol symbol, CancellationToken cancellationToken)
{
var symbolNamespace = symbol.ContainingNamespace.Name;
string signature = symbol.GetSignature();
var memberImportance = symbol.GetImportance();
var presentedAccessibility = GetPresentedAccessibility(symbol);
var attributes = symbol.GetAttributes().ToLookup(ClassNameEndingInAttribute, a => string.Join(", ", a.ConstructorArguments.Select(x => x.Value.ToString())));
var apiNode = parentNode.AddMember(signature, symbolNamespace, presentedAccessibility, GetPresentedKind(symbol), symbol.Name, attributes, memberImportance);
AddMembers(apiNode, symbol, cancellationToken);
return(apiNode);
}
public void FromApiNode_Null()
{
// ARRANGE
Node expected = null;
ApiNode param = null;
// ACT
Node actual = NodeMapper.FromApiNode(param);
// ASSERT
Assert.Equal(expected, actual, new NodeComparer());
}
public Node GetNode(long nodeId)
{
_client.Executor.CheckApiServerVersion();
#region Parameter Validation
nodeId.MustPositive(nameof(nodeId));
#endregion
IRestRequest restRequest = _client.Builder.GetNode(nodeId);
ApiNode result = _client.Executor.DoSyncApiCall <ApiNode>(restRequest, RequestType.GetNode);
return(NodeMapper.FromApiNode(result));
}
public Node CreateFolder(CreateFolderRequest request)
{
_client.Executor.CheckApiServerVersion();
#region Parameter Validation
request.MustNotNull(nameof(request));
request.ParentId.MustPositive(nameof(request.ParentId));
request.Name.MustNotNullOrEmptyOrWhitespace(nameof(request.Name));
#endregion
ApiCreateFolderRequest apiCreateFolderRequest = FolderMapper.ToApiCreateFolderRequest(request);
IRestRequest restRequest = _client.Builder.PostFolder(apiCreateFolderRequest);
ApiNode result = _client.Executor.DoSyncApiCall <ApiNode>(restRequest, RequestType.PostFolder);
return(NodeMapper.FromApiNode(result));
}
public Node UpdateFile(UpdateFileRequest request)
{
_client.Executor.CheckApiServerVersion();
#region Parameter Validation
request.MustNotNull(nameof(request));
request.Id.MustPositive(nameof(request.Id));
request.Name.MustNotNullOrEmptyOrWhitespace(nameof(request.Name), true);
#endregion
ApiUpdateFileRequest apiUpdateFileRequest = FileMapper.ToApiUpdateFileRequest(request);
IRestRequest restRequest = _client.Builder.PutFile(request.Id, apiUpdateFileRequest);
ApiNode result = _client.Executor.DoSyncApiCall <ApiNode>(restRequest, RequestType.PutFile);
return(NodeMapper.FromApiNode(result));
}
private async Task AddTypes(Project project, ApiNode assemblyNode, CancellationToken cancellationToken)
{
foreach (var document in project.Documents)
{
var tree = await document.GetSyntaxTreeAsync(cancellationToken);
var root = await tree.GetRootAsync(cancellationToken);
var semantic = await document.GetSemanticModelAsync(cancellationToken);
var classes = root.ChildNodes();
var semanticDocumentMembers = classes
.Select(syntaxNode => semantic.GetDeclaredSymbol(syntaxNode))
.Where(symbol => symbol != null);
foreach (var semanticDocSymbol in semanticDocumentMembers.Where(m => !NonApiSymbolKinds.Contains(m.Kind)))
{
CreateApiNode(assemblyNode, semanticDocSymbol, cancellationToken);
}
}
}
public Node MoveNodes(MoveNodesRequest request)
{
_client.Executor.CheckApiServerVersion();
#region Parameter Validation
request.MustNotNull(nameof(request));
request.TargetNodeId.MustPositive(nameof(request.TargetNodeId));
request.NodesToBeMoved.EnumerableMustNotNullOrEmpty(nameof(request.NodesToBeMoved));
request.NodesToBeMoved.ForEach(current => current.NodeId.MustPositive(nameof(current.NodeId)));
#endregion
ApiMoveNodesRequest apiMoveNodesRequest = NodeMapper.ToApiMoveNodesRequest(request);
IRestRequest restRequest = _client.Builder.PostMoveNodes(request.TargetNodeId, apiMoveNodesRequest);
ApiNode result = _client.Executor.DoSyncApiCall <ApiNode>(restRequest, RequestType.PostMoveNodes);
return(NodeMapper.FromApiNode(result));
}
internal static Node FromApiNode(ApiNode apiNode)
{
if (apiNode == null)
{
return(null);
}
Node node = new Node {
Id = apiNode.Id,
Type = EnumConverter.ConvertValueToNodeTypeEnum(apiNode.Type),
ParentId = apiNode.ParentId,
ParentPath = apiNode.ParentPath,
Name = apiNode.Name,
Extension = apiNode.FileType,
MediaType = apiNode.MediaType,
MediaToken = apiNode.MediaToken,
Size = apiNode.Size,
Quota = apiNode.Quota,
Classification = EnumConverter.ConvertValueToClassificationEnum(apiNode.Classification),
Notes = apiNode.Notes,
Hash = apiNode.Hash,
ExpireAt = apiNode.ExpireAt,
CreatedAt = apiNode.CreatedAt,
CreatedBy = UserMapper.FromApiUserInfo(apiNode.CreatedBy),
UpdatedAt = apiNode.UpdatedAt,
UpdatedBy = UserMapper.FromApiUserInfo(apiNode.UpdatedBy),
HasInheritPermissions = apiNode.InheritPermissions,
Permissions = FromApiNodePermissions(apiNode.Permissions),
IsFavorite = apiNode.IsFavorite,
IsEncrypted = apiNode.IsEncrypted,
CountChildren = apiNode.CountChildren,
CountRooms = apiNode.CountRooms,
CountFolders = apiNode.CountFolders,
CountFiles = apiNode.CountFiles,
CountDeletedVersions = apiNode.CountDeletedVersions,
RecycleBinRetentionPeriod = apiNode.RecycleBinRetentionPeriod,
CountDownloadShares = apiNode.CountDownloadShares,
CountUploadShares = apiNode.CountUploadShares,
BranchVersion = apiNode.BranchVersion
};
return(node);
}
protected override Node StartUpload()
{
NotifyStarted(ActionId);
ApiCreateFileUpload apiFileUploadRequest = FileMapper.ToApiCreateFileUpload(FileUploadRequest);
try {
apiFileUploadRequest.UseS3 = CheckUseS3();
} catch (DracoonApiException apiException) {
DracoonClient.Log.Warn(LogTag, "S3 direct upload is not possible.", apiException);
}
IRestRequest uploadTokenRequest = Client.Builder.PostCreateFileUpload(apiFileUploadRequest);
UploadToken = Client.Executor.DoSyncApiCall <ApiUploadToken>(uploadTokenRequest, RequestType.PostUploadToken);
Node publicResultNode;
PlainFileKey plainFileKey = CreateFileKey();
ApiCompleteFileUpload apiCompleteFileUpload = FileMapper.ToApiCompleteFileUpload(FileUploadRequest);
if (apiFileUploadRequest.UseS3.HasValue && apiFileUploadRequest.UseS3.Value)
{
List <ApiS3FileUploadPart> s3Parts = EncryptedS3Upload(ref plainFileKey);
EncryptedFileKey encryptedFileKey = EncryptFileKey(plainFileKey);
apiCompleteFileUpload.FileKey = FileMapper.ToApiFileKey(encryptedFileKey);
apiCompleteFileUpload.Parts = s3Parts;
IRestRequest completeFileUploadRequest = Client.Builder.PutCompleteS3FileUpload(UploadToken.UploadId, apiCompleteFileUpload);
Client.Executor.DoSyncApiCall <VoidResponse>(completeFileUploadRequest, RequestType.PutCompleteS3Upload);
publicResultNode = NodeMapper.FromApiNode(S3Finished());
}
else
{
EncryptedUpload(ref plainFileKey);
EncryptedFileKey encryptedFileKey = EncryptFileKey(plainFileKey);
apiCompleteFileUpload.FileKey = FileMapper.ToApiFileKey(encryptedFileKey);
IRestRequest completeFileUploadRequest =
Client.Builder.PutCompleteFileUpload(new Uri(UploadToken.UploadUrl).PathAndQuery, apiCompleteFileUpload);
ApiNode resultNode = Client.Executor.DoSyncApiCall <ApiNode>(completeFileUploadRequest, RequestType.PutCompleteUpload);
publicResultNode = NodeMapper.FromApiNode(resultNode);
}
NotifyFinished(ActionId, publicResultNode);
return(publicResultNode);
}
private async Task AddTypes(Project project, ApiNode assemblyNode, CancellationToken cancellationToken)
{
foreach (var document in project.Documents)
{
var tree = await document.GetSyntaxTreeAsync(cancellationToken);
var root = await tree.GetRootAsync(cancellationToken);
var semantic = await document.GetSemanticModelAsync(cancellationToken);
var classes = root.ChildNodes();
var semanticDocumentMembers = classes
.Select(syntaxNode => semantic.GetDeclaredSymbol(syntaxNode))
.Where(symbol => symbol != null);
foreach (var semanticDocSymbol in semanticDocumentMembers.Where(m => !s_NonApiSymbolKinds.Contains(m.Kind)))
{
CreateApiNode(assemblyNode, semanticDocSymbol, cancellationToken);
}
}
}
protected ApiConfig GetApiConfig(ApiNode node)
{
var config = new ApiConfig {
AuthMethod = AuthenticationMethod.NoAuthentication
};
var configNode = node.SearchByType <ConfigNode>().FirstOrDefault();
if (configNode == null)
{
throw new System.Exception($"Could not find API configuration for {node.Name}");
}
foreach (var configProp in config.GetType().GetProperties())
{
// find KV pair in config node that matches this property
var kvNode = configNode.SearchByType <KeyValueNode>().Where(n => n.Key.ToLower() == configProp.Name.ToLower()).FirstOrDefault();
if (kvNode != null)
{
if (typeof(AuthenticationMethod).IsAssignableFrom(configProp.PropertyType))
{
if (Enum.TryParse <AuthenticationMethod>(kvNode.Value, true, out var enumVal))
{
configProp.SetValue(config, enumVal);
}
else
{
throw new Exception($"Invalid value for {configProp.Name}");
}
}
else
{
configProp.SetValue(config, kvNode.Value);
}
}
}
return(config);
}
public Node CreateRoom(CreateRoomRequest request)
{
_client.Executor.CheckApiServerVersion();
#region Parameter Validation
request.MustNotNull(nameof(request));
request.ParentId.MustPositive(nameof(request.ParentId));
request.Name.MustNotNullOrEmptyOrWhitespace(nameof(request.Name));
request.Quota.NullableMustNotNegative(nameof(request.Quota));
request.RecycleBinRetentionPeriod.NullableMustNotNegative(nameof(request.RecycleBinRetentionPeriod));
if (request.AdminUserIds.CheckEnumerableNullOrEmpty() && request.AdminGroupIds.CheckEnumerableNullOrEmpty())
{
throw new ArgumentNullException(nameof(request.AdminUserIds) + " | " + nameof(request.AdminGroupIds),
"Room must have an admin user or admin group.");
}
if (request.AdminUserIds != null)
{
request.AdminUserIds.EnumerableMustNotNullOrEmpty(nameof(request.AdminUserIds));
request.AdminUserIds.ForEach(id => id.MustPositive(nameof(request.AdminUserIds) + " element"));
}
if (request.AdminGroupIds != null)
{
request.AdminGroupIds.EnumerableMustNotNullOrEmpty(nameof(request.AdminGroupIds));
request.AdminGroupIds.ForEach(id => id.MustPositive(nameof(request.AdminGroupIds) + " element"));
}
#endregion
ApiCreateRoomRequest apiCreateRoomRequest = RoomMapper.ToApiCreateRoomRequest(request);
IRestRequest restRequest = _client.Builder.PostRoom(apiCreateRoomRequest);
ApiNode result = _client.Executor.DoSyncApiCall <ApiNode>(restRequest, RequestType.PostRoom);
return(NodeMapper.FromApiNode(result));
}
private IApiNode AddAsChildOf(ApiNode parent)
{
var newMember = parent.AddMember(m_Signature, (parent.Namespace + "." + m_Name).TrimStart('.'), m_SymbolAccessibility, m_SymbolKind, m_Name);
AddMembersAsChildrenOf(newMember);
return newMember;
}
public void FromApiNode()
{
// ARRANGE
Classification expectedClassification = Classification.Confidential;
NodeType expectedType = NodeType.File;
string expectedTypeValue = "file";
Node expected = FactoryNode.Node;
expected.Type = expectedType;
expected.Classification = expectedClassification;
ApiNode param = new ApiNode {
Id = expected.Id,
Type = expectedTypeValue,
ParentId = expected.ParentId,
ParentPath = expected.ParentPath,
Name = expected.Name,
MediaType = expected.MediaType,
MediaToken = expected.MediaToken,
Size = expected.Size,
Quota = expected.Quota,
Classification = (int)expected.Classification,
Notes = expected.Notes,
Hash = expected.Hash,
ExpireAt = expected.ExpireAt,
CreatedAt = expected.CreatedAt,
CreatedBy = new ApiUserInfo {
Id = expected.CreatedBy.Id.Value,
AvatarUuid = expected.CreatedBy.AvatarUUID,
DisplayName = expected.CreatedBy.DisplayName
},
UpdatedAt = expected.UpdatedAt,
UpdatedBy = new ApiUserInfo {
Id = expected.UpdatedBy.Id.Value,
AvatarUuid = expected.UpdatedBy.AvatarUUID,
DisplayName = expected.UpdatedBy.DisplayName
},
InheritPermissions = expected.HasInheritPermissions,
Permissions = new ApiNodePermissions {
Manage = expected.Permissions.Manage,
Read = expected.Permissions.Read,
Create = expected.Permissions.Create,
Change = expected.Permissions.Change,
Delete = expected.Permissions.Delete,
ManageDownloadShare = expected.Permissions.ManageDownloadShare,
ManageUploadShare = expected.Permissions.ManageUploadShare,
ReadRecycleBin = expected.Permissions.CanReadRecycleBin,
RestoreRecycleBin = expected.Permissions.CanRestoreRecycleBin,
DeleteRecycleBin = expected.Permissions.CanDeleteRecycleBin
},
IsFavorite = expected.IsFavorite,
IsEncrypted = expected.IsEncrypted,
CountChildren = expected.CountChildren,
CountFiles = expected.CountFiles,
CountRooms = expected.CountRooms,
CountFolders = expected.CountFolders,
CountDeletedVersions = expected.CountDeletedVersions,
RecycleBinRetentionPeriod = expected.RecycleBinRetentionPeriod,
CountDownloadShares = expected.CountDownloadShares,
CountUploadShares = expected.CountUploadShares,
BranchVersion = expected.BranchVersion,
FileType = expected.Extension
};
Mock.Arrange(() => EnumConverter.ConvertValueToNodeTypeEnum(expectedTypeValue)).Returns(expectedType);
Mock.Arrange(() => EnumConverter.ConvertValueToClassificationEnum((int)expectedClassification)).Returns(expectedClassification);
Mock.Arrange(() => UserMapper.FromApiUserInfo(param.CreatedBy)).Returns(expected.CreatedBy);
Mock.Arrange(() => UserMapper.FromApiUserInfo(param.UpdatedBy)).Returns(expected.UpdatedBy);
// ACT
Node actual = NodeMapper.FromApiNode(param);
// ASSERT
Assert.Equal(expected, actual, new NodeComparer());
}
private void AddMembers(ApiNode parent, ISymbol symbol, CancellationToken cancellationToken)
{
foreach (var childSymbol in symbol.GetApiAffectingMembers())
{
var childNode = CreateApiNode(parent, childSymbol, cancellationToken);
}
}
public void FromApiNodeList()
{
// ARRANGE
Classification expectedClassification = Classification.Confidential;
NodeType expectedType = NodeType.File;
string expectedTypeValue = "file";
NodeList expected = FactoryNode.NodeList;
ApiNodeList param = new ApiNodeList {
Range = new ApiRange {
Offset = expected.Offset,
Limit = expected.Limit,
Total = expected.Total
},
Items = new List <ApiNode>(expected.Items.Count)
};
foreach (Node current in expected.Items)
{
current.Type = expectedType;
current.Classification = expectedClassification;
ApiNode currentApi = new ApiNode {
Id = current.Id,
Type = expectedTypeValue,
ParentId = current.ParentId,
ParentPath = current.ParentPath,
Name = current.Name,
MediaType = current.MediaType,
MediaToken = current.MediaToken,
Size = current.Size,
Quota = current.Quota,
Classification = (int)current.Classification,
Notes = current.Notes,
Hash = current.Hash,
ExpireAt = current.ExpireAt,
CreatedAt = current.CreatedAt,
CreatedBy = new ApiUserInfo {
Id = current.CreatedBy.Id.Value,
AvatarUuid = current.CreatedBy.AvatarUUID,
DisplayName = current.CreatedBy.DisplayName
},
UpdatedAt = current.UpdatedAt,
UpdatedBy = new ApiUserInfo {
Id = current.UpdatedBy.Id.Value,
AvatarUuid = current.UpdatedBy.AvatarUUID,
DisplayName = current.UpdatedBy.DisplayName
},
InheritPermissions = current.HasInheritPermissions,
Permissions = new ApiNodePermissions {
Manage = current.Permissions.Manage,
Read = current.Permissions.Read,
Create = current.Permissions.Create,
Change = current.Permissions.Change,
Delete = current.Permissions.Delete,
ManageDownloadShare = current.Permissions.ManageDownloadShare,
ManageUploadShare = current.Permissions.ManageUploadShare,
ReadRecycleBin = current.Permissions.CanReadRecycleBin,
RestoreRecycleBin = current.Permissions.CanRestoreRecycleBin,
DeleteRecycleBin = current.Permissions.CanDeleteRecycleBin
},
IsFavorite = current.IsFavorite,
IsEncrypted = current.IsEncrypted,
CountChildren = current.CountChildren,
CountFiles = current.CountFiles,
CountRooms = current.CountRooms,
CountFolders = current.CountFolders,
CountDeletedVersions = current.CountDeletedVersions,
RecycleBinRetentionPeriod = current.RecycleBinRetentionPeriod,
CountDownloadShares = current.CountDownloadShares,
CountUploadShares = current.CountUploadShares,
BranchVersion = current.BranchVersion,
FileType = current.Extension
};
param.Items.Add(currentApi);
Mock.Arrange(() => NodeMapper.FromApiNode(currentApi)).Returns(current);
}
// ACT
NodeList actual = NodeMapper.FromApiNodeList(param);
// ASSERT
Assert.Equal(expected, actual, new NodeListComparer());
}
public ApiNode Build()
{
var topLevel = new ApiNode(m_Signature, "", m_SymbolAccessibility, m_SymbolKind, m_Name);
AddMembersAsChildrenOf(topLevel);
return topLevel;
}
/// <summary>
/// Builds the specified for parent.
/// </summary>
/// <param name="forParent">if set to <c>true</c> [for parent].</param>
/// <exception cref="System.ArgumentException"></exception>
private void Build(bool forParent)
{
this.Links = new HateoasList();
if (this.Information.PathTokens[this.Information.PathTokens.Count - 1].ToLower().Equals("query"))
{
this.IsQuery = true;
}
else
{
this.IsQuery = false;
}
ApiNode node = Configuration.Root;
IList <string> paths = new List <string>();
IList <string> values = new List <string>();
int max = this.IsQuery ? this.Information.PathTokens.Count - 1 : this.Information.PathTokens.Count;
if (forParent)
{
max = max - 1;
}
this.HasKeyParameter = max % 2 == 0;
Type entityType = null;
for (int i = 0; i < max; i++)
{
if ((i % 2) == 0)
{
if (node.Sons.ContainsKey(this.Information.PathTokens[i]))
{
node = node.Sons[Information.PathTokens[i]];
entityType = this.SecurityManager.MetamodelManager.GetEntityByDto(node.DtoType).EntityType;
for (int j = 0; j < paths.Count; j++)
{
paths[j] = string.Format("{0}.{1}", entityType.Name, paths[j]);
}
}
else
{
throw new ArgumentException(string.Format("Api path not found: {0}", this.Information.Path));
}
}
else
{
paths.Add(node.ParameterName);
values.Add(this.Information.PathTokens[i]);
}
}
if (this.HasKeyParameter)
{
this.KeyParameter = values[values.Count - 1];
}
else
{
this.KeyParameter = string.Empty;
}
this.CurrentNode = node;
if (!string.IsNullOrEmpty(node.ParentParameterName))
{
this.IsByParent = true;
this.ParentKeyParameter = node.ParentParameterName;
}
else
{
this.IsByParent = false;
this.ParentKeyParameter = string.Empty;
}
this.KeyParameterName = node.ParameterName;
this.EntityType = entityType;
this.DtoType = node.DtoType;
this.BuildLinks();
max = this.HasKeyParameter ? paths.Count - 1 : paths.Count;
for (int i = 0; i < max; i++)
{
paths[i] = paths[i].Substring(entityType.Name.Length + 1);
}
this.QueryInfo = new QueryInfo();
for (int i = 0; i < paths.Count; i++)
{
this.QueryInfo.Equal(paths[i], values[i]);
}
}
