public async Task <ActionResult> EditAsync(string id)
{
if (id == null)
{
return(BadRequest());
}
Item item = await _respository.GetItemAsync(id);
if (item == null)
{
return(NotFound());
}
return(View(item));
}
public async Task <ActionResult> EditAsync(string id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Item item = await db.GetItemAsync(id);
if (item == null)
{
return(HttpNotFound());
}
return(View(item));
}
public async Task <IActionResult> Index(string searchString)
{
var result = await _documentDbRepository.GetItemAsync(searchString);
result.TrashCanStatuses.Sort((x, y) => y.Timestamp.CompareTo(x.Timestamp));
return(View(result));
}
public async Task <Unit> Handle(Request request, CancellationToken cancellationToken)
{
var orderRequest = await _orderRepository.GetItemAsync(request.Id);
orderRequest.Reject();
await _orderRepository.UpdateItemAsync(orderRequest);
return(Unit.Value);
}
private async Task <bool> ToggleBotInChannel(IActivity activity, bool enabled, CancellationToken cancellationToken)
{
// First, check if the user sending the request is a Team Administrator.
if (activity.From.Role == "bot")
{
return(false);
}
// THIS IS NOT THE BEST. I KNOW. I can't figure out how to get the list of admins for a channel.
// (The Teams Bot documentation sucks for advanced users.)
// Only let me and TechOps toggle the bot on and off.
if (activity.From.Name.Contains("TechOps") || activity.From.Name.Contains("Aaron Rosenberger"))
{
string channelId = (string)activity.ChannelData["teamsChannelId"];
string teamId;
try
{
teamId = (string)activity.ChannelData["teamsTeamId"];
}
catch (Exception)
{
Trace.TraceError("Could not get team id.");
teamId = "defaultpartition";
}
_isEnabled = enabled;
TeamsChannelMetadataModel metadata = await _db.GetItemAsync(channelId, teamId, cancellationToken);
bool existsInDb = metadata != null;
if (!existsInDb)
{
metadata = new TeamsChannelMetadataModel
{
Id = channelId,
TeamId = teamId
};
}
metadata.IsEnabled = _isEnabled;
if (existsInDb)
{
await _db.UpdateItemAsync(metadata.Id, metadata, metadata.TeamId, cancellationToken);
}
else
{
await _db.CreateItemAsync(metadata, metadata.TeamId, cancellationToken);
}
return(true);
}
return(false);
}
public async Task <string> GetScore(Activity activity, Match match, CancellationToken cancellationToken)
{
KarmaModel karma;
string response = null;
var mention = Utilities.GetUserMentions(activity).FirstOrDefault();
var entity = match.Groups[1].Value;
if (mention != null)
{
karma = await _db.GetItemAsync(mention.Mentioned.Id, "msteams_user", cancellationToken);
response = $"{mention.Mentioned.Name}'s karma is {karma.Score}";
}
else if (!string.IsNullOrEmpty(entity))
{
karma = await _db.GetItemAsync(entity.ToLower(), "msteams_entity", cancellationToken);
response = $"{entity}'s karma is {karma.Score}";
}
return(response);
}
/// <summary>
/// Retrieves the indicated file.
/// </summary>
/// <param name="id">
/// ID that uniquely identifies the file to be retrieved. The ID is is the key of the
/// metadata stored in DocumentDb.
/// </param>
/// <returns>The file indicated by the specified ID.</returns>
public async Task <HttpResponseMessage> Get(Guid?id)
{
// Check that token contains a user ID
var userId = Thread.CurrentPrincipal == null ? null : Thread.CurrentPrincipal.GetUserIdFromPrincipal();
if (userId == null)
{
return(HandleErrors(GeneralErrorCodes.TokenInvalid("UserId"), HttpStatusCode.Unauthorized));
}
// Make sure user ID is active
var userIdGuid = new Guid(userId);
var user = await _context.Users.FirstOrDefaultAsync(u => u.Id == userIdGuid);
if (user == null || !user.IsActive)
{
return(HandleErrors(GeneralErrorCodes.TokenInvalid("UserId"), HttpStatusCode.Unauthorized));
}
// Make sure there's a tenant associated with the user
if (user.Tenants.Count < 1)
{
return(HandleErrors(GeneralErrorCodes.TokenInvalid("UserId"), HttpStatusCode.Unauthorized));
}
// Validate the argument (invalid Guid's are received as nulls)
if (id == null)
{
return(HandleErrors(ValidationErrorCode.PropertyIsInvalid(nameof(id)), HttpStatusCode.BadRequest));
}
// Retrieve the metadata associated with the specified ID
var metadata = await _documentDb.GetItemAsync(id.ToString());
if (metadata == null || string.IsNullOrWhiteSpace(metadata.BlobStorageContainerName) ||
string.IsNullOrWhiteSpace(metadata.BlobStorageBlobName))
{
return(HandleErrors(EntityErrorCode.EntityNotFound, HttpStatusCode.NotFound));
}
// Make sure the user is authorized (intentionally returns Not Found even though it's an authorization problem)
if (metadata.TenantIds.Count < 1 ||
!metadata.TenantIds.Intersect(user.Tenants.Select(u => u.Id)).Any())
{
return(HandleErrors(EntityErrorCode.EntityNotFound, HttpStatusCode.NotFound));
}
// Retrieve the blob
var stream = new MemoryStream();
BlobDownloadResult result;
try
{
result = await _blobManager.DownloadBlobAsync(stream, _blobStorageConnectionString,
metadata.BlobStorageContainerName, metadata.BlobStorageBlobName);
}
catch (Exception ex)
{
FFLogManager.LogException(ex);
return(HandleErrors(EntityErrorCode.EntityNotFound, HttpStatusCode.NotFound));
}
if (stream.Length == 0)
{
return(HandleErrors(EntityErrorCode.EntityNotFound, HttpStatusCode.NotFound));
}
// Create the response
stream.Position = 0;
var response = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StreamContent(stream)
};
// Determine file name
string filename = result.BlobName;
if (!string.IsNullOrWhiteSpace(metadata.OriginalFileName))
{
var fileInfo = new FileInfo(metadata.OriginalFileName);
if (!string.IsNullOrWhiteSpace(fileInfo.Name))
{
filename = fileInfo.Name;
}
}
// Set response content headers
response.Content.Headers.ContentLength = stream.Length;
response.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
{
FileName = filename,
Size = stream.Length
};
return(response);
}
/// <summary>
/// Responds to a karma request. NOTE: Assumes <paramref name="karmaString"/> is a valid karma string.
/// </summary>
/// <param name="karmaString">A valid karma string.</param>
/// <param name="uniqueId">If the entity given karma was a Teams user, the unique ID for that user</param>
/// <param name="givenName">If the entity given karma was a Teams user, the Given Name for that user</param>
/// <returns>The bot's response including the karma amount difference.</returns>
public async Task <string> GetReplyMessageForKarma(string karmaString, string uniqueId, string givenName, CancellationToken cancellationToken)
{
// We don't want commonly used karma strings to be interpreted as karma, like "C++"
if (KarmaBlacklist.Contains(karmaString.Replace(" ", "")))
{
return(null);
}
// Break down the karma string into parts
Match karmaMatch = GetKarmaRegexMatch(karmaString);
// Get the entity that was given karma
string entityForMessaging = karmaMatch.Groups[1].Value;
string uniqueEntity = givenName ?? Regex.Replace(entityForMessaging, "<.*?>|@|\"|[\\s]", "").ToLower();
// Delta: the karma in pluses or minuses.
string delta = karmaMatch.Groups[2].Value;
// The amount of karma to give or take away.
int deltaLength = delta.Length - 1;
if (delta.Contains("-"))
{
deltaLength *= -1;
}
string id = uniqueId ?? uniqueEntity;
string partition = GetPartitionForKey(karmaString);
KarmaModel karmaItem = await _db.GetItemAsync(id, partition, cancellationToken);
bool existsInDb = karmaItem != null;
if (!existsInDb)
{
karmaItem = new KarmaModel
{
Id = id,
Entity = uniqueEntity,
Partition = partition,
Score = 0
};
}
string replyMessage = string.Empty;
if (deltaLength > 5)
{
// BUZZKILL MODE
deltaLength = 5;
replyMessage += $"{Strings.BuzzkillMode} {Strings.BuzzkillModeMessage} ... ";
}
else if (deltaLength < -5)
{
deltaLength = -5;
replyMessage += $"{Strings.BuzzkillMode} {Strings.BuzzkillModeMessage} ... ";
}
string messageFormat;
if (deltaLength > 0)
{
messageFormat = ReplyMessageIncreasedFormat;
}
else
{
messageFormat = ReplyMessageDecreasedFormat;
}
karmaItem.Score += deltaLength;
replyMessage += string.Format(messageFormat, entityForMessaging, karmaItem.Score);
if (existsInDb)
{
await _db.UpdateItemAsync(id, karmaItem, partition, cancellationToken);
}
else
{
await _db.CreateItemAsync(karmaItem, partition, cancellationToken);
}
return(replyMessage);
}
