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)); }