public void ConfigHelper_ReturnsDefault_WhenGettingSupportedActionTypes()
{
var configValue = _configHelper.SupportedActionTypes;
const MessageActionType defaultValue = ConfigHelper.SupportedActionTypesDefault;
Assert.AreEqual(defaultValue, configValue);
}
public Message(object data, object sender, MessageActionType actionType)
{
this.MessageId = Guid.NewGuid();
this.SendDate = DateTime.Now;
this.MessageType = data.GetType();
this.Data = data;
this.Sender = sender;
this.ActionType = actionType;
}
public Message(Location destination, Location origin, string messageContent, string messageAction, MessageType messageType, MessageActionType messageActionType) : this()
{
CreatedDateTime = DateTime.Now;
Destination = destination;
Origin = origin;
Content = messageContent;
Action = messageAction;
MessageType = messageType;
ActionType = messageActionType;
}
private Message CreateBaseMessage(MessageActionType messageAction = MessageActionType.Published, MessageContentType contentType = MessageContentType.JobProfile)
{
var message = A.Fake <Message>();
message.Body = Encoding.ASCII.GetBytes("Some body json object here");
message.UserProperties.Add("ActionType", messageAction.ToString());
message.UserProperties.Add("CType", contentType);
return(message);
}
public Message(Location destination, Location origin, string messageContent, string messageAction, Guid?referenceMessageId, MessageType messageType, MessageActionType messageActionType)
{
CreatedDateTime = DateTime.Now;
Destination = destination;
Origin = origin;
_id = Guid.NewGuid();
Content = messageContent;
ActionType = messageActionType;
Action = messageAction;
ReferenceMessageId = referenceMessageId;
MessageType = messageType;
}
private PatchUniformModel GetPatchUniformModel(MessageActionType messageAction = MessageActionType.Published, Guid?patchUniformId = null)
{
return(new PatchUniformModel
{
JobProfileId = jobProfileId,
Id = patchUniformId ?? uniformId,
Title = "Amended Uniform",
MessageAction = messageAction,
SequenceNumber = 123,
Description = "Amended uniform description",
IsNegative = true,
Url = "/someAmendedUrl",
});
}
public virtual void SendMessage(object data, object sender, MessageActionType actionType)
{
var message = new Message(data, sender, actionType);
if (this.actions.ContainsKey(message.MessageType))
{
if (this.actions.TryGetValue(message.MessageType, out IReadOnlyCollection <Action <Message> > actions))
{
foreach (var action in actions)
{
action(message);
}
}
}
}
public Message(Location destination, Location origin, string messageContent, string messageAction, MessageType messageType, Type contentType, MessageActionType messageActionType) : this()
{
if (contentType is null)
{
contentType = new object().GetType();
}
CreatedDateTime = DateTime.Now;
Destination = destination;
Origin = origin;
Content = messageContent;
Action = messageAction;
MessageType = messageType;
ContentType = contentType.ToString();
ActionType = messageActionType;
}
public Person AddOrUpdate(Person inputPerson)
{
if (inputPerson.LastBroadcastDate == default(DateTime))
{
inputPerson.LastBroadcastDate = inputPerson.AskDate.Value;
}
inputPerson.UpdatedDate = DateTime.UtcNow;
Person person = this.repository.AddOrUpdatePerson(inputPerson, out bool isNewPerson);
MessageActionType action = isNewPerson ? MessageActionType.Add : MessageActionType.Update;
this.messageBus.SendMessage(person, this, action);
return(person);
}
public Phrase AddOrUpdate(Phrase inputPhrase)
{
if (!inputPhrase.OrderId.HasValue)
{
int maxOrderId = this.repository.GetAll()
.Where(p => p.OrderId.HasValue)
.Select(p => p.OrderId.Value)
.DefaultIfEmpty()
.Max();
inputPhrase.OrderId = maxOrderId + 1;
}
Phrase phrase = this.repository.AddOrUpdatePhrase(inputPhrase, out bool isNewPhrase);
MessageActionType action = isNewPhrase ? MessageActionType.Add : MessageActionType.Update;
this.messageBus.SendMessage(phrase, this, action);
return(phrase);
}
private IList <IMessage> CreateMessage(
EntityType entityType,
IEnumerable <DataRow> rows,
MessageActionType actionType = MessageActionType.StarChefEventsUpdated
)
{
IList <IMessage> messages = new List <IMessage>();
foreach (var row in rows)
{
var entityId = Convert.ToInt32(row[0]);
messages.Add(new Fourth.StarChef.Invariables.UpdateMessage(entityId,
this.dbDSN,
(int)actionType,
this.databaseId,
(int)entityType));
}
return(messages);
}
private static IBaseRepository CreateRepository(MessageActionType actionType, string connectionString)
{
switch (actionType)
{
case MessageActionType.ArtifactsPublished:
return(new ArtifactsPublishedRepository(connectionString));
case MessageActionType.ArtifactsChanged:
return(new ArtifactsChangedRepository(connectionString));
case MessageActionType.GenerateChildren:
case MessageActionType.GenerateTests:
case MessageActionType.GenerateUserStories:
return(new GenerateActionsRepository(connectionString));
case MessageActionType.Notification:
return(new NotificationRepository(connectionString));
case MessageActionType.ProjectsChanged:
return(new ProjectsChangedRepository(connectionString));
case MessageActionType.PropertyItemTypesChanged:
return(new PropertyItemTypesChangedRepository(connectionString));
case MessageActionType.UsersGroupsChanged:
return(new UsersGroupsChangedRepository(connectionString));
case MessageActionType.WorkflowsChanged:
return(new WorkflowsChangedRepository(connectionString));
case MessageActionType.Webhooks:
return(new WebhooksRepository(connectionString));
default:
throw new UnsupportedActionTypeException($"Failed to instantiate repository for unsupported Action Type: {actionType}");
}
}
public InvokeAddInCommandAction(MessageActionType type) : base(MessageActionType.InvokeAddInCommand)
{
}
public Message BuildMessageData(Location destination, string messageContent, string messageAction, MessageType messageType, Guid?requestorId, MessageActionType messageActionType, Type contentType)
{
Message response = new Message(
destination: destination,
origin: _process.GetLocation(),
messageContent: messageContent,
messageAction: messageAction,
messageType: messageType,
contentType: contentType,
messageActionType: messageActionType
);
response.ReferenceMessageId = requestorId;
return(response);
}
public Message BuildMessage(Location destination, string content, string action, Type contentType, Guid?referenceMessageId, MessageActionType actionType)
{
Message response = new Message(
destination: destination,
origin: _process.GetLocation(),
messageContent: content,
messageAction: action,
messageType: MessageType.Console,
contentType: contentType,
messageActionType: actionType
);
response.ReferenceMessageId = referenceMessageId;
return(response);
}
public async Task <HttpStatusCode> ProcessAsync(string message, long sequenceNumber, MessageContentType messageContentType, MessageActionType messageAction)
{
switch (messageContentType)
{
case MessageContentType.Environment:
{
var serviceBusMessage = JsonConvert.DeserializeObject <PatchEnvironmentServiceBusModel>(message);
var patchEnvironmentsModel = mapper.Map <PatchEnvironmentsModel>(serviceBusMessage);
patchEnvironmentsModel.MessageAction = messageAction;
patchEnvironmentsModel.SequenceNumber = sequenceNumber;
return(await httpClientService.PatchAsync(patchEnvironmentsModel, "environment").ConfigureAwait(false));
}
case MessageContentType.Location:
{
var serviceBusMessage = JsonConvert.DeserializeObject <PatchLocationServiceBusModel>(message);
var patchLocationModel = mapper.Map <PatchLocationModel>(serviceBusMessage);
patchLocationModel.MessageAction = messageAction;
patchLocationModel.SequenceNumber = sequenceNumber;
return(await httpClientService.PatchAsync(patchLocationModel, "location").ConfigureAwait(false));
}
case MessageContentType.Uniform:
{
var serviceBusMessage = JsonConvert.DeserializeObject <PatchUniformServiceBusModel>(message);
var patchUniformModel = mapper.Map <PatchUniformModel>(serviceBusMessage);
patchUniformModel.MessageAction = messageAction;
patchUniformModel.SequenceNumber = sequenceNumber;
return(await httpClientService.PatchAsync(patchUniformModel, "uniform").ConfigureAwait(false));
}
case MessageContentType.JobProfile:
return(await ProcessJobProfileMessageAsync(message, messageAction, sequenceNumber).ConfigureAwait(false));
default:
break;
}
return(await Task.FromResult(HttpStatusCode.InternalServerError).ConfigureAwait(false));
}
private async Task <HttpStatusCode> ProcessJobProfileMessageAsync(string message, MessageActionType messageAction, long sequenceNumber)
{
var jobProfile = mappingService.MapToSegmentModel(message, sequenceNumber);
switch (messageAction)
{
case MessageActionType.Draft:
case MessageActionType.Published:
var result = await httpClientService.PutAsync(jobProfile).ConfigureAwait(false);
if (result == HttpStatusCode.NotFound)
{
return(await httpClientService.PostAsync(jobProfile).ConfigureAwait(false));
}
return(result);
case MessageActionType.Deleted:
return(await httpClientService.DeleteAsync(jobProfile.DocumentId).ConfigureAwait(false));
default:
throw new ArgumentOutOfRangeException(nameof(messageAction), $"Invalid message action '{messageAction}' received, should be one of '{string.Join(",", Enum.GetNames(typeof(MessageActionType)))}'");
}
}
public async Task <HttpStatusCode> ProcessAsync(string message, long sequenceNumber, MessageContentType messageContentType, MessageActionType messageAction)
{
switch (messageContentType)
{
case MessageContentType.JobProfile:
return(await ProcessJobProfileMessageAsync(message, messageAction, sequenceNumber).ConfigureAwait(false));
default:
break;
}
return(await Task.FromResult(HttpStatusCode.InternalServerError).ConfigureAwait(false));
}
/// <summary>
/// Builds a message with the current process as origin and tags the message with a specific request id (to id the call site)
/// </summary>
/// <param name="destination">The destination for the message.</param>
/// <param name="messageContent">Content of the message.</param>
/// <param name="messageAction">The message action. See MessageDataAction.cs or MessageConsoleAction.cs.</param>
/// <param name="messageType">Type of the message, from MessageType.cs in FrostCommon.</param>
/// <param name="requestorId">The requestor identifier. Send this when you want to identify a return message at a call site.</param>
/// <returns></returns>
public Message BuildMessage(Location destination, string messageContent, string messageAction, MessageType messageType, Guid?requestorId, MessageActionType messageActionType, Type contentType)
{
return(_messageBuilder.BuildMessageData(destination, messageContent, messageAction, messageType, requestorId, messageActionType, contentType));
}
protected MessageAction(MessageActionType type)
{
Type = type;
}
