/// <inheritdoc />
public Task <List <T> > Handle(GetRangeRequest <T> request, CancellationToken cancellationToken, RequestHandlerDelegate <List <T> > next)
{
if (request == default)
{
throw new ArgumentNullException(nameof(request));
}
if (next == default)
{
throw new ArgumentNullException(nameof(next));
}
if (!_options.UseScopedLogging)
{
return(Handle());
}
using (request.Scope)
{
return(Handle());
}
async Task <List <T> > Handle()
{
var start = new GetRangeNotification(request.Logger);
await _mediator.Publish(start, cancellationToken).ConfigureAwait(false);
var response = await next().ConfigureAwait(false);
var finish = new GetRangeNotification <T>(response, request.Logger);
await _mediator.Publish(finish, cancellationToken).ConfigureAwait(false);
return(response);
}
}
private async ValueTask <bool> GetNonCachedModels(IDictionary <TId, T?> keyValuePairs, string userId, string name)
{
if (keyValuePairs.All(x => x.Value != default))
{
return(true);
}
var queryRequest = new QueryRequest <T>(name);
var query = await _mediator.Send(queryRequest).ConfigureAwait(false);
var keys = keyValuePairs.Where(x => x.Value == default).Select(x => x.Key).ToArray();
query = query.Where(x => keys.Contains(x.Key));
var getRangeRequest = new GetRangeRequest <T>(name, query, _logger);
var models = await _mediator.Send(getRangeRequest).ConfigureAwait(false);
var values = new List <KeyValuePair <RedisKey, RedisValue> >(models.Count);
var allowed = true;
foreach (var model in models.Where(x => x.Key != null))
{
allowed = SetKey(keyValuePairs, model, userId);
values.Add(new KeyValuePair <RedisKey, RedisValue>(model.Key.ToString(), Serialize(model)));
}
if (values.Any(x => !IsNullOrWhiteSpace(x.Key)))
{
await _database.StringSetAsync(values.Where(x => !IsNullOrWhiteSpace(x.Key)).ToArray(), flags: FireAndForget).ConfigureAwait(false);
}
return(allowed);
}
private Packet GetRange(GetRangeRequest req)
{
var res = new GetRangeResponse();
try
{
var calendarItems = new CalendarItemCollection();
var calendarFolder = _outlookApp.Session.GetDefaultFolder(Outlook.OlDefaultFolders.olFolderCalendar);
var filter = string.Format("[End] > '{0}' and [Start] < '{1}'", req.Start.ToString("g"), req.End.ToString("g"));
var appoItems = calendarFolder.Items.Restrict(filter);
foreach (Outlook.AppointmentItem appoItem in appoItems)
{
if (appoItem.RecurrenceState != Outlook.OlRecurrenceState.olApptNotRecurring)
{
continue;
}
// filterでうまくフィルタできなかったことがあるので、ここで再チェックする
if ((appoItem.End >= req.Start) && (appoItem.Start < req.End))
{
_appointmentItems.Add(appoItem);
var calendarItem = CreateCalendarItem(appoItem);
calendarItems.Add(calendarItem);
}
}
res.CalendarItems = calendarItems;
}
catch (Exception ex)
{
res.ErrorMessage = ex.Message;
}
return(res);
}
public async Task <IActionResult> GetAssets(
[SwaggerParameter("The query options", Required = true), Required] ODataQueryOptions <Asset> options,
CancellationToken cancellationToken)
{
var queryRequest = new QueryRequest <Asset>(nameof(MongoDB));
var query = await _mediator.Send(queryRequest, cancellationToken).ConfigureAwait(false);
try
{
query = (IQueryable <Asset>)options.ApplyTo(query);
}
catch (ODataException e)
{
ModelState.AddModelError(nameof(options), e.Message);
return(BadRequest(ModelState));
}
if (!User.IsInRole("Admin"))
{
query = query.Where(x => x.CreatedBy == Guid.Parse(User.FindFirstValue(Sub)));
}
var getRangeRequest = new GetRangeRequest <Asset>(nameof(MongoDB), query, _logger);
var response = await _mediator.Send(getRangeRequest, cancellationToken).ConfigureAwait(false);
var notification = new GetRangeNotification <Asset, Guid>(response.ToDictionary(x => x.Id));
await _mediator.Publish(notification, cancellationToken).ConfigureAwait(false);
return(Ok(response));
}
public static void GetRange()
{
Console.WriteLine("Start get range...");
PrepareTable();
PrepareData();
OTSClient otsClient = Config.GetClient();
// 读取 (0, INF_MIN)到(100, INF_MAX)这个范围内的所有行
PrimaryKey inclusiveStartPrimaryKey = new PrimaryKey();
inclusiveStartPrimaryKey.Add("pk0", new ColumnValue(0));
inclusiveStartPrimaryKey.Add("pk1", ColumnValue.INF_MIN);
PrimaryKey exclusiveEndPrimaryKey = new PrimaryKey();
exclusiveEndPrimaryKey.Add("pk0", new ColumnValue(100));
exclusiveEndPrimaryKey.Add("pk1", ColumnValue.INF_MAX);
GetRangeRequest request = new GetRangeRequest(TableName, GetRangeDirection.Forward, inclusiveStartPrimaryKey, exclusiveEndPrimaryKey);
GetRangeResponse response = otsClient.GetRange(request);
IList <RowDataFromGetRange> rows = response.RowDataList;
PrimaryKey nextStartPrimaryKey = response.NextPrimaryKey;
while (nextStartPrimaryKey != null)
{
request = new GetRangeRequest(TableName, GetRangeDirection.Forward, nextStartPrimaryKey, exclusiveEndPrimaryKey);
response = otsClient.GetRange(request);
nextStartPrimaryKey = response.NextPrimaryKey;
foreach (RowDataFromGetRange row in response.RowDataList)
{
rows.Add(row);
}
}
foreach (RowDataFromGetRange row in rows)
{
Console.WriteLine("-----------------");
foreach (KeyValuePair <string, ColumnValue> entry in row.PrimaryKey)
{
Console.WriteLine(entry.Key + ":" + PrintColumnValue(entry.Value));
}
foreach (KeyValuePair <string, ColumnValue> entry in row.Attribute)
{
Console.WriteLine(entry.Key + ":" + PrintColumnValue(entry.Value));
}
Console.WriteLine("-----------------");
}
Console.WriteLine("TotalRowsRead: " + rows.Count);
}
public static void GetRange()
{
Console.WriteLine("Start get range...");
PrepareTable();
PrepareData();
OTSClient otsClient = Config.GetClient();
// 读取 (0, INF_MIN)到(100, INF_MAX)这个范围内的所有行
PrimaryKey inclusiveStartPrimaryKey = new PrimaryKey
{
{ "pk0", new ColumnValue(0) },
{ "pk1", ColumnValue.INF_MIN }
};
PrimaryKey exclusiveEndPrimaryKey = new PrimaryKey
{
{ "pk0", new ColumnValue(100) },
{ "pk1", ColumnValue.INF_MAX }
};
GetRangeRequest request = new GetRangeRequest(TableName, GetRangeDirection.Forward, inclusiveStartPrimaryKey, exclusiveEndPrimaryKey);
GetRangeResponse response = otsClient.GetRange(request);
IList <Row> rows = response.RowDataList;
PrimaryKey nextStartPrimaryKey = response.NextPrimaryKey;
while (nextStartPrimaryKey != null)
{
request = new GetRangeRequest(TableName, GetRangeDirection.Forward, nextStartPrimaryKey, exclusiveEndPrimaryKey);
response = otsClient.GetRange(request);
nextStartPrimaryKey = response.NextPrimaryKey;
foreach (var row in response.RowDataList)
{
rows.Add(row);
}
}
foreach (var row in rows)
{
PrintRow(row);
}
Console.WriteLine("TotalRowsRead: " + rows.Count);
}
public IEnumerable <Row> GetRangeIterator(
string tableName,
GetRangeDirection direction,
PrimaryKey inclusiveStartPrimaryKey,
PrimaryKey exclusiveEndPrimaryKey,
CapacityUnit consumedCapacityUnitCounter,
HashSet <string> columnsToGet = null,
int?count = null,
IColumnCondition condition = null)
{
int?leftCount = count;
if (leftCount != null && leftCount < 0)
{
throw new OTSClientException("the value of count must be larger than 0");
}
PrimaryKey nextStartPrimaryKey = inclusiveStartPrimaryKey;
while (nextStartPrimaryKey != null)
{
var request = new GetRangeRequest(
tableName, direction, nextStartPrimaryKey, exclusiveEndPrimaryKey,
columnsToGet, leftCount, condition);
var response = GetRange(request);
consumedCapacityUnitCounter.Read += response.ConsumedCapacityUnit.Read;
nextStartPrimaryKey = response.NextPrimaryKey;
foreach (var rowData in response.RowDataList)
{
yield return(rowData);
}
if (leftCount != null)
{
leftCount -= response.RowDataList.Count;
if (leftCount <= 0)
{
break;
}
}
}
}
/// <summary>
/// 从索引表中读取数据
/// </summary>
public static void GetRangeFromIndexTable()
{
Console.WriteLine("Start getRange from index...");
OTSClient otsClient = Config.GetClient();
// 指定第一主键Col1的值，进行扫描
PrimaryKey inclusiveStartPrimaryKey = new PrimaryKey
{
{ Col1, new ColumnValue("Col1Value") },
{ Pk1, ColumnValue.INF_MIN },
{ Pk2, ColumnValue.INF_MIN }
};
PrimaryKey exclusiveEndPrimaryKey = new PrimaryKey
{
{ Col1, new ColumnValue("Col1Value") },
{ Pk1, ColumnValue.INF_MAX },
{ Pk2, ColumnValue.INF_MAX }
};
GetRangeRequest request = new GetRangeRequest(IndexName, GetRangeDirection.Forward, inclusiveStartPrimaryKey, exclusiveEndPrimaryKey);
GetRangeResponse response = otsClient.GetRange(request);
IList <Row> rows = response.RowDataList;
PrimaryKey nextStartPrimaryKey = response.NextPrimaryKey;
while (nextStartPrimaryKey != null)
{
request = new GetRangeRequest(TableName, GetRangeDirection.Forward, nextStartPrimaryKey, exclusiveEndPrimaryKey);
response = otsClient.GetRange(request);
nextStartPrimaryKey = response.NextPrimaryKey;
foreach (var row in response.RowDataList)
{
rows.Add(row);
}
}
foreach (var row in rows)
{
PrintRow(row);
}
Console.WriteLine("TotalRowsRead: " + rows.Count);
}
public void TestAPIWithParameter(string apiName)
{
var tableName = TestContext.tableName;
var pkSchema = TestContext.pkSchema;
var reservedThroughput = TestContext.reservedThroughput;
var primaryKey = TestContext.primaryKey;
var attribute = TestContext.attribute;
var condition = TestContext.condition;
var startPrimaryKey = TestContext.startPrimaryKey;
var endPrimaryKey = TestContext.endPrimaryKey;
var putRowConsumed = TestContext.putRowConsumed;
var getRowConsumed = TestContext.getRowConsumed;
var updateRowConsumed = TestContext.updateRowConsumed;
var deleteRowConsumed = TestContext.deleteRowConsumed;
var getRangeConsumed = TestContext.getRangeConsumed;
var updateOfAttributeForPut = TestContext.updateOfAttributeForPut;
var updateOfAttributeForDelete = TestContext.updateOfAttributeForDelete;
var columnsToGet = TestContext.columnsToGet;
var limit = TestContext.limit;
var direction = TestContext.direction;
var tableMeta = new TableMeta(tableName, pkSchema);
switch (apiName)
{
case "CreateTable":
var request0 = new CreateTableRequest(tableMeta, reservedThroughput);
OTSClient.CreateTable(request0);
return;
case "ListTable":
var request1 = new ListTableRequest();
var response1 = OTSClient.ListTable(request1);
Assert.AreEqual(new List <string>()
{
tableName
}, response1.TableNames);
return;
case "UpdateTable":
var request2 = new UpdateTableRequest(tableName, reservedThroughput);
var response2 = OTSClient.UpdateTable(request2);
if (reservedThroughput.Read.HasValue && reservedThroughput.Write.HasValue)
{
AssertCapacityUnit(
reservedThroughput,
response2.ReservedThroughputDetails.CapacityUnit);
}
Assert.IsTrue(response2.ReservedThroughputDetails.LastDecreaseTime >= 0);
Assert.IsTrue(response2.ReservedThroughputDetails.LastIncreaseTime >= 0);
Assert.IsTrue(response2.ReservedThroughputDetails.NumberOfDecreasesToday >= 0);
return;
case "DeleteTable":
var request3 = new DeleteTableRequest(tableName);
OTSClient.DeleteTable(request3);
var request31 = new ListTableRequest();
var response31 = OTSClient.ListTable(request31);
Assert.AreEqual(new List <string>()
{
}, response31.TableNames);
return;
case "DescribeTable":
var request4 = new DescribeTableRequest(tableName);
var response4 = OTSClient.DescribeTable(request4);
Assert.AreEqual(tableName, response4.TableMeta.TableName);
AssertPrimaryKeySchema(pkSchema, response4.TableMeta.PrimaryKeySchema);
AssertCapacityUnit(reservedThroughput, response4.ReservedThroughputDetails.CapacityUnit);
Assert.IsTrue(response4.ReservedThroughputDetails.LastDecreaseTime >= 0);
Assert.IsTrue(response4.ReservedThroughputDetails.LastIncreaseTime >= 0);
Assert.IsTrue(response4.ReservedThroughputDetails.NumberOfDecreasesToday >= 0);
return;
case "PutRow":
var request5 = new PutRowRequest(tableName, condition, primaryKey, attribute);
var response5 = OTSClient.PutRow(request5);
AssertCapacityUnit(putRowConsumed, response5.ConsumedCapacityUnit);
return;
case "GetRow":
var request6 = new GetRowRequest(tableName, primaryKey, columnsToGet);
var response6 = OTSClient.GetRow(request6);
AssertPrimaryKey(primaryKey, response6.PrimaryKey, columnsToGet);
AssertAttribute(attribute, response6.Attribute, columnsToGet);
AssertCapacityUnit(getRowConsumed, response6.ConsumedCapacityUnit);
return;
case "DeleteRow":
var request7 = new DeleteRowRequest(tableName, condition, primaryKey);
var response7 = OTSClient.DeleteRow(request7);
AssertCapacityUnit(deleteRowConsumed, response7.ConsumedCapacityUnit);
var request71 = new GetRowRequest(tableName, primaryKey);
var response71 = OTSClient.GetRow(request71);
AssertPrimaryKey(new PrimaryKey(), response71.PrimaryKey);
AssertAttribute(new AttributeColumns(), response71.Attribute);
return;
case "UpdateRow_Put":
var request8 = new UpdateRowRequest(tableName, condition, primaryKey, updateOfAttributeForPut);
var response8 = OTSClient.UpdateRow(request8);
AssertCapacityUnit(updateRowConsumed, response8.ConsumedCapacityUnit);
var request81 = new GetRowRequest(tableName, primaryKey);
var response81 = OTSClient.GetRow(request81);
AssertPrimaryKey(primaryKey, response81.PrimaryKey);
AssertAttribute(attribute, response81.Attribute);
AssertCapacityUnit(getRowConsumed, response81.ConsumedCapacityUnit);
return;
case "UpdateRow_Delete":
var request9 = new UpdateRowRequest(tableName, condition, primaryKey, updateOfAttributeForDelete);
var response9 = OTSClient.UpdateRow(request9);
AssertCapacityUnit(deleteRowConsumed, response9.ConsumedCapacityUnit);
var request91 = new GetRowRequest(tableName, primaryKey);
var response91 = OTSClient.GetRow(request91);
// Don't assert primary key
AssertAttribute(new AttributeColumns(), response91.Attribute);
return;
case "BatchGetRow":
var request11 = new BatchGetRowRequest();
request11.Add(tableName, new List <PrimaryKey>()
{
primaryKey
}, columnsToGet);
var response11 = OTSClient.BatchGetRow(request11);
Assert.AreEqual(1, response11.RowDataGroupByTable.Count);
Assert.IsTrue(response11.RowDataGroupByTable.ContainsKey(tableName));
Assert.AreEqual(1, response11.RowDataGroupByTable[tableName].Count);
if (!response11.RowDataGroupByTable[tableName][0].IsOK)
{
throw new OTSServerException(apiName, HttpStatusCode.OK,
response11.RowDataGroupByTable[tableName][0].ErrorCode,
response11.RowDataGroupByTable[tableName][0].ErrorMessage);
}
AssertPrimaryKey(primaryKey, response11.RowDataGroupByTable[tableName][0].PrimaryKey);
AssertAttribute(attribute, response11.RowDataGroupByTable[tableName][0].Attribute);
AssertCapacityUnit(getRowConsumed, response11.RowDataGroupByTable[tableName][0].Consumed);
return;
case "BatchWriteRow_Put":
var request12 = new BatchWriteRowRequest();
var rowChanges = new RowChanges();
rowChanges.AddPut(condition, primaryKey, attribute);
request12.Add(tableName, rowChanges);
var response12 = OTSClient.BatchWriteRow(request12);
Assert.AreEqual(1, response12.TableRespones.Count);
Assert.IsTrue(response12.TableRespones.ContainsKey(tableName));
Assert.AreEqual(1, response12.TableRespones[tableName].PutResponses.Count);
Assert.AreEqual(0, response12.TableRespones[tableName].UpdateResponses.Count);
Assert.AreEqual(0, response12.TableRespones[tableName].DeleteResponses.Count);
if (response12.TableRespones[tableName].PutResponses[0].IsOK)
{
AssertCapacityUnit(putRowConsumed,
response12.TableRespones[tableName].PutResponses[0].Consumed);
}
else
{
throw new OTSServerException("/BatchWriteRow", HttpStatusCode.OK,
response12.TableRespones[tableName].PutResponses[0].ErrorCode,
response12.TableRespones[tableName].PutResponses[0].ErrorMessage);
}
var request121 = new GetRowRequest(tableName, primaryKey);
var response121 = OTSClient.GetRow(request121);
AssertPrimaryKey(primaryKey, response121.PrimaryKey);
AssertAttribute(attribute, response121.Attribute);
AssertCapacityUnit(getRowConsumed, response121.ConsumedCapacityUnit);
return;
case "BatchWriteRow_Update":
var request13 = new BatchWriteRowRequest();
var rowChanges2 = new RowChanges();
rowChanges2.AddUpdate(condition, primaryKey, updateOfAttributeForPut);
request13.Add(tableName, rowChanges2);
var response13 = OTSClient.BatchWriteRow(request13);
Assert.AreEqual(1, response13.TableRespones.Count);
Assert.IsTrue(response13.TableRespones.ContainsKey(tableName));
Assert.AreEqual(0, response13.TableRespones[tableName].PutResponses.Count);
Assert.AreEqual(1, response13.TableRespones[tableName].UpdateResponses.Count);
Assert.AreEqual(0, response13.TableRespones[tableName].DeleteResponses.Count);
if (response13.TableRespones[tableName].UpdateResponses[0].IsOK)
{
AssertCapacityUnit(updateRowConsumed,
response13.TableRespones[tableName].UpdateResponses[0].Consumed);
}
else
{
throw new OTSServerException("/BatchWriteRow", HttpStatusCode.OK,
response13.TableRespones[tableName].UpdateResponses[0].ErrorCode,
response13.TableRespones[tableName].UpdateResponses[0].ErrorMessage);
}
var request131 = new GetRowRequest(tableName, primaryKey);
var response131 = OTSClient.GetRow(request131);
AssertPrimaryKey(primaryKey, response131.PrimaryKey);
AssertAttribute(attribute, response131.Attribute);
AssertCapacityUnit(getRowConsumed, response131.ConsumedCapacityUnit);
return;
case "BatchWriteRow_Delete":
var request14 = new BatchWriteRowRequest();
var rowChanges3 = new RowChanges();
rowChanges3.AddDelete(condition, primaryKey);
request14.Add(tableName, rowChanges3);
var response14 = OTSClient.BatchWriteRow(request14);
Assert.AreEqual(1, response14.TableRespones.Count);
Assert.IsTrue(response14.TableRespones.ContainsKey(tableName));
Assert.AreEqual(0, response14.TableRespones[tableName].PutResponses.Count);
Assert.AreEqual(0, response14.TableRespones[tableName].UpdateResponses.Count);
Assert.AreEqual(1, response14.TableRespones[tableName].DeleteResponses.Count);
if (response14.TableRespones[tableName].DeleteResponses[0].IsOK)
{
AssertCapacityUnit(deleteRowConsumed,
response14.TableRespones[tableName].DeleteResponses[0].Consumed);
}
else
{
throw new OTSServerException("/BatchWriteRow", HttpStatusCode.OK,
response14.TableRespones[tableName].DeleteResponses[0].ErrorCode,
response14.TableRespones[tableName].DeleteResponses[0].ErrorMessage);
}
var request141 = new GetRowRequest(tableName, primaryKey);
var response141 = OTSClient.GetRow(request141);
AssertPrimaryKey(new PrimaryKey(), response141.PrimaryKey);
AssertAttribute(new AttributeColumns(), response141.Attribute);
return;
case "GetRange":
var request15 = new GetRangeRequest(tableName, direction,
startPrimaryKey, endPrimaryKey,
columnsToGet, limit);
var response15 = OTSClient.GetRange(request15);
Assert.AreEqual(1, response15.RowDataList.Count);
Assert.AreEqual(null, response15.NextPrimaryKey);
AssertCapacityUnit(getRangeConsumed, response15.ConsumedCapacityUnit);
AssertPrimaryKey(primaryKey, response15.RowDataList[0].PrimaryKey, columnsToGet);
AssertAttribute(attribute, response15.RowDataList[0].Attribute, columnsToGet);
return;
default:
throw new Exception(String.Format("invalid api name: {0}", apiName));
}
}
/// <summary>
/// GetRange的异步版本。
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public Task <GetRangeResponse> GetRangeAsync(GetRangeRequest request)
{
return(CallAsync <GetRangeRequest, GetRangeResponse>("/GetRange", request));
}
/// <summary>
/// 根据范围条件获取多行数据。
/// </summary>
/// <param name="request">请求实例</param>
/// <returns>响应实例</returns>
public GetRangeResponse GetRange(GetRangeRequest request)
{
return(GetResponseFromAsyncTask(GetRangeAsync(request)));
}
