public async Task CreateDropAutoscaleDatabaseStreamApi()
{
string databaseId = Guid.NewGuid().ToString();
using (ResponseMessage response = await this.cosmosClient.CreateDatabaseStreamAsync(
new DatabaseProperties(databaseId),
ThroughputProperties.CreateAutoscaleThroughput(5000)))
{
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
}
DatabaseCore database = (DatabaseInlineCore)this.cosmosClient.GetDatabase(databaseId);
ThroughputResponse autoscale = await database.ReadThroughputAsync(requestOptions : null);
Assert.IsNotNull(autoscale);
Assert.AreEqual(5000, autoscale.Resource.MaxAutoscaleThroughput);
ThroughputResponse autoscaleReplaced = await database.ReplaceThroughputAsync(
ThroughputProperties.CreateAutoscaleThroughput(10000));
Assert.IsNotNull(autoscaleReplaced);
Assert.AreEqual(10000, autoscaleReplaced.Resource.MaxAutoscaleThroughput);
await database.DeleteAsync();
}
public async Task CreateDropAutoscaleAutoUpgradeDatabase()
{
DatabaseCore database = (DatabaseInlineCore)await this.cosmosClient.CreateDatabaseAsync(
nameof(CreateDropAutoscaleAutoUpgradeDatabase) + Guid.NewGuid(),
ThroughputProperties.CreateAutoscaleThroughput(
maxAutoscaleThroughput: 5000,
autoUpgradeMaxThroughputIncrementPercentage: 10));
// Container is required to validate database throughput upgrade scenarios
Container container = await database.CreateContainerAsync("Test", "/id");
ThroughputResponse autoscale = await database.ReadThroughputAsync(requestOptions : null);
Assert.IsNotNull(autoscale);
Assert.AreEqual(5000, autoscale.Resource.MaxAutoscaleThroughput);
Assert.AreEqual(10, autoscale.Resource.AutoUpgradeMaxThroughputIncrementPercentage);
ThroughputResponse autoscaleReplaced = await database.ReplaceThroughputAsync(
ThroughputProperties.CreateAutoscaleThroughput(6000));
Assert.IsNotNull(autoscaleReplaced);
Assert.AreEqual(6000, autoscaleReplaced.Resource.MaxAutoscaleThroughput);
Assert.IsNull(autoscaleReplaced.Resource.AutoUpgradeMaxThroughputIncrementPercentage);
ThroughputResponse autoUpgradeReplace = await database.ReplaceThroughputAsync(
ThroughputProperties.CreateAutoscaleThroughput(
maxAutoscaleThroughput: 7000,
autoUpgradeMaxThroughputIncrementPercentage: 20));
Assert.IsNotNull(autoUpgradeReplace);
Assert.AreEqual(7000, autoUpgradeReplace.Resource.MaxAutoscaleThroughput);
Assert.AreEqual(20, autoUpgradeReplace.Resource.AutoUpgradeMaxThroughputIncrementPercentage);
await database.DeleteAsync();
}
public async Task CreateDropFixedDatabase()
{
DatabaseCore database = (DatabaseInlineCore)await this.cosmosClient.CreateDatabaseAsync(
nameof(CreateDropAutoscaleDatabase) + Guid.NewGuid().ToString(),
ThroughputProperties.CreateManualThroughput(5000));
ThroughputResponse fixedDatabaseThroughput = await database.ReadThroughputAsync(requestOptions : null);
Assert.IsNotNull(fixedDatabaseThroughput);
Assert.AreEqual(5000, fixedDatabaseThroughput.Resource.Throughput);
Assert.IsNull(fixedDatabaseThroughput.Resource.MaxAutoscaleThroughput);
Assert.IsNull(fixedDatabaseThroughput.Resource.AutoUpgradeMaxThroughputIncrementPercentage);
ThroughputResponse fixedReplaced = await database.ReplaceThroughputAsync(
ThroughputProperties.CreateManualThroughput(6000));
Assert.IsNotNull(fixedReplaced);
Assert.AreEqual(6000, fixedReplaced.Resource.Throughput);
Assert.IsNull(fixedReplaced.Resource.MaxAutoscaleThroughput);
Assert.IsNull(fixedReplaced.Resource.AutoUpgradeMaxThroughputIncrementPercentage);
ThroughputResponse fixedReplacedIfExists = await database.ReplaceThroughputPropertiesIfExistsAsync(
ThroughputProperties.CreateManualThroughput(7000));
Assert.IsNotNull(fixedReplacedIfExists);
Assert.AreEqual(7000, fixedReplacedIfExists.Resource.Throughput);
Assert.IsNull(fixedReplacedIfExists.Resource.MaxAutoscaleThroughput);
Assert.IsNull(fixedReplacedIfExists.Resource.AutoUpgradeMaxThroughputIncrementPercentage);
await database.DeleteAsync();
}
[Ignore] // Not currently working with emulator
public async Task CreateDropAutoscaleContainer()
{
DatabaseCore database = (DatabaseInlineCore)await this.cosmosClient.CreateDatabaseAsync(
Guid.NewGuid().ToString());
ThroughputResponse databaseThroughput = await database.ReadThroughputIfExistsAsync(requestOptions : null);
Assert.IsNotNull(databaseThroughput);
Assert.AreEqual(HttpStatusCode.NotFound, databaseThroughput.StatusCode);
ContainerCore container = (ContainerInlineCore)await database.CreateContainerAsync(
new ContainerProperties(Guid.NewGuid().ToString(), "/pk"),
ThroughputProperties.CreateAutoscaleProvionedThroughput(5000));
Assert.IsNotNull(container);
ThroughputResponse autoscale = await container.ReadThroughputAsync(requestOptions : null);
Assert.IsNotNull(autoscale);
Assert.AreEqual(5000, autoscale.Resource.MaxAutoscaleThroughput);
ThroughputResponse autoscaleReplaced = await container.ReplaceThroughputPropertiesAsync(
ThroughputProperties.CreateAutoscaleProvionedThroughput(10000));
Assert.IsNotNull(autoscaleReplaced);
Assert.AreEqual(10000, autoscaleReplaced.Resource.MaxAutoscaleThroughput);
await database.DeleteAsync();
}
public void ValidateUriGenerationForResources()
{
string databaseId = "db1234";
string crId = "cr42";
Mock <CosmosClient> mockClient = new Mock <CosmosClient>();
mockClient.Setup(x => x.Endpoint).Returns(new Uri("http://localhost"));
CosmosClientContext context = new ClientContextCore(
client: mockClient.Object,
clientOptions: new CosmosClientOptions(),
userJsonSerializer: null,
defaultJsonSerializer: null,
sqlQuerySpecSerializer: null,
cosmosResponseFactory: null,
requestHandler: null,
documentClient: null);
DatabaseCore db = new DatabaseCore(context, databaseId);
Assert.AreEqual(db.LinkUri.OriginalString, "dbs/" + databaseId);
ContainerCore container = new ContainerCore(context, db, crId);
Assert.AreEqual(container.LinkUri.OriginalString, "dbs/" + databaseId + "/colls/" + crId);
}
public void InitializeBatchExecutorForContainer_NotNull_WhenAllowBulk_True()
{
string databaseId = "db1234";
string crId = "cr42";
Mock <CosmosClient> mockClient = new Mock <CosmosClient>();
mockClient.Setup(x => x.Endpoint).Returns(new Uri("http://localhost"));
CosmosClientContext context = new ClientContextCore(
client: mockClient.Object,
clientOptions: new CosmosClientOptions()
{
AllowBulkExecution = true
},
userJsonSerializer: null,
defaultJsonSerializer: null,
sqlQuerySpecSerializer: null,
cosmosResponseFactory: null,
requestHandler: null,
documentClient: null);
DatabaseCore db = new DatabaseCore(context, databaseId);
ContainerCore container = new ContainerCore(context, db, crId);
Assert.IsNotNull(container.BatchExecutor);
}
public async Task SingleTaskScheduler_ExecutorTest()
{
CosmosClientContext context = this.MockClientContext();
DatabaseCore db = new DatabaseCore(context, "test");
List <Task <ContainerCore> > tasks = new List <Task <ContainerCore> >();
for (int i = 0; i < 20; i++)
{
tasks.Add(
Task.Factory.StartNew(() => new ContainerCore(context, db, "test"),
CancellationToken.None,
TaskCreationOptions.None,
new SingleTaskScheduler()));
}
await Task.WhenAll(tasks);
BatchAsyncContainerExecutor firstExecutor = tasks[0].Result.BatchExecutor;
Assert.IsNotNull(firstExecutor);
for (int i = 1; i < 20; i++)
{
BatchAsyncContainerExecutor otherExecutor = tasks[i].Result.BatchExecutor;
Assert.AreEqual(firstExecutor, otherExecutor);
}
}
public async Task DatabaseContractTest()
{
DatabaseResponse response = await this.CreateDatabaseHelper();
Assert.IsNotNull(response);
Assert.IsTrue(response.RequestCharge > 0);
Assert.IsNotNull(response.Headers);
Assert.IsNotNull(response.Headers.ActivityId);
DatabaseProperties databaseSettings = response.Resource;
Assert.IsNotNull(databaseSettings.Id);
Assert.IsNotNull(databaseSettings.ResourceId);
Assert.IsNotNull(databaseSettings.ETag);
Assert.IsTrue(databaseSettings.LastModified.HasValue);
Assert.IsTrue(databaseSettings.LastModified.Value > new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc), databaseSettings.LastModified.Value.ToString());
DatabaseCore databaseCore = response.Database as DatabaseInlineCore;
Assert.IsNotNull(databaseCore);
Assert.IsNotNull(databaseCore.LinkUri);
Assert.IsFalse(databaseCore.LinkUri.ToString().StartsWith("/"));
response = await response.Database.DeleteAsync(cancellationToken : this.cancellationToken);
Assert.AreEqual(HttpStatusCode.NoContent, response.StatusCode);
}
public async Task EncryptionResourceTokenAuth()
{
User user = EncryptionTests.databaseCore.GetUser(Guid.NewGuid().ToString());
await EncryptionTests.databaseCore.CreateUserAsync(user.Id);
PermissionProperties permission = await user.CreatePermissionAsync(
new PermissionProperties(Guid.NewGuid().ToString(), PermissionMode.All, EncryptionTests.container));
TestDoc testDoc = await EncryptionTests.CreateItemAsync(EncryptionTests.containerCore, EncryptionTests.dekId, TestDoc.PathsToEncrypt);
(string endpoint, string _) = TestCommon.GetAccountInfo();
CosmosClient resourceTokenBasedClient = new CosmosClientBuilder(endpoint, permission.Token)
.WithEncryptionKeyWrapProvider(new TestKeyWrapProvider())
.Build();
DatabaseCore databaseForTokenClient = (DatabaseInlineCore)resourceTokenBasedClient.GetDatabase(EncryptionTests.databaseCore.Id);
Container containerForTokenClient = databaseForTokenClient.GetContainer(EncryptionTests.container.Id);
await EncryptionTests.PerformForbiddenOperationAsync(() =>
databaseForTokenClient.GetDataEncryptionKey(EncryptionTests.dekId).ReadAsync(), "DEK.ReadAsync");
await EncryptionTests.PerformForbiddenOperationAsync(() =>
containerForTokenClient.ReadItemAsync <TestDoc>(testDoc.Id, new PartitionKey(testDoc.PK)), "ReadItemAsync");
await EncryptionTests.PerformForbiddenOperationAsync(() =>
containerForTokenClient.ReadItemStreamAsync(testDoc.Id, new PartitionKey(testDoc.PK)), "ReadItemStreamAsync");
}
public async Task AllowBatchingRequestsSendsToExecutor_Delete()
{
CosmosClient cosmosClient = MockCosmosUtil.CreateMockCosmosClient();
ClientContextCore clientContextCore = new ClientContextCore(
cosmosClient,
new CosmosClientOptions()
{
AllowBulkExecution = true
},
new CosmosJsonDotNetSerializer(),
new CosmosJsonDotNetSerializer(),
null,
cosmosClient.ResponseFactory,
null,
new MockDocumentClient()
);
DatabaseCore db = new DatabaseCore(clientContextCore, "test");
ExecutorContainerCore container = new ExecutorContainerCore(clientContextCore, db, "test");
dynamic testItem = new
{
id = Guid.NewGuid().ToString(),
pk = "FF627B77-568E-4541-A47E-041EAC10E46F",
};
Cosmos.PartitionKey partitionKey = new Cosmos.PartitionKey(testItem.pk);
ItemResponse <dynamic> response = await container.DeleteItemAsync <dynamic>(
partitionKey : partitionKey,
id : testItem.id);
container.MockedExecutor.Verify(c => c.AddAsync(It.IsAny <ItemBatchOperation>(), It.IsAny <ItemRequestOptions>(), It.IsAny <CancellationToken>()), Times.Once);
}
public async Task EncryptionBulkCrud()
{
TestDoc docToReplace = await EncryptionTests.CreateItemAsync(EncryptionTests.containerCore, EncryptionTests.dekId, TestDoc.PathsToEncrypt);
docToReplace.NonSensitive = Guid.NewGuid().ToString();
docToReplace.Sensitive = Guid.NewGuid().ToString();
TestDoc docToUpsert = await EncryptionTests.CreateItemAsync(EncryptionTests.containerCore, EncryptionTests.dekId, TestDoc.PathsToEncrypt);
docToUpsert.NonSensitive = Guid.NewGuid().ToString();
docToUpsert.Sensitive = Guid.NewGuid().ToString();
TestDoc docToDelete = await EncryptionTests.CreateItemAsync(EncryptionTests.containerCore, EncryptionTests.dekId, TestDoc.PathsToEncrypt);
(string endpoint, string authKey) = TestCommon.GetAccountInfo();
CosmosClient clientWithBulk = new CosmosClientBuilder(endpoint, authKey)
.WithEncryptionKeyWrapProvider(new TestKeyWrapProvider())
.WithBulkExecution(true)
.Build();
DatabaseCore databaseWithBulk = (DatabaseInlineCore)clientWithBulk.GetDatabase(EncryptionTests.databaseCore.Id);
ContainerCore containerWithBulk = (ContainerInlineCore)databaseWithBulk.GetContainer(EncryptionTests.container.Id);
List <Task> tasks = new List <Task>();
tasks.Add(EncryptionTests.CreateItemAsync(containerWithBulk, EncryptionTests.dekId, TestDoc.PathsToEncrypt));
tasks.Add(EncryptionTests.UpsertItemAsync(containerWithBulk, TestDoc.Create(), EncryptionTests.dekId, TestDoc.PathsToEncrypt, HttpStatusCode.Created));
tasks.Add(EncryptionTests.ReplaceItemAsync(containerWithBulk, docToReplace, EncryptionTests.dekId, TestDoc.PathsToEncrypt));
tasks.Add(EncryptionTests.UpsertItemAsync(containerWithBulk, docToUpsert, EncryptionTests.dekId, TestDoc.PathsToEncrypt, HttpStatusCode.OK));
tasks.Add(EncryptionTests.DeleteItemAsync(containerWithBulk, docToDelete));
await Task.WhenAll(tasks);
}
public async Task AllowBatchingRequestsSendsToExecutor_ReadStream()
{
ClientContextCore clientContextCore = this.CreateMockBulkClientContextCore();
DatabaseCore db = new DatabaseCore(clientContextCore, "test");
ExecutorContainerCore container = new ExecutorContainerCore(clientContextCore, db, "test");
dynamic testItem = new
{
id = Guid.NewGuid().ToString(),
pk = "FF627B77-568E-4541-A47E-041EAC10E46F",
};
using (Stream itemStream = MockCosmosUtil.Serializer.ToStream <dynamic>(testItem))
{
ItemRequestOptions itemRequestOptions = new ItemRequestOptions();
Cosmos.PartitionKey partitionKey = new Cosmos.PartitionKey(testItem.pk);
using (ResponseMessage streamResponse = await container.ReadItemStreamAsync(
partitionKey: partitionKey,
id: testItem.id))
{
container.MockedExecutor.Verify(c => c.AddAsync(It.IsAny <ItemBatchOperation>(), It.IsAny <ItemRequestOptions>(), It.IsAny <CancellationToken>()), Times.Once);
}
}
}
[TestCategory("Quarantine")] // Not currently working with emulator
public async Task CreateDropAutoscaleContainerStreamApi()
{
DatabaseCore database = (DatabaseInlineCore)await this.cosmosClient.CreateDatabaseAsync(
Guid.NewGuid().ToString());
ThroughputResponse databaseThroughput = await database.ReadThroughputIfExistsAsync(requestOptions : null);
Assert.IsNotNull(databaseThroughput);
Assert.AreEqual(HttpStatusCode.NotFound, databaseThroughput.StatusCode);
string streamContainerId = Guid.NewGuid().ToString();
using (ResponseMessage response = await database.CreateContainerStreamAsync(
new ContainerProperties(streamContainerId, "/pk"),
ThroughputProperties.CreateAutoscaleThroughput(5000)))
{
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
ContainerCore streamContainer = (ContainerInlineCore)database.GetContainer(streamContainerId);
ThroughputResponse autoscaleIfExists = await streamContainer.ReadThroughputIfExistsAsync(requestOptions : null);
Assert.IsNotNull(autoscaleIfExists);
Assert.AreEqual(5000, autoscaleIfExists.Resource.MaxAutoscaleThroughput);
}
}
public async Task ShouldContinueUntilResponseOk()
{
// Setting 3 ranges, first one returns a 304, second returns Ok
MultiRangeMockDocumentClient documentClient = new MultiRangeMockDocumentClient();
CosmosClient client = MockCosmosUtil.CreateMockCosmosClient();
Mock <CosmosClientContext> mockContext = new Mock <CosmosClientContext>();
mockContext.Setup(x => x.ClientOptions).Returns(MockCosmosUtil.GetDefaultConfiguration());
mockContext.Setup(x => x.DocumentClient).Returns(documentClient);
mockContext.Setup(x => x.SerializerCore).Returns(MockCosmosUtil.Serializer);
mockContext.Setup(x => x.Client).Returns(client);
mockContext.Setup(x => x.CreateLink(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())).Returns(new Uri("/dbs/test/colls/test", UriKind.Relative));
ResponseMessage firstResponse = new ResponseMessage(HttpStatusCode.NotModified);
firstResponse.Headers.ETag = "FirstContinuation";
ResponseMessage secondResponse = new ResponseMessage(HttpStatusCode.OK);
secondResponse.Headers.ETag = "SecondContinuation";
mockContext.SetupSequence(x => x.ProcessResourceOperationAsync <ResponseMessage>(
It.IsAny <Uri>(),
It.IsAny <Documents.ResourceType>(),
It.IsAny <Documents.OperationType>(),
It.IsAny <RequestOptions>(),
It.IsAny <ContainerCore>(),
It.IsAny <PartitionKey?>(),
It.IsAny <Stream>(),
It.IsAny <Action <RequestMessage> >(),
It.IsAny <Func <ResponseMessage, ResponseMessage> >(),
It.IsAny <CosmosDiagnosticsContext>(),
It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(firstResponse))
.Returns(Task.FromResult(secondResponse));
DatabaseCore databaseCore = new DatabaseCore(mockContext.Object, "mydb");
StandByFeedIteratorCore iterator = new StandByFeedIteratorCore(
mockContext.Object, new ContainerCore(mockContext.Object, databaseCore, "myColl"), null, 10, new ChangeFeedRequestOptions());
ResponseMessage firstRequest = await iterator.ReadNextAsync();
Assert.IsTrue(firstRequest.Headers.ContinuationToken.Contains(firstResponse.Headers.ETag), "Response should contain the first continuation");
Assert.IsTrue(firstRequest.Headers.ContinuationToken.Contains(secondResponse.Headers.ETag), "Response should contain the second continuation");
Assert.AreEqual(HttpStatusCode.OK, firstRequest.StatusCode);
mockContext.Verify(x => x.ProcessResourceOperationAsync <ResponseMessage>(
It.IsAny <Uri>(),
It.IsAny <Documents.ResourceType>(),
It.IsAny <Documents.OperationType>(),
It.IsAny <RequestOptions>(),
It.IsAny <ContainerCore>(),
It.IsAny <PartitionKey?>(),
It.IsAny <Stream>(),
It.IsAny <Action <RequestMessage> >(),
It.IsAny <Func <ResponseMessage, ResponseMessage> >(),
It.IsAny <CosmosDiagnosticsContext>(),
It.IsAny <CancellationToken>()), Times.Exactly(2));
}
public ExecutorContainerCore(
CosmosClientContext clientContext,
DatabaseCore database,
string containerId) : base(clientContext, database, containerId)
{
this.MockedExecutor
.Setup(e => e.AddAsync(It.IsAny <ItemBatchOperation>(), It.IsAny <ItemRequestOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new TransactionalBatchOperationResult(HttpStatusCode.OK));
}
public void Null_When_OptionsOff()
{
CosmosClientContext context = this.MockClientContext(allowBulkExecution: false);
DatabaseCore db = new DatabaseCore(context, "test");
ContainerCore container = new ContainerCore(context, db, "test");
Assert.IsNull(container.BatchExecutor);
}
public ExecutorWithThrottlingContainerCore(
CosmosClientContext clientContext,
DatabaseCore database,
string containerId) : base(clientContext, database, containerId)
{
this.MockedExecutor
.SetupSequence(e => e.AddAsync(It.IsAny <ItemBatchOperation>(), It.IsAny <ItemRequestOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new BatchOperationResult((HttpStatusCode)StatusCodes.TooManyRequests))
.ReturnsAsync(new BatchOperationResult(HttpStatusCode.OK));
}
public static async Task ClassInitialize(TestContext context)
{
EncryptionTests.client = EncryptionTests.GetClient();
EncryptionTests.databaseCore = (DatabaseInlineCore)await EncryptionTests.client.CreateDatabaseAsync(Guid.NewGuid().ToString());
EncryptionTests.container = await EncryptionTests.databaseCore.CreateContainerAsync(Guid.NewGuid().ToString(), "/PK", 400);
EncryptionTests.containerCore = (ContainerInlineCore)EncryptionTests.container;
EncryptionTests.dekProperties = await CreateDekAsync(EncryptionTests.databaseCore, EncryptionTests.dekId);
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
if (ContextFactory.ConnectionString == null)
{
DatabaseCore.SetDatabaseConnection();
}
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
optionsBuilder.UseLoggerFactory(DatabaseCore.GetLoggerFactory(LogLevel.Error)).UseMySql(ContextFactory.ConnectionString);
}
public void InitializeBatchExecutorForContainer_Null_WhenAllowBulk_False()
{
string databaseId = "db1234";
string crId = "cr42";
CosmosClientContext context = this.CreateMockClientContext();
DatabaseCore db = new DatabaseCore(context, databaseId);
ContainerCore container = new ContainerCore(context, db, crId);
Assert.IsNull(container.BatchExecutor);
}
public static void TestProvider(DataProviderType providerType)
{
DatabaseCore db = DatabaseCore.Create(providerType, @"Data Source=(localdb)\MSSQLLocalDB;Database=ZKTecoTime;User ID=manuel.ortiz;Password=1910Skynet;Pooling=true;Encrypt=False;TrustServerCertificate=False;Trusted_Connection=Yes;");
using (var cn = db.CreateOpenConnection())
{
cn.Open();
cn.Close();
cn.Dispose();
}
}
public AppCore(MainWindow wi)
{
if (dCore == null)
{
dCore = new DatabaseCore(DatabasePath);
}
wi = Wi;
dCore.OpenDataBase();
databaseOpened = true;
}
/// <summary>
/// 获得所有类别名
/// </summary>
/// <returns>所有类别名</returns>
public List <string> GetPartNames()
{
DatabaseCore dc = new DatabaseCore(_sqlCon);
DataTable dt = dc.SelectData("dbo.Parts", null);
List <string> result = new List <string>();
foreach (DataRow dr in dt.Rows)
{
result.Add(dr["PartName"].ToString());
}
return(result);
}
public void Fresh(DatabaseCore accessor)
{
if (accessor == null)
{
return;
}
var data = Fetch(accessor);
if (data != null)
{
Value = data;
}
}
/// <summary>
/// 将数据写入数据库
/// </summary>
/// <param name="dataString"></param>
private static void WriteIntoDatabase(byte[] dataByte, DateTime dateTime, OleDbConnection oleDbCon)
{
DatabaseCore dataCore = new DatabaseCore(oleDbCon);
//数据库列名
string[] colName = { "ID", "Year", "Month", "Day", "Hour", "Minute", "Second",
"WindSpeed(m/s)", "AirTemperayure", "Rasiation(W/m2)",
"WindDirection", "Humidity(%RH)",
"Component2Temperature", "Component3Temperature",
"Component4Temperature", "Component5Temperature", "Component6Temperature", };
//string colString = "Year, Month, Day, Hour, Minute, Second, WindSpeed(m/s), AirTemperayure, Rasiation(W/m2), WindDirection, Humidity(%RH), Component1Temperature, Component2Temperature, Component3Temperature,Component4Temperature, Component5Temperature, Component6Temperature";
//string valueString = "";//要插入的语句
Dictionary <string, string> QXdataDic = new Dictionary <string, string>();
//添加日期数据
int year = dateTime.Year;
int month = dateTime.Month;
int day = dateTime.Day;
int hour = dateTime.Hour;
int minute = dateTime.Minute;
int second = dateTime.Second;
int[] time = { year, month, day, hour, minute, second };
for (int i = 0; i < time.Length; i++)
{
QXdataDic.Add(colName[i + 1], time[i].ToString()); //第一列不添加
}
//添加气象仪数据
int[] index = { 1, 3, 6, 7, 9, 11, 12, 13, 14, 15 }; //有效通道
double[] precision = { 0.1, 0.1, 1.0, 1.0, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, }; //每个有效通道数值的精度
for (int i = 0; i < index.Length; i++)
{
int k = (index[i] + 1) * 2; //前面两个字内容无效, 所以+2 , 但由于dataByte的下标从零开始, 所以要-1 即: (index[i]-1+2), 每个数据占两个字节, 所以*2
int value = (dataByte[k] << 8) + dataByte[k + 1]; //高位左移8位地位 = 实际值
if (value >> 15 == 1) //如果最高位为1, 则取补, 否则不改变
{
value = -(0x10000 - value);
}
double dvalue = value * precision[i]; //取精度
QXdataDic.Add(colName[i + 7], dvalue.ToString());
}
try
{
dataCore.InsertData("MeteorologicalData", QXdataDic); //插入数据
}
catch (Exception ex)
{
throw ex;
}
}
public Class1()
{
_databaseCore = new DatabaseCore();
var serviceCollection = new ServiceCollection();
_databaseCore.OnResourceStartHandler(() =>
{
_serviceProvider = serviceCollection
.AddSingleton(ContextFactory.Instance)
.BuildServiceProvider();
LoadServices();
});
}
public void ValidateUriGenerationForResources()
{
string databaseId = "db1234";
string crId = "cr42";
CosmosClientContext context = this.CreateMockClientContext();
DatabaseCore db = new DatabaseCore(context, databaseId);
Assert.AreEqual(db.LinkUri.OriginalString, "dbs/" + databaseId);
ContainerCore container = new ContainerCore(context, db, crId);
Assert.AreEqual(container.LinkUri.OriginalString, "dbs/" + databaseId + "/colls/" + crId);
}
public async Task UserTests(bool directMode)
{
CosmosClient client = directMode ? DirectCosmosClient : GatewayCosmosClient;
DatabaseCore database = (DatabaseInlineCore)client.GetDatabase(DatabaseId);
List <string> createdIds = new List <string>();
try
{
UserResponse userResponse = await database.CreateUserAsync("BasicQueryUser1");
createdIds.Add(userResponse.User.Id);
userResponse = await database.CreateUserAsync("BasicQueryUser2");
createdIds.Add(userResponse.User.Id);
userResponse = await database.CreateUserAsync("BasicQueryUser3");
createdIds.Add(userResponse.User.Id);
//Read All
List <UserProperties> results = await this.ToListAsync(
database.GetUserQueryStreamIterator,
database.GetUserQueryIterator <UserProperties>,
null,
CosmosBasicQueryTests.RequestOptions
);
CollectionAssert.IsSubsetOf(createdIds, results.Select(x => x.Id).ToList());
//Basic query
List <UserProperties> queryResults = await this.ToListAsync(
database.GetUserQueryStreamIterator,
database.GetUserQueryIterator <UserProperties>,
"select * from T where STARTSWITH(T.id, \"BasicQueryUser\")",
CosmosBasicQueryTests.RequestOptions
);
CollectionAssert.AreEquivalent(createdIds, queryResults.Select(x => x.Id).ToList());
}
finally
{
foreach (string id in createdIds)
{
await database.GetUser(id).DeleteAsync();
}
}
}
private static async Task <DataEncryptionKeyProperties> CreateDekAsync(DatabaseCore databaseCore, string dekId)
{
DataEncryptionKeyResponse dekResponse = await databaseCore.CreateDataEncryptionKeyAsync(
dekId,
CosmosEncryptionAlgorithm.AE_AES_256_CBC_HMAC_SHA_256_RANDOMIZED,
EncryptionTests.metadata1);
Assert.AreEqual(HttpStatusCode.Created, dekResponse.StatusCode);
Assert.IsTrue(dekResponse.RequestCharge > 0);
Assert.IsNotNull(dekResponse.ETag);
DataEncryptionKeyProperties dekProperties = dekResponse.Resource;
Assert.AreEqual(dekResponse.ETag, dekProperties.ETag);
Assert.AreEqual(dekId, dekProperties.Id);
return(dekProperties);
}
private void OnMainStudentFormClosing(object sender, FormClosingEventArgs e)
{
MessageDialog messageDialog = new MessageDialog(@"Bạn thực sự muốn thoát?", MessageDialog.DialogType.YesNo);
messageDialog.SendValueDelegate = delegate(MessageDialog.DialogResultType result)
{
if (result == MessageDialog.DialogResultType.No)
{
e.Cancel = true;
}
else if (result == MessageDialog.DialogResultType.Yes)
{
DatabaseCore.ReleaseConnect();
}
};
messageDialog.ShowDialog();
}