private static TPayload SafeConvertBack <TPayload>(DynamicTableEntity dte)
{
var payloadType = typeof(TPayload);
if (!_validPropertyNames.ContainsKey(payloadType))
{
lock (payloadType)
{
if (!_validPropertyNames.ContainsKey(payloadType))
{
var properties = payloadType.GetProperties(BindingFlags.Public | BindingFlags.Instance);
_validPropertyNames[payloadType] = properties.Select(p => p.Name).ToList();
}
}
}
var propertyNames = _validPropertyNames[payloadType];
var entityProperties = new Dictionary <string, EntityProperty>();
foreach (var kv in dte.Properties.Where(p => propertyNames.Contains(p.Key)))
{
entityProperties[kv.Key] = kv.Value;
}
var payload = EntityPropertyConverter.ConvertBack <TPayload>(entityProperties, new OperationContext());
return(payload);
}
/// <summary>
/// Get the latest <see cref="Snapshot"/> from storage.
/// </summary>
/// <returns>The most recent <see cref="Snapshot"/> of</returns>
protected override Snapshot Get(Type aggregateRootType, string streamName)
{
// Create the table query.
var rangeQuery = new TableQuery <DynamicTableEntity>().Where
(
TableQuery.CombineFilters
(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, StorageStore <object, object> .GetSafeStorageKey(streamName)),
TableOperators.And,
TableQuery.GenerateFilterCondition("AggregateId", QueryComparisons.Equal, streamName)
)
);
var operationContext = new OperationContext();
Snapshot result = TableStorageStore.ReadableSource.ExecuteQuery(rangeQuery)
#pragma warning disable 0436
.Select(eventData => EntityPropertyConverter.ConvertBack <EventData>(eventData.Properties, operationContext))
#pragma warning restore 0436
.Where(eventData => eventData.AggregateId == streamName)
.OrderByDescending(eventData => eventData.Version)
.Take(1)
.Select(EventDeserialiser.Deserialise)
.SingleOrDefault();
return(result);
}
/// <summary>
/// Gets a collection of <see cref="IEvent{TAuthenticationToken}"/> for the <see cref="IAggregateRoot{TAuthenticationToken}"/> of type <paramref name="aggregateRootType"/> with the ID matching the provided <paramref name="aggregateId"/>.
/// </summary>
/// <param name="aggregateRootType"> <see cref="Type"/> of the <see cref="IAggregateRoot{TAuthenticationToken}"/> the <see cref="IEvent{TAuthenticationToken}"/> was raised in.</param>
/// <param name="aggregateId">The <see cref="IAggregateRoot{TAuthenticationToken}.Id"/> of the <see cref="IAggregateRoot{TAuthenticationToken}"/>.</param>
/// <param name="useLastEventOnly">Loads only the last event<see cref="IEvent{TAuthenticationToken}"/>.</param>
/// <param name="fromVersion">Load events starting from this version</param>
public override IEnumerable <IEvent <TAuthenticationToken> > Get(Type aggregateRootType, Guid aggregateId, bool useLastEventOnly = false, int fromVersion = -1)
{
string streamName = GenerateStreamName(aggregateRootType, aggregateId);
// Create the table query.
var rangeQuery = new TableQuery <DynamicTableEntity>().Where
(
TableQuery.CombineFilters
(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, StorageStore <object, object> .GetSafeStorageKey(streamName)),
TableOperators.And,
TableQuery.GenerateFilterCondition("AggregateId", QueryComparisons.Equal, streamName)
)
);
var operationContext = new OperationContext();
IEnumerable <EventData> query = TableStorageStore.ReadableSource.ExecuteQuery(rangeQuery)
#pragma warning disable 0436
.Select(eventData => EntityPropertyConverter.ConvertBack <EventData>(eventData.Properties, operationContext))
#pragma warning restore 0436
.Where(eventData => eventData.AggregateId == streamName && eventData.Version > fromVersion)
.OrderByDescending(eventData => eventData.Version);
if (useLastEventOnly)
{
query = query.AsQueryable().Take(1);
}
return(query
.Select(eventData => EventDeserialiser.Deserialise(eventData))
.ToList());
}
public async Task <TModel> Get <TModel>(string tableName, string partitionKey, string rowKey)
{
var context = new OperationContext();
var entity = await GetSinglePointResult(tableName, partitionKey, rowKey);
var model = EntityPropertyConverter.ConvertBack <TModel>(entity.Properties, context);
return(model);
}
public async Task <IEnumerable <T> > QueryAsync <T>(IEnumerable <QueryParameter> queryParameters,
IGraphRequestContext graphRequestContext)
{
var info = Get <T>(graphRequestContext);
var results = await info.Table.ExecuteQuerySegmentedAsync(GenerateTableQuery(queryParameters.ToList()), null);
return(results.Results.Select(x => EntityPropertyConverter.ConvertBack <T>(x.Properties, new OperationContext())).ToList());
}
public async Task <Rating> GetRating(string coinId, string userId)
{
TableOperation getOperation = TableOperation.Retrieve <DynamicTableEntity>(coinId, userId);
var result = await this.ratingsTable.ExecuteAsync(getOperation);
var tableEntity = result.Result as DynamicTableEntity;
return(tableEntity == null ? null : EntityPropertyConverter.ConvertBack <Rating>(tableEntity.Properties, new OperationContext()));
}
public async Task <MasternodeStats> GetMasternodeStats(string coinId)
{
TableOperation getOperation = TableOperation.Retrieve <DynamicTableEntity>("coin", coinId);
var result = await this.masternodeStatsTable.ExecuteAsync(getOperation);
var tableEntity = result.Result as DynamicTableEntity;
return(EntityPropertyConverter.ConvertBack <MasternodeStats>(tableEntity.Properties, new OperationContext()));
}
public async Task <TEntity> GetByKeys(string partitionKey, string rowKey, CancellationToken cancellationToken)
{
var dynamicTableEntity = await Get(partitionKey, rowKey, cancellationToken);
if (dynamicTableEntity == null)
{
return(null);
}
return(EntityPropertyConverter.ConvertBack <TEntity>(dynamicTableEntity.Properties, new OperationContext()));
}
public async Task <TEntity> GetByIds(Guid partitionId, Guid rowId, CancellationToken cancellationToken)
{
var dynamicTableEntity = await Get(partitionId.ToString(), rowId.ToString(), cancellationToken);
if (dynamicTableEntity == null)
{
return(null);
}
return(EntityPropertyConverter.ConvertBack <TEntity>(dynamicTableEntity.Properties, new OperationContext()));
}
public override void Get(string id)
{
CloudTableClient tableClient = ProgramNew.storageAccount.CreateCloudTableClient();
CloudTable table = tableClient.GetTableReference(this.GetType().Name);
// Point Query
TableOperation retrieveServiceOperation = TableOperation.Retrieve <ServiceDetail>("NLAG-CT-20190224", "SERVICEDETAILS");
var serviceDetails = table.ExecuteAsync(retrieveServiceOperation).Result;
TableOperation retrieveRehearsalOperation = TableOperation.Retrieve <RehearsalDetail>("NLAG-CT-20190224", "REHEARSALDETAILS");
var rehearsalDetails = table.ExecuteAsync(retrieveRehearsalOperation).Result;
//Range Query on Row Key
TableQuery rangeQuery = new TableQuery().Where(
TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, "NLAG-CT-20190224"),
TableOperators.And,
TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.GreaterThan, "")));
var worshipLeaders = table.ExecuteQuerySegmentedAsync(rangeQuery, null).Result;
foreach (var item in worshipLeaders.Results)
{
if (item.RowKey == "REHEARSALDETAILS")
{
var props = item.Properties;
RehearsalDetail rehearsal = EntityPropertyConverter.ConvertBack <RehearsalDetail>(item.Properties, null);
}
}
;
//Range Query on Partition Key
var rangeQueryPKey = new TableQuery().Where(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.GreaterThan, "NLAG-CT-20190210"));
var pkeys = table.ExecuteQuerySegmentedAsync(rangeQueryPKey, null).Result;
//Partition Scan
TableQuery queryPScan = new TableQuery().Where(
TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, "NLAG-CT-20190217"),
TableOperators.And,
TableQuery.GenerateFilterCondition("AG1", QueryComparisons.Equal, "Manjrekar")));
var ag1Manjrekar = table.ExecuteQuerySegmentedAsync(queryPScan, null).Result;
//Table Scan
TableQuery queryTScan = new TableQuery().Where(
TableQuery.GenerateFilterCondition("AG1", QueryComparisons.Equal, "Manjrekar"));
var ag1ManjrekarTScan = table.ExecuteQuerySegmentedAsync(queryTScan, null).Result;
}
public override void Update(TData data)
{
DynamicTableEntity dynamicTableEntity = CreateTableEntity(data) as DynamicTableEntity;
if (dynamicTableEntity == null)
{
base.Update(data);
return;
}
//Convert the DynamicTableEntity back to original complex object.
TData result = EntityPropertyConverter.ConvertBack <TData>(dynamicTableEntity.Properties, new OperationContext());
Update(new EntityTableEntity <TData>(result));
}
public override IEnumerable <EventData> Get(Guid correlationId)
{
// Create the table query.
var rangeQuery = new TableQuery <DynamicTableEntity>().Where
(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, StorageStore <object, object> .GetSafeStorageKey(correlationId.ToString("N")))
);
var operationContext = new OperationContext();
IEnumerable <EventData> query = CorrelationIdTableStorageStore.ReadableSource.ExecuteQuery(rangeQuery)
.Select(eventData => EntityPropertyConverter.ConvertBack <EventData>(eventData.Properties, operationContext))
.OrderBy(eventData => eventData.Timestamp);
return(query.ToList());
}
public async Task <IEnumerable <Coin> > GetCoins()
{
TableContinuationToken token = null;
var list = new List <Coin>();
do
{
var queryResult = await this.coinsTable.ExecuteQuerySegmentedAsync(new TableQuery <DynamicTableEntity>(), token);
list.AddRange(queryResult.Results.Select(x => EntityPropertyConverter.ConvertBack <Coin>(x.Properties, new OperationContext())));
token = queryResult.ContinuationToken;
} while (token != null);
return(list);
}
public static async Task <TPayload> Unwrap <TPayload>
(this DynamicTableEntity dte, string columnName = Columns.Json)
{
if (dte == null)
{
return(default(TPayload));
}
return(await Task.Factory.StartNew <TPayload>(() =>
{
var payload =
EntityPropertyConverter.ConvertBack <TPayload>
(dte.Properties, new OperationContext());
return payload;
}).ConfigureAwait(false));
}
public override EntityTableEntity <TData> GetByKeyAndRow(Guid rsn)
{
TableOperation searchQuery = TableOperation.Retrieve <DynamicTableEntity>(typeof(TData).FullName, rsn.ToString("N"));
TableResult searchResult = ReadableSource.Execute(searchQuery);
var dynamicTableEntity = searchResult.Result as DynamicTableEntity;
if (dynamicTableEntity == null)
{
return(base.GetByKeyAndRow(rsn));
}
//Convert the DynamicTableEntity back to original complex object.
TData result = EntityPropertyConverter.ConvertBack <TData>(dynamicTableEntity.Properties, new OperationContext());
return(new EntityTableEntity <TData>(result));
}
public async Task <IEnumerable <Rating> > GetRatings(string coinId)
{
TableContinuationToken token = null;
var list = new List <Rating>();
var query = new TableQuery <DynamicTableEntity>();
query.FilterString = $"PartitionKey eq '{coinId}'";
do
{
var queryResult = await this.ratingsTable.ExecuteQuerySegmentedAsync(query, token);
list.AddRange(queryResult.Results.Select(x => EntityPropertyConverter.ConvertBack <Rating>(x.Properties, new OperationContext())));
token = queryResult.ContinuationToken;
} while (token != null);
return(list);
}
public async Task <IEnumerable <T> > QueryAsync <T>(IEnumerable <QueryParameter> queryParameters,
IGraphRequestContext graphRequestContext)
{
var info = Get <T>(graphRequestContext);
var list = new List <T>();
var continuationToken = default(TableContinuationToken);
do
{
var results = await info.Table.ExecuteQuerySegmentedAsync(GenerateTableQuery(queryParameters.ToList()), continuationToken);
list.AddRange(results.Results.Select(x => EntityPropertyConverter.ConvertBack <T>(x.Properties, new OperationContext())).ToList());
continuationToken = results.ContinuationToken;
}while (continuationToken != null);
return(list);
}
