public override async Task <DeviceActivationCommandResponse> ExecuteAsync()
{
var device = await _database.FirstOrDefault(x => x.RegistrationCode.Equals(RegistrationCode.ToUpper()));
if (device == null)
{
return(new DeviceActivationCommandResponse(ActivationStatus.NotFound));
}
if (device.ActivatedOn.HasValue)
{
return(new DeviceActivationCommandResponse(ActivationStatus.NotFound));
}
device.ActivatedOn = DateTime.UtcNow;
device.TeamId = TeamId;
device.TeamDomain = TeamDomain;
device.ChannelId = ChannelId;
device.ChannelName = ChannelName;
device.UserName = UserName;
device.UserId = UserId;
await _database.UpdateItemAsync(device);
return(new DeviceActivationCommandResponse(ActivationStatus.Success));
}
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);
}
public async Task <ActionResult> EditAsync([Bind(Include = "Id,Name,Description,Completed")] Item item)
{
if (ModelState.IsValid)
{
await db.UpdateItemAsync(item.Id, item);
return(RedirectToAction("Index"));
}
return(View(item));
}
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 EditOrderDetail(OrderDTO orderDto)
{
Order orderEntity = new Order
{
Id = orderDto.Id.ToString(),
Created_At = orderDto.Created_At,
//CustomerId = orderDto.OrderCustomer.Id,
OrderCustomer = orderDto.OrderCustomer,
OrdersDetails = orderDto.Details.Select(m => new OrderDetail {
Discount = m.Discount, OrderDetailId = m.Id, OrderId = m.OrderId, ProductId = m.ProductId, Quantity = m.Quantity
}).ToArray(),
ShipAdress = orderDto.shipAdress,
ShipCity = orderDto.shipCity,
ShipCountry = orderDto.shipCountry,
ShipPostalCode = orderDto.shipPostalCode,
TotalAmount = orderDto.TotalAmount
};
await repositoryOrders.UpdateItemAsync(orderEntity.Id, orderEntity);
}
/// <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);
}
