/// <summary>
/// Determines the Umbraco document (if any) matching the http request.
/// </summary>
/// <returns>A value indicating whether a document and template nave been found.</returns>
internal bool LookupDocument()
{
const string tracePrefix = "LookupDocument: ";
LogHelper.Debug <PublishedContentRequest>("{0}Path=\"{1}\"", () => tracePrefix, () => _publishedContentRequest.Uri.AbsolutePath);
// look for the document
// the first successful resolver, if any, will set this.Node, and may also set this.Template
// some lookups may implement caching
using (DisposableTimer.DebugDuration <PluginManager>(
string.Format("{0}Begin resolvers", tracePrefix),
string.Format("{0}End resolvers, {1}", tracePrefix, (_publishedContentRequest.HasNode ? "a document was found" : "no document was found"))))
{
_routingContext.DocumentLookups.Any(lookup => lookup.TrySetDocument(_publishedContentRequest));
}
// fixme - not handling umbracoRedirect
// should come after internal redirects
// so after ResolveDocument2() => docreq.IsRedirect => handled by the module!
// handle not-found, redirects, access, template
LookupDocument2();
// handle umbracoRedirect (moved from umbraco.page)
FollowRedirect();
bool resolved = _publishedContentRequest.HasNode && _publishedContentRequest.HasTemplate;
return(resolved);
}
public PersistenceAssertionBuilder <T> RunAssertionsWithQuery(IHiveReadProvider readerProvider, IHiveReadWriteProvider writeProvider, T mockedEntity, Func <HiveId, Expression <Func <T, bool> > > expression)
{
HiveId generatedId;
object[] checkValuesAfterCommitting = GetCheckValuesAfterCommitting(writeProvider, out generatedId, mockedEntity);
using (DisposableTimer.TraceDuration <NHibernateHiveTests>("Start read", "End read"))
{
using (var unit = readerProvider.CreateReadOnlyUnitOfWork())
{
var result = unit.ReadRepository.QueryContext.Query <T>().Where(expression(generatedId)).FirstOrDefault();
Assert.IsNotNull(result,
"No entity was retrieved back from the datastore for query {0} (id was {1})",
expression,
generatedId);
Assert.IsTrue(generatedId == result.Id);
LogHelper.TraceIfEnabled <PersistenceAssertionBuilder <T> >("Item owned by {0}, retrieved from {1}", () => result.PersistenceMetadata.OwnerProviderAlias, () => result.PersistenceMetadata.ReturnedByProviderAlias);
for (int i = 0; i < _valuesAndAssertions.Count; i++)
{
_valuesAndAssertions[i].Item2.Invoke(result, checkValuesAfterCommitting[i]);
}
}
}
return(this);
}
public PersistenceAssertionBuilder <T> RunAssertions(IHiveReadProvider readerProvider, IHiveReadWriteProvider writeProvider, T mockedEntity)
{
HiveId generatedId;
object[] checkValuesAfterCommitting = GetCheckValuesAfterCommitting(writeProvider, out generatedId, mockedEntity);
using (DisposableTimer.TraceDuration <NHibernateHiveTests>("Start read", "End read"))
{
using (var unit = readerProvider.CreateReadOnlyUnitOfWork())
{
var result = unit.ReadRepository.GetEntity <T>(generatedId);
Assert.IsNotNull(result, "No entity was retrieved back from the datastore with id {0}", generatedId);
Assert.AreEqual(generatedId, result.Id, "Got a different value back from the database for the Id");
LogHelper.TraceIfEnabled <PersistenceAssertionBuilder <T> >("Item owned by {0}, retrieved from {1}", () => result.PersistenceMetadata.OwnerProviderAlias, () => result.PersistenceMetadata.ReturnedByProviderAlias);
for (int i = 0; i < _valuesAndAssertions.Count; i++)
{
_valuesAndAssertions[i].Item2.Invoke(result, checkValuesAfterCommitting[i]);
}
}
_postWriteCallback.Invoke();
}
return(this);
}
/// <summary>
/// Executes the controller action
/// </summary>
private static void ExecuteControllerAction(ControllerContext context, IController controller)
{
using (DisposableTimer.TraceDuration <UmbracoPageResult>("Executing Umbraco RouteDefinition controller", "Finished"))
{
controller.Execute(context.RequestContext);
}
}
/// <summary>
/// The RegEx matches any HTML attribute values that start with a tilde (~), those that match are passed to ResolveUrl to replace the tilde with the application path.
/// </summary>
/// <param name="text"></param>
/// <param name="preview"></param>
/// <returns></returns>
/// <remarks>
/// When used with a Virtual-Directory set-up, this would resolve all URLs correctly.
/// The recommendation is that the "ResolveUrlsFromTextString" option (in umbracoSettings.config) is set to false for non-Virtual-Directory installs.
/// </remarks>
public static string ResolveUrlsFromTextString(string text)
{
if (UmbracoSettings.ResolveUrlsFromTextString == false)
{
return(text);
}
using (var timer = DisposableTimer.DebugDuration(typeof(IOHelper), "ResolveUrlsFromTextString starting", "ResolveUrlsFromTextString complete"))
{
// find all relative urls (ie. urls that contain ~)
var tags = ResolveUrlPattern.Matches(text);
LogHelper.Debug(typeof(IOHelper), "After regex: " + timer.Stopwatch.ElapsedMilliseconds + " matched: " + tags.Count);
foreach (Match tag in tags)
{
var url = "";
if (tag.Groups[1].Success)
{
url = tag.Groups[1].Value;
}
// The richtext editor inserts a slash in front of the url. That's why we need this little fix
// if (url.StartsWith("/"))
// text = text.Replace(url, ResolveUrl(url.Substring(1)));
// else
if (String.IsNullOrEmpty(url) == false)
{
var resolvedUrl = (url.Substring(0, 1) == "/") ? IOHelper.ResolveUrl(url.Substring(1)) : IOHelper.ResolveUrl(url);
text = text.Replace(url, resolvedUrl);
}
}
}
return(text);
}
public BootManager(HttpApplication app)
{
_timer = DisposableTimer.Start(timer => LogHelper.TraceIfEnabled <BootManager>("Application start took {0}ms", () => timer));
_app = app;
LogHelper.TraceIfEnabled <BootManager>("Created");
_rebelWireup = new RebelContainerBuilder <HttpApplication>(_app);
}
public virtual IBootManager Initialize()
{
if (_isInitialized)
throw new InvalidOperationException("The boot manager has already been initialized");
InitializeProfilerResolver();
_timer = DisposableTimer.DebugDuration<CoreBootManager>("Umbraco application starting", "Umbraco application startup complete");
//create database and service contexts for the app context
var dbFactory = new DefaultDatabaseFactory(GlobalSettings.UmbracoConnectionName);
Database.Mapper = new PetaPocoMapper();
var dbContext = new DatabaseContext(dbFactory);
var serviceContext = new ServiceContext(
new PetaPocoUnitOfWorkProvider(dbFactory),
new FileUnitOfWorkProvider(),
new PublishingStrategy());
CreateApplicationContext(dbContext, serviceContext);
InitializeApplicationEventsResolver();
InitializeResolvers();
//initialize the DatabaseContext
dbContext.Initialize();
//now we need to call the initialize methods
ApplicationEventsResolver.Current.ApplicationEventHandlers
.ForEach(x => x.OnApplicationInitialized(UmbracoApplication, ApplicationContext));
_isInitialized = true;
return this;
}
public virtual CacheCreationResult <T> GetOrCreate <T>(string key, Func <CacheValueOf <T> > callback)
{
var inheritorType = GetType();
LogHelper.TraceIfEnabled(inheritorType, "In GetOrCreate for {0}", key.ToString);
using (DisposableTimer.TraceDuration(inheritorType, "Start GetOrCreate", "End GetOrCreate"))
{
var existing = Get <T>(key);
if (existing != null)
{
LogHelper.TraceIfEnabled <AbstractCacheProvider>("Item existed");
var existingCast = existing as CacheValueOf <T>;
if (existingCast != null)
{
return(new CacheCreationResult <T>(false, false, true, existingCast));
}
return(new CacheCreationResult <T>(false, false, true, default(CacheValueOf <T>), true));
}
LogHelper.TraceIfEnabled(inheritorType, "Item did not exist");
var newValue = callback.Invoke();
var result = AddOrChange(key, newValue);
return(new CacheCreationResult <T>(result.WasUpdated, result.WasInserted, false, newValue));
}
}
public XmlStoreHiveTests()
{
using (DisposableTimer.TraceDuration <XmlStoreHiveTests>("Start setup", "End setup"))
{
// Create reader
var xmlPath =
Path.Combine(
Path.GetDirectoryName(Assembly.GetExecutingAssembly().CodeBase.Substring("file:\\\\".Length + 1)),
"App_Data\\umbraco.config");
_fakeFrameworkContext = new FakeFrameworkContext();
_dataContextFactory = new DataContextFactory(xmlPath);
_readOnlyUnitOfWorkFactory = new ReadOnlyUnitOfWorkFactory();
_directHiveReadProvider = new HiveReadProvider(new HiveProviderSetup(_fakeFrameworkContext, "r-unit-tester", new FakeHiveProviderBootstrapper(), _readOnlyUnitOfWorkFactory, null, _dataContextFactory));
// Create writer
_readWriteUnitOfWorkFactory = new ReadWriteUnitOfWorkFactory();
_writeProvider = new HiveReadWriteProvider(new HiveProviderSetup(_fakeFrameworkContext, "rw-unit-tester", new FakeHiveProviderBootstrapper(), null, _readWriteUnitOfWorkFactory, _dataContextFactory));
// Create hive wrappers for the readers and writers
var governorRUowFactory = new ReadOnlyUnitOfWorkFactoryWrapper(new[] { _directHiveReadProvider });
var governorRWUowFactory = new ReadWriteUnitOfWorkFactoryWrapper(new[] { _writeProvider });
_hiveReadProviderViaGovernor = new Framework.Hive.PersistenceGovernor.HiveReadProvider(new HiveProviderSetup(_fakeFrameworkContext, "r-unit-tester", new FakeHiveProviderBootstrapper(), governorRUowFactory, null, null), new[] { _directHiveReadProvider });
_hiveReadWriteProviderViaGovernor = new Framework.Hive.PersistenceGovernor.HiveReadWriteProvider(new HiveProviderSetup(_fakeFrameworkContext, "rw-unit-tester", new FakeHiveProviderBootstrapper(), null, governorRWUowFactory, null), new[] { _writeProvider });
}
}
public virtual void RegisterMacroEngines(IContainerBuilder builder, TypeFinder typeFinder)
{
if (_macroEnginesRegistered)
{
return;
}
using (DisposableTimer.Start(timer =>
{
LogHelper.TraceIfEnabled <RebelComponentRegistrar>("RegisterMacroEngines start took {0}ms", () => timer);
_macroEnginesRegistered = true;
}))
{
//now register each type in the container and also add it to our collection);
foreach (var t in FindTypesInRequiredAssemblies <AbstractMacroEngine>(typeFinder))
{
var engineType = t;
RegisterComponent <AbstractMacroEngine, MacroEngineAttribute, MacroEngineMetadata>(
t, builder, true,
(pluginDef, attribute, registrar) =>
registrar
.WithMetadata <MacroEngineMetadata, string>(am => am.EngineName, attribute.EngineName)
.WithMetadata <MacroEngineMetadata, bool>(am => am.IsInternalRebelEngine,
engineType.GetCustomAttributes(typeof(RebelMacroEngineAttribute), false).Any())
.ScopedAs.Singleton()); //only need one each
}
}
}
public void Can_Bulk_Insert()
{
// Arrange
var db = DatabaseContext.Database;
var servers = new List <ServerRegistrationDto>();
for (var i = 0; i < 1000; i++)
{
servers.Add(new ServerRegistrationDto
{
Address = "address" + i,
ComputerName = "computer" + i,
DateRegistered = DateTime.Now,
IsActive = true,
LastNotified = DateTime.Now
});
}
// Act
using (DisposableTimer.TraceDuration <PetaPocoExtensionsTest>("starting insert", "finished insert"))
{
db.BulkInsertRecords(servers);
}
// Assert
Assert.That(db.ExecuteScalar <int>("SELECT COUNT(*) FROM umbracoServer"), Is.EqualTo(1000));
}
/// <summary>
/// Register the tree controllers
/// </summary>
/// <param name="builder"></param>
/// <param name="typeFinder"></param>
public virtual void RegisterTreeControllers(IContainerBuilder builder, TypeFinder typeFinder)
{
if (_treeControllersRegistered)
{
return;
}
using (DisposableTimer.Start(timer =>
{
LogHelper.TraceIfEnabled <RebelComponentRegistrar>("RegisterTreeControllers start took {0}ms", () => timer);
_treeControllersRegistered = true;
}))
{
//now register each type in the container and also add it to our collection
foreach (var t in FindTypesInRequiredAssemblies <TreeController>(typeFinder))
{
var treeType = t;
RegisterComponent <TreeController, TreeAttribute, TreeMetadata>(t, builder, true,
(pluginDef, attribute, registrar) =>
registrar
.WithMetadata <EditorMetadata, string>(am => am.ControllerName, RebelController.GetControllerName(treeType))
.WithMetadata <TreeMetadata, string>(am => am.TreeTitle, attribute.TreeTitle)
.WithMetadata <TreeMetadata, bool>(am => am.IsInternalRebelTree,
treeType.GetCustomAttributes(typeof(RebelTreeAttribute), false).Any()));
}
}
}
/// <summary>
/// Registers all tasks.
/// </summary>
/// <param name="builder">The builder.</param>
/// <param name="typeFinder">The type finder.</param>
/// <remarks></remarks>
public virtual void RegisterTasks(IContainerBuilder builder, TypeFinder typeFinder)
{
if (_tasksRegistered)
{
return;
}
using (DisposableTimer.Start(timer =>
{
LogHelper.TraceIfEnabled <RebelComponentRegistrar>("RegisterTasks start took {0}ms", () => timer);
_tasksRegistered = true;
}))
{
foreach (var t in FindTypesInRequiredAssemblies <AbstractTask>(typeFinder))
{
RegisterComponent <AbstractTask, TaskAttribute, TaskMetadata>(t, builder, false,
(pluginDef, attribute, registrar) =>
{
//if there's no attribute since we're not requiring that all AbstractTasks have one,
//then don't register it into IoC as it might be something like our 'Delegate' task
//or another custom one that is added to the task manager at runtime
if (attribute == null)
{
return;
}
registrar
.WithMetadata <TaskMetadata, string>(metadata => metadata.TriggerName, attribute.Trigger)
.WithMetadata <TaskMetadata, bool>(metadata => metadata.ContinueOnError, attribute.ContinueOnFailure)
.ScopedAs.Singleton();
}); //only need one each
}
}
}
public void Get_All_Published_Content_Of_Type()
{
var result = PrimeDbWithLotsOfContent();
var contentSvc = (ContentService)ServiceContext.ContentService;
var countOfPublished = result.Count(x => x.Published);
var contentTypeId = result.First().ContentTypeId;
using (DisposableTimer.DebugDuration <PerformanceTests>("Getting published content of type normally"))
{
//do this 10x!
for (var i = 0; i < 10; i++)
{
//clear the cache to make this test valid
RuntimeCacheProvider.Current.Clear();
//get all content items that are published of this type
var published = contentSvc.GetContentOfContentType(contentTypeId).Where(content => content.Published);
Assert.AreEqual(countOfPublished, published.Count(x => x.ContentTypeId == contentTypeId));
}
}
using (DisposableTimer.DebugDuration <PerformanceTests>("Getting published content of type optimized"))
{
//do this 10x!
for (var i = 0; i < 10; i++)
{
//clear the cache to make this test valid
RuntimeCacheProvider.Current.Clear();
//get all content items that are published of this type
var published = contentSvc.GetPublishedContentOfContentType(contentTypeId);
Assert.AreEqual(countOfPublished, published.Count(x => x.ContentTypeId == contentTypeId));
}
}
}
/// <summary>
/// Finds & Registers the Surface controllers
/// </summary>
/// <param name="builder"></param>
/// <param name="typeFinder"></param>
public virtual void RegisterSurfaceControllers(IContainerBuilder builder, TypeFinder typeFinder)
{
if (_surfaceControllersRegistered)
{
return;
}
using (DisposableTimer.Start(timer =>
{
LogHelper.TraceIfEnabled <RebelComponentRegistrar>("RegisterSurfaceControllers start took {0}ms", () => timer);
_surfaceControllersRegistered = true;
}))
{
//now register each type in the container and also add it to our collection);
foreach (var t in FindTypesInRequiredAssemblies <SurfaceController>(typeFinder))
{
var surfaceType = t;
RegisterComponent <SurfaceController, SurfaceAttribute, SurfaceMetadata>(
t, builder, false,
(pluginDef, attribute, registrar) =>
registrar
.WithMetadata <SurfaceMetadata, string>(am => am.ControllerName, RebelController.GetControllerName(surfaceType))
.WithMetadata <SurfaceMetadata, bool>(am => am.HasChildActionMacros,
surfaceType.GetMethods().Any(a => a.GetCustomAttributes(typeof(ChildActionOnlyAttribute), false).Any())));
}
}
}
public BootManager(HttpApplication app)
{
_timer = DisposableTimer.Start(timer => LogHelper.TraceIfEnabled<BootManager>("Application start took {0}ms", () => timer));
_app = app;
LogHelper.TraceIfEnabled<BootManager>("Created");
_rebelWireup = new RebelContainerBuilder<HttpApplication>(_app);
}
public override bool PerformRun()
{
if (_appContext == null)
{
return(true); // repeat...
}
switch (_appContext.GetCurrentServerRole())
{
case ServerRole.Slave:
LogHelper.Debug <LogScrubber>("Does not run on slave servers.");
return(true); // DO repeat, server role can change
case ServerRole.Unknown:
LogHelper.Debug <LogScrubber>("Does not run on servers with unknown role.");
return(true); // DO repeat, server role can change
}
// ensure we do not run if not main domain, but do NOT lock it
if (_appContext.MainDom.IsMainDom == false)
{
LogHelper.Debug <LogScrubber>("Does not run if not MainDom.");
return(false); // do NOT repeat, going down
}
using (DisposableTimer.DebugDuration <LogScrubber>("Log scrubbing executing", "Log scrubbing complete"))
{
Log.CleanLogs(GetLogScrubbingMaximumAge(_settings));
}
return(true); // repeat
}
public void RemoveRelation(IRelationById item, AbstractScopedCache repositoryScopedCache)
{
var sessionIdAsString = GetSessionId().ToString("n");
using (DisposableTimer.TraceDuration <NhSessionHelper>("In RemoveRelation for session " + sessionIdAsString, "End RemoveRelation for session " + sessionIdAsString))
{
var relationType = GetOrCreateNodeRelationType(item.Type.RelationName, repositoryScopedCache);
// Nh should handle this for us but got an error with mappings atm in SqlCe (APN 09/11/11)
// Clear session cache to make sure it loads all of the tags in order to delete them all
NhSession.Flush();
// Clear the repository cache of this relation in case one has been added and then removed in the same unit of work
var cacheKey = GenerateCacheKeyForRelation(item, relationType);
repositoryScopedCache.InvalidateItems(cacheKey);
var sourceIdValue = (Guid)item.SourceId.Value;
var destinationIdValue = (Guid)item.DestinationId.Value;
var existingRelation = GetDbRelation(relationType.Alias, sourceIdValue, destinationIdValue).ToArray();
if (existingRelation.Any())
{
existingRelation.ForEach(x => NhSession.Delete(x));
}
}
}
public override bool PerformRun()
{
if (_appContext == null)
{
return(true); // repeat...
}
switch (_appContext.GetCurrentServerRole())
{
case ServerRole.Slave:
LogHelper.Debug <LogScrubber>("Does not run on replica servers.");
return(true); // DO repeat, server role can change
case ServerRole.Unknown:
LogHelper.Debug <LogScrubber>("Does not run on servers with unknown role.");
return(true); // DO repeat, server role can change
}
// ensure we do not run if not main domain, but do NOT lock it
if (_appContext.MainDom.IsMainDom == false)
{
LogHelper.Debug <LogScrubber>("Does not run if not MainDom.");
return(false); // do NOT repeat, going down
}
// running on a background task, and Log.CleanLogs uses the old SqlHelper,
// better wrap in a scope and ensure it's all cleaned up and nothing leaks
using (var scope = ApplicationContext.Current.ScopeProvider.CreateScope())
using (DisposableTimer.DebugDuration <LogScrubber>("Log scrubbing executing", "Log scrubbing complete"))
{
Log.CleanLogs(GetLogScrubbingMaximumAge(_settings));
scope.Complete();
}
return(true); // repeat
}
/// <summary>
/// Gets a collection of the given type from the given <see cref="IEnumerable{IPublishedContent}"/>.
/// </summary>
/// <param name="items">
/// The <see cref="IEnumerable{IPublishedContent}"/> to convert.
/// </param>
/// <param name="type">
/// The <see cref="Type"/> of items to return.
/// </param>
/// <param name="documentTypeAlias">
/// The document type alias.
/// </param>
/// <param name="convertingType">
/// The <see cref="Action{ConvertingTypeEventArgs}"/> to fire when converting.
/// </param>
/// <param name="convertedType">
/// The <see cref="Action{ConvertedTypeEventArgs}"/> to fire when converted.
/// </param>
/// <param name="culture">
/// The <see cref="CultureInfo"/>.
/// </param>
/// <returns>
/// The resolved <see cref="IEnumerable{T}"/>.
/// </returns>
public static IEnumerable <object> As(
this IEnumerable <IPublishedContent> items,
Type type,
string documentTypeAlias = null,
Action <ConvertingTypeEventArgs> convertingType = null,
Action <ConvertedTypeEventArgs> convertedType = null,
CultureInfo culture = null)
{
using (DisposableTimer.DebugDuration <IEnumerable <object> >(string.Format("IEnumerable As ({0})", documentTypeAlias)))
{
IEnumerable <object> typedItems;
if (string.IsNullOrWhiteSpace(documentTypeAlias))
{
typedItems = items.Select(x => x.As(type, convertingType, convertedType, culture));
}
else
{
typedItems = items.Where(x => documentTypeAlias.InvariantEquals(x.DocumentTypeAlias))
.Select(x => x.As(type, convertingType, convertedType, culture));
}
// We need to cast back here as nothing is strong typed anymore.
return((IEnumerable <object>)EnumerableInvocations.Cast(type, typedItems));
}
}
internal static string ResolveUrlsFromTextString(string text)
{
if (UmbracoSettings.ResolveUrlsFromTextString)
{
using (var timer = DisposableTimer.DebugDuration(typeof(IOHelper), "ResolveUrlsFromTextString starting", "ResolveUrlsFromTextString complete"))
{
// find all relative urls (ie. urls that contain ~)
var tags = ResolveUrlPattern.Matches(text);
LogHelper.Debug(typeof(IOHelper), "After regex: " + timer.Stopwatch.ElapsedMilliseconds + " matched: " + tags.Count);
foreach (Match tag in tags)
{
string url = "";
if (tag.Groups[1].Success)
{
url = tag.Groups[1].Value;
}
if (string.IsNullOrEmpty(url) == false)
{
string resolvedUrl = (url.Substring(0, 1) == "/") ? ResolveUrl(url.Substring(1)) : ResolveUrl(url);
text = text.Replace(url, resolvedUrl);
}
}
}
}
return(text);
}
/// <summary>
/// Loads the specified item. To be called from the OnLoad method of Item.
/// </summary>
/// <param name="item">The item.</param>
public virtual void Load(Item item)
{
using (DisposableTimer.DebugDuration <ItemRenderer>(string.Format("Item: {0}", item.Field)))
{
ParseMacros(item);
}
}
internal static string ResolveUrlsFromTextString(string text)
{
if (UmbracoConfig.For.UmbracoSettings().Content.ResolveUrlsFromTextString)
{
using (DisposableTimer.DebugDuration(typeof(IOHelper), "ResolveUrlsFromTextString starting", "ResolveUrlsFromTextString complete"))
{
// find all relative urls (ie. urls that contain ~)
var tags = ResolveUrlPattern.Matches(text);
foreach (Match tag in tags)
{
string url = "";
if (tag.Groups[1].Success)
{
url = tag.Groups[1].Value;
}
if (String.IsNullOrEmpty(url) == false)
{
string resolvedUrl = (url.Substring(0, 1) == "/") ? ResolveUrl(url.Substring(1)) : ResolveUrl(url);
text = text.Replace(url, resolvedUrl);
}
}
}
}
return(text);
}
/// <summary>
/// Parses the macros inside the text, by creating child elements for each item.
/// </summary>
/// <param name="item">The item.</param>
protected virtual void ParseMacros(Item item)
{
// do nothing if the macros have already been rendered
if (item.Controls.Count > 0)
{
return;
}
string elementText = GetFieldContents(item);
using (DisposableTimer.DebugDuration <ItemRenderer>("Parsing Macros"))
{
MacroTagParser.ParseMacros(
elementText,
//callback for when a text block is parsed
textBlock => item.Controls.Add(new LiteralControl(textBlock)),
//callback for when a macro is parsed:
(macroAlias, attributes) =>
{
var macroControl = new Macro
{
Alias = macroAlias
};
foreach (var i in attributes.Where(i => macroControl.Attributes[i.Key] == null))
{
macroControl.Attributes.Add(i.Key, i.Value);
}
item.Controls.Add(macroControl);
});
}
}
/// <summary>
/// Registers all menu items
/// </summary>
/// <param name="builder"></param>
/// <param name="typeFinder"></param>
public virtual void RegisterMenuItems(IContainerBuilder builder, TypeFinder typeFinder)
{
if (_menuItemsRegistered)
{
return;
}
using (DisposableTimer.Start(timer =>
{
LogHelper.TraceIfEnabled <RebelComponentRegistrar>("RegisterMenuItems start took {0}ms", () => timer);
_menuItemsRegistered = true;
}))
{
foreach (var t in FindTypesInRequiredAssemblies <MenuItem>(typeFinder))
{
RegisterComponent <MenuItem, MenuItemAttribute, MenuItemMetadata>(t, builder, true,
(pluginDef, attribute, registrar) =>
registrar
.WithMetadata <MenuItemMetadata, string>(am => am.Title, attribute.Title)
.WithMetadata <MenuItemMetadata, bool>(am => am.SeperatorBefore, attribute.SeparatorBefore)
.WithMetadata <MenuItemMetadata, bool>(am => am.SeperatorAfter, attribute.SeparatorAfter)
.WithMetadata <MenuItemMetadata, string>(am => am.Icon, attribute.Icon)
.WithMetadata <MenuItemMetadata, string>(am => am.OnClientClick, attribute.OnClientClick)
.ScopedAs.Singleton()); //only need one each
}
}
}
/// <summary>
/// Returns the recursive value using a legacy strategy of looking at the xml cache and the splitPath in the elements collection
/// </summary>
/// <param name="elements"></param>
/// <returns></returns>
private string GetRecursiveValueLegacy(IDictionary elements)
{
using (DisposableTimer.DebugDuration <item>("Checking recusively"))
{
var content = "";
var umbracoXml = presentation.UmbracoContext.Current.GetXml();
var splitpath = (String[])elements["splitpath"];
for (int i = 0; i < splitpath.Length - 1; i++)
{
XmlNode element = umbracoXml.GetElementById(splitpath[splitpath.Length - i - 1]);
if (element == null)
{
continue;
}
var xpath = UmbracoConfig.For.UmbracoSettings().Content.UseLegacyXmlSchema ? "./data [@alias = '{0}']" : "./{0}";
var currentNode = element.SelectSingleNode(string.Format(xpath, _fieldName));
//continue if all is null
if (currentNode == null || currentNode.FirstChild == null || string.IsNullOrEmpty(currentNode.FirstChild.Value) || string.IsNullOrEmpty(currentNode.FirstChild.Value.Trim()))
{
continue;
}
HttpContext.Current.Trace.Write("item.recursive", "Item loaded from " + splitpath[splitpath.Length - i - 1]);
content = currentNode.FirstChild.Value;
break;
}
return(content);
}
}
/// <summary>
/// Registers all RebelPropertyEditors
/// </summary>
/// <param name="builder"></param>
/// <param name="typeFinder"></param>
public virtual void RegisterPropertyEditors(IContainerBuilder builder, TypeFinder typeFinder)
{
if (_propEditorsRegistered)
{
return;
}
using (DisposableTimer.Start(timer =>
{
LogHelper.TraceIfEnabled <RebelComponentRegistrar>("RegisterPropertyEditors start took {0}ms", () => timer);
_propEditorsRegistered = true;
}))
{
foreach (var t in FindTypesInRequiredAssemblies <PropertyEditor>(typeFinder))
{
var propEditorType = t;
//builder.ForType(propEditorType).Register();
RegisterComponent <PropertyEditor, PropertyEditorAttribute, PropertyEditorMetadata>(t, builder, true,
(pluginDef, attribute, registrar) =>
registrar
.WithMetadata <PropertyEditorMetadata, string>(am => am.Name, attribute.Name)
.WithMetadata <PropertyEditorMetadata, string>(am => am.Alias, attribute.Alias)
.WithMetadata <PropertyEditorMetadata, bool>(am => am.IsContentPropertyEditor, attribute.IsContentPropertyEditor)
.WithMetadata <PropertyEditorMetadata, bool>(am => am.IsParameterEditor, attribute.IsParameterEditor)
.WithMetadata <PropertyEditorMetadata, bool>(am => am.IsInternalRebelEditor,
propEditorType.GetCustomAttributes(typeof(RebelPropertyEditorAttribute), false).Any()));
}
}
}
public void Benchmark_Original_Finder()
{
using (DisposableTimer.TraceDuration <TypeFinderTests>("Starting test", "Finished test"))
{
using (DisposableTimer.TraceDuration <TypeFinderTests>("Starting FindClassesOfType", "Finished FindClassesOfType"))
{
for (var i = 0; i < 1000; i++)
{
Assert.Greater(TypeFinderOriginal.FindClassesOfType <DisposableObject>(_assemblies).Count(), 0);
}
}
using (DisposableTimer.TraceDuration <TypeFinderTests>("Starting FindClassesOfTypeWithAttribute", "Finished FindClassesOfTypeWithAttribute"))
{
for (var i = 0; i < 1000; i++)
{
Assert.Greater(TypeFinderOriginal.FindClassesOfTypeWithAttribute <TestEditor, MyTestAttribute>(_assemblies).Count(), 0);
}
}
using (DisposableTimer.TraceDuration <TypeFinderTests>("Starting FindClassesWithAttribute", "Finished FindClassesWithAttribute"))
{
for (var i = 0; i < 1000; i++)
{
Assert.Greater(TypeFinderOriginal.FindClassesWithAttribute <XsltExtensionAttribute>(_assemblies).Count(), 0);
}
}
}
}
/// <summary>
/// Registers the permissions.
/// </summary>
/// <param name="builder">The builder.</param>
/// <param name="typeFinder">The type finder.</param>
public virtual void RegisterPermissions(IContainerBuilder builder, TypeFinder typeFinder)
{
if (_permissionsRegistered)
{
return;
}
using (DisposableTimer.Start(timer =>
{
LogHelper.TraceIfEnabled <RebelComponentRegistrar>("RegisterPermissions start took {0}ms", () => timer);
_permissionsRegistered = true;
}))
{
foreach (var t in FindTypesInRequiredAssemblies <Permission>(typeFinder))
{
RegisterComponent <Permission, PermissionAttribute, PermissionMetadata>(t, builder, true,
(pluginDef, attribute, registrar) =>
registrar
.WithMetadata <PermissionMetadata, string>(metadata => metadata.Name, attribute.Name)
.WithMetadata <PermissionMetadata, string>(metadata => metadata.Type, attribute.Type)
.WithMetadata <PermissionMetadata, UserType>(metadata => metadata.UserType, attribute.UserType)
.ScopedAs.Singleton()); //only need one each
}
}
}
/// <summary>
/// Returns an ActionResult for the specified Macro.
/// </summary>
/// <param name="macroAlias"></param>
/// <param name="currentControllerContext"></param>
/// <param name="isForRichTextEditor">If the request is to render the contents in the back office rich text editor</param>
/// <param name="resolveContent">callback to get the 'Content' model</param>
public ActionResult RenderMacro(
string macroAlias,
IDictionary <string, string> macroParams,
ControllerContext currentControllerContext,
bool isForRichTextEditor,
Func <Content> resolveContent)
{
using (DisposableTimer.Start(timer =>
LogHelper.TraceIfEnabled <MacroRenderer>("RenderMacro for {0} took {1}ms", () => macroAlias, () => timer)))
{
try
{
// get the macro's model
var macroModel = GetMacroModel(macroAlias);
if (isForRichTextEditor && !macroModel.Item1.RenderContentInEditor)
{
return(NoRichTextRenderMode(macroAlias));
}
else
{
return(GetMacroResult(macroAlias, () => macroModel.Item1, resolveContent, macroParams, currentControllerContext));
}
}
catch (ApplicationException ex)
{
//if there's an exception, display a friendly message and log the error
var txt = "Macro.RenderingFailed.Message".Localize(this, new { Error = ex.Message, MacroName = macroAlias });
var title = "Macro.RenderingFailed.Title".Localize();
LogHelper.Error <MacroRenderer>(txt, ex);
return(MacroError(txt, title));
}
}
}
public override object ConvertDataToSource(PublishedPropertyType propertyType, object source, bool preview)
{
var defaultValue = new ArchetypeModel();
if (source == null)
{
return(defaultValue);
}
var sourceString = source.ToString();
if (!sourceString.DetectIsJson())
{
return(defaultValue);
}
using (var timer = DisposableTimer.DebugDuration <ArchetypeValueConverter>(string.Format("ConvertDataToSource ({0})", propertyType != null ? propertyType.PropertyTypeAlias : "null")))
{
var archetype = ArchetypeHelper.Instance.DeserializeJsonToArchetype(sourceString,
(propertyType != null ? propertyType.DataTypeId : -1),
(propertyType != null ? propertyType.ContentType : null));
return(archetype);
}
}
private static void ContextOnEndRequest(object sender, EventArgs eventArgs)
{
var app = (HttpApplication)sender;
var context = app.Context;
if (context.Error != null)
{
return; //rollback on error
}
//completes the current request scope if there's not errors pending
var scope = GetTransactionScope(context);
var requestId = context.GetRequestId();
if (scope != null)
{
using (DisposableTimer.StartNew("[TransactionScopeHttpModule]: Commiting Transaction for request [{0}]".Fmt(requestId)))
{
scope.Complete();
}
}
else
{
Trace.TraceWarning("[TransactionScopeHttpModule]: No TransactionScope found for Current Request: [{0}]. Error ?", requestId);
}
}
public virtual IBootManager Initialize()
{
if (_isInitialized)
throw new InvalidOperationException("The boot manager has already been initialized");
LogHelper.Info<CoreBootManager>("Umbraco application starting");
_timer = DisposableTimer.Start(x => LogHelper.Info<CoreBootManager>("Umbraco application startup complete" + " (took " + x + "ms)"));
//create the ApplicationContext
ApplicationContext = ApplicationContext.Current = new ApplicationContext();
InitializeResolvers();
_isInitialized = true;
return this;
}
public override IBootManager Initialize()
{
if (_isInitialized)
throw new InvalidOperationException("The Merchello core boot manager has already been initialized");
OnMerchelloInit();
_timer = DisposableTimer.DebugDuration<CoreBootManager>("Merchello starting", "Merchello startup complete");
// create the service context for the MerchelloAppContext
var connString = ConfigurationManager.ConnectionStrings[MerchelloConfiguration.Current.Section.DefaultConnectionStringName].ConnectionString;
var providerName = ConfigurationManager.ConnectionStrings[MerchelloConfiguration.Current.Section.DefaultConnectionStringName].ProviderName;
var serviceContext = new ServiceContext(new PetaPocoUnitOfWorkProvider(connString, providerName));
CreateMerchelloContext(serviceContext);
_isInitialized = true;
return this;
}
/// <summary>
/// The initialize.
/// </summary>
/// <returns>
/// The <see cref="IBootManager"/>.
/// </returns>
/// <exception cref="InvalidOperationException">
/// Throws an exception if Gleaner is already initialized
/// </exception>
public virtual void Initialize()
{
if (IsInitialized)
{
throw new InvalidOperationException("The Gleaner core boot manager has already been initialized");
}
_timer = DisposableTimer.DebugDuration<CoreBootManager>("Gleaner starting", "Gleaner startup complete");
// create the service context for the GleanerAppContext
var serviceContext = new ServiceContext();
var cache = ApplicationContext.Current == null
? new CacheHelper(
new ObjectCacheRuntimeCacheProvider(),
new StaticCacheProvider(),
new NullCacheProvider())
: ApplicationContext.Current.ApplicationCache;
CreateGleanerContext(serviceContext, cache);
IsInitialized = true;
}
/// <summary>
/// The initialize.
/// </summary>
/// <returns>
/// The <see cref="IBootManager"/>.
/// </returns>
/// <exception cref="InvalidOperationException">
/// Throws an exception if Merchello is already initialized
/// </exception>
public override IBootManager Initialize()
{
if (IsInitialized)
throw new InvalidOperationException("The Merchello core boot manager has already been initialized");
OnMerchelloInit();
_timer = DisposableTimer.DebugDuration<CoreBootManager>("Merchello starting", "Merchello startup complete");
// create the service context for the MerchelloAppContext
var connString = ConfigurationManager.ConnectionStrings[MerchelloConfiguration.Current.Section.DefaultConnectionStringName].ConnectionString;
var providerName = ConfigurationManager.ConnectionStrings[MerchelloConfiguration.Current.Section.DefaultConnectionStringName].ProviderName;
_unitOfWorkProvider = new PetaPocoUnitOfWorkProvider(connString, providerName);
var serviceContext = new ServiceContext(_unitOfWorkProvider);
var cache = ApplicationContext.Current == null
? new CacheHelper(
new ObjectCacheRuntimeCacheProvider(),
new StaticCacheProvider(),
new NullCacheProvider())
: ApplicationContext.Current.ApplicationCache;
InitializeGatewayResolver(serviceContext, cache);
CreateMerchelloContext(serviceContext, cache);
InitializeResolvers();
InitializeObserverSubscriptions();
IsInitialized = true;
return this;
}
