public async Task <IEnumerable <T> > GetItemsAsync <T>(
IConnectionSettings connectionSettings,
Expression <Func <T, bool> > predicate,
Expression <Func <T, dynamic> > select)
where T : class
{
var client = GetClient(connectionSettings);
var query = client.CreateDocumentQuery <T>(
UriFactory.CreateDocumentCollectionUri(
connectionSettings.DatabaseId,
connectionSettings.Collection),
new FeedOptions {
MaxItemCount = -1
})
.Where(predicate)
.Select(select)
.AsDocumentQuery();
var results = new List <T>();
while (query.HasMoreResults)
{
var response = await query.ExecuteNextAsync <T>();
// Unable to get RequestCharge during testing since we've casted the return type
// to match our select. Appears to work fine on the real cosmos; something missing on the CosmosMocker.
results.AddRange(response);
}
return(results);
}
public ILogSource GetSource(IConnectionSettings connectionSettings)
{
AzureConnectionSettings azureConnectionSettings = connectionSettings as AzureConnectionSettings;
azureConnectionSettings = new AzureConnectionSettings(azureConnectionSettings.StorageName, azureConnectionSettings.StorageKey, true, azureConnectionSettings.QueryFilter, azureConnectionSettings.StartTimeFilter, azureConnectionSettings.EndTimeFilter, azureConnectionSettings.RoleFilter, azureConnectionSettings.RoleInstanceFilter);
return(new AzureLogSource(azureConnectionSettings));
}
internal virtual ElasticsearchPathInfo <K> ToPathInfo <K>(IConnectionSettings settings, K queryString)
where K : FluentQueryString <K>, new()
{
var inferrer = new ElasticInferrer(settings);
if (this._Index == null)
{
this._Index = inferrer.IndexName <T>();
}
if (this._Type == null)
{
this._Type = inferrer.TypeName <T>();
}
var index = new ElasticInferrer(settings).IndexName(this._Index);
var type = new ElasticInferrer(settings).TypeName(this._Type);
var pathInfo = new ElasticsearchPathInfo <K>()
{
Index = index,
Type = type
};
pathInfo.QueryString = queryString ?? new K();
return(pathInfo);
}
public BaseJsonTests()
{
this._settings = new ConnectionSettings(Test.Default.Uri)
.SetDefaultIndex(Test.Default.DefaultIndex);
this._connection = new InMemoryConnection(this._settings);
this._client = new ElasticClient(this._settings, this._connection);
}
public string Resolve(IConnectionSettings connectionSettings)
{
connectionSettings.ThrowIfNull("connectionSettings");
string typeName = this.Name;
if (this.Type == null)
{
return(this.Name);
}
if (connectionSettings.DefaultTypeNames.TryGetValue(this.Type, out typeName))
{
return(typeName);
}
if (this.Type != null)
{
var att = new PropertyNameResolver().GetElasticPropertyFor(this.Type);
if (att != null && !att.TypeNameMarker.IsNullOrEmpty())
{
typeName = att.TypeNameMarker.Name;
}
else if (att != null && !string.IsNullOrEmpty(att.Name))
{
typeName = att.Name;
}
else
{
typeName = connectionSettings.DefaultTypeNameInferrer(this.Type);
}
return(typeName);
}
return(this.Name);
}
public void SetConnectionSettings(IConnectionSettings contractObject)
{
var connectionSettings = ConnectionSettings.Create(contractObject);
lock (Anchor)
{
bool changed = false;
if (!connectionSettings.Equals(_authenticationSettings.ConnectionSettings))
{
_authenticationSettings.ConnectionSettings =
(IConnectionSettings)connectionSettings.Clone();
changed = true;
}
if (changed)
{
Save();
}
}
if (HasConnectionSettings)
{
IdentifierService.RegisterMasterIdentifierIfNeeded(this);
}
}
internal virtual ElasticsearchPathInfo <K> ToPathInfo <K>(IConnectionSettings settings, K queryString)
where K : FluentQueryString <K>, new()
{
var inferrer = new ElasticInferrer(settings);
if (!this._AllIndices.HasValue && this._Indices == null)
{
this._Indices = new[] { (IndexNameMarker)inferrer.DefaultIndex }
}
;
string index = "_all";
if (!this._AllIndices.GetValueOrDefault(false))
{
index = string.Join(",", this._Indices.Select(inferrer.IndexName));
}
var pathInfo = new ElasticsearchPathInfo <K>()
{
Index = index,
};
pathInfo.QueryString = queryString ?? new K();
return(pathInfo);
}
}
public static IConnectionSettings ToAuditSettings(this IConnectionSettings connectionSetting)
{
return(new AuditConnectionSetting(connectionSetting.EndPointUri,
connectionSetting.PrimaryKey,
connectionSetting.DatabaseId,
connectionSetting.Collection));
}
public ElasticClient(IConnectionSettings settings,bool useThrift)
{
if (settings == null)
throw new ArgumentNullException("settings");
this.Settings = settings;
if (useThrift)
this.Connection = new ThriftConnection(settings);
else
this.Connection = new Connection(settings);
this.SerializationSettings = new JsonSerializerSettings()
{
ContractResolver = new ElasticResolver(),
NullValueHandling = NullValueHandling.Ignore,
Converters = new List<JsonConverter>
{
new DateHistogramConverter(),
new IsoDateTimeConverter(),
new QueryJsonConverter(),
new FacetsMetaDataConverter()
}
};
this.PropertyNameResolver = new PropertyNameResolver(this.SerializationSettings);
}
/// <inheritdoc/>
public async Task <T> GetItemByIdAsync <T>(IConnectionSettings connectionSettings, string id)
{
try
{
var client = GetClient(connectionSettings);
var documentUri = UriFactory.CreateDocumentUri(
connectionSettings.DatabaseId,
connectionSettings.Collection,
id);
var response = await client.ReadDocumentAsync(documentUri);
_requestChargeService.RequestCharges.Add(new RequestChargeService.RequestCharge()
{
Request = $"GetItemByIdAsync<{typeof(T).Name}>(id={id})",
Charge = response.RequestCharge
});
return((T)(dynamic)response.Resource);
}
catch (DocumentClientException documentClientException)
{
if (documentClientException.StatusCode == HttpStatusCode.NotFound)
{
return(default(T));
}
throw;
}
}
public DatabaseFactory(IConnectionSettings connectionSettings)
{
Contract.Requires(Check.Argument.IsNotNull(connectionSettings));
_connectionString = connectionSettings.ConnectionString;
_defaultContainerName = connectionSettings.DefaultContainerName;
}
public static void RegisterDatabase(this IServiceCollection services, IConnectionSettings connectionSettings)
{
services.AddDbContext <CreditHubDbContext>(options =>
{
options.UseNpgsql(connectionSettings.PostgreSql);
});
}
public ConnectionStatus(IConnectionSettings settings, Exception e) : this(settings)
{
this._settings = settings;
this.Success = false;
this.Error = new ConnectionError(e);
this.Result = this.Error.Response;
}
public PathResolver(IConnectionSettings connectionSettings)
{
connectionSettings.ThrowIfNull("hasDefaultIndices");
this._connectionSettings = connectionSettings;
this._indexNameResolver = new IndexNameResolver(connectionSettings);
this._typeNameResolver = new TypeNameResolver();
this._idResolver = new IdResolver();
}
override public void Start(Script script, IConnectionSettings cs, AuditProcedure auditProcedure, Dictionary <string, string> variables)
{
_script = script;
_script.Success = true;
_script.ExecutionStatus = ExecutionStatus.Executed;
base.Start(script, cs, auditProcedure, variables);
}
public PutMappingDescriptor(IConnectionSettings connectionSettings)
{
this._connectionSettings = connectionSettings;
this._Mapping = new RootObjectMapping()
{
};
this.Infer = new ElasticInferrer(this._connectionSettings);
}
public AsyncRequestOperation(HttpWebRequest request, string requestData, IConnectionSettings connectionSettings, ConnectionStatusTracer tracer)
{
m_request = request;
m_requestData = requestData;
m_connectionSettings = connectionSettings;
m_tracer = tracer;
Start();
}
protected override void ConfigureSettings(ITransceiverConnectionSettings connectionSettings)
{
_subscriberSettings = connectionSettings.RpcServerReceiver;
var transmitterSettings = connectionSettings.RpcServerTransmitter;
_transmitterConnectionString = $"Endpoint=sb://{transmitterSettings.AccountId}.servicebus.windows.net/;SharedAccessKeyName={transmitterSettings.UserName};SharedAccessKey={transmitterSettings.AccessKey};";
}
private CloudBlobClient CreateBlobClient(IConnectionSettings settings)
{
var baseuri = $"https://{settings.AccountId}.blob.core.windows.net";
var uri = new Uri(baseuri);
return(new CloudBlobClient(uri, new Microsoft.WindowsAzure.Storage.Auth.StorageCredentials(settings.AccountId, settings.AccessKey)));
}
public static void RegisterRedis(this IServiceCollection services, IConnectionSettings connectionSettings)
{
services.AddDistributedRedisCache(options =>
{
options.Configuration = connectionSettings.Redis;
options.InstanceName = "CreditHub:";
});
}
public NestedObjectMappingDescriptor(IConnectionSettings connectionSettings)
{
this._connectionSettings = connectionSettings;
this._TypeName = TypeNameMarker.Create <TChild>();
this._Mapping = new NestedObjectMapping()
{
};
}
public DecaTecWebDavClient(IConnectionSettings connectionSettings)
{
_connectionSettings = connectionSettings;
var credentials = new NetworkCredential(_connectionSettings.UserName, _connectionSettings.GetPassword());
_session = new WebDavSession(credentials);
}
/// <summary>
/// CTOR
/// </summary>
/// <param name="url">The URL.</param>
/// <param name="credentials">The credentials.</param>
private FtpConnection(IConnectionSettings connectionSettings)
{
this.connectionSettings = connectionSettings;
TaskScheduler.UnobservedTaskException += TaskScheduler_UnobservedTaskException;
this.PropertyChanged += FtpConnection_PropertyChanged;
}
public NotificationServiceClient(
INotificationFactory factory,
IConnectionSettings settings)
{
_cancellation = new CancellationTokenSource();
_factory = factory;
_settings = settings;
}
public static string ConnectionStringCreate(IConnectionSettings settings, string databaseName)
{
if (settings.AuthMode == SqlAuthMode.SqlServer)
{
return string.Format(CONN_SQL, settings.ServerName, databaseName, settings.UserName, settings.Password);
}
return string.Format(CONN_WIN, settings.ServerName, databaseName);
}
public ObjectMappingDescriptor(IConnectionSettings connectionSettings)
{
this._TypeName = new TypeNameResolver().GetTypeNameFor <TChild>();
this._Mapping = new ObjectMapping()
{
};
this._connectionSettings = connectionSettings;
}
public static string ConnectionStringCreate(IConnectionSettings settings, string databaseName)
{
if (settings.AuthMode == SqlAuthMode.SqlServer)
{
return(string.Format(CONN_SQL, settings.ServerName, databaseName, settings.UserName, settings.Password));
}
return(string.Format(CONN_WIN, settings.ServerName, databaseName));
}
public TelegramServiceTest()
{
// Prepare Database
//
_connectionSettings = TestHelper.GetConnectionSettings();
_migrationRunner = new MigrationRunner(_connectionSettings.BuildConnectionString());
_migrationRunner.RunMigrationsUp();
}
public static void RegisterInfraServices(this IServiceCollection services, IConnectionSettings connectionSettings, IConfiguration configuration)
{
services.RegisterDatabase(connectionSettings);
services.RegisterRepositories();
services.RegisterRedis(connectionSettings);
}
public ElasticInferrer(IConnectionSettings connectionSettings)
{
this._connectionSettings = connectionSettings;
this.IdResolver = new IdResolver();
this.IndexNameResolver = new IndexNameResolver(this._connectionSettings);
this.TypeNameResolver = new TypeNameResolver(this._connectionSettings);
this.PropertyNameResolver = new PropertyNameResolver(this._connectionSettings);
}
protected BaseApprendaApiClient(IConnectionSettings connectionSettings, IRestSession restSession) : this(connectionSettings)
{
if (restSession == null)
{
throw new ArgumentNullException(nameof(restSession));
}
SessionToken = restSession.ApprendaSessionToken;
}
/// <summary>
///
/// </summary>
public ThriftConnection(IConnectionSettings connectionSettings)
{
Created = DateTime.Now;
var tsocket = new TSocket(connectionSettings.Host, connectionSettings.Port);
_transport = new TBufferedTransport(tsocket, 1024);
_protocol = new TBinaryProtocol(_transport);
_client = new Rest.Client(_protocol);
}
public Connection(IConnectionSettings settings)
{
if (settings == null)
throw new ArgumentNullException("settings");
this._ConnectionSettings = settings;
this._ResourceLock = new Semaphore(settings.MaximumAsyncConnections, settings.MaximumAsyncConnections);
}
private TfsTeamProjectCollection InitializeTFSCollection(IConnectionSettings connectionSettings)
{
ReportProgress($"Connecting to {connectionSettings.Uri} ...");
var tfsCollection = new TfsTeamProjectCollection(connectionSettings.Uri);
tfsCollection.EnsureAuthenticated();
return(tfsCollection);
}
internal TypeMappingWriter(Type t, string typeName, IConnectionSettings connectionSettings, int maxRecursion, ConcurrentDictionary<Type, int> seenTypes)
{
this._type = GetUnderlyingType(t);
this._connectionSettings = connectionSettings;
this.TypeName = typeName;
this.MaxRecursion = maxRecursion;
this.SeenTypes = seenTypes;
}
public CloseCaseService(
IDatabaseAccess databaseAccess,
IExaminationConnectionSettings connectionSettings,
IOptions <UrgencySettings> urgencySettings)
{
_connectionSettings = connectionSettings;
_databaseAccess = databaseAccess;
_urgencySettings = urgencySettings.Value;
}
public RawElasticClient(IConnectionSettings settings, IConnection connection)
{
if (settings == null)
throw new ArgumentNullException("settings");
this.Settings = settings;
this.Connection = connection;
this.Serializer = new ElasticSerializer(this.Settings);
}
public static string Resolve(this IndexNameMarker marker, IConnectionSettings connectionSettings)
{
if (marker == null)
return null;
connectionSettings.ThrowIfNull("connectionSettings");
if (marker.Type == null)
return marker.Name;
return new IndexNameResolver(connectionSettings).GetIndexForType(marker.Type);
}
/// <summary>
/// Copies information between objects inheriting the IConnectionSettings interface
/// </summary>
/// <param name="source"></param>
/// <param name="destination"></param>
public static void CopyConnectionSettings(IConnectionSettings source, IConnectionSettings destination)
{
destination.BufferedInput = source.BufferedInput;
destination.ConnectionAddress = source.ConnectionAddress;
destination.ConnectionName = source.ConnectionName;
destination.LocalEcho = source.LocalEcho;
destination.NewLineSequence = source.NewLineSequence;
destination.Port = source.Port;
destination.TerminalType = source.TerminalType;
}
public Connection(IConnectionSettings settings)
{
if (settings == null)
throw new ArgumentNullException("settings");
this._ConnectionSettings = settings;
var semaphore = Math.Max(1, settings.MaximumAsyncConnections);
this._ResourceLock = new Semaphore(semaphore, semaphore);
this._enableTrace = settings.TraceEnabled;
}
public Connection(IConnectionSettings settings)
: base(Connection.addressFamily)
{
base.Encoding = settings.Encoding;
base.Address = settings.Host;
base.Connected += connection_Connected;
base.Disconnected += connection_Disconnected;
base.Sent += connection_Sent;
base.Recieved += connection_Recieved;
}
public TypeMappingWriter(Type t, TypeNameMarker typeName, IConnectionSettings connectionSettings, int maxRecursion)
{
this._type = t;
this._connectionSettings = connectionSettings;
this.TypeName = typeName;
this.MaxRecursion = maxRecursion;
this.SeenTypes = new ConcurrentDictionary<Type, int>();
this.SeenTypes.TryAdd(t, 0);
}
public ElasticClient(IConnectionSettings settings,bool useThrift)
{
this.Settings = settings;
this.Connection = new ThriftConnection(settings);
this.SerializationSettings = new JsonSerializerSettings()
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
NullValueHandling = NullValueHandling.Ignore,
Converters = new List<JsonConverter> { new IsoDateTimeConverter(), new QueryJsonConverter(), new FacetsMetaDataConverter() }
};
this.PropertyNameResolver = new PropertyNameResolver(this.SerializationSettings);
}
public ThriftConnection(IConnectionSettings connectionSettings)
{
this._timeout = connectionSettings.Timeout;
this._poolSize = connectionSettings.MaximumAsyncConnections;
this._resourceLock = new Semaphore(_poolSize, _poolSize);
for (var i = 0; i <= connectionSettings.MaximumAsyncConnections; i++)
{
var tsocket = new TSocket(connectionSettings.Host, connectionSettings.Port);
var transport = new TBufferedTransport(tsocket, 1024);
var protocol = new TBinaryProtocol(transport);
var client = new Rest.Client(protocol);
_clients.Enqueue(client);
}
}
public ElasticClient(IConnectionSettings settings, IConnection connection)
{
if (settings == null)
throw new ArgumentNullException("settings");
this._connectionSettings = settings;
this.Connection = connection;
this.PathResolver = new PathResolver(settings);
this.PropertyNameResolver = new PropertyNameResolver();
this.Serializer = new ElasticSerializer(this._connectionSettings);
this.Raw = new RawElasticClient(this._connectionSettings, connection);
this.Infer = new ElasticInferrer(this._connectionSettings);
}
public ConnectionListener(
IConnectionSettings connectionSettings,
IConnectionFactory connectionFactory,
IPlayerRepository playerRepository,
IAdminCredentials adminCredentials)
{
_connectionSettings = connectionSettings;
_connectionFactory = connectionFactory;
_playerRepository = playerRepository;
_adminCredentials = adminCredentials;
_connections = new List<IConnection>();
var taskScheduler = new ThreadPerTaskScheduler();
_taskFactory = new TaskFactory(taskScheduler);
}
public Directory(IConnectionSettings connectionSettings, IDirectorySearcherOptions directorySearcherOptions)
{
if(connectionSettings == null)
throw new ArgumentNullException("connectionSettings");
this._connectionSettings = connectionSettings;
this._directorySearcherOptions = directorySearcherOptions;
string hostUrl = connectionSettings.Scheme.ToString() + "://" + connectionSettings.Host;
if(connectionSettings.Port != null)
hostUrl += ":" + connectionSettings.Port.Value.ToString(CultureInfo.InvariantCulture);
if(!hostUrl.EndsWith("/", StringComparison.Ordinal))
hostUrl += "/";
this._hostUrl = hostUrl;
this._rootPath = hostUrl + connectionSettings.DistinguishedName;
}
AzureServiceBusEndpointAddress(AddressType addressType, string ns, string queueOrTopicName,
IConnectionSettings settings, int prefetchCount)
{
_addressType = addressType;
_namespace = ns;
_queueOrTopicName = queueOrTopicName;
_settings = settings;
_prefetchCount = prefetchCount;
string suffix = "";
if (addressType == AddressType.Topic)
suffix = "?topic=true";
_friendlyUri = new Uri(string.Format("azure-sb://{0}/{1}{2}",
ns,
queueOrTopicName,
suffix));
}
public MySqlStorage(IConnectionSettings connectionSettings)
{
string connection = string.Format("server={0};port={1};username={2};password={3};database={4}",
connectionSettings.getHost(), connectionSettings.getPort(), connectionSettings.getLogin(), connectionSettings.getPassword(), connectionSettings.getDatabaseName());
//This is my insert query in which i am taking input from the user through windows forms
//This is MySqlConnection here i have created the object and pass my connection string.
_mySqlConnection = new MySqlConnection(connection);
try
{
_mySqlConnection.Open();
}
catch (MySql.Data.MySqlClient.MySqlException)
{
if (connectionFailed != null)
{
connectionFailed("Не удалось подключиться к базе данных, проверьте файл настроек");
}
}
}
public void Connect(IConnectionSettings connectionSettings)
{
Log.Debug(string.Format("Connecting to device {0}", this.DeviceName));
try
{
this.Protocol.ConnectionSettings = connectionSettings;
this.Protocol.Connect();
this.IsConnected = true;
this.Protocol.DataReceived += Protocol_DataReceived;
if (this.ConnectionSuccess != null)
this.ConnectionSuccess();
}
catch (Exception e)
{
Log.ErrorFormat("Cannot establish connection with the device {0}", this.DeviceName);
Log.Error(e);
if (this.ConnectionFailed != null)
this.ConnectionFailed();
}
}
public Connection(IConnectionSettings settings)
{
this._ConnectionSettings = settings;
this._ResourceLock = new Semaphore(settings.MaximumAsyncConnections, settings.MaximumAsyncConnections);
}
public InMemoryConnection(IConnectionSettings settings, ConnectionStatus fixedResult)
: base(settings)
{
this._fixedResult = fixedResult;
}
public ILogSource GetSource(IConnectionSettings connectionSettings)
{
AzureConnectionSettings azureConnectionSettings = connectionSettings as AzureConnectionSettings;
azureConnectionSettings = new AzureConnectionSettings(azureConnectionSettings.StorageName, azureConnectionSettings.StorageKey, true, azureConnectionSettings.QueryFilter, azureConnectionSettings.StartTimeFilter, azureConnectionSettings.EndTimeFilter, azureConnectionSettings.RoleFilter, azureConnectionSettings.RoleInstanceFilter);
return new AzureLogSource(azureConnectionSettings);
}
public IEnumerable<ILogSource> GetSources(IConnectionSettings settings)
{
return new List<ILogSource> { GetSource(settings) };
}
public Directory(IConnectionSettings connectionSettings)
: this(connectionSettings, null)
{
}
public TestConnection(IConnectionSettings settings)
: base(settings)
{
}
public ElasticCamelCaseResolver(IConnectionSettings connectionSettings)
: base(connectionSettings)
{
}
public ElasticResolver(IConnectionSettings connectionSettings)
: base(true)
{
this.ConnectionSettings = connectionSettings;
}
public InMemoryConnection(IConnectionSettings settings)
: base(settings)
{
}
public RawElasticClient(IConnectionSettings settings)
: this(settings, new Connection(settings))
{
}
