public async Task ProcessDeploymentStepAsync(DeploymentStep step, DeploymentPlanResult result)
{
if (!(step is ContentDefinitionDeploymentStep contentDefinitionStep))
{
return;
}
var contentTypeDefinitionRecord = await _contentDefinitionStore.LoadContentDefinitionAsync();
var contentTypes = contentDefinitionStep.IncludeAll
? contentTypeDefinitionRecord.ContentTypeDefinitionRecords
: contentTypeDefinitionRecord.ContentTypeDefinitionRecords
.Where(x => contentDefinitionStep.ContentTypes.Contains(x.Name));
var contentParts = contentDefinitionStep.IncludeAll
? contentTypeDefinitionRecord.ContentPartDefinitionRecords
: contentTypeDefinitionRecord.ContentPartDefinitionRecords
.Where(x => contentDefinitionStep.ContentParts.Contains(x.Name));
result.Steps.Add(new JObject(
new JProperty("name", "ContentDefinition"),
new JProperty("ContentTypes", JArray.FromObject(contentTypes)),
new JProperty("ContentParts", JArray.FromObject(contentParts))
));
return;
}
public async Task ProcessDeploymentStepAsync(DeploymentStep step, DeploymentPlanResult result)
{
var allRolesState = step as AllRolesDeploymentStep;
if (allRolesState == null)
{
return;
}
// Get all roles
var allRoleNames = await _roleService.GetRoleNamesAsync();
var permissions = new JArray();
var tasks = new List <Task>();
foreach (var roleName in allRoleNames)
{
var role = (Role)await _roleManager.FindByNameAsync(_roleManager.NormalizeKey(roleName));
if (role != null)
{
permissions.Add(JObject.FromObject(
new RolesStepRoleModel
{
Name = role.NormalizedRoleName,
Permissions = role.RoleClaims.Where(x => x.ClaimType == Permission.ClaimType).Select(x => x.ClaimValue).ToArray()
}));
}
}
result.Steps.Add(new JObject(
new JProperty("name", "Roles"),
new JProperty("Roles", permissions)
));
}
public async Task ProcessDeploymentStepAsync(DeploymentStep step, DeploymentPlanResult result)
{
var settingsStep = step as SiteSettingsPropertyDeploymentStep <TModel>;
if (settingsStep == null)
{
return;
}
var siteSettings = await _siteService.GetSiteSettingsAsync();
var settingJProperty = new JProperty(typeof(TModel).Name, JObject.FromObject(siteSettings.As <TModel>()));
var settingsStepJObject = result.Steps.FirstOrDefault(s => s["name"]?.ToString() == "Settings");
if (settingsStepJObject != null)
{
settingsStepJObject.Add(settingJProperty);
}
else
{
result.Steps.Add(new JObject(
new JProperty("name", "Settings"),
new JProperty(settingJProperty)
));
}
}
public async Task ProcessDeploymentStepAsync(DeploymentStep deploymentStep, DeploymentPlanResult result)
{
if (!(deploymentStep is DeploymentPlanDeploymentStep deploymentPlanStep))
{
return;
}
if (!await _deploymentPlanService.DoesUserHavePermissionsAsync())
{
return;
}
var deploymentPlans = deploymentPlanStep.IncludeAll
? (await _deploymentPlanService.GetAllDeploymentPlansAsync()).ToArray()
: (await _deploymentPlanService.GetDeploymentPlansAsync(deploymentPlanStep.DeploymentPlanNames)).ToArray();
var plans = (from plan in deploymentPlans
select new
{
plan.Name,
Steps = (from step in plan.DeploymentSteps
select new
{
Type = step.GetType().Name,
Step = step
}).ToArray()
}).ToArray();
// Adding deployment plans
result.Steps.Add(new JObject(
new JProperty("name", "deployment"),
new JProperty("Plans", JArray.FromObject(plans))
));
}
public async Task ProcessDeploymentStepAsync(DeploymentStep step, DeploymentPlanResult result)
{
var adminMenuStep = step as AdminMenuDeploymentStep;
if (adminMenuStep == null)
{
return;
}
var data = new JArray();
result.Steps.Add(new JObject(
new JProperty("name", "AdminMenu"),
new JProperty("data", data)
));
// For each AdminNode, store info about its concrete type: linkAdminNode, contentTypesAdminNode etc...
var serializer = new JsonSerializer()
{
TypeNameHandling = TypeNameHandling.Auto
};
foreach (var adminMenu in (await _adminMenuService.GetAdminMenuListAsync()).AdminMenu)
{
var objectData = JObject.FromObject(adminMenu, serializer);
data.Add(objectData);
}
return;
}
public async Task ProcessDeploymentStepAsync(DeploymentStep step, DeploymentPlanResult result)
{
var allContentStep = step as AllWorkflowTypeDeploymentStep;
if (allContentStep == null)
{
return;
}
var data = new JArray();
result.Steps.Add(new JObject(
new JProperty("name", "WorkflowType"),
new JProperty("data", data)
));
foreach (var workflow in await _workflowTypeStore.ListAsync())
{
var objectData = JObject.FromObject(workflow);
// Don't serialize the Id as it could be interpreted as an updated object when added back to YesSql
objectData.Remove(nameof(workflow.Id));
data.Add(objectData);
}
return;
}
public async Task ProcessDeploymentStepAsync(DeploymentStep step, DeploymentPlanResult result)
{
var luceneIndexStep = step as LuceneIndexDeploymentStep;
if (luceneIndexStep == null)
{
return;
}
var indexSettings = await _luceneIndexSettingsService.GetSettingsAsync();
var data = new JArray();
var indicesToAdd = luceneIndexStep.IncludeAll ? indexSettings.Select(x => x.IndexName).ToArray() : luceneIndexStep.IndexNames;
foreach (var index in indexSettings)
{
if (indicesToAdd.Contains(index.IndexName))
{
var indexSettingsDict = new Dictionary <string, LuceneIndexSettings>();
indexSettingsDict.Add(index.IndexName, index);
data.Add(JObject.FromObject(indexSettingsDict));
}
}
// Adding Lucene settings
result.Steps.Add(new JObject(
new JProperty("name", "lucene-index"),
new JProperty("Indices", data)
));
}
public async Task <IActionResult> Execute(int id)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.Export))
{
return(Unauthorized());
}
var deploymentPlan = await _session.GetAsync <DeploymentPlan>(id);
if (deploymentPlan == null)
{
return(NotFound());
}
string archiveFileName;
var filename = deploymentPlan.Name.ToSafeName() + ".zip";
using (var fileBuilder = new TemporaryFileBuilder())
{
archiveFileName = PathExtensions.Combine(Path.GetTempPath(), filename);
var deploymentPlanResult = new DeploymentPlanResult(fileBuilder);
await _deploymentManager.ExecuteDeploymentPlanAsync(deploymentPlan, deploymentPlanResult);
ZipFile.CreateFromDirectory(fileBuilder.Folder, archiveFileName);
}
return(new PhysicalFileResult(archiveFileName, "application/zip")
{
FileDownloadName = filename
});
}
public async Task ProcessDeploymentStepAsync(DeploymentStep step, DeploymentPlanResult result)
{
var customSettingsStep = step as CustomSettingsDeploymentStep;
if (customSettingsStep == null)
{
return;
}
var settingsList = new List <JProperty> {
new JProperty("name", "custom-settings")
};
var settingsTypes = customSettingsStep.IncludeAll
? _customSettingsService.GetAllSettingsTypes().ToArray()
: _customSettingsService.GetSettingsTypes(customSettingsStep.SettingsTypeNames).ToArray();
foreach (var settingsType in settingsTypes)
{
if (!await _customSettingsService.CanUserCreateSettingsAsync(settingsType))
{
return;
}
}
foreach (var settingsType in settingsTypes)
{
var settings = await _customSettingsService.GetSettingsAsync(settingsType);
settingsList.Add(new JProperty(settings.ContentType, JObject.FromObject(settings)));
}
// Adding custom settings
result.Steps.Add(new JObject(settingsList.ToArray()));
}
public async Task ProcessDeploymentStepAsync(DeploymentStep step, DeploymentPlanResult result)
{
// TODO: Batch and create separate content files in the result.
var contentState = step as ContentDeploymentStep;
if (contentState == null)
{
return;
}
var data = new JArray();
foreach (var contentItem in await _session.Query <ContentItem, ContentItemIndex>(x => x.Published && x.ContentType.IsIn(contentState.ContentTypes)).ListAsync())
{
var objectData = JObject.FromObject(contentItem);
// Don't serialize the Id as it could be interpreted as an updated object when added back to YesSql.
objectData.Remove(nameof(ContentItem.Id));
data.Add(objectData);
}
if (data.HasValues)
{
var jobj = new JObject
{
["name"] = "content",
["data"] = data
};
result.Steps.Add(jobj);
}
}
public async Task ProcessDeploymentStepAsync(DeploymentStep step, DeploymentPlanResult result)
{
// TODO: Batch and create separate content files in the result
var contentState = step as ContentTypeDeploymentStep;
if (contentState == null)
{
return;
}
var data = new JArray();
foreach (var contentItem in await _session.QueryAsync <ContentItem, ContentItemIndex>(x => x.Published && x.ContentType.IsIn(contentState.ContentTypes)).List())
{
data.Add(JObject.FromObject(contentItem));
}
if (data.HasValues)
{
var jobj = new JObject();
jobj["name"] = "content";
jobj["data"] = data;
result.Steps.Add(jobj);
}
return;
}
public Task ProcessDeploymentStepAsync(DeploymentStep step, DeploymentPlanResult result)
{
var settingsStep = step as SettingsDeploymentStep;
if (settingsStep == null || (!settingsStep.IncludeAzureHubSettings && !settingsStep.IncludeSignalHubSettings))
{
return(Task.CompletedTask);
}
if (settingsStep.IncludeAzureHubSettings)
{
var options = new AzureHubSettings();
_azureHubOptions.Configure(options);
var data = new JArray();
result.Steps.Add(new JObject(
new JProperty("name", nameof(AzureHubSettings)),
new JProperty("settings", JObject.FromObject(options))
));
}
if (settingsStep.IncludeSignalHubSettings)
{
var options = new SignalHubSettings();
_signalHubOptions.Configure(options);
var data = new JArray();
result.Steps.Add(new JObject(
new JProperty("name", nameof(SignalHubSettings)),
new JProperty("settings", JObject.FromObject(options))
));
}
return(Task.CompletedTask);
}
public async Task ProcessDeploymentStepAsync(DeploymentStep step, DeploymentPlanResult result)
{
var allContentState = step as AllContentDeploymentStep;
if (allContentState == null)
{
return;
}
var data = new JArray();
result.Steps.Add(new JObject(
new JProperty("name", "Content"),
new JProperty("data", data)
));
foreach (var contentItem in await _session.Query <ContentItem, ContentItemIndex>(x => x.Published).ListAsync())
{
var objectData = JObject.FromObject(contentItem);
// Don't serialize the Id as it could be interpreted as an updated object when added back to YesSql
objectData.Remove(nameof(ContentItem.Id));
data.Add(objectData);
}
return;
}
public async Task ProcessDeploymentStepAsync(DeploymentStep step, DeploymentPlanResult result)
{
var openIdServerStep = step as OpenIdServerDeploymentStep;
if (openIdServerStep == null)
{
return;
}
var settings = await _openIdServerService
.GetSettingsAsync();
var settingsModel = new OpenIdServerSettingsStepModel
{
AccessTokenFormat = settings.AccessTokenFormat,
Authority = settings.Authority?.AbsoluteUri,
EncryptionCertificateStoreLocation = settings.EncryptionCertificateStoreLocation,
EncryptionCertificateStoreName = settings.EncryptionCertificateStoreName,
EncryptionCertificateThumbprint = settings.EncryptionCertificateThumbprint,
SigningCertificateStoreLocation = settings.SigningCertificateStoreLocation,
SigningCertificateStoreName = settings.SigningCertificateStoreName,
SigningCertificateThumbprint = settings.SigningCertificateThumbprint,
// The recipe step only reads these flags, and uses constants for the paths.
// Conversely, we export true for endpoints with a path, false for those without.
EnableAuthorizationEndpoint = !string.IsNullOrWhiteSpace(settings.AuthorizationEndpointPath),
EnableLogoutEndpoint = !string.IsNullOrWhiteSpace(settings.LogoutEndpointPath),
EnableTokenEndpoint = !string.IsNullOrWhiteSpace(settings.TokenEndpointPath),
EnableUserInfoEndpoint = !string.IsNullOrWhiteSpace(settings.UserinfoEndpointPath),
EnableIntrospectionEndpoint = !string.IsNullOrWhiteSpace(settings.IntrospectionEndpointPath),
EnableRevocationEndpoint = !string.IsNullOrWhiteSpace(settings.RevocationEndpointPath),
AllowAuthorizationCodeFlow = settings.AllowAuthorizationCodeFlow,
AllowClientCredentialsFlow = settings.AllowClientCredentialsFlow,
AllowHybridFlow = settings.AllowHybridFlow,
AllowImplicitFlow = settings.AllowImplicitFlow,
AllowPasswordFlow = settings.AllowPasswordFlow,
AllowRefreshTokenFlow = settings.AllowRefreshTokenFlow,
DisableAccessTokenEncryption = settings.DisableAccessTokenEncryption,
DisableRollingRefreshTokens = settings.DisableRollingRefreshTokens,
UseReferenceAccessTokens = settings.UseReferenceAccessTokens,
RequireProofKeyForCodeExchange = settings.RequireProofKeyForCodeExchange,
};
// Use nameof(OpenIdServerSettings) as name,
// to match the recipe step.
var obj = new JObject(
new JProperty(
"name",
nameof(OpenIdServerSettings)));
obj.Merge(JObject.FromObject(settingsModel));
result.Steps.Add(obj);
}
public async Task ProcessDeploymentStepAsync(DeploymentStep step, DeploymentPlanResult result)
{
if (!(step is MediaDeploymentStep mediaStep))
{
return;
}
List <string> paths;
if (mediaStep.IncludeAll)
{
var fileStoreEntries = await _mediaFileStore.GetDirectoryContentAsync(null, true);
paths =
(
from fileStoreEntry in fileStoreEntries
where !fileStoreEntry.IsDirectory
select fileStoreEntry.Path
).ToList();
}
else
{
paths = new List <string>(mediaStep.FilePaths ?? Array.Empty <string>());
foreach (var directoryPath in mediaStep.DirectoryPaths ?? Array.Empty <string>())
{
var fileStoreEntries = await _mediaFileStore.GetDirectoryContentAsync(directoryPath, true);
paths.AddRange(
from fileStoreEntry in fileStoreEntries
where !fileStoreEntry.IsDirectory
select fileStoreEntry.Path);
}
paths.Sort();
}
foreach (var path in paths)
{
var stream = await _mediaFileStore.GetFileStreamAsync(path);
await result.FileBuilder.SetFileAsync(path, stream);
}
// Adding media files
result.Steps.Add(new JObject(
new JProperty("name", "media"),
new JProperty("Files", JArray.FromObject(
(from path in paths
select new
{
SourcePath = path,
TargetPath = path
}).ToArray()
))
));
}
public async Task ServerDeploymentSourceIsReadableByRecipe()
{
// Arrange
var recipeFile = "Recipe.json";
var expectedSettings = CreateSettings("https://deploy.localhost", TokenFormat.JsonWebToken, true);
var deployServerServiceMock = CreateServerServiceWithSettingsMock(expectedSettings);
var actualSettings = CreateSettings("https://recipe.localhost", TokenFormat.DataProtection, false);
var recipeServerServiceMock = CreateServerServiceWithSettingsMock(actualSettings);
var settingsProperties = typeof(OpenIdServerSettings)
.GetProperties();
foreach (var property in settingsProperties)
{
Assert.NotEqual(
property.GetValue(expectedSettings),
property.GetValue(actualSettings));
}
var fileBuilder = new MemoryFileBuilder();
var descriptor = new RecipeDescriptor();
var result = new DeploymentPlanResult(fileBuilder, descriptor);
var deploymentSource = new OpenIdServerDeploymentSource(deployServerServiceMock.Object);
// Act
await deploymentSource.ProcessDeploymentStepAsync(new OpenIdServerDeploymentStep(), result);
await result.FinalizeAsync();
var deploy = JObject.Parse(
fileBuilder.GetFileContents(
recipeFile,
Encoding.UTF8));
var recipeContext = new RecipeExecutionContext
{
RecipeDescriptor = descriptor,
Name = deploy.Property("steps").Value.First.Value <string>("name"),
Step = (JObject)deploy.Property("steps").Value.First,
};
var recipeStep = new OpenIdServerSettingsStep(recipeServerServiceMock.Object);
await recipeStep.ExecuteAsync(recipeContext);
// Assert
foreach (var property in settingsProperties)
{
Assert.Equal(
property.GetValue(expectedSettings),
property.GetValue(actualSettings));
}
}
public Task ProcessDeploymentStepAsync(DeploymentStep step, DeploymentPlanResult result)
{
var customFile = step as CustomFileDeploymentStep;
if (customFile == null)
{
return(Task.CompletedTask);
}
return(result.FileBuilder.SetFileAsync(customFile.FileName, Encoding.UTF8.GetBytes(customFile.FileContent)));
}
public Task ProcessDeploymentStepAsync(DeploymentStep deploymentStep, DeploymentPlanResult result)
{
if (!(deploymentStep is JsonRecipeDeploymentStep jsonRecipeStep))
{
return(Task.CompletedTask);
}
result.Steps.Add(JObject.Parse(jsonRecipeStep.Json));
return(Task.CompletedTask);
}
public async Task ExecuteDeploymentPlanAsync(DeploymentPlan deploymentPlan, DeploymentPlanResult result)
{
foreach (var step in deploymentPlan.DeploymentSteps)
{
foreach (var source in _deploymentSources)
{
await source.ProcessDeploymentStepAsync(step, result);
}
}
await result.FinalizeAsync();
}
public async Task ProcessDeploymentStepAsync(DeploymentStep step, DeploymentPlanResult result)
{
var themesState = step as ThemesDeploymentStep;
if (themesState == null)
{
return;
}
result.Steps.Add(new JObject(
new JProperty("name", "Themes"),
new JProperty(nameof(ThemeStepModel.Site), await _siteThemeService.GetCurrentThemeNameAsync()),
new JProperty(nameof(ThemeStepModel.Admin), await _adminThemeService.GetAdminThemeNameAsync())
));
}
public Task ProcessDeploymentStepAsync(DeploymentStep step, DeploymentPlanResult result)
{
if (!(step is DeleteContentDefinitionDeploymentStep deleteContentDefinitionStep))
{
return(Task.CompletedTask);
}
result.Steps.Add(new JObject(
new JProperty("name", "DeleteContentDefinition"),
new JProperty("ContentTypes", JArray.FromObject(deleteContentDefinitionStep.ContentTypes)),
new JProperty("ContentParts", JArray.FromObject(deleteContentDefinitionStep.ContentParts))
));
return(Task.CompletedTask);
}
public async Task <IActionResult> Execute(int id)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.Export))
{
return(Forbid());
}
var deploymentPlan = await _session.GetAsync <DeploymentPlan>(id);
if (deploymentPlan == null)
{
return(NotFound());
}
string archiveFileName;
var filename = deploymentPlan.Name.ToSafeName() + ".zip";
using (var fileBuilder = new TemporaryFileBuilder())
{
archiveFileName = fileBuilder.Folder + ".zip";
var recipeDescriptor = new RecipeDescriptor();
var recipeFileDeploymentStep = deploymentPlan.DeploymentSteps.FirstOrDefault(ds => ds.Name == nameof(RecipeFileDeploymentStep)) as RecipeFileDeploymentStep;
if (recipeFileDeploymentStep != null)
{
recipeDescriptor.Name = recipeFileDeploymentStep.RecipeName;
recipeDescriptor.DisplayName = recipeFileDeploymentStep.DisplayName;
recipeDescriptor.Description = recipeFileDeploymentStep.Description;
recipeDescriptor.Author = recipeFileDeploymentStep.Author;
recipeDescriptor.WebSite = recipeFileDeploymentStep.WebSite;
recipeDescriptor.Version = recipeFileDeploymentStep.Version;
recipeDescriptor.IsSetupRecipe = recipeFileDeploymentStep.IsSetupRecipe;
recipeDescriptor.Categories = (recipeFileDeploymentStep.Categories ?? "").Split(',', StringSplitOptions.RemoveEmptyEntries);
recipeDescriptor.Tags = (recipeFileDeploymentStep.Tags ?? "").Split(',', StringSplitOptions.RemoveEmptyEntries);
}
var deploymentPlanResult = new DeploymentPlanResult(fileBuilder, recipeDescriptor);
await _deploymentManager.ExecuteDeploymentPlanAsync(deploymentPlan, deploymentPlanResult);
ZipFile.CreateFromDirectory(fileBuilder.Folder, archiveFileName);
}
return(new PhysicalFileResult(archiveFileName, "application/zip")
{
FileDownloadName = filename
});
}
public async Task ProcessDeploymentStepAsync(DeploymentStep step, DeploymentPlanResult result)
{
var azureADStep = step as AzureADDeploymentStep;
if (azureADStep == null)
{
return;
}
var settings = await _azureADService.GetSettingsAsync();
result.Steps.Add(new JObject(
new JProperty("name", "AzureAD"),
new JProperty("AzureAD", JObject.FromObject(settings))
));
}
public async Task ProcessDeploymentStepAsync(DeploymentStep step, DeploymentPlanResult result)
{
if (!(step is AllSitemapsDeploymentStep))
{
return;
}
var sitemaps = await _sitemapManager.GetSitemapsAsync();
var jArray = JArray.FromObject(sitemaps, Serializer);
result.Steps.Add(new JObject(
new JProperty("name", "Sitemaps"),
new JProperty("data", jArray)
));
}
public async Task ProcessDeploymentStepAsync(DeploymentStep step, DeploymentPlanResult result)
{
var openIdValidationStep = step as OpenIdValidationDeploymentStep;
if (openIdValidationStep == null)
{
return;
}
var validationSettings = await _openIdValidationService.GetSettingsAsync();
result.Steps.Add(new JObject(
new JProperty("name", "OpenIdValidation"),
new JProperty("OpenIdValidation", JObject.FromObject(validationSettings))
));
}
public async Task ProcessDeploymentStepAsync(DeploymentStep step, DeploymentPlanResult result)
{
var robotsState = step as RobotsDeploymentStep;
if (robotsState == null)
{
return;
}
var siteSettings = await _siteService.GetSiteSettingsAsync();
result.Steps.Add(new JObject(
new JProperty("name", "Settings"),
new JProperty("RobotsSettings", JObject.FromObject(siteSettings.As <RobotsSettings>()))
));
}
public async Task ProcessDeploymentStepAsync(DeploymentStep step, DeploymentPlanResult result)
{
var allQueriesStep = step as AllQueriesDeploymentStep;
if (allQueriesStep == null)
{
return;
}
var queries = await _queryManager.ListQueriesAsync();
result.Steps.Add(new JObject(
new JProperty("name", "Queries"),
new JProperty("Queries", queries.Select(JObject.FromObject))
));
}
public async Task ProcessDeploymentStepAsync(DeploymentStep step, DeploymentPlanResult result)
{
var facebookLoginStep = step as FacebookLoginDeploymentStep;
if (facebookLoginStep == null)
{
return;
}
var settings = await _facebookService.GetSettingsAsync();
result.Steps.Add(new JObject(
new JProperty("name", "FacebookLogin"),
new JProperty("FacebookLogin", JObject.FromObject(settings))
));
}
public async Task ProcessDeploymentStepAsync(DeploymentStep step, DeploymentPlanResult result)
{
var allMediaProfilesStep = step as AllMediaProfilesDeploymentStep;
if (allMediaProfilesStep == null)
{
return;
}
var mediaProfiles = await _mediaProfilesManager.GetMediaProfilesDocumentAsync();
result.Steps.Add(new JObject(
new JProperty("name", "MediaProfiles"),
new JProperty("MediaProfiles", JObject.FromObject(mediaProfiles.MediaProfiles))
));
}
public async Task ProcessDeploymentStepAsync(DeploymentStep step, DeploymentPlanResult result)
{
var allLayersState = step as AllLayersDeploymentStep;
if (allLayersState == null)
{
return;
}
var layers = await _layerService.GetLayersAsync();
result.Steps.Add(new JObject(
new JProperty("name", "Layers"),
new JProperty("Layers", layers.Layers.Select(JObject.FromObject))
));
}
