/// <summary>
/// Queries for replies posted within a specific time period.
/// </summary>
/// <param name="context">The DynamoDB context used to perform the query.</param>
/// <param name="forumName">The name of the ofrum we're interested in.</param>
/// <param name="threadSubject">Information about the subject we are
/// interested in.</param>
public static async Task FindRepliesPostedWithinTimePeriod(
IDynamoDBContext context,
string forumName,
string threadSubject)
{
string forumId = forumName + "#" + threadSubject;
Console.WriteLine("\nReplies posted within time period:");
DateTime startDate = DateTime.UtcNow - TimeSpan.FromDays(30);
DateTime endDate = DateTime.UtcNow - TimeSpan.FromDays(1);
List <object> times = new List <object>();
times.Add(startDate);
times.Add(endDate);
List <ScanCondition> scs = new List <ScanCondition>();
var sc = new ScanCondition("LastPostedBy", ScanOperator.Between, times.ToArray());
scs.Add(sc);
var cfg = new DynamoDBOperationConfig
{
QueryFilter = scs
};
AsyncSearch <Reply> response = context.QueryAsync <Reply>(forumId, cfg);
IEnumerable <Reply> repliesInAPeriod = await response.GetRemainingAsync();
foreach (Reply r in repliesInAPeriod)
{
Console.WriteLine("{r.Id}\t{r.PostedBy}\t{r.Message}\t{r.ReplyDateTime}");
}
}
/// <summary>
/// Queries a DynamoDB table to find replies posted within the last 15 days.
/// </summary>
/// <param name="context">The DynamoDB context used to perform the query.</param>
/// <param name="forumName">The name of the forum we're interested in.</param>
/// <param name="threadSubject">The thread object containing the query parameters.</param>
public static async Task FindRepliesInLast15Days(
IDynamoDBContext context,
string forumName,
string threadSubject)
{
string replyId = $"{forumName} #{threadSubject}";
DateTime twoWeeksAgoDate = DateTime.UtcNow - TimeSpan.FromDays(15);
List <object> times = new List <object>();
times.Add(twoWeeksAgoDate);
List <ScanCondition> scs = new List <ScanCondition>();
var sc = new ScanCondition("LastPostedBy", ScanOperator.GreaterThan, times.ToArray());
scs.Add(sc);
var cfg = new DynamoDBOperationConfig
{
QueryFilter = scs,
};
AsyncSearch <Reply> response = context.QueryAsync <Reply>(replyId, cfg);
IEnumerable <Reply> latestReplies = await response.GetRemainingAsync();
Console.WriteLine("\nReplies in last 15 days:");
foreach (Reply r in latestReplies)
{
Console.WriteLine($"{r.Id}\t{r.PostedBy}\t{r.Message}\t{r.ReplyDateTime}");
}
}
private void AddManaCostConditions(GetCardRequest request, List <ScanCondition> conditions)
{
LambdaLogger.Log($"Entering: AddManaCostConditions({ JsonConvert.SerializeObject(request) })");
var queryList = new List <Single>();
foreach (var manaCost in request.ManaCostFilter)
{
if (manaCost.Value)
{
queryList.Add(Single.Parse(manaCost.Key.ToString()));
}
}
if (queryList.Contains(Single.Parse("7")))
{
queryList.AddRange(new List <Single> {
Single.Parse("8"), Single.Parse("9"),
Single.Parse("10"), Single.Parse("11"),
Single.Parse("12"), Single.Parse("13"),
Single.Parse("14"), Single.Parse("15")
});
}
LambdaLogger.Log($"Query List: { JsonConvert.SerializeObject(queryList) }");
if (queryList.Any())
{
var objects = queryList.Select(x => (object)x).ToArray();
var condition = new ScanCondition("ManaCost", ScanOperator.In, objects);
conditions.Add(condition);
}
}
public async Task <IList <T> > GetByUserIdAsync <T>(string userId)
{
var condition = new ScanCondition("UserId", ScanOperator.Equal, userId);
var transactions = await ScanAsync <T>(new ScanCondition[] { condition }).GetRemainingAsync();
return(transactions);
}
public async Task <IEnumerable <TranscribeData> > GetLatestDataToTranscribe(DateTime?startDate = null)
{
List <TranscribeData> data = new List <TranscribeData>();
startDate = startDate ?? DateTime.Now.AddDays(-1);
try
{
using (var ctx = GetContext())
{
var dateTimeCond = new ScanCondition(nameof(TranscribeData.TimeStamp),
Amazon.DynamoDBv2.DocumentModel.ScanOperator.GreaterThan,
startDate.Value.Ticks);
var search = ctx.ScanAsync <TranscribeData>(new[] { dateTimeCond }, DyConfig);
var items = await search.GetRemainingAsync();
data.AddRange(items);
}
}
catch (Exception ex)
{
// Log
}
return(data);
}
public async Task <User> GetAUserAsync(Guid userId)
{
var condition = new ScanCondition("UserId", ScanOperator.Equal, userId);
var user = await context.ScanAsync <User>(new List <ScanCondition>() { condition }).GetRemainingAsync();
return(user.First());
}
public async Task <IEnumerable <IApplication> > ListByAccountIdAsync(Guid accountId)
{
var scanCondition = new ScanCondition(nameof(Application.AccountId), ScanOperator.Equal, accountId);
var query = DynamoDBContext.ScanAsync <Application>(new[] { scanCondition });
var apps = await query.GetNextSetAsync();
return(apps);
}
public IEnumerable <T> GetAll <T>(string propertyName, string value) where T : class
{
ScanCondition scan = new ScanCondition(propertyName, Amazon.DynamoDBv2.DocumentModel.ScanOperator.Equal, value);
dbContext = CreateDynamoDBContext();
IEnumerable <T> items = dbContext.Scan <T>(scan);
return(items);
}
public async Task <AnnotationPackage[]> GetPackagesAsync(bool annotated)
{
var scanConditions = new ScanCondition[]
{
new ScanCondition("IsAnnotated", ScanOperator.Equal, annotated)
};
return(await this.GetPackagesAsync(scanConditions).ConfigureAwait(false));
}
public async Task <IList <Book> > Find(string isbnPart)
{
var condition = new ScanCondition(nameof(BookDocument.isbn), ScanOperator.BeginsWith, isbnPart);
var documents = await _dbContext
.ScanAsync <BookDocument>(new[] { condition })
.GetNextSetAsync();
return(documents.Select(Convert).ToList());
}
public async Task <List <WSConnection> > scanAllSubcribers()
{
var condition = new ScanCondition("connectionId", ScanOperator.IsNotNull);
var listCondition = new List <ScanCondition>();
listCondition.Add(condition);
return(await wsContext.ScanAsync <WSConnection>(listCondition));
}
public static async Task <IEnumerable <T> > Where <T>(
this IDynamoDBContext context,
ScanCondition scanCondition = null)
where T : class
{
return(await context.Where <T>(!scanCondition.IsNull()
?new List <ScanCondition> {
scanCondition
}
: null));
}
private static void AssertEquals(Validation validation, ScanCondition actual, ScanCondition expected)
{
validation.IsNotNull(actual, "actual").Check()
.IsNotNull(actual.Values, "value").Check()
.IsNotEmpty(actual.Values, "values not empty").Check()
.IsEqual(actual.Values.Length, 1, "values count").Check()
//check the value of the scan condition
.IsEqual(actual.Operator, expected.Operator, "operator")
.IsEqual(actual.PropertyName, expected.PropertyName, "property name")
.IsEqual(actual.Values.First(), expected.Values.First(), "actual value")
.Check();
}
private static DynamoDBOperationConfig CreateConfigForOnlyActiveContactDetails()
{
var onlyActiveCondition = new ScanCondition(nameof(ContactDetailsEntity.IsActive), ScanOperator.Equal, true);
List <ScanCondition> scanConditions = new List <ScanCondition>
{
onlyActiveCondition
};
return(new DynamoDBOperationConfig()
{
QueryFilter = scanConditions
});
}
private void AddBaseTypeConditions(GetCardRequest request, List <ScanCondition> conditions)
{
LambdaLogger.Log($"Entering: AddBaseTypeConditions({ JsonConvert.SerializeObject(request) })");
var queryList = new List <string>();
foreach (var baseType in request.BaseTypeFilter)
{
if (baseType.Value)
{
queryList.Add(baseType.Key);
}
}
if (queryList.Contains("Creature"))
{
queryList.Add("Artifact Creature");
queryList.Add("Enchantment Creature");
queryList.Add("Enchantment Artifact Creature");
}
else
{
if (queryList.Contains("Artifact"))
{
queryList.Add("Artifact Creature");
}
if (queryList.Contains("Enchantment"))
{
queryList.Add("Enchantment Creature");
}
}
if (queryList.Contains("Planeswalker"))
{
queryList.Add("Legendary Planeswalker");
}
LambdaLogger.Log($"Query List: { JsonConvert.SerializeObject(queryList) }");
if (queryList.Any())
{
var objects = queryList.Select(x => (object)x).ToArray();
var condition = new ScanCondition("BaseType", ScanOperator.In, objects);
conditions.Add(condition);
}
}
public async Task <IAccount> AddOrGetAsync(string name, string emailAddress, string avatarUrl, string gitHubId = null, string googleId = null, string microsoftId = null)
{
if (gitHubId == null && googleId == null && microsoftId == null)
{
throw new Exception("GitHubId, GoogleId or MicrosoftId required for new accounts");
}
ScanCondition scanCondition = null;
if (gitHubId != null)
{
scanCondition = new ScanCondition(nameof(Account.GitHubId), ScanOperator.Equal, gitHubId);
}
else if (googleId != null)
{
scanCondition = new ScanCondition(nameof(Account.GoogleId), ScanOperator.Equal, googleId);
}
else if (microsoftId != null)
{
scanCondition = new ScanCondition(nameof(Account.MicrosoftId), ScanOperator.Equal, microsoftId);
}
var query = DynamoDBContext.ScanAsync <Account>(new[] { scanCondition });
var accounts = await query.GetNextSetAsync();
Account account = null;
if (!accounts.Any())
{
account = new Account()
{
Id = Guid.NewGuid(),
Name = name,
EmailAddress = emailAddress,
AvatarUrl = avatarUrl,
GitHubId = gitHubId,
GoogleId = googleId,
MicrosoftId = microsoftId
};
await DynamoDBContext.SaveAsync(account);
}
else
{
account = accounts.First();
}
return(account);
}
/// <summary>
/// ----------------------------------------------------
/// ***HACK***
/// Review DynamoDB Scan condition!!!
/// ----------------------------------------------------
/// DYNAMO CAN WITH ARRAY CONDITIONS DOES NOT
///
/// IEnumerable<ScanCondition> conditions = scopeNames.Select(sn => new ScanCondition(nameof(sn), ScanOperator.Equal, sn));
///
/// var batch = context.ScanAsync<ApiResourceDynamoDB>(conditions, new DynamoDBOperationConfig
// {
// ConditionalOperator = ConditionalOperatorValues.Or
// });
///
/// ----------------------------------------------------
/// Finds the API resources by scope async.
///
/// var apis =
/// from api in _context.ApiResources
/// where api.Scopes.Where(x => names.Contains(x.Name)).Any()
/// select api;
///
/// see https://github.com/diogodamiani/IdentityServer4.Contrib.MongoDB/blob/6f13fc65c9f06d9d24f8df7cad18fa2a1257072b/src/IdentityServer4.MongoDB/Stores/ResourceStore.cs#L55
/// </summary>
/// <returns>The API resources by scope async.</returns>
/// <param name="scopeNames">Scope names.</param>
public async Task <IEnumerable <ApiResource> > FindApiResourcesByScopeAsync(IEnumerable <string> scopeNames)
{
if (scopeNames == null)
{
return(null);
}
List <ApiResource> response = new List <ApiResource>();
try
{
using (var context = new DynamoDBContext(client, ddbConfig))
{
foreach (var sn in scopeNames)
{
var condition = new ScanCondition(nameof(ApiResourceDynamoDB.ScopeNames), ScanOperator.Contains, sn);
var batch = context.ScanAsync <ApiResourceDynamoDB>(new List <ScanCondition> {
condition
});
while (!batch.IsDone)
{
var dataset = await batch.GetNextSetAsync();
if (dataset.Any())
{
var resources = dataset.Select(items => items.GetApiResource())?.Distinct();
foreach (var i in resources)
{
if (!response.Exists(x => x.Name == i.Name))
{
response.Add(i);
}
}
}
}
}
}
}
catch (Exception ex)
{
logger.LogError(default(EventId), ex, "ResourceRepository.FindApiResourcesByScopeAsync failed");
await Task.FromException(ex);
return(null);
}
return(response);
}
public async Task <IEnumerable <T> > ListByUserId <T>(string id, CancellationToken cancellationToken)
{
var resultList = new List <T>();
using (var context = new DynamoDBContext(_client))
{
var scanCondition = new ScanCondition(nameof(Note.userId), ScanOperator.Equal, id);
var search = context.ScanAsync <T>(new[] { scanCondition }, _configuration);
while (!search.IsDone)
{
var entities = await search.GetNextSetAsync(cancellationToken);
resultList.AddRange(entities);
}
}
return(resultList);
}
/// <summary>
/// Queries the DynamoDB ProductCatalog table for products costing less
/// than zero.
/// </summary>
/// <param name="context">The DynamoDB context object used to perform the
/// query.</param>
public static async Task FindProductsPricedLessThanZero(IDynamoDBContext context)
{
int price = 0;
List <ScanCondition> scs = new List <ScanCondition>();
var sc1 = new ScanCondition("Price", ScanOperator.LessThan, price);
var sc2 = new ScanCondition("ProductCategory", ScanOperator.Equal, "Book");
scs.Add(sc1);
scs.Add(sc2);
AsyncSearch <Book> response = context.ScanAsync <Book>(scs);
IEnumerable <Book> itemsWithWrongPrice = await response.GetRemainingAsync();
Console.WriteLine("\nFindProductsPricedLessThanZero: Printing result.....");
foreach (Book r in itemsWithWrongPrice)
{
Console.WriteLine($"{r.Id}\t{r.Title}\t{r.Price}\t{r.Isbn}");
}
}
private void AddBaseTypeConditions(GetCardRequest request, List <ScanCondition> conditions)
{
LambdaLogger.Log($"Entering: AddBaseTypeConditions({ JsonConvert.SerializeObject(request) })");
var queryList = new List <string>();
foreach (var baseType in request.BaseTypeFilter)
{
if (baseType.Value)
{
queryList.Add(baseType.Key);
}
}
LambdaLogger.Log($"Query List: { JsonConvert.SerializeObject(queryList) }");
if (queryList.Any())
{
var objects = queryList.Select(x => (object)x).ToArray();
var condition = new ScanCondition("BaseType", ScanOperator.In, objects);
conditions.Add(condition);
}
}
public NotFoundException(ScanCondition condition) : base($"{typeof(T)} not found where {condition}")
{
}
public static IEnumerable <ScanCondition> And(this ScanCondition where, ScanCondition toAdd)
{
return(new List <ScanCondition> {
where, toAdd
});
}
public static IEnumerable <ScanCondition> And(this IEnumerable <ScanCondition> where, ScanCondition toAdd)
{
return(where.Append(toAdd));
}
public async Task <TU> FindOneAsync <TU>(ScanCondition where, bool allowNull = true)
{
return(await FindOneAsync <TU>(new[] { where }, allowNull));
}
public static async Task <T> FirstOrDefault <T>(this IDynamoDBContext context, ScanCondition scanCondition)
where T : class
{
return((await context.Where <T>(scanCondition))
.FirstOrDefault());
}
