public void Initialize(InitializationEngine context)
{
DependencyResolver.SetResolver(new StaticWebServiceLocatorDependencyResolver(context.Locate.Advanced));
var configuration = StaticWebConfiguration.CurrentSite;
if (configuration != null && configuration.Enabled && configuration.UseRouting)
{
StaticWebRouting.LoadRoutes();
}
var events = ServiceLocator.Current.GetInstance <IContentEvents>();
events.PublishedContent += OnPublishedContent;
events.PublishingContent += OnPublishingContent;
events.MovingContent += OnMovingContent;
events.MovedContent += OnMovedContent;
events.DeletingContent += OnDeletingContent;
events.DeletedContent += OnDeletedContent;
var contentSecurityRepository = ServiceLocator.Current.GetInstance <IContentSecurityRepository>();
contentSecurityRepository.ContentSecuritySaved += OnContentSecuritySaved;
}
/// <summary>
/// Called when a scheduled job executes
/// </summary>
/// <returns>A status message to be stored in the database log and visible from admin mode</returns>
public override string Execute()
{
_stopSignaled = false;
_cancellationTokenSource = new CancellationTokenSource();
//Call OnStatusChanged to periodically notify progress of job for manually started jobs
OnStatusChanged(String.Format("Starting execution of {0}", this.GetType()));
_sitePages = new Dictionary <string, ConcurrentDictionary <string, string> >();
StringBuilder resultMessage = new StringBuilder();
var siteDefinitionRepository = ServiceLocator.Current.GetInstance <ISiteDefinitionRepository>();
var siteDefinitions = siteDefinitionRepository.List().ToList();
var hasAnyMatchingConfiguration = false;
var numberOfSiteDefinitions = siteDefinitions.Count;
foreach (var siteDefinition in siteDefinitions)
{
_generatedPages = new Dictionary <int, string>();
//_generatedResources = new ConcurrentDictionary<string, string>();
_numberOfPages = 0;
_numberOfObsoletePages = 0;
_numberOfObsoleteResources = 0;
var configuration = StaticWebConfiguration.Get(siteDefinition);
if (configuration == null || !configuration.Enabled)
{
if (configuration != null && !string.IsNullOrEmpty(configuration.Name))
{
resultMessage.AppendLine($"<div class=\"ui-state-error\"><b>{configuration.Name}</b> - Was ignored because not enabled or missing required settings.<br /></div>");
}
else
{
resultMessage.AppendLine($"<div class=\"ui-state-error\"><b>{siteDefinition.Name}</b> - Was ignored because it was not configured.<br /></div>");
}
continue;
}
hasAnyMatchingConfiguration = true;
// This website has been setup for using StaticWebEpiServerPlugin
SiteDefinition.Current = siteDefinition;
var parallelOptions = new ParallelOptions
{
MaxDegreeOfParallelism = configuration.MaxDegreeOfParallelismForScheduledJob,
CancellationToken = _cancellationTokenSource.Token
};
// Add Empty placeholder for pages to come
_sitePages.Add(configuration.Name, new ConcurrentDictionary <string, string>());
//Add implementation
var startPage = SiteDefinition.Current.StartPage.ToReferenceWithoutVersion();
var pages = GetPages(configuration, parallelOptions, startPage);
GeneratingPages(configuration, parallelOptions, pages);
if (configuration.UseRouting)
{
OnStatusChanged("Saving routes to file");
StaticWebRouting.SaveRoutes();
}
if (configuration.RemoveObsoletePages)
{
OnStatusChanged("Looking for obsolete pages");
RemoveObsoletePages(configuration);
}
if (configuration.RemoveObsoleteResources)
{
OnStatusChanged("Looking for obsolete resources");
RemoveObsoleteResources(configuration);
}
resultMessage.AppendLine($"<b>{configuration.Name}</b> - {_sitePages[configuration.Name].Count} pages generated.");
if (_numberOfObsoletePages > 0)
{
resultMessage.AppendLine($" {_numberOfObsoletePages} obsolete pages removed.");
}
if (_numberOfObsoleteResources > 0)
{
resultMessage.AppendLine($" {_numberOfObsoleteResources} obsolete resources removed.");
}
resultMessage.AppendLine($"<br />");
}
if (!hasAnyMatchingConfiguration)
{
return("StaticWeb is not enabled! Add 'StaticWeb:InputUrl' and 'StaticWeb:OutputFolder' under 'appSettings' element in web.config");
}
return(resultMessage.ToString());
}
public void GeneratePage(SiteConfigurationElement configuration, string pageUrl, bool?useTemporaryAttribute, bool ignoreHtmlDependencies, string simpleAddress = null, ConcurrentDictionary <string, string> generatedResources = null)
{
if (configuration == null || !configuration.Enabled)
{
return;
}
//string orginalUrl = GetPageUrl(contentLink, language);
if (pageUrl == null)
{
return;
}
string relativePath = GetPageRelativePath(pageUrl);
string relativeSimplePath = GetPageRelativePath(simpleAddress);
var hasSimpleAddress = !string.IsNullOrEmpty(simpleAddress);
var fullPageUrl = configuration.Url + pageUrl;
var fullSimpeAddress = configuration.Url + simpleAddress;
var generatePageEvent = new StaticWebGeneratePageEventArgs(fullPageUrl, simpleAddress);
if (generatedResources != null)
{
generatePageEvent.Resources = generatedResources;
}
else
{
generatePageEvent.Resources = new ConcurrentDictionary <string, string>();
}
string html = null;
var pageTypeConfiguration = StaticWebConfiguration.AllowedResourceTypes.FirstOrDefault(r => r.FileExtension == "");
if (pageTypeConfiguration == null)
{
// don't download resource as it is of a known type we don't want to download
generatePageEvent.CancelAction = true;
generatePageEvent.CancelReason = "AllowedResourceTypes configuration for file extension '' is missing (read: used by page).";
}
else
{
generatePageEvent.TypeConfiguration = pageTypeConfiguration;
}
BeforeGeneratePage?.Invoke(this, generatePageEvent);
// someone wants to cancel this generation of this event.
if (generatePageEvent.CancelAction)
{
return;
}
BeforeGetPageContent?.Invoke(this, generatePageEvent);
if (configuration.UseRouting)
{
StaticWebRouting.Remove(relativePath);
if (hasSimpleAddress)
{
StaticWebRouting.Remove(relativeSimplePath);
}
}
// someone wants to cancel this generation of this event.
if (!generatePageEvent.CancelAction)
{
var resourceInfo = DownloadResource(configuration.Url, pageUrl, generatePageEvent.TypeConfiguration);
if (resourceInfo != null)
{
if (generatePageEvent.TypeConfiguration.MimeType.StartsWith("*"))
{
generatePageEvent.TypeConfiguration = resourceInfo.TypeConfiguration;
}
if (resourceInfo.Data != null)
{
html = Encoding.UTF8.GetString(resourceInfo.Data);
}
}
}
generatePageEvent.Content = html;
// We don't care about a cancel action here
AfterGetPageContent?.Invoke(this, generatePageEvent);
if (generatePageEvent.Content == null)
{
return;
}
// reset cancel action and reason
generatePageEvent.CancelAction = false;
generatePageEvent.CancelReason = null;
BeforeTryToFixLinkUrls?.Invoke(this, generatePageEvent);
// someone wants to cancel/ignore ensuring resources.
if (!generatePageEvent.CancelAction)
{
generatePageEvent.Content = TryToFixLinkUrls(generatePageEvent.Content);
}
// reset cancel action and reason
generatePageEvent.CancelAction = false;
generatePageEvent.CancelReason = null;
BeforeEnsurePageResources?.Invoke(this, generatePageEvent);
// someone wants to cancel/ignore ensuring resources.
if (!generatePageEvent.CancelAction)
{
generatePageEvent.Content = EnsureDependencies(generatePageEvent.PageUrl, generatePageEvent.Content, configuration, useTemporaryAttribute, ignoreHtmlDependencies, generatePageEvent.TypeConfiguration, generatePageEvent.CurrentResources, generatePageEvent.Resources, 0);
}
// reset cancel action and reason
generatePageEvent.CancelAction = false;
generatePageEvent.CancelReason = null;
// We don't care about a cancel action here
AfterEnsurePageResources?.Invoke(this, generatePageEvent);
string filePath = configuration.OutputPath + relativePath + generatePageEvent.TypeConfiguration.DefaultName + generatePageEvent.TypeConfiguration.FileExtension;
var filePaths = new List <string>
{
filePath
};
if (hasSimpleAddress)
{
string filePath2 = configuration.OutputPath + relativeSimplePath + generatePageEvent.TypeConfiguration.DefaultName + generatePageEvent.TypeConfiguration.FileExtension;
filePaths.Add(filePath2);
}
generatePageEvent.FilePaths = filePaths;
// reset cancel action and reason
generatePageEvent.CancelAction = false;
generatePageEvent.CancelReason = null;
BeforeGeneratePageWrite?.Invoke(this, generatePageEvent);
// someone wants to cancel this page write.
if (!generatePageEvent.CancelAction)
{
// only write and route content if it is not empty
if (!string.IsNullOrEmpty(generatePageEvent.Content))
{
foreach (string outputFilePath in generatePageEvent.FilePaths)
{
var directory = Path.GetDirectoryName(outputFilePath);
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
WriteFile(outputFilePath, Encoding.UTF8.GetBytes(generatePageEvent.Content), useTemporaryAttribute);
if (configuration.UseRouting)
{
StaticWebRouting.Add(relativePath);
if (hasSimpleAddress)
{
StaticWebRouting.Add(relativeSimplePath);
}
}
}
}
}
AfterGeneratePageWrite?.Invoke(this, generatePageEvent);
// someone wants to cancel AFTER page write.
if (generatePageEvent.CancelAction)
{
return;
}
AfterGeneratePage?.Invoke(this, generatePageEvent);
}
