public override async Task <long> BeginCreateInstanceIndexAsync(int partitionKey, DicomDataset instance, IEnumerable <QueryTag> queryTags, CancellationToken cancellationToken)
{
EnsureArg.IsNotNull(instance, nameof(instance));
EnsureArg.IsNotNull(queryTags, nameof(queryTags));
using (SqlConnectionWrapper sqlConnectionWrapper = await SqlConnectionWrapperFactory.ObtainSqlConnectionWrapperAsync(cancellationToken))
using (SqlCommandWrapper sqlCommandWrapper = sqlConnectionWrapper.CreateSqlCommand())
{
var rows = ExtendedQueryTagDataRowsBuilder.Build(instance, queryTags.Where(tag => tag.IsExtendedQueryTag), Version);
VLatest.AddInstanceV6TableValuedParameters parameters = new VLatest.AddInstanceV6TableValuedParameters(
rows.StringRows,
rows.LongRows,
rows.DoubleRows,
rows.DateTimeWithUtcRows,
rows.PersonNameRows
);
VLatest.AddInstanceV6.PopulateCommand(
sqlCommandWrapper,
partitionKey,
instance.GetString(DicomTag.StudyInstanceUID),
instance.GetString(DicomTag.SeriesInstanceUID),
instance.GetString(DicomTag.SOPInstanceUID),
instance.GetSingleValueOrDefault <string>(DicomTag.PatientID),
instance.GetSingleValueOrDefault <string>(DicomTag.PatientName),
instance.GetSingleValueOrDefault <string>(DicomTag.ReferringPhysicianName),
instance.GetStringDateAsDate(DicomTag.StudyDate),
instance.GetSingleValueOrDefault <string>(DicomTag.StudyDescription),
instance.GetSingleValueOrDefault <string>(DicomTag.AccessionNumber),
instance.GetSingleValueOrDefault <string>(DicomTag.Modality),
instance.GetStringDateAsDate(DicomTag.PerformedProcedureStepStartDate),
instance.GetStringDateAsDate(DicomTag.PatientBirthDate),
instance.GetSingleValueOrDefault <string>(DicomTag.ManufacturerModelName),
(byte)IndexStatus.Creating,
parameters);
try
{
return((long)(await sqlCommandWrapper.ExecuteScalarAsync(cancellationToken)));
}
catch (SqlException ex)
{
if (ex.Number == SqlErrorCodes.Conflict)
{
if (ex.State == (byte)IndexStatus.Creating)
{
throw new PendingInstanceException();
}
throw new InstanceAlreadyExistsException();
}
throw new DataStoreException(ex);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="propertyIds"></param>
/// <returns>Dictionary with Property Type Id as Key</returns>
public async Task <IDictionary <int, SqlPropertyTypeInfo> > GetStandardPropertyTypeIdsForPropertyIdsAsync(ISet <int> propertyIds)
{
var param = new DynamicParameters();
param.Add("@propertyIds", SqlConnectionWrapper.ToDataTable(propertyIds));
return((await ConnectionWrapper.QueryAsync <SqlPropertyTypeInfo>("GetStandardPropertyTypeIdsForPropertyIds", param,
commandType: CommandType.StoredProcedure))
.ToDictionary(k => k.PropertyTypeId));
}
/// <summary>
/// Implementation of your slot.
/// </summary>
/// <param name="signaler">Signaler used to raise the signal.</param>
/// <param name="input">Arguments to your slot.</param>
public void Signal(ISignaler signaler, Node input)
{
using (var connection = new SqlConnectionWrapper(GetConnectionString(input)))
{
signaler.Scope(
"mssql.connect",
connection, () => signaler.Signal("eval", input));
input.Value = null;
}
}
public async Task <List <SqlWorkFlowStateInformation> > GetWorkflowStatesForArtifactsAsync(int userId, IEnumerable <int> artifactIds, int revisionId, bool addDrafts = true)
{
var param = new DynamicParameters();
param.Add("@userId", userId);
param.Add("@artifactIds", SqlConnectionWrapper.ToDataTable(artifactIds));
param.Add("@revisionId", revisionId);
param.Add("@addDrafts", addDrafts);
return((await ConnectionWrapper.QueryAsync <SqlWorkFlowStateInformation>("[dbo].[GetWorkflowStatesForArtifacts]", param, commandType: CommandType.StoredProcedure)).ToList());
}
public async Task <List <SqlWorkflowEvent> > GetWorkflowPropertyTransitionsForArtifactsAsync(int userId, int revisionId, int eventType, IEnumerable <int> itemIds)
{
var param = new DynamicParameters();
param.Add("@userId", userId);
param.Add("@revisionId", revisionId);
param.Add("@eventType", eventType);
param.Add("@itemIds", SqlConnectionWrapper.ToDataTable(itemIds));
return((await ConnectionWrapper.QueryAsync <SqlWorkflowEvent>("[dbo].[GetWorkflowTriggersForArtifacts]", param, commandType: CommandType.StoredProcedure)).ToList());
}
public async Task <IEnumerable <string> > CheckLiveWorkflowsForNameUniquenessAsync(IEnumerable <string> names, int?exceptWorkflowId = null)
{
var prm = new DynamicParameters();
prm.Add("@names", SqlConnectionWrapper.ToStringDataTable(names));
prm.Add("@exceptWorkflowId", exceptWorkflowId);
var duplicateNames = await _connectionWrapper.QueryAsync <string>("CheckLiveWorkflowsForNameUniqueness", prm, commandType : CommandType.StoredProcedure);
return(duplicateNames);
}
public void InitializeThrowsIfCalledWithAuthenticationTokenOnDotNetFramework452ButNotOnOtherTargets()
{
#if NET452
Assert.Throws <InvalidOperationException>(() => new SqlConnectionWrapper(DatabaseFixture.LogEventsConnectionString, "AuthenticationToken"));
#else
// Should not throw
using (_ = new SqlConnectionWrapper(@"Data Source=(localdb)\MSSQLLocalDB;Initial Catalog=Master", "AuthenticationToken"))
{ }
#endif
}
public async Task GivenATransactionScope_WhenReading_TheUncommittedValuesShouldOnlyBeAvailableWithTheTransactionAndWithHints()
{
var newId = Guid.NewGuid().ToString();
var searchParamHash = new string("RandomSearchParam").ComputeHash();
using (var transactionScope = _fixture.SqlTransactionHandler.BeginTransaction())
{
using (SqlConnectionWrapper connectionWrapperWithTransaction = await _fixture.SqlConnectionWrapperFactory.ObtainSqlConnectionWrapperAsync(CancellationToken.None, true))
using (SqlCommandWrapper sqlCommandWrapper = connectionWrapperWithTransaction.CreateSqlCommand())
{
sqlCommandWrapper.CommandText = @"
INSERT INTO Resource
VALUES(97, @newId, 1, 0, 5095719085917680000, 0, null, CAST('test' AS VARBINARY(MAX)), 0, @searchParamHash)";
sqlCommandWrapper.Parameters.Add(new SqlParameter {
ParameterName = "newId", Value = newId
});
sqlCommandWrapper.Parameters.Add(new SqlParameter {
ParameterName = "searchParamHash", Value = searchParamHash
});
await sqlCommandWrapper.ExecuteNonQueryAsync(CancellationToken.None);
}
// Within the same transaction, the resource should be found
using (SqlConnectionWrapper connectionWrapperWithTransaction = await _fixture.SqlConnectionWrapperFactory.ObtainSqlConnectionWrapperAsync(CancellationToken.None, true))
{
await VerifyCommandResults(connectionWrapperWithTransaction, newId, true);
}
// Outside of the transaction, the resource should not be found
using (SqlConnectionWrapper connectionWrapperWithTransaction = await _fixture.SqlConnectionWrapperFactory.ObtainSqlConnectionWrapperAsync(CancellationToken.None, false))
{
await VerifyCommandResults(connectionWrapperWithTransaction, newId, false);
}
// Outside of the transaction, but with the readuncommitted hint, the resource should be found.
using (SqlConnectionWrapper connectionWrapperWithTransaction = await _fixture.SqlConnectionWrapperFactory.ObtainSqlConnectionWrapperAsync(CancellationToken.None, false))
{
await VerifyCommandResults(connectionWrapperWithTransaction, newId, true, "WITH (READUNCOMMITTED)");
}
}
// Outside of the transactionscope, the resource should not be found
using (SqlConnectionWrapper connectionWrapperWithTransaction = await _fixture.SqlConnectionWrapperFactory.ObtainSqlConnectionWrapperAsync(CancellationToken.None, false))
{
await VerifyCommandResults(connectionWrapperWithTransaction, newId, false);
}
// Outside of the transactionscope, but with the readuncommitted hint, the resource should not be found
using (SqlConnectionWrapper connectionWrapperWithTransaction = await _fixture.SqlConnectionWrapperFactory.ObtainSqlConnectionWrapperAsync(CancellationToken.None, false))
{
await VerifyCommandResults(connectionWrapperWithTransaction, newId, false, "WITH (READUNCOMMITTED)");
}
}
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));
}
private async Task <IEnumerable <LinkedArtifactInfo> > GetDocumentArtifactInfos(IEnumerable <int> artifactIds, int userId, int revisionId = int.MaxValue, bool addDrafts = true)
{
var parameters = new DynamicParameters();
var artifactIdsTable = SqlConnectionWrapper.ToDataTable(artifactIds, "Int32Collection", "Int32Value");
parameters.Add("@artifactIds", artifactIdsTable);
parameters.Add("@userId", userId);
parameters.Add("@revisionId", revisionId);
parameters.Add("@addDrafts", addDrafts);
return(await _connectionWrapper.QueryAsync <LinkedArtifactInfo>("GetDocumentArtifactInfos", parameters, commandType : CommandType.StoredProcedure));
}
public void Setup()
{
_logger = Substitute.For <ILogger <SqlServerNotificationService> >();
_settings = Substitute.For <SettingsService>((IServiceProvider)null);
_sqlConnectionWrapper = Substitute.For <SqlConnectionWrapper>();
_service = new SqlServerNotificationService(_logger, _settings, _sqlConnectionWrapper);
_settings.Notifications_SqlServer_Connection.Returns("conn1");
_settings.Notifications_SqlServer_TableName.Returns("ta'bl\"e1");
}
private async Task <SqlDiscardPublishDetailsResult> GetDiscardPublishDetailsInternal(int userId,
IEnumerable <int> artifactIds,
bool addProjectsNames,
IDbTransaction transaction)
{
var result = new SqlDiscardPublishDetailsResult();
var projectIdSet = new HashSet <int>();
var parameters = new DynamicParameters();
parameters.Add("@userId", userId);
var artifactIdsTable = SqlConnectionWrapper.ToDataTable(artifactIds);
parameters.Add("@artifactIds", artifactIdsTable);
result.Details.Clear();
if (transaction == null)
{
result.Details.AddRange
(
(
await ConnectionWrapper.QueryAsync <SqlDiscardPublishDetails>
(
"GetDiscardPublishDetails",
parameters,
commandType: CommandType.StoredProcedure)).ToList());
}
else
{
result.Details.AddRange
(
(
await transaction.Connection.QueryAsync <SqlDiscardPublishDetails>
(
"GetDiscardPublishDetails",
parameters,
transaction,
commandType: CommandType.StoredProcedure)).ToList());
}
foreach (var sqlDiscardPublishDetail in result.Details)
{
projectIdSet.Add(sqlDiscardPublishDetail.VersionProjectId);
}
if (addProjectsNames)
{
result.ProjectInfos.Clear();
result.ProjectInfos.AddRange(await GetProjectNames(userId, projectIdSet, transaction));
}
return(result);
}
/// <summary>
/// Implementation of your slot.
/// </summary>
/// <param name="signaler">Signaler used to raise the signal.</param>
/// <param name="input">Arguments to your slot.</param>
/// <returns>An awaitable task.</returns>
public async Task SignalAsync(ISignaler signaler, Node input)
{
using (var connection = new SqlConnectionWrapper(GetConnectionString(input)))
{
await signaler.ScopeAsync(
"mssql.connect",
connection,
async() => await signaler.SignalAsync("eval", input));
input.Value = null;
}
}
public async Task<List<int>> GetItemSimilarItemIds(int artifactId, int userId, int limit, bool isInstanceAdmin, IEnumerable<int> projectIds)
{
var prm = new DynamicParameters();
prm.Add("@itemId", artifactId);
prm.Add("@userId", userId);
prm.Add("@limit", limit);
prm.Add("@allProjects", isInstanceAdmin);
prm.Add("@projectIds", SqlConnectionWrapper.ToDataTable(projectIds));
return (await
_connectionWrapper.QueryAsync<int>("GetItemSimilarItemIds", prm, commandType: CommandType.StoredProcedure)).Distinct().ToList();
}
public void CreateSqlBulkCopyReturnsSqlBulkCopyWrapper()
{
// Arrange
using (var sut = new SqlConnectionWrapper(DatabaseFixture.LogEventsConnectionString, null))
{
// Act
var result = sut.CreateSqlBulkCopy(false, "DestinationTableName");
// Assert
Assert.NotNull(result);
}
}
public void CreateCommandReturnsSqlCommandWrapper()
{
// Arrange
using (var sut = new SqlConnectionWrapper(DatabaseFixture.LogEventsConnectionString, null))
{
// Act
var result = sut.CreateCommand();
// Assert
Assert.NotNull(result);
}
}
public override async Task <long> CreateInstanceIndexAsync(DicomDataset instance, IEnumerable <QueryTag> queryTags, CancellationToken cancellationToken)
{
EnsureArg.IsNotNull(instance, nameof(instance));
EnsureArg.IsNotNull(queryTags, nameof(queryTags));
using (SqlConnectionWrapper sqlConnectionWrapper = await _sqlConnectionFactoryWrapper.ObtainSqlConnectionWrapperAsync(cancellationToken))
using (SqlCommandWrapper sqlCommandWrapper = sqlConnectionWrapper.CreateSqlCommand())
{
// Build parameter for extended query tag.
VLatest.AddInstanceTableValuedParameters parameters = AddInstanceTableValuedParametersBuilder.Build(
instance,
queryTags.Where(tag => tag.IsExtendedQueryTag));
VLatest.AddInstance.PopulateCommand(
sqlCommandWrapper,
instance.GetString(DicomTag.StudyInstanceUID),
instance.GetString(DicomTag.SeriesInstanceUID),
instance.GetString(DicomTag.SOPInstanceUID),
instance.GetSingleValueOrDefault <string>(DicomTag.PatientID),
instance.GetSingleValueOrDefault <string>(DicomTag.PatientName),
instance.GetSingleValueOrDefault <string>(DicomTag.ReferringPhysicianName),
instance.GetStringDateAsDate(DicomTag.StudyDate),
instance.GetSingleValueOrDefault <string>(DicomTag.StudyDescription),
instance.GetSingleValueOrDefault <string>(DicomTag.AccessionNumber),
instance.GetSingleValueOrDefault <string>(DicomTag.Modality),
instance.GetStringDateAsDate(DicomTag.PerformedProcedureStepStartDate),
(byte)IndexStatus.Creating,
parameters);
try
{
return((long)(await sqlCommandWrapper.ExecuteScalarAsync(cancellationToken)));
}
catch (SqlException ex)
{
switch (ex.Number)
{
case SqlErrorCodes.Conflict:
{
if (ex.State == (byte)IndexStatus.Creating)
{
throw new PendingInstanceException();
}
throw new InstanceAlreadyExistsException();
}
}
throw new DataStoreException(ex);
}
}
}
public void CreateCommandWithParameterReturnsSqlCommandWrapper()
{
// Arrange
using (var sut = new SqlConnectionWrapper(DatabaseFixture.LogEventsConnectionString, null))
{
// Act
var result = sut.CreateCommand("CommandText");
// Assert
Assert.NotNull(result);
Assert.Equal("CommandText", result.CommandText);
}
}
public async Task <IEnumerable <PropertyType> > GetProjectPropertyTypesAsync(
int projectId, IEnumerable <int> predefinedTypeIds)
{
var parameters = new DynamicParameters();
parameters.Add("@projectId", projectId);
parameters.Add("@predefinedPropertyTypes", SqlConnectionWrapper.ToDataTable(predefinedTypeIds));
var ptVersions = await _connectionWrapper.QueryAsync <PropertyTypeVersion>(
"GetProjectPropertyTypes", parameters, commandType : CommandType.StoredProcedure);
return(ptVersions.Select(pv => pv.ConvertToPropertyType()).ToList());
}
private async Task <ICollection <SqlItemInfo> > GetPublishStatesInternal(int userId,
ISet <int> ids,
bool ignoreComments,
IDbTransaction transaction)
{
var parameters = new DynamicParameters();
parameters.Add("@userId", userId);
var artifactIds = SqlConnectionWrapper.ToDataTable(ids);
parameters.Add("@artifactIds", artifactIds);
parameters.Add("@ignoreComments", ignoreComments);
IList <SqlItemInfo> existingItemsInfo;
if (transaction == null)
{
existingItemsInfo =
(
await ConnectionWrapper.QueryAsync <SqlItemInfo>
(
"GetPublishInfo",
parameters,
commandType: CommandType.StoredProcedure)).ToList();
}
else
{
existingItemsInfo =
(
await transaction.Connection.QueryAsync <SqlItemInfo>
(
"GetPublishInfo",
parameters,
transaction,
commandType: CommandType.StoredProcedure)).ToList();
}
existingItemsInfo.AddRange
(
ids.Except
(
existingItemsInfo.Select(i => i.ItemId))
.Select
(
id => new SqlItemInfo
{
ItemId = id,
NotFound = true
}));
return(existingItemsInfo);
}
/// <summary>
/// Initialization of the package; this method is called right after the package is sited, so this is the place
/// where you can put all the initialization code that rely on services provided by VisualStudio.
/// </summary>
protected override void Initialize()
{
base.Initialize();
Logger.WriteInformation("Initializing");
try
{
HttpClient = new HttpClient();
HttpClient.DefaultRequestHeaders.Add("User-Agent",
"Mozilla/4.0 (Compatible; Windows NT 5.1; MSIE 6.0) (compatible; MSIE 6.0; Windows NT 5.1; .NET CLR 1.1.4322; .NET CLR 2.0.50727)");
var pSolution = (IVsSolution)GetService(typeof(SVsSolution));
var result = pSolution.AdviseSolutionEvents(new SolutionEventsHandler(), out SolutionEventsHandlerId);
Settings = new Settings();
UserImages = new UserImageCache();
Redis = new RedisWrapper();
Slack = new SlackWrapper();
LocalIdeModel = new LocalIDEModel();
IDEWrapper = new IDEWrapper((EnvDTE.DTE)GetService(typeof(EnvDTE.DTE)));
var versionedAssembly = GetVersionedAssembly();
SourceControlRepo = new CachedSourceControlRepository(
new GitRepository(),
GetVersionedType <ISourceControlRepository>(versionedAssembly, "TeamCoding.Documents.SourceControlRepositories.TeamFoundationServiceRepository"),
new SolutionNameBasedRepository());
CaretInfoProvider = GetVersionedType <ICaretInfoProvider>(versionedAssembly, "TeamCoding.Documents.CaretInfoProvider");
CaretAdornmentDataProvider = GetVersionedType <ICaretAdornmentDataProvider>(versionedAssembly, "TeamCoding.Documents.CaretAdornmentDataProvider");
IdentityProvider = new CachedFailoverIdentityProvider(new VSOptionsIdentityProvider(),
new CredentialManagerIdentityProvider(new[] { "git:https://github.com", "https://github.com/" }),
new VSIdentityProvider(),
new MachineIdentityProvider());
ConnectionWrapper = new SqlConnectionWrapper();
WindowsServiceClient = new WinServiceClient(Settings.SharedSettings.WinServiceIPAddressProperty);
RemoteModelChangeManager = new CombinedRemoteModelPersister(new RedisRemoteModelPersister(),
new SharedFolderRemoteModelPersister(),
new SlackRemoteModelPersister(),
new SqlServerRemoteModelPersister(ConnectionWrapper),
new WinServiceRemoteModelPersister(WindowsServiceClient));
LocalModelChangeManager = new CombinedLocalModelPersister(new RedisLocalModelPersister(LocalIdeModel),
new SharedFolderLocalModelPersister(LocalIdeModel),
new SlackLocalModelPersister(LocalIdeModel),
new SqlServerLocalModelPersister(ConnectionWrapper, LocalIdeModel),
new WinServiceLocalModelPersister(WindowsServiceClient, LocalIdeModel));
RemoteModelChangeManager.RemoteModelReceived += RemoteModelChangeManager_RemoteModelReceived;
TeamCoding.VisualStudio.ToolWindows.OverviewWindow.OverviewCommand.Initialize(this);
}
catch (Exception ex) when(!System.Diagnostics.Debugger.IsAttached)
{
Logger.WriteError(ex);
}
}
// TODO: Make cancellation token an input.
public async Task <IReadOnlyCollection <ResourceSearchParameterStatus> > GetSearchParameterStatuses()
{
// If the search parameter table in SQL does not yet contain status columns
if (_schemaInformation.Current < SchemaVersionConstants.SearchParameterStatusSchemaVersion)
{
// Get status information from file.
return(await _filebasedSearchParameterStatusDataStore.GetSearchParameterStatuses());
}
using (IScoped <SqlConnectionWrapperFactory> scopedSqlConnectionWrapperFactory = _scopedSqlConnectionWrapperFactory())
using (SqlConnectionWrapper sqlConnectionWrapper = await scopedSqlConnectionWrapperFactory.Value.ObtainSqlConnectionWrapperAsync(CancellationToken.None, true))
using (SqlCommandWrapper sqlCommandWrapper = sqlConnectionWrapper.CreateSqlCommand())
{
VLatest.GetSearchParamStatuses.PopulateCommand(sqlCommandWrapper);
var parameterStatuses = new List <ResourceSearchParameterStatus>();
using (SqlDataReader sqlDataReader = await sqlCommandWrapper.ExecuteReaderAsync(CommandBehavior.SequentialAccess, CancellationToken.None))
{
while (await sqlDataReader.ReadAsync())
{
(string uri, string stringStatus, DateTimeOffset? lastUpdated, bool?isPartiallySupported) = sqlDataReader.ReadRow(
VLatest.SearchParam.Uri,
VLatest.SearchParam.Status,
VLatest.SearchParam.LastUpdated,
VLatest.SearchParam.IsPartiallySupported);
if (string.IsNullOrEmpty(stringStatus) || lastUpdated == null || isPartiallySupported == null)
{
// These columns are nullable because they are added to dbo.SearchParam in a later schema version.
// They should be populated as soon as they are added to the table and should never be null.
throw new NullReferenceException(Resources.SearchParameterStatusShouldNotBeNull);
}
var status = Enum.Parse <SearchParameterStatus>(stringStatus, true);
var resourceSearchParameterStatus = new ResourceSearchParameterStatus()
{
Uri = new Uri(uri),
Status = status,
IsPartiallySupported = (bool)isPartiallySupported,
LastUpdated = (DateTimeOffset)lastUpdated,
};
parameterStatuses.Add(resourceSearchParameterStatus);
}
}
return(parameterStatuses);
}
}
public override async Task <IReadOnlyList <ExtendedQueryTagStoreEntry> > AssignReindexingOperationAsync(
IReadOnlyCollection <int> queryTagKeys,
Guid operationId,
bool returnIfCompleted = false,
CancellationToken cancellationToken = default)
{
EnsureArg.HasItems(queryTagKeys, nameof(queryTagKeys));
using SqlConnectionWrapper sqlConnectionWrapper = await ConnectionWrapperFactory.ObtainSqlConnectionWrapperAsync(cancellationToken);
using SqlCommandWrapper sqlCommandWrapper = sqlConnectionWrapper.CreateSqlCommand();
IEnumerable <ExtendedQueryTagKeyTableTypeV1Row> rows = queryTagKeys.Select(x => new ExtendedQueryTagKeyTableTypeV1Row(x));
VLatest.AssignReindexingOperation.PopulateCommand(sqlCommandWrapper, rows, operationId, returnIfCompleted);
try
{
var queryTags = new List <ExtendedQueryTagStoreEntry>();
using SqlDataReader reader = await sqlCommandWrapper.ExecuteReaderAsync(cancellationToken);
while (await reader.ReadAsync(cancellationToken))
{
(int tagKey, string tagPath, string tagVR, string tagPrivateCreator, byte tagLevel, byte tagStatus, byte queryStatus, int errorCount) = reader.ReadRow(
VLatest.ExtendedQueryTag.TagKey,
VLatest.ExtendedQueryTag.TagPath,
VLatest.ExtendedQueryTag.TagVR,
VLatest.ExtendedQueryTag.TagPrivateCreator,
VLatest.ExtendedQueryTag.TagLevel,
VLatest.ExtendedQueryTag.TagStatus,
VLatest.ExtendedQueryTag.QueryStatus,
VLatest.ExtendedQueryTag.ErrorCount);
queryTags.Add(new ExtendedQueryTagStoreEntry(
tagKey,
tagPath,
tagVR,
tagPrivateCreator,
(QueryTagLevel)tagLevel,
(ExtendedQueryTagStatus)tagStatus,
(QueryStatus)queryStatus,
errorCount));
}
return(queryTags);
}
catch (SqlException ex)
{
throw new DataStoreException(ex);
}
}
public override async Task <IReadOnlyList <ExtendedQueryTagStoreEntry> > AddExtendedQueryTagsAsync(
IReadOnlyCollection <AddExtendedQueryTagEntry> extendedQueryTagEntries,
int maxAllowedCount,
bool ready = false,
CancellationToken cancellationToken = default)
{
EnsureArg.IsNotNull(extendedQueryTagEntries, nameof(extendedQueryTagEntries));
EnsureArg.IsGt(maxAllowedCount, 0, nameof(maxAllowedCount));
using SqlConnectionWrapper sqlConnectionWrapper = await ConnectionWrapperFactory.ObtainSqlConnectionWrapperAsync(cancellationToken);
using SqlCommandWrapper sqlCommandWrapper = sqlConnectionWrapper.CreateSqlCommand();
IEnumerable <AddExtendedQueryTagsInputTableTypeV1Row> rows = extendedQueryTagEntries.Select(ToAddExtendedQueryTagsInputTableTypeV1Row);
VLatest.AddExtendedQueryTags.PopulateCommand(sqlCommandWrapper, maxAllowedCount, ready, new VLatest.AddExtendedQueryTagsTableValuedParameters(rows));
try
{
var results = new List <ExtendedQueryTagStoreEntry>();
using SqlDataReader reader = await sqlCommandWrapper.ExecuteReaderAsync(cancellationToken);
while (await reader.ReadAsync(cancellationToken))
{
(int tagKey, string tagPath, string tagVR, string tagPrivateCreator, int tagLevel, int tagStatus, byte queryStatus, int errorCount) = reader.ReadRow(
VLatest.ExtendedQueryTag.TagKey,
VLatest.ExtendedQueryTag.TagPath,
VLatest.ExtendedQueryTag.TagVR,
VLatest.ExtendedQueryTag.TagPrivateCreator,
VLatest.ExtendedQueryTag.TagLevel,
VLatest.ExtendedQueryTag.TagStatus,
VLatest.ExtendedQueryTag.QueryStatus,
VLatest.ExtendedQueryTag.ErrorCount);
results.Add(new ExtendedQueryTagStoreEntry(tagKey, tagPath, tagVR, tagPrivateCreator, (QueryTagLevel)tagLevel, (ExtendedQueryTagStatus)tagStatus, (QueryStatus)queryStatus, errorCount));
}
return(results);
}
catch (SqlException ex)
{
throw ex.Number switch
{
SqlErrorCodes.Conflict => ex.State == 1
? new ExtendedQueryTagsExceedsMaxAllowedCountException(maxAllowedCount)
: new ExtendedQueryTagsAlreadyExistsException(),
_ => new DataStoreException(ex),
};
}
}
private static IItemSearchRepository CreateFullTextSearchRepository <T>(
FullTextSearchCriteria searchCriteria,
ICollection <T> queryResult,
ICollection <int?> queryResult2 = null)
{
var connectionWrapper = new SqlConnectionWrapperMock();
connectionWrapper.SetupQueryAsync("SearchFullText",
new Dictionary <string, object>
{
{ "predefineds", SqlItemSearchRepository.Predefineds },
{ "page", Page },
{ "pageSize", PageSize },
{ "maxItems", MaxItems },
},
queryResult);
connectionWrapper.SetupQueryMultipleAsync("SearchFullTextMetaData",
new Dictionary <string, object>
{
{ "predefineds", SqlItemSearchRepository.Predefineds },
},
new Tuple <IEnumerable <T>, IEnumerable <int?> >(queryResult, queryResult2));
if (searchCriteria.ItemTypeIds != null)
{
connectionWrapper.SetupQueryAsync("SearchFullTextByItemTypes",
new Dictionary <string, object>
{
{ "predefineds", SqlItemSearchRepository.Predefineds },
{ "page", Page },
{ "pageSize", PageSize },
{ "maxItems", MaxItems },
{ "itemTypeIds", SqlConnectionWrapper.ToDataTable(searchCriteria.ItemTypeIds) }
},
queryResult);
connectionWrapper.SetupQueryMultipleAsync("SearchFullTextByItemTypesMetaData",
new Dictionary <string, object>
{
{ "predefineds", SqlItemSearchRepository.Predefineds },
{ "itemTypeIds", SqlConnectionWrapper.ToDataTable(searchCriteria.ItemTypeIds) }
},
new Tuple <IEnumerable <T>, IEnumerable <int?> >(queryResult, queryResult2));
}
var configuration = new Mock <ISearchConfiguration>();
configuration.Setup(c => c.MaxItems).Returns(MaxItems.ToStringInvariant());
configuration.Setup(c => c.MaxSearchableValueStringSize).Returns(MaxSearchableValueStringSize.ToStringInvariant());
return(new SqlItemSearchRepository(connectionWrapper.Object, configuration.Object));
}
private async Task <IDictionary <int, string> > GetProjectNames(int userId,
HashSet <int> projectIdSet,
IDbTransaction transaction)
{
var result = new Dictionary <int, string>();
var parameters = new DynamicParameters();
parameters.Add("@userId", userId);
var projectIdsTable = SqlConnectionWrapper.ToDataTable(projectIdSet);
parameters.Add("@projectIds", projectIdsTable);
IList <SqlDiscardPublishProjectInfo> discardPublishProjectDetails;
if (transaction == null)
{
discardPublishProjectDetails =
(
await ConnectionWrapper.QueryAsync <SqlDiscardPublishProjectInfo>
(
"GetDiscardPublishProjectsDetails",
parameters,
commandType: CommandType.StoredProcedure)).ToList();
}
else
{
discardPublishProjectDetails =
(
await transaction.Connection.QueryAsync <SqlDiscardPublishProjectInfo>
(
"GetDiscardPublishProjectsDetails",
parameters,
transaction,
commandType: CommandType.StoredProcedure)).ToList();
}
foreach (var sqlDiscardPublishProjectInfo in discardPublishProjectDetails)
{
if (!result.ContainsKey(sqlDiscardPublishProjectInfo.ItemId))
{
result.Add(sqlDiscardPublishProjectInfo.ItemId, sqlDiscardPublishProjectInfo.Name);
}
else
{
result[sqlDiscardPublishProjectInfo.ItemId] = sqlDiscardPublishProjectInfo.Name;
}
}
return(result);
}
/// <summary>
/// Implementation of your slot.
/// </summary>
/// <param name="signaler">Signaler used to raise the signal.</param>
/// <param name="input">Arguments to your slot.</param>
public void Signal(ISignaler signaler, Node input)
{
using (var connection = new SqlConnectionWrapper(
Executor.GetConnectionString(
input,
"mssql",
"master",
_configuration)))
{
signaler.Scope(
"mssql.connect",
connection, () => signaler.Signal("eval", input));
input.Value = null;
}
}
public async Task <List <CurrentVersionInformation> > GetCurrentVersionAsync(CancellationToken cancellationToken)
{
var currentVersions = new List <CurrentVersionInformation>();
using (SqlConnectionWrapper sqlConnectionWrapper = await _sqlConnectionWrapperFactory.ObtainSqlConnectionWrapperAsync(cancellationToken: cancellationToken))
using (SqlCommandWrapper sqlCommandWrapper = sqlConnectionWrapper.CreateSqlCommand())
{
SchemaShared.SelectCurrentVersionsInformation.PopulateCommand(sqlCommandWrapper);
try
{
using (var dataReader = await sqlCommandWrapper.ExecuteReaderAsync(cancellationToken))
{
if (dataReader.HasRows)
{
while (await dataReader.ReadAsync(cancellationToken))
{
IList <string> instanceNames = new List <string>();
if (!dataReader.IsDBNull(2))
{
string names = dataReader.GetString(2);
instanceNames = names.Split(",").ToList();
}
var status = (string)dataReader.GetValue(1);
// To combine the complete and completed version since earlier status was marked in 'complete' status and now the fix has made to mark the status in completed state
status = string.Equals(status, "complete", StringComparison.OrdinalIgnoreCase) ? "completed" : status;
var schemaVersionStatus = (SchemaVersionStatus)Enum.Parse(typeof(SchemaVersionStatus), status, true);
var currentVersion = new CurrentVersionInformation((int)dataReader.GetValue(0), schemaVersionStatus, instanceNames);
currentVersions.Add(currentVersion);
}
}
else
{
return(currentVersions);
}
}
}
catch (SqlException e)
{
_logger.LogError(e, "Error from SQL database on retrieving current version information");
throw;
}
}
return(currentVersions);
}
private void Setup <T>(Expression <Func <ISqlConnectionWrapper, Task <T> > > expression, T result, Dictionary <string, object> outParameters = null)
{
var setup = Setup(expression).ReturnsAsync(result);
if (outParameters != null)
{
setup.Callback((string s, object p, IDbTransaction t, int?o, CommandType c) =>
{
foreach (var kv in outParameters)
{
SqlConnectionWrapper.Set(p, kv.Key, kv.Value);
}
});
}
setup.Verifiable();
}
private async Task <IList <WorkflowState> > GetCurrentStatesInternal(int userId, IEnumerable <int> artifactIds, int revisionId, bool addDrafts)
{
var param = new DynamicParameters();
param.Add("@userId", userId);
var artifactIdsTable = SqlConnectionWrapper.ToDataTable(artifactIds);
param.Add("@artifactIds", artifactIdsTable);
param.Add("@revisionId", revisionId);
param.Add("@addDrafts", addDrafts);
return(ToWorkflowStates(
await
ConnectionWrapper.QueryAsync <SqlWorkFlowStateInformation>("GetWorkflowStatesForArtifacts", param,
commandType: CommandType.StoredProcedure)));
}
