protected virtual async Task <GetItemResult <T> > GetMessageProperty <T>(Ideas.Shared.ServiceBus.Message message, string propertyName, bool allowNull = false)
{
if (message == null)
{
throw new ArgumentNullException("msg");
}
var result = new GetItemResult <T>();
if (!message.MessageProperties.ContainsKey(propertyName))
{
string errorMessage = $"{ propertyName } not found in message";
result.SetMessageDeadLettered(errorMessage);
await _messageReceiver.DeadLetterAsync(message.LockToken, errorMessage);
}
else
{
object propertyObj = message.MessageProperties[propertyName];
if (propertyObj == null)
{
if (!allowNull)
{
string errorMessage = $"{ propertyName } was null";
_logger.Error("{PropertyName} was empty in Service Bus message", propertyName);
result.SetMessageDeadLettered(errorMessage);
await _messageReceiver.DeadLetterAsync(message.LockToken, errorMessage);
}
// else return null (or default) and don't dead letter
}
else
{
try
{
result.Item = (T)propertyObj;
}
catch (Exception)
{
string errorMessage = $"{ propertyName } was not of type { typeof(T).FullName }";
_logger.Error("{PropertyName} had value {Value}, which was not of the expected type '{Type}", propertyName, propertyObj, typeof(T).FullName);
result.SetMessageDeadLettered(errorMessage);
await _messageReceiver.DeadLetterAsync(message.LockToken, errorMessage);
}
}
}
return(result);
}
protected virtual async Task <GetItemResult <ClaimsPrincipal> > GetMessageOwner(Message message)
{
if (message == null)
{
throw new ArgumentNullException("msg");
}
var ownerClaimsResult = await GetMessageString(message, propertyName : "OwnerClaims");
var result = new GetItemResult <ClaimsPrincipal>();
if (ownerClaimsResult.WasMessageDeadLettered)
{
result.SetMessageDeadLettered(ownerClaimsResult.Errors.FirstOrDefault());
}
else
{
try
{
result.Item = CreatePrincipal(ownerClaimsResult.Item);
_logger.Information("Message owner is {UserName} with email {Email}", result?.Item?.Identity?.Name, result?.Item?.GetEmail());
}
catch (Exception err)
{
string errorMessage = $"Unable to get Owner from token { ownerClaimsResult.Item }: { err.Message }";
_logger.Error(err, "Unable to get Owner from token {Token}: {ErrorMessage}", ownerClaimsResult.Item, err.Message);
result.SetMessageDeadLettered(errorMessage);
await _messageReceiver.DeadLetterAsync(message.LockToken, errorMessage);
}
}
// last fail safe
if (!result.WasMessageDeadLettered && result.Item == null)
{
string errorMessage = $"Unable to get Owner, reason unknown";
_logger.Error(errorMessage);
result.SetMessageDeadLettered(errorMessage);
await _messageReceiver.DeadLetterAsync(message.LockToken, errorMessage);
}
return(result);
}
protected virtual async Task <GetItemResult <Initiative> > GetMessageInitiative(Message message, ClaimsPrincipal owner = null)
{
if (message == null)
{
throw new ArgumentNullException("msg");
}
var initiativeIdResult = await GetMessageProperty <int>(message, propertyName : "InitiativeId");
var result = new GetItemResult <Initiative>();
if (initiativeIdResult.WasMessageDeadLettered)
{
result.SetMessageDeadLettered(initiativeIdResult.Errors.FirstOrDefault());
}
else
{
try
{
_logger.Information("Message is for initiative {InitiativeId}, retrieving initiative...", initiativeIdResult.Item);
// if the remote repositoty factory is populated, we'll use that,
// otherwise we'll just use the default
var ideaRepository = GetInitiativeRepository(owner);
result.Item = await ideaRepository.GetInitiativeAsync(initiativeIdResult.Item);
_logger.Information("Retrieved initiative {InitiativeId}, has title '{Title}'", initiativeIdResult.Item, result?.Item?.Title);
}
catch (Exception err)
{
string errorMessage = $"Unable to get Initiative { initiativeIdResult.Item }: { err.Message }";
_logger.Error(err, "Unable to get Initiative {InitiativeId}: {ErrorMessage}", initiativeIdResult.Item, err.Message);
result.SetMessageDeadLettered(errorMessage);
await _messageReceiver.DeadLetterAsync(message.LockToken, errorMessage);
}
}
return(result);
}