public async Task StoreTenantInfoAsync(TenantInformation tenantInfo)
{
await _dataStorageManager.StoreAsync(
DataStorageKey.CurrentSession_TenantInfo,
_objectMapper.Map <TenantInformationPersistanceModel>(tenantInfo)
);
}
public static async Task Send(ActionMessage message, TenantInformation tenant, IWorkflowMessagingProcessor workflowMessagingProcessor)
{
Logger.Log($"Sending {message.ActionType} message with transaction ID '{message.TransactionId}' for tenant '{tenant.TenantId}': {message.ToJSON()}", message, tenant);
await workflowMessagingProcessor.SendMessageAsync(tenant.TenantId, message);
Logger.Log($"Successfully sent {message.ActionType} message", message, tenant);
}
protected override async Task <bool> HandleActionInternal(TenantInformation tenant, ActionMessage actionMessage, IBaseRepository baseRepository)
{
var message = (NotificationMessage)actionMessage;
var result = await SendNotificationEmail(tenant, message, (INotificationRepository)baseRepository);
Logger.Log($"Finished processing message with result: {result}", message, tenant);
return(await Task.FromResult(result == SendEmailResult.Success));
}
public async Task StoreTenantInfoAsync(TenantInformation tenantInfo)
{
_dataStorageManager.SetValue(
DataStorageKey.CurrentSession_TenantInfo,
mapper.Map <TenantInformationPersistanceModel>(tenantInfo)
);
await Task.CompletedTask;
}
public void TestInitialize()
{
_transactionValidator = new TransactionValidator();
_message = new NotificationMessage
{
TransactionId = 123
};
_tenant = new TenantInformation();
_baseRepoMock = new Mock <IBaseRepository>(MockBehavior.Strict);
}
public void TestInitialize()
{
_helper = new UsersGroupsChangedActionHelper();
_message = new UsersGroupsChangedMessage
{
ChangeType = UsersGroupsChangedType.Update,
UserId = 1,
RevisionId = 2
};
_repositoryMock = new Mock <IUsersGroupsChangedRepository>(MockBehavior.Strict);
_workflowMessagingProcessorMock = new Mock <IWorkflowMessagingProcessor>(MockBehavior.Strict);
_tenantInformation = new TenantInformation();
}
public void TestInitialize()
{
_helper = new WorkflowsChangedActionHelper();
_message = new WorkflowsChangedMessage
{
WorkflowId = 1,
RevisionId = 2,
UserId = 3
};
_repositoryMock = new Mock <IWorkflowsChangedRepository>(MockBehavior.Strict);
_workflowMessagingProcessorMock = new Mock <IWorkflowMessagingProcessor>(MockBehavior.Strict);
_tenantInformation = new TenantInformation();
}
/// <summary>
/// Initializes a new instance of the <see cref="UserCultureInfo"/> class.
/// </summary>
public UserCultureInfo(TenantInformation ti)
{
if (ti != null && ti.Timezone != null)
{
TimeZone = TimeZoneInfo.FindSystemTimeZoneById(ti.Timezone);
}
else
{
TimeZone = TimeZoneInfo.FindSystemTimeZoneById("Pakistan Standard Time");
}
// TODO: Need to through DB Context.
DateTimeFormat = "M/d/yyyy h:m:ss tt"; // Default format.
}
public void TestInitialize()
{
_helper = new PropertyItemTypesChangedActionHelper();
_message = new PropertyItemTypesChangedMessage
{
IsStandard = true,
ChangeType = PropertyItemTypeChangeType.ItemType,
UserId = 1,
RevisionId = 2
};
_repositoryMock = new Mock <IPropertyItemTypesChangedRepository>(MockBehavior.Strict);
_workflowMessagingProcessorMock = new Mock <IWorkflowMessagingProcessor>(MockBehavior.Strict);
_tenantInformation = new TenantInformation();
}
public IActionResult Me([FromServices] TenantInformation ti)
{
var user = _context.Users.Where(e => e.Id == ti.UserId).FirstOrDefault();
var timeformat = _context.schools.FirstOrDefault();
return(new JsonResult(new
{
user = user,
school = timeformat.name,
logo = timeformat.imgPath,
timeformat = timeformat.date_format,
currency_symbol = timeformat.currency_format,
currency_name = timeformat.currency_name
}));
}
protected override async Task <bool> HandleActionInternal(TenantInformation tenant, ActionMessage actionMessage, IBaseRepository baseRepository)
{
var message = (GenerateTestsMessage)actionMessage;
if (message == null || message.ArtifactId <= 0 || message.ProjectId <= 0 || message.RevisionId <= 0 || message.UserId <= 0 || string.IsNullOrWhiteSpace(message.UserName) || tenant == null)
{
Logger.Log($"Invalid GenerateTestsMessage received: {message?.ToJSON()}", message, tenant, LogLevel.Error);
return(false);
}
Logger.Log($"Handling of type: {message.ActionType} started for user ID {message.UserId}, revision ID {message.RevisionId} with message {message.ToJSON()}", message, tenant, LogLevel.Debug);
var repository = (IGenerateActionsRepository)baseRepository;
var generateProcessTestInfos = new List <GenerateProcessTestInfo>
{
new GenerateProcessTestInfo
{
ProcessId = message.ArtifactId
}
};
var parameters = SerializationHelper.ToXml(generateProcessTestInfos);
var user = await repository.GetUser(message.UserId);
Logger.Log($"Retrieved user: {user?.Login}", message, tenant);
var jobId = await repository.JobsRepository.AddJobMessage(JobType.GenerateProcessTests,
false,
parameters,
null,
message.ProjectId,
message.ProjectName,
message.UserId,
user?.Login,
message.BaseHostUri);
if (jobId.HasValue)
{
Logger.Log($"Job scheduled for {message.ActionType} with id: {jobId.Value}", message, tenant);
}
else
{
Logger.Log("No jobId received", message, tenant);
}
return(jobId.HasValue && jobId > 0);
}
public async Task <bool> HandleWorkflowsChangedAction(TenantInformation tenant, ActionMessage actionMessage, IBaseRepository baseRepository, IWorkflowMessagingProcessor workflowMessagingProcessor)
{
var message = (WorkflowsChangedMessage)actionMessage;
var repository = (IWorkflowsChangedRepository)baseRepository;
Logger.Log("Getting affected artifact IDs", message, tenant);
var workflowIds = new[]
{
message.WorkflowId
};
var artifactIds = await repository.GetAffectedArtifactIds(workflowIds, message.RevisionId);
await ArtifactsChangedMessageSender.Send(artifactIds, tenant, actionMessage, workflowMessagingProcessor);
return(true);
}
public void TestInitialize()
{
var artifactIds = new[]
{
1
};
_message = new ArtifactsChangedMessage(artifactIds)
{
ChangeType = ArtifactChangedType.Save,
RevisionId = 12,
UserId = 34
};
_repositoryMock = new Mock <IArtifactsChangedRepository>(MockBehavior.Strict);
_helper = new ArtifactsChangedActionHelper();
_tenantInformation = new TenantInformation();
}
protected override async Task <bool> HandleActionInternal(TenantInformation tenant, ActionMessage actionMessage, IBaseRepository baseRepository)
{
var message = (ProjectsChangedMessage)actionMessage;
var repository = (ProjectsChangedRepository)baseRepository;
Logger.Log("Getting affected artifact IDs", message, tenant);
var artifactIds = await repository.GetAffectedArtifactIds();
if (!artifactIds.Any())
{
Logger.Log("No artifact IDs found", message, tenant);
return(false);
}
Logger.Log($"Found artifact IDs {string.Join(",", artifactIds)}", message, tenant);
return(true);
}
protected override async Task <bool> PreActionValidation(TenantInformation tenant, ActionMessage actionMessage, IBaseRepository baseRepository)
{
var projectContainerActionMessage = actionMessage as ProjectContainerActionMessage;
if (projectContainerActionMessage == null)
{
Logger.Log("The message is not a projectContainerActionMessage", actionMessage, tenant, LogLevel.Error);
return(false);
}
var isProjectMaxArtifactBoundaryReached = await baseRepository.IsProjectMaxArtifactBoundaryReached(projectContainerActionMessage.ProjectId);
if (isProjectMaxArtifactBoundaryReached)
{
Logger.Log($"Max artifact boundary for project {projectContainerActionMessage.ProjectId} has been reached", projectContainerActionMessage, tenant, LogLevel.Error);
}
return(!isProjectMaxArtifactBoundaryReached);
}
public async Task <HttpResponseMessage> SendWebhook(TenantInformation tenant, WebhookMessage message)
{
try
{
var webhookUri = new Uri(message.Url);
var httpClientProvider = new HttpClientProvider();
var httpClient = httpClientProvider.CreateWithCustomCertificateValidation(webhookUri, message.IgnoreInvalidSSLCertificate, ConfigHelper.WebhookConnectionTimeout);
var request = new HttpRequestMessage
{
RequestUri = webhookUri,
Method = HttpMethod.Post,
Content = new StringContent(message.WebhookJsonPayload, Encoding.UTF8, "application/json")
};
AddHttpHeaders(request, message, tenant);
AddBasicAuthentication(request, message, tenant);
AddSignatureAuthentication(request, message, tenant);
AddNServiceBusHeaders(request, message, tenant);
return(await httpClient.SendAsync(request));
}
catch (HttpRequestException e)
{
if (e.InnerException is WebException)
{
var webException = (WebException)e.InnerException;
if (webException.Status == WebExceptionStatus.TrustFailure)
{
throw new WebhookExceptionRetryPerPolicy($"Failed to send webhook due to invalid SSL Certificate. {webException.Message}.");
}
else
{
throw new WebhookExceptionRetryPerPolicy($"Failed to send webhook due {webException.Status}. {webException.Message} {webException.Response}");
}
}
else
{
throw new WebhookExceptionRetryPerPolicy($"Failed to send webhook due to {e.InnerException}.");
}
}
}
public void TestInitialize()
{
_tenantInformation = new TenantInformation
{
TenantId = Guid.NewGuid().ToString(),
BlueprintConnectionString = ""
};
_notificationMessage = new NotificationMessage
{
ArtifactId = 1,
ArtifactName = "MyArtifact",
ArtifactTypeId = 2,
ArtifactTypePredefined = (int)ItemTypePredefined.Process,
ArtifactUrl = "",
From = "*****@*****.**",
To = new[]
{
"*****@*****.**"
},
Header = "header",
Message = "",
ProjectId = 3,
ProjectName = "MyProject",
RevisionId = 5,
Subject = "Test Email",
UserId = 1,
BlueprintUrl = ""
};
_emailSettings = new EmailSettings
{
HostName = "localhost",
Id = "1",
EnableSSL = true,
Authenticated = true,
EnableAllUsers = true,
UserName = "******",
Password = "",
Port = 227,
SenderEmailAddress = "*****@*****.**"
};
_notificationRepositoryMock = new Mock <INotificationRepository>(MockBehavior.Strict);
_notificationsActionHelper = new NotificationsActionHelper();
}
protected override async Task <bool> HandleActionInternal(TenantInformation tenant, ActionMessage actionMessage, IBaseRepository baseRepository)
{
var message = (ArtifactsPublishedMessage)actionMessage;
Logger.Log($"Handling started for user ID {message.UserId}, revision ID {message.RevisionId} with message {message.ToJSON()}", message, tenant, LogLevel.Debug);
var repository = (IArtifactsPublishedRepository)baseRepository;
var serviceLogRepository = new ServiceLogRepository(new HttpClientProvider(),
new LocalFileLog(),
tenant.AdminStoreLog);
// Get modified properties for all artifacts and create a dictionary with key as artifact ids
bool handledAllUpdatedArtifacts = await UpdatedArtifactsNotificationHandler.ProcessUpdatedArtifacts(tenant,
message,
repository,
serviceLogRepository,
_actionsParser,
WorkflowMessagingProcessor.Instance);
if (!handledAllUpdatedArtifacts)
{
Logger.Log("Could not process messages for all published updated artifacts", message, tenant, LogLevel.Debug);
}
Logger.Log("Finished processing updated artifacts", message, tenant);
var handledAllCreatedArtifacts =
await
CreatedArtifactsNotificationHandler.ProcessCreatedArtifacts(tenant,
message,
repository,
serviceLogRepository,
WorkflowMessagingProcessor.Instance);
if (!handledAllCreatedArtifacts)
{
Logger.Log("Could not process messages for all published created artifacts", message, tenant, LogLevel.Debug);
}
Logger.Log("Finished processing created artifacts", message, tenant);
Logger.Log("Finished processing message", message, tenant, LogLevel.Debug);
return(handledAllUpdatedArtifacts && handledAllCreatedArtifacts);
}
protected override async Task <bool> HandleActionInternal(TenantInformation tenant, ActionMessage actionMessage, IBaseRepository baseRepository)
{
var message = (ArtifactsChangedMessage)actionMessage;
var repository = (IArtifactsChangedRepository)baseRepository;
var artifactIds = message.ArtifactIds?.ToList();
if (artifactIds == null || !artifactIds.Any())
{
Logger.Log("The Artifacts Changed Message contains no artifact IDs", message, tenant);
return(false);
}
Logger.Log($"Handling Artifacts Changed Message with change type {message.ChangeType} and {artifactIds.Count} artifact IDs: {string.Join(", ", artifactIds)}", message, tenant);
Logger.Log("Started repopulating search items", message, tenant);
await repository.RepopulateSearchItems(artifactIds);
Logger.Log("Finished repopulating search items", message, tenant);
return(true);
}
public async Task <bool> HandleUsersGroupsChangedAction(TenantInformation tenant, ActionMessage actionMessage, IBaseRepository baseRepository, IWorkflowMessagingProcessor workflowMessagingProcessor)
{
var message = (UsersGroupsChangedMessage)actionMessage;
var repository = (IUsersGroupsChangedRepository)baseRepository;
Logger.Log($"Handling Users Groups Changed Message for change type {message.ChangeType}", message, tenant);
if (message.ChangeType == UsersGroupsChangedType.Create)
{
Logger.Log("No need to send Artifacts Changed Messages when Creating Users or Groups", message, tenant);
return(true);
}
Logger.Log("Getting affected artifact IDs", message, tenant);
var artifactIds = await repository.GetAffectedArtifactIds(message.UserIds, message.GroupIds, message.RevisionId);
await ArtifactsChangedMessageSender.Send(artifactIds, tenant, actionMessage, workflowMessagingProcessor);
return(true);
}
public async Task <TransactionStatus> GetStatus(ActionMessage message, TenantInformation tenant, IBaseRepository repository)
{
var transactionId = message.TransactionId;
var tries = 1;
while (true)
{
var status = await repository.GetTransactionStatus(transactionId);
if (!Enum.IsDefined(typeof(TransactionStatus), status))
{
throw new ArgumentOutOfRangeException($"Invalid Transaction Status: {status}");
}
var transactionStatus = (TransactionStatus)status;
switch (transactionStatus)
{
case TransactionStatus.Committed:
Logger.Log($"Transaction {transactionId} has been committed", message, tenant);
return(transactionStatus);
case TransactionStatus.Uncommitted:
if (tries < TriesMax)
{
Logger.Log($"Transaction {transactionId} is uncommitted. Trying again", message, tenant);
Thread.Sleep(MillisecondsTimeout);
tries++;
continue;
}
var errorMessage = $"Transaction {transactionId} is still uncommitted. Unable to handle the message at this time";
Logger.Log(errorMessage, message, tenant);
throw new EntityNotFoundException(errorMessage);
case TransactionStatus.RolledBack:
Logger.Log($"Transaction {transactionId} was rolled back. The message will not be handled", message, tenant);
return(transactionStatus);
default:
throw new ArgumentOutOfRangeException($"Unhandled Transaction Status {transactionStatus}");
}
}
}
public void BaseMessageHandler_ThrowsException_WhenTheRightTenantIsNotFound()
{
// arrange
var tenant = new TenantInformation
{
TenantId = TenantId + "different"
};
var wrongTenant = new Dictionary <string, TenantInformation>
{
{ tenant.TenantId, tenant }
};
_tenantInfoRetrieverMock.Setup(m => m.GetTenants()).ReturnsAsync(wrongTenant);
var handler = new NotificationMessageHandler(_actionHelperMock.Object, _tenantInfoRetrieverMock.Object, _configHelperMock.Object, _transactionValidatorMock.Object);
var message = new NotificationMessage();
// act
TestHandlerAndMessageWithHeader(handler, message);
// assert
_actionHelperMock.Verify(m => m.HandleAction(It.IsAny <TenantInformation>(), It.IsAny <ActionMessage>(), It.IsAny <BaseRepository>()), Times.Never);
}
public void TestInitialize()
{
_jobsRepositoryMock = new Mock <IJobsRepository>(MockBehavior.Strict);
_generateActionsRepositoryMock = new Mock <IGenerateActionsRepository>(MockBehavior.Strict);
_actionHelper = new GenerateUserStoriesActionHelper();
_message = new GenerateUserStoriesMessage
{
UserId = 123,
UserName = "******",
ArtifactId = 23,
BaseHostUri = "http://localhost:9801",
ProjectId = 123,
ProjectName = "my project",
RevisionId = 123
};
_tenantInformation = new TenantInformation
{
BlueprintConnectionString = "TestBlueprintConnectionString",
TenantId = "TestTenantId"
};
}
public async Task HandleAction_WhenAncestorInfiniteLoopExists_ReturnsFalse()
{
// arrange
const int duplicateId = 11;
var ancestorsWithDuplicate = new[]
{
duplicateId,
12,
13,
14,
duplicateId
};
var generateDescendantsMessage = new GenerateDescendantsMessage
{
AncestorArtifactTypeIds = ancestorsWithDuplicate,
ArtifactId = ArtifactId,
BaseHostUri = "uri",
ChildCount = 1,
DesiredArtifactTypeId = DesiredArtifactTypeId,
ProjectId = ProjectId,
ProjectName = "project",
RevisionId = RevisionId,
TypePredefined = 1,
UserId = UserId,
UserName = UserName
};
_generateActionsRepositoryMock.Setup(m => m.IsProjectMaxArtifactBoundaryReached(It.IsAny <int>())).ReturnsAsync(false);
var tenantInformation = new TenantInformation();
var actionHelper = new GenerateDescendantsActionHelper();
// act
var result = await actionHelper.HandleAction(tenantInformation, generateDescendantsMessage, _generateActionsRepositoryMock.Object);
// assert
Assert.IsFalse(result, "Children should not have been generated.");
_jobsRepoMock.Verify(t => t.AddJobMessage(It.IsAny <JobType>(), It.IsAny <bool>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <int?>(), It.IsAny <string>(), It.IsAny <int>(), It.IsAny <string>(), It.IsAny <string>()), Times.Never);
}
public void TestInitialize()
{
_actionHelperMock = new Mock <IActionHelper>(MockBehavior.Strict);
_configHelperMock = new Mock <IConfigHelper>(MockBehavior.Strict);
_configHelperMock.Setup(m => m.SupportedActionTypes).Returns(MessageActionType.All);
_tenantInfoRetrieverMock = new Mock <ITenantInfoRetriever>(MockBehavior.Strict);
var tenant = new TenantInformation
{
TenantId = TenantId,
BlueprintConnectionString = "test connection string"
};
var tenants = new Dictionary <string, TenantInformation>
{
{ tenant.TenantId, tenant }
};
_tenantInfoRetrieverMock.Setup(m => m.GetTenants()).ReturnsAsync(tenants);
_transactionValidatorMock = new Mock <ITransactionValidator>(MockBehavior.Strict);
_transactionValidatorMock.Setup(m => m.GetStatus(It.IsAny <ActionMessage>(), It.IsAny <TenantInformation>(), It.IsAny <BaseRepository>())).ReturnsAsync(TransactionStatus.Committed);
}
protected override async Task <bool> HandleActionInternal(TenantInformation tenant, ActionMessage actionMessage, IBaseRepository baseRepository)
{
var message = (WebhookMessage)actionMessage;
var result = await SendWebhook(tenant, message);
if (result.IsSuccessStatusCode)
{
Logger.Log($"Finished processing webhook with result: {result.StatusCode}", message, tenant);
return(true);
}
if (result.StatusCode == HttpStatusCode.Gone)
{
Logger.Log($"Failed to send webhook. Will not try again.", message, tenant, LogLevel.Error);
throw new WebhookExceptionDoNotRetry($"Failed to send webhook.");
}
else
{
Logger.Log($"Failed to send webhook. {(int)result.StatusCode} - {result.StatusCode}. Will try again in {ConfigHelper.WebhookRetryInterval} seconds.",
message, tenant, LogLevel.Error);
throw new WebhookExceptionRetryPerPolicy($"Failed to send webhook");
}
}
private async Task <SendEmailResult> SendNotificationEmail(TenantInformation tenant, NotificationMessage message, INotificationRepository repository)
{
Logger.Log($"Handling started for user ID {message.UserId} with message {message.ToJSON()}", message, tenant);
if (message.To == null || !message.To.Any() || message.To.All(string.IsNullOrWhiteSpace))
{
Logger.Log("Failed to send email because no recipients were specified", message, tenant, LogLevel.Error);
return(await Task.FromResult(SendEmailResult.Error));
}
Logger.Log("Getting email settings", message, tenant);
var emailSettings = await repository.GetEmailSettings();
if (emailSettings == null || string.IsNullOrWhiteSpace(emailSettings.HostName))
{
Logger.Log($"Failed to send email because invalid email settings were provided for tenant {tenant.TenantId}", message, tenant, LogLevel.Error);
return(await Task.FromResult(SendEmailResult.Error));
}
Logger.Log($"Email settings found. Host Name: {emailSettings.HostName}. Sender Email Address: {emailSettings.SenderEmailAddress}. User Name: {emailSettings.UserName}", message, tenant);
// Get the logo
byte[] logoImageArray = new LogoDataProvider().GetLogo();
string logoImageSrc = null;
if (logoImageArray != null)
{
logoImageSrc = GetImageSrc(logoImageArray, DiscussionEmail.LogoImageAttachmentContentId);
}
var notificationEmail = new NotificationEmail(
message.ProjectId,
message.ProjectName,
message.ArtifactId,
message.ArtifactName,
message.ArtifactUrl,
message.Message,
message.Header,
logoImageSrc,
message.BlueprintUrl);
var emailMessage = new Message
{
Subject = message.Subject,
FromDisplayName = message.From,
To = message.To.ToArray(),
From = emailSettings.SenderEmailAddress,
IsBodyHtml = true,
Body = new NotificationEmailContent(notificationEmail).TransformText()
};
if (logoImageArray != null)
{
emailMessage.DiscussionEmail = new DiscussionEmail
{
LogoImageSrc = logoImageSrc,
LogoImageAttachmentArray = logoImageArray
};
}
var smtpClientConfiguration = new SMTPClientConfiguration
{
Authenticated = emailSettings.Authenticated,
EnableSsl = emailSettings.EnableSSL,
HostName = emailSettings.HostName,
// Bug 61312: Password must be decrypted before saving in configuration
Password = SystemEncryptions.DecryptFromSilverlight(emailSettings.Password),
Port = emailSettings.Port,
UserName = emailSettings.UserName
};
if (string.IsNullOrWhiteSpace(smtpClientConfiguration.HostName))
{
Logger.Log("Sending email failed because no host name was found. Check your email settings", message, tenant, LogLevel.Error);
return(await Task.FromResult(SendEmailResult.Error));
}
Logger.Log($"Sending Email to {string.Join(",", emailMessage.To)}", message, tenant);
repository.SendEmail(smtpClientConfiguration, emailMessage);
Logger.Log("Email Sent Successfully", message, tenant);
return(await Task.FromResult(SendEmailResult.Success));
}
protected override async Task <bool> HandleActionInternal(TenantInformation tenant, ActionMessage actionMessage, IBaseRepository baseRepository)
{
var message = (GenerateDescendantsMessage)actionMessage;
if (message == null || message.ArtifactId <= 0 || message.ProjectId <= 0 || message.RevisionId <= 0 || message.UserId <= 0 || message.DesiredArtifactTypeId == null || string.IsNullOrWhiteSpace(message.UserName) || tenant == null)
{
Logger.Log($"Invalid GenerateDescendantsMessage received: {message?.ToJSON()}", message, tenant, LogLevel.Error);
return(false);
}
Logger.Log($"Handling of type: {message.ActionType} started for user ID {message.UserId}, revision ID {message.RevisionId} with message {message.ToJSON()}", message, tenant, LogLevel.Debug);
var ancestors = new List <int>(message.AncestorArtifactTypeIds ?? new int[0]);
Logger.Log($"{ancestors.Count} ancestor artifact type IDs found: {string.Join(",", ancestors)}", message, tenant, LogLevel.Debug);
var ancestorLoopExists = ancestors.GroupBy(i => i).Any(group => group.Count() > 1);
if (ancestorLoopExists)
{
Logger.Log("Child generation was stopped. Infinite loop detected in the ancestor artifact type IDs.", message, tenant, LogLevel.Debug);
return(false);
}
var repository = (IGenerateActionsRepository)baseRepository;
var sqlItemTypeRepository = repository.ItemTypeRepository;
var desiredItemType = await sqlItemTypeRepository.GetCustomItemTypeForProvidedStandardItemTypeIdInProject(message.ProjectId, message.DesiredArtifactTypeId.GetValueOrDefault());
if (desiredItemType == null || desiredItemType.ItemTypeId <= 0 || string.IsNullOrWhiteSpace(desiredItemType.Name))
{
Logger.Log($"No artifact type found with instance Id: {message.DesiredArtifactTypeId.GetValueOrDefault()} in Project: {message.ProjectId}", message, tenant);
return(false);
}
var generateDescendantsInfo = new GenerateDescendantsInfo
{
RevisionId = message.RevisionId,
ProjectId = message.ProjectId,
ArtifactId = message.ArtifactId,
UserId = message.UserId,
ChildCount = message.ChildCount,
DesiredArtifactTypeId = desiredItemType.ItemTypeId,
Predefined = (ItemTypePredefined)message.TypePredefined,
DesiredArtifactTypeName = desiredItemType.Name,
AncestorArtifactTypeIds = message.AncestorArtifactTypeIds?.ToArray()
};
var parameters = SerializationHelper.ToXml(generateDescendantsInfo);
var user = await repository.GetUser(message.UserId);
Logger.Log($"Retrieved user: {user?.Login}", message, tenant);
var jobId = await repository.JobsRepository.AddJobMessage(JobType.GenerateDescendants,
false,
parameters,
null,
message.ProjectId,
message.ProjectName,
message.UserId,
user?.Login, // Login is equal to username
message.BaseHostUri);
if (jobId.HasValue)
{
Logger.Log($"Job scheduled for {message.ActionType} with id: {jobId.Value}", message, tenant);
}
else
{
Logger.Log("No jobId received", message, tenant);
}
return(jobId.HasValue && jobId > 0);
}
public AccountAndTenant(Account account, TenantInformation tenant)
{
UserAccount = account;
TenantToUse = tenant;
}
protected override async Task <bool> HandleActionInternal(TenantInformation tenant, ActionMessage actionMessage, IBaseRepository baseRepository)
{
return(await HandleUsersGroupsChangedAction(tenant, actionMessage, baseRepository, WorkflowMessagingProcessor.Instance));
}