private async Task GetOpenArtifactPermissions(
Dictionary <int, RolePermissions> itemIdsPermissions, IEnumerable <ProjectsArtifactsItem> projectIdsArtifactIdsItemIds,
int sessionUserId, IEnumerable <int> projectArtifactIds, int revisionId = int.MaxValue,
bool addDrafts = true, IDbTransaction transaction = null)
{
var parameters = new DynamicParameters();
parameters.Add("@userId", sessionUserId);
parameters.Add("@artifactIds", SqlConnectionWrapper.ToDataTable(projectArtifactIds));
IEnumerable <OpenArtifactPermission> openArtifactPermissions;
if (transaction == null)
{
openArtifactPermissions = await _connectionWrapper.QueryAsync <OpenArtifactPermission>(
"GetOpenArtifactPermissions", parameters, commandType : CommandType.StoredProcedure);
}
else
{
openArtifactPermissions = await transaction.Connection.QueryAsync <OpenArtifactPermission>(
"GetOpenArtifactPermissions", parameters, transaction, commandType : CommandType.StoredProcedure);
}
foreach (var openArtifactPermission in openArtifactPermissions)
{
foreach (var projectIdArtifactIdItemId in projectIdsArtifactIdsItemIds)
{
if (projectIdArtifactIdItemId.HolderId == openArtifactPermission.HolderId && !itemIdsPermissions.Keys.Contains(projectIdArtifactIdItemId.VersionArtifactId))
{
itemIdsPermissions.Add(projectIdArtifactIdItemId.VersionArtifactId, (RolePermissions)openArtifactPermission.Permissions);
}
}
}
}
public async Task <IEnumerable <SqlWebhooks> > CreateWebhooks(IEnumerable <SqlWebhooks> webhooks, IDbTransaction transaction = null)
{
if (webhooks == null)
{
throw new ArgumentException(nameof(webhooks));
}
IEnumerable <SqlWebhooks> result = new List <SqlWebhooks>();
var dWebhooks = webhooks.ToList();
if (dWebhooks.Any())
{
var parameters = new DynamicParameters();
parameters.Add("@webhooks", ToWebhooksCollectionDataTable(dWebhooks));
if (transaction == null)
{
result = await _connectionWrapper.QueryAsync <SqlWebhooks>("CreateWebhooks", parameters, commandType : CommandType.StoredProcedure);
}
else
{
result = await transaction.Connection.QueryAsync <SqlWebhooks>("CreateWebhooks", parameters, transaction,
commandType : CommandType.StoredProcedure);
}
}
return(result);
}
public Task <IEnumerable <LicenseInfo> > GetActiveLicenses(DateTime now, int licenseLockTimeMinutes)
{
var prm = new DynamicParameters();
prm.Add("@Now", now);
prm.Add("@LicenseLockTimeMinutes", licenseLockTimeMinutes);
return(_connectionWrapper.QueryAsync <LicenseInfo>("[AdminStore].GetActiveLicenses", prm, commandType: CommandType.StoredProcedure));
}
public async Task <TenantInfo> GetTenantInfo(IDbTransaction transaction = null)
{
if (transaction != null)
{
return((await transaction.Connection.QueryAsync <TenantInfo>("[dbo].[GetTenantInfo]", transaction: transaction, commandType: CommandType.StoredProcedure))
.FirstOrDefault());
}
return((await _connectionWrapper.QueryAsync <TenantInfo>("[dbo].[GetTenantInfo]", commandType: CommandType.StoredProcedure))
.FirstOrDefault());
}
private async Task <IEnumerable <Attachment> > GetAttachments(int itemId, int userId, int revisionId = int.MaxValue, bool addDrafts = true)
{
var artifactVersionsPrm = new DynamicParameters();
artifactVersionsPrm.Add("@itemId", itemId);
artifactVersionsPrm.Add("@userId", userId);
artifactVersionsPrm.Add("@revisionId", revisionId);
artifactVersionsPrm.Add("@addDrafts", addDrafts);
return(await _connectionWrapper.QueryAsync <Attachment>("GetItemAttachments", artifactVersionsPrm, commandType : CommandType.StoredProcedure));
}
public async Task <SqlItemType> GetCustomItemTypeForProvidedStandardItemTypeIdInProject(int projectId,
int standardItemTypeId)
{
var parameters = new DynamicParameters();
parameters.Add("@projectId", projectId);
parameters.Add("@standardItemTypeId", standardItemTypeId);
return((await _connectionWrapper.QueryAsync <SqlItemType>("GetCustomItemTypeForProvidedStandardItemType", parameters, commandType: CommandType.StoredProcedure)).FirstOrDefault());
}
private async Task <IEnumerable <LinkInfo> > GetLinkInfo(int itemId, int userId, bool addDrafts, int revisionId = int.MaxValue, IEnumerable <int> linkTypes = null)
{
var parameters = new DynamicParameters();
parameters.Add("@itemId", itemId);
parameters.Add("@userId", userId);
parameters.Add("@addDrafts", addDrafts);
parameters.Add("@revisionId", revisionId);
parameters.Add("@types", SqlConnectionWrapper.ToDataTable(linkTypes));
return(await _connectionWrapper.QueryAsync <LinkInfo>("GetRelationshipLinkInfo", parameters, commandType : CommandType.StoredProcedure));
}
public async Task <IEnumerable <UserInfo> > GetUserInfos(IEnumerable <int> userIds, IDbTransaction transaction = null)
{
var userInfosPrm = new DynamicParameters();
var userIdsTable = SqlConnectionWrapper.ToDataTable(userIds, "Int32Collection", "Int32Value");
userInfosPrm.Add("@userIds", userIdsTable);
if (transaction != null)
{
return(await transaction.Connection.QueryAsync <UserInfo>("GetUserInfos", userInfosPrm, transaction, commandType : CommandType.StoredProcedure));
}
return(await _connectionWrapper.QueryAsync <UserInfo>("GetUserInfos", userInfosPrm, commandType : CommandType.StoredProcedure));
}
public async Task <IEnumerable <Reply> > GetReplies(int discussionId, int projectId)
{
var repliesPrm = new DynamicParameters();
repliesPrm.Add("@DiscussionId", discussionId);
var replies = (await _connectionWrapper.QueryAsync <Reply>("GetItemReplies", repliesPrm, commandType: CommandType.StoredProcedure)).ToList();
var areEmailDiscussionsEnabled = await _mentionHelper.AreEmailDiscussionsEnabled(projectId);
await InitializeCommentsProperties(replies, areEmailDiscussionsEnabled);
return(replies.OrderBy(r => r.LastEditedOn));
}
public async Task <List <StatusResponse> > GetStatuses(int timeout)
{
try
{
var query = await _connectionWrapper.QueryAsync <JobExecutorModel>("GetJobServices", commandType : CommandType.StoredProcedure);
var result = query.ToList();
if (result.Count > 0)
{
foreach (var jobex in result)
{
statusResponses.Add(ParseStatus(jobex));
}
}
else
{
statusResponses.Add(new StatusResponse()
{
Name = Name, AccessInfo = AccessInfo, Result = "No Executor Found at Database", NoErrors = false
});
}
}
catch (Exception ex)
{
statusResponses.Add(new StatusResponse()
{
Name = Name, AccessInfo = AccessInfo, Result = ex.ToString(), NoErrors = false
});
}
return(statusResponses);
}
public virtual async Task <IEnumerable <ConfigSetting> > GetSettings(bool allowRestricted)
{
var prm = new DynamicParameters();
prm.Add("@AllowRestricted", allowRestricted);
return(await _connectionWrapper.QueryAsync <ConfigSetting>("[AdminStore].GetConfigSettings", prm, commandType : CommandType.StoredProcedure));
}
public async Task <IReadOnlyList <int> > GetContentArtifactIdsAsync(
int collectionId, int userId, bool addDrafts = true)
{
var parameters = new DynamicParameters();
parameters.Add("@userId", userId);
parameters.Add("@collectionId", collectionId);
parameters.Add("@addDrafts", addDrafts);
var result = await _connectionWrapper.QueryAsync <int>(
GetArtifactIdsInCollectionQuery,
parameters,
commandType : CommandType.Text);
return(result.ToList());
}
/// <summary>
/// Performs searching projects by name
/// </summary>
/// <param name="userId">User Id</param>
/// <param name="searchCriteria">SearchCriteria object</param>
/// <param name="resultCount">Result Count</param>
/// <param name="separatorString">Separator String</param>
/// <returns></returns>
public async Task <ProjectSearchResultSet> SearchName(
int userId,
SearchCriteria searchCriteria,
int resultCount,
string separatorString)
{
var param = new DynamicParameters();
param.Add("@userId", userId);
param.Add("@projectName", searchCriteria.Query);
param.Add("@resultCount", resultCount);
param.Add("@separatorString", separatorString);
try
{
var items = await _connectionWrapper.QueryAsync <ProjectSearchResult>("GetProjectsByName",
param,
commandType : CommandType.StoredProcedure,
commandTimeout : _searchConfigurationProvider.SearchTimeout);
return(new ProjectSearchResultSet
{
Items = items
});
}
catch (SqlException sqlException)
{
// Sql timeout error
if (sqlException.Number == ErrorCodes.SqlTimeoutNumber)
{
throw new SqlTimeoutException("Server did not respond with a response in the allocated time. Please try again later.", ErrorCodes.Timeout);
}
throw;
}
}
/// <summary>
/// Perform a full text search
/// </summary>
/// <param name="userId"></param>
/// <param name="searchCriteria">SearchCriteria object</param>
/// <param name="page">Page Number</param>
/// <param name="pageSize">Page Size</param>
/// <returns></returns>
public async Task <FullTextSearchResultSet> SearchFullText(int userId, FullTextSearchCriteria searchCriteria, int page, int pageSize)
{
string sql;
var param = new DynamicParameters();
param.Add("@userId", userId);
param.Add("@query", GetQuery(searchCriteria.Query));
param.Add("@projectIds", SqlConnectionWrapper.ToDataTable(searchCriteria.ProjectIds));
param.Add("@predefineds", Predefineds);
param.Add("@primitiveItemTypePredefineds", PrimitiveItemTypePredefineds);
param.Add("@page", page);
param.Add("@pageSize", pageSize);
param.Add("@maxItems", _searchConfigurationProvider.MaxItems);
param.Add("@maxSearchableValueStringSize", _searchConfigurationProvider.MaxSearchableValueStringSize);
if (searchCriteria.ItemTypeIds?.ToArray().Length > 0)
{
param.Add("@itemTypeIds", SqlConnectionWrapper.ToDataTable(searchCriteria.ItemTypeIds));
sql = "SearchFullTextByItemTypes";
}
else
{
sql = "SearchFullText";
}
try
{
var items = (await _connectionWrapper.QueryAsync <FullTextSearchResult>(sql, param, commandType: CommandType.StoredProcedure, commandTimeout: _searchConfigurationProvider.SearchTimeout)).ToList();
return(new FullTextSearchResultSet
{
Items = items,
Page = page,
PageItemCount = items.Count,
PageSize = pageSize
});
}
catch (SqlException sqlException)
{
switch (sqlException.Number)
{
// Sql timeout error
case ErrorCodes.SqlTimeoutNumber:
throw new SqlTimeoutException("Server did not respond with a response in the allocated time. Please try again later.", ErrorCodes.Timeout);
}
throw;
}
}
public async Task <IEnumerable <ItemLabel> > GetItemsLabels(int userId, IEnumerable <int> itemIds, bool addDrafts = true, int revisionId = int.MaxValue)
{
var parameters = new DynamicParameters();
parameters.Add("@itemIds", SqlConnectionWrapper.ToDataTable(itemIds));
parameters.Add("@userId", userId);
parameters.Add("@addDrafts", addDrafts);
parameters.Add("@revisionId", revisionId);
return(await _connectionWrapper.QueryAsync <ItemLabel>("GetItemsLabels", parameters, commandType: CommandType.StoredProcedure));
}
public async Task <IEnumerable <Feature> > GetFeaturesAsync(bool includeExpired = false)
{
var prm = new DynamicParameters();
prm.Add("@includeExpired", includeExpired);
var features = (await _connectionWrapper.QueryAsync <Feature>("[dbo].[GetFeatures]", prm, commandType: CommandType.StoredProcedure));
return(features);
}
public async Task <File> GetFileHead(Guid guid)
{
var prm = new DynamicParameters();
prm.Add("@FileId", guid);
var file = (await _connectionWrapper.QueryAsync <File>("[FileStore].ReadFileHead", prm, commandTimeout: _commandTimeout, commandType: CommandType.StoredProcedure)).FirstOrDefault();
if (file != null)
{
if (file.ExpiredTime.HasValue)
{
file.ExpiredTime = DateTime.SpecifyKind(file.ExpiredTime.Value, DateTimeKind.Utc);
}
file.StoredTime = DateTime.SpecifyKind(file.StoredTime, DateTimeKind.Utc);
}
return(file);
}
private async Task <StatusResponse> GetStatus(int timeout)
{
var result = (await _connectionWrapper.QueryAsync <string>($"{_dbSchema}.GetStatus", commandType: CommandType.StoredProcedure, commandTimeout: timeout)).Single();
var responseData = new StatusResponse()
{
Name = Name,
AccessInfo = AccessInfo,
Result = result,
NoErrors = true
};
return(responseData);
}
private async Task <DJobMessage> GetJobMessage(int jobId)
{
var param = new DynamicParameters();
param.Add("@jobMessageId", jobId);
try
{
return((await _connectionWrapper.QueryAsync <DJobMessage>("GetJobMessage", param, commandType: CommandType.StoredProcedure)).SingleOrDefault());
}
catch (SqlException sqlException)
{
switch (sqlException.Number)
{
// Sql timeout error
case ErrorCodes.SqlTimeoutNumber:
throw new SqlTimeoutException("Server did not respond with a response in the allocated time. Please try again later.", ErrorCodes.Timeout);
}
throw;
}
}
public async Task<List<ArtifactSearchResult>> GetSuggestedArtifactDetails(List<int> artifactIds, int userId)
{
var prm = new DynamicParameters();
prm.Add("@userId", userId);
prm.Add("@artifactIds", SqlConnectionWrapper.ToDataTable(artifactIds));
return (await _connectionWrapper.QueryAsync<ArtifactSearchResult>("GetSuggestedArtifactDetails", prm, commandType: CommandType.StoredProcedure)).ToList();
}
public async Task <Session> GetSession(Guid guid)
{
var prm = new DynamicParameters();
prm.Add("@SessionId", guid);
return((await _connectionWrapper.QueryAsync <Session>("[AdminStore].GetSession", prm, commandType: CommandType.StoredProcedure)).FirstOrDefault());
}
public async Task SavePropertyChangeActions(
int userId,
IEnumerable <IPropertyChangeAction> actions,
IEnumerable <WorkflowPropertyType> propertyTypes,
VersionControlArtifactInfo artifact,
IDbTransaction transaction = null)
{
var propertyValueVersionsTable = PopulateSavePropertyValueVersionsTable(actions, propertyTypes, artifact);
var propertyValueImagesTable = PopulateImagePropertyValueVersionsTable();
var parameters = new DynamicParameters();
parameters.Add("@propertyValueVersions", propertyValueVersionsTable);
parameters.Add("@propertyValueImages", propertyValueImagesTable);
parameters.Add("@userId", userId);
const string storedProcedure = "SavePropertyValueVersions";
if (transaction == null)
{
await _connectionWrapper.QueryAsync <dynamic>
(
storedProcedure,
parameters,
commandType : CommandType.StoredProcedure);
}
else
{
await transaction.Connection.QueryAsync <dynamic>
(
storedProcedure,
parameters,
transaction,
commandType : CommandType.StoredProcedure);
}
}
private async Task <bool> IncludeDraftVersion(int?userId, int sessionUserId, int artifactId, bool includeDrafts)
{
if (!includeDrafts || userId.HasValue && userId.Value != sessionUserId)
{
return(false);
}
var parameters = new DynamicParameters();
var artifactIdsTable = SqlConnectionWrapper.ToDataTable(new List <int> {
artifactId
});
parameters.Add("@userId", sessionUserId);
parameters.Add("@artifactIds", artifactIdsTable);
return((await _connectionWrapper.QueryAsync <int>("GetArtifactsWithDraft", parameters, commandType: CommandType.StoredProcedure)).Count() == 1);
}
public async Task <InstanceItem> GetInstanceFolderAsync(int folderId, int userId, bool fromAdminPortal = false)
{
if (folderId < 1)
{
throw new ArgumentOutOfRangeException(nameof(folderId));
}
var parameters = new DynamicParameters();
parameters.Add("@folderId", folderId);
parameters.Add("@userId", userId);
parameters.Add("@fromAdminPortal", fromAdminPortal);
var folder = (await _connectionWrapper.QueryAsync <InstanceItem>("GetInstanceFolderById", parameters, commandType: CommandType.StoredProcedure))?.FirstOrDefault();
if (folder == null)
{
throw new ResourceNotFoundException(string.Format("Instance Folder (Id:{0}) is not found.", folderId), ErrorCodes.ResourceNotFound);
}
folder.Type = InstanceItemTypeEnum.Folder;
return(folder);
}
protected async Task <ArtifactBasicDetails> GetArtifactBasicDetails(ISqlConnectionWrapper connectionWrapper, int artifactId, int userId, IDbTransaction transaction = null)
{
var prm = new DynamicParameters();
prm.Add("@userId", userId);
prm.Add("@itemId", artifactId);
if (transaction == null)
{
return((await connectionWrapper.QueryAsync <ArtifactBasicDetails>(
"GetArtifactBasicDetails", prm, commandType: CommandType.StoredProcedure)).FirstOrDefault());
}
else
{
return((await transaction.Connection.QueryAsync <ArtifactBasicDetails>(
"GetArtifactBasicDetails", prm, transaction, commandType: CommandType.StoredProcedure)).FirstOrDefault());
}
}
public async Task <QueryResult <GroupDto> > GetGroupsAsync(int userId, TabularData tabularData, Func <Sorting, string> sort = null)
{
var orderField = string.Empty;
if (sort != null && tabularData.Sorting != null)
{
orderField = sort(tabularData.Sorting);
}
if (!string.IsNullOrWhiteSpace(tabularData.Search))
{
tabularData.Search = UsersHelper.ReplaceWildcardCharacters(tabularData.Search);
}
var parameters = new DynamicParameters();
if (userId > 0)
{
parameters.Add("@UserId", userId);
}
parameters.Add("@Offset", tabularData.Pagination.Offset);
parameters.Add("@Limit", tabularData.Pagination.Limit);
parameters.Add("@OrderField", orderField);
parameters.Add("@Search", tabularData.Search);
parameters.Add("@Total", dbType: DbType.Int32, direction: ParameterDirection.Output);
parameters.Add("@ErrorCode", dbType: DbType.Int32, direction: ParameterDirection.Output);
var userGroups = await _connectionWrapper.QueryAsync <Group>("GetGroups", parameters, commandType : CommandType.StoredProcedure);
var total = parameters.Get <int?>("Total");
var errorCode = parameters.Get <int?>("ErrorCode");
if (errorCode.HasValue)
{
switch (errorCode.Value)
{
case (int)SqlErrorCodes.UserLoginNotExist:
throw new ResourceNotFoundException(ErrorMessages.UserNotExist, ErrorCodes.ResourceNotFound);
}
}
var mappedGroups = GroupMapper.Map(userGroups);
var queryDataResult = new QueryResult <GroupDto> {
Items = mappedGroups, Total = total.Value
};
return(queryDataResult);
}
public async Task <IEnumerable <SqlWorkflow> > CreateWorkflowsAsync(IEnumerable <SqlWorkflow> workflows, int publishRevision, IDbTransaction transaction = null)
{
if (workflows == null)
{
throw new ArgumentNullException(nameof(workflows));
}
var dWorkflows = workflows.ToList();
if (!dWorkflows.Any())
{
throw new ArgumentException(I18NHelper.FormatInvariant("{0} is empty.", nameof(workflows)));
}
if (publishRevision < 1)
{
throw new ArgumentException(I18NHelper.FormatInvariant("{0} is less than 1.", nameof(publishRevision)));
}
var parameters = new DynamicParameters();
parameters.Add("@publishRevision", publishRevision);
parameters.Add("@workflows", ToWorkflowsCollectionDataTable(dWorkflows));
IEnumerable <SqlWorkflow> result;
if (transaction == null)
{
result = await _connectionWrapper.QueryAsync <SqlWorkflow>
(
"CreateWorkflows",
parameters,
commandType : CommandType.StoredProcedure);
}
else
{
result = await transaction.Connection.QueryAsync <SqlWorkflow>
(
"CreateWorkflows",
parameters,
transaction,
commandType : CommandType.StoredProcedure);
}
return(result);
}
public async Task <IEnumerable <LdapSettings> > GetLdapSettingsAsync()
{
return(await _connectionWrapper.QueryAsync <LdapSettings>("GetLdapSettings", commandType : CommandType.StoredProcedure));
}
