public async Task <OpResults <Value> > GetGramerciesByRecipientIdAsync(string recipientId)
{
OpResults <Value> results = new OpResults <Value>();
try
{
Value result = await _faunaClient.Query(
Map(
Paginate(
Match(
Index("user_gramercy"),
recipientId,
(int)Constants.Enums.GramercyStatus.Approved
)
),
Lambda(
"gramercy",
Get(
Var("gramercy")
)
)
)
);
Value[] data = result.At("data").To <Value[]>().Value;
results.Results = data.ToList();
}
catch (Exception ex)
{
results.FromException(ex);
}
return(results);
}
public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] HttpRequest req,
ILogger log)
{
log.LogInformation($"PendingGramercies executed at: {DateTime.UtcNow}");
var result = await _tokenProvider.ValidateToken(req);
try
{
if (result.Status == AccessTokenStatus.Valid &&
result.Principal.IsInRole(moderatorRoleName))
{
GramercyManager gramercyManager = new GramercyManager();
OpResults <Gramercy> gramercyResults = await gramercyManager.GetPendingGramerciesAsync();
if (gramercyResults.Code != Constants.Enums.OperationResultCode.Success)
{
log.LogInformation($"PendingGramercies error: {gramercyResults.Message}");
return(new BadRequestResult());
}
return(new JsonResult(gramercyResults.Results));
}
else
{
return(new UnauthorizedResult());
}
}
finally
{
log.LogInformation($"PendingGramercies completed at: {DateTime.UtcNow}");
}
}
protected internal override void AddBin(Dictionary<string, object> bins, string name, object value)
{
object prev;
if (bins.TryGetValue(name, out prev))
{
// Multiple values returned for the same bin.
if (prev is OpResults)
{
// List already exists. Add to it.
OpResults list = (OpResults)prev;
list.Add(value);
}
else
{
// Make a list to store all values.
OpResults list = new OpResults();
list.Add(prev);
list.Add(value);
bins[name] = list;
}
}
else
{
bins[name] = value;
}
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] HttpRequest req,
ILogger log)
{
log.LogInformation($"GramerciesByUser executed at: {DateTime.UtcNow}");
string recipientId = req.Query["recipientId"];
if (string.IsNullOrEmpty(recipientId))
{
return(new JsonResult(new List <Gramercy>()));
}
try
{
GramercyManager gramercyManager = new GramercyManager();
OpResults <Gramercy> gramercyResults = await gramercyManager.GetGramerciesByRecipientIdAsync(recipientId);
if (gramercyResults.Code != Constants.Enums.OperationResultCode.Success)
{
log.LogInformation($"GramerciesByUser error: recipient: {recipientId} | {gramercyResults.Message}");
}
return(new JsonResult(gramercyResults.Results));
}
finally
{
log.LogInformation($"GramerciesByUser completed at: {DateTime.UtcNow}");
}
}
public async Task <OpResult <Gramercy> > GetRandomGramercyAsync(string twitterId)
{
OpResult <Gramercy> result = new OpResult <Gramercy>();
try
{
FaunaContext faunaContext = new FaunaContext();
OpResults <Value> userGrammerciesResults = await faunaContext.GetGramerciesByRecipientIdAsync(twitterId);
if (userGrammerciesResults.Code != Constants.Enums.OperationResultCode.Success)
{
result.CopyFrom(userGrammerciesResults);
return(result);
}
if (userGrammerciesResults.Results.Count() > 0)
{
Random rando = new Random();
result.Result = userGrammerciesResults.Results
.ElementAt(rando.Next(0, userGrammerciesResults.Results.Count() - 1))
.ToGramercy();
}
}
catch (Exception ex)
{
result.FromException(ex);
}
return(result);
}
public async Task <OpResults <Value> > GetPendingGramerciesAsync()
{
OpResults <Value> results = new OpResults <Value>();
try
{
Value pendingResults = await _faunaClient.Query(
Map(
Paginate(
Match(
Index("status_gramercy"),
(int)Constants.Enums.GramercyStatus.Pending
)
),
Lambda(
"gramercy",
Get(
Var("gramercy")
)
)
)
);
Value heldResults = await _faunaClient.Query(
Map(
Paginate(
Match(
Index("status_gramercy"),
(int)Constants.Enums.GramercyStatus.Hold
)
),
Lambda(
"gramercy",
Get(
Var("gramercy")
)
)
)
);
List <Value> data = pendingResults.At("data").To <Value[]>().Value.ToList();
data.AddRange(heldResults.At("data").To <Value[]>().Value.ToList());
results.Results = data;
}
catch (Exception ex)
{
results.FromException(ex);
}
return(results);
}
public async Task <OperationResult> SendAnonymousGramerciesAsync()
{
OperationResult result = new OperationResult();
try
{
// Use the FaunaDbContext to get all non-sent gramercies with:
// 1. isRelayed = false
// 2. senderHandle = null
FaunaContext faunaContext = new FaunaContext();
OpResults <Value> unsentGramercyResults = await faunaContext.GetUnsentGramerciesAsync();
if (unsentGramercyResults.Code != Constants.Enums.OperationResultCode.Success)
{
result.CopyFrom(unsentGramercyResults);
return(result);
}
int unsentGramercies = unsentGramercyResults.Results.Count();
if (unsentGramercies > 0)
{
TwitterClient twitterClient = new TwitterClient();
// For each gramercy, send a tweet and record isRelayed = true
foreach (Value gramercyValue in unsentGramercyResults.Results)
{
Gramercy gramercy = gramercyValue.ToGramercy();
string message = $"Hey @{gramercy.RecipientHandle}, someone thinks you're #awesum! {gramercy.Message}";
OperationResult sendResult = twitterClient.SendTweet(message);
if (sendResult.Code == Constants.Enums.OperationResultCode.Success)
{
gramercy.IsRelayed = true;
await faunaContext.SaveGramercyAsync(gramercy, gramercyValue, true);
}
}
}
}
catch (Exception ex)
{
result.FromException(ex);
}
return(result);
}
public async Task <OpResults <Gramercy> > GetGramerciesByRecipientIdAsync(string recipientId)
{
OpResults <Gramercy> results = new OpResults <Gramercy>();
try
{
FaunaContext faunaContext = new FaunaContext();
OpResults <Value> userGramercyResults = await faunaContext.GetGramerciesByRecipientIdAsync(recipientId);
if (userGramercyResults.Code != Constants.Enums.OperationResultCode.Success)
{
results.CopyFrom(userGramercyResults);
return(results);
}
results.Results = userGramercyResults.Results.Select(s => s.ToGramercy()).ToList();
}
catch (Exception ex)
{
results.FromException(ex);
}
return(results);
}
public async Task <OpResults <Gramercy> > GetPendingGramerciesAsync()
{
OpResults <Gramercy> results = new OpResults <Gramercy>();
try
{
FaunaContext faunaContext = new FaunaContext();
OpResults <Value> pendingGramercyResults = await faunaContext.GetPendingGramerciesAsync();
if (pendingGramercyResults.Code != Constants.Enums.OperationResultCode.Success)
{
results.CopyFrom(pendingGramercyResults);
return(results);
}
results.Results = pendingGramercyResults.Results.Select(s => s.ToGramercy()).ToList();
}
catch (Exception ex)
{
results.FromException(ex);
}
return(results);
}
