public void CannotCreate_ItemBelow_UnallowedParent()
{
var page = new IntegrityPage();
// Doesn't throw
activator.CreateInstance <IntegrityStartPage>(page);
}
public void CannotCreate_ItemBelow_UnallowedParent()
{
var page = new IntegrityPage();
ExceptionAssert.Throws <NotAllowedParentException>(delegate
{
var neverReturned = activator.CreateInstance <IntegrityStartPage>(page);
});
}
public virtual ContentItem InsertRootNode(Type type, string name, string title)
{
ContentItem item = activator.CreateInstance(type, null);
item.Name = name;
item.Title = title;
item[InstallationAppPath] = N2.Web.Url.ToAbsolute("~/");
item[installationHost] = webContext.Url.HostUrl.ToString();
persister.Save(item);
return(item);
}
public ActionResult Add(string name)
{
var part = activator.CreateInstance <TestPart>(CurrentItem);
part.Name = name;
part.Title = name;
part.ZoneName = "TestParts";
Engine.Persister.Save(part);
return(View("Index"));
}
public IEnumerable <TemplateDefinition> GetTemplates(Type contentType)
{
var httpContext = httpContextProvider.Get();
if (httpContext == null)
{
return(new TemplateDefinition[0]);
}
try
{
httpContext.Request.GetType();
}
catch (Exception)
{
return(new TemplateDefinition[0]);
}
const string cacheKey = "RazorDefinitions";
var definitions = httpContext.Cache[cacheKey] as IEnumerable <ItemDefinition>;
lock (this)
{
if (definitions == null || rebuild)
{
DequeueRegistrations();
var vpp = vppProvider.Get();
var descriptions = analyzer.AnalyzeViews(vpp, httpContext, sources).ToList();
definitions = BuildDefinitions(descriptions);
var files = descriptions.SelectMany(p => p.TouchedPaths).Distinct().ToList();
//var dirs = files.Select(f => f.Substring(0, f.LastIndexOf('/'))).Distinct();
var cacheDependency = vpp.GetCacheDependency(files.FirstOrDefault(), files, DateTime.UtcNow);
httpContext.Cache.Remove(cacheKey);
httpContext.Cache.Add(cacheKey, definitions, cacheDependency, Cache.NoAbsoluteExpiration, Cache.NoSlidingExpiration, CacheItemPriority.AboveNormal, new CacheItemRemovedCallback(delegate
{
logger.Debug("Razor template changed");
}));
rebuild = false;
}
}
var templates = definitions.Where(d => d.ItemType == contentType).Select(d =>
{
var td = new TemplateDefinition();
td.Definition = d;
td.Description = d.Description;
td.Name = d.TemplateKey;
td.OriginalFactory = () => null;
td.TemplateFactory = () => activator.CreateInstance(d.ItemType, null, d.TemplateKey);
td.TemplateUrl = null;
td.Title = d.Title;
td.ReplaceDefault = "Index".Equals(d.TemplateKey, StringComparison.InvariantCultureIgnoreCase);
return(td);
}).ToArray();
return(templates);
}
private void CreateItem(TemplateDefinition template, NameValueCollection request)
{
ContentItem parent = navigator.Navigate(request["below"]);
ContentItem item = activator.CreateInstance(template.Definition.ItemType, parent);
item.ZoneName = request["zone"];
item["TemplateName"] = template.Name;
string before = request["before"];
if (!string.IsNullOrEmpty(before))
{
ContentItem beforeItem = navigator.Navigate(before);
int newIndex = parent.Children.IndexOf(beforeItem);
Utility.Insert(item, parent, newIndex);
foreach (var sibling in Utility.UpdateSortOrder(parent.Children))
{
persister.Repository.Save(sibling);
}
}
persister.Save(item);
}
private string CreateItem(TemplateDefinition template, NameValueCollection request)
{
var path = new PathData(navigator.Navigate(request["below"]));
if (!versionRepository.TryParseVersion(request[PathData.VersionIndexQueryKey], request[PathData.VersionKeyQueryKey], path))
{
path.CurrentItem = versions.AddVersion(path.CurrentItem, asPreviousVersion: false);
}
var parent = path.CurrentItem;
ContentItem item = activator.CreateInstance(template.Definition.ItemType, parent);
item.ZoneName = request["zone"];
item.TemplateKey = template.Name;
string beforeVersionKey = request["beforeVersionKey"];
string beforeSortOrder = request["beforeSortOrder"];
string before = request["before"];
if (string.IsNullOrEmpty(beforeSortOrder))
{
item.AddTo(parent);
}
else
{
int index = int.Parse(beforeSortOrder);
parent.InsertChildBefore(item, index);
}
versionRepository.Save(parent);
return(request["returnUrl"].ToUrl().SetQueryParameter(PathData.VersionIndexQueryKey, parent.VersionIndex));
}
protected virtual void OnItemCreating(ItemEventArgs e)
{
EventHandler <ItemEventArgs> handler = base.Events[EventItemCreating] as EventHandler <ItemEventArgs>;
if (handler != null)
{
handler.Invoke(this, e);
}
if (e.AffectedItem != null)
{
IDefinitionManager definitions = Engine.Definitions;
ISecurityManager security = Engine.SecurityManager;
ContentActivator activator = Engine.Resolve <ContentActivator>();
ItemDefinition parentDefinition = definitions.GetDefinition(parentItem);
if (parentDefinition.IsChildAllowed(definitions, parentItem, parentDefinition))
{
e.AffectedItem = Engine.Resolve <ContentActivator>().CreateInstance(parentItem.GetContentType(), parentItem);
return;
}
foreach (ItemDefinition definition in definitions.GetAllowedChildren(parentItem, null).WhereAuthorized(security, HttpContext.Current.User, parentItem))
{
e.AffectedItem = activator.CreateInstance(definition.ItemType, parentItem);
return;
}
throw new N2.Definitions.NoItemAllowedException(parentItem);
}
}
/// <summary>Creates a container.</summary>
/// <param name="containerContainer"></param>
/// <param name="setupCreatedItem"></param>
/// <returns></returns>
protected virtual T Create(ContentItem containerContainer, Action <T> setupCreatedItem)
{
var container = activator.CreateInstance <T>(containerContainer);
setupCreatedItem(container);
persister.Save(container);
return(container);
}
/// <summary>Creates a container.</summary>
/// <param name="containerContainer"></param>
/// <param name="setupCreatedItem"></param>
/// <returns></returns>
protected virtual T Create(ContentItem containerContainer, Action <T> setupCreatedItem, string name = null)
{
var container = activator.CreateInstance <T>(containerContainer);
container.Name = name;
container.AddTo(containerContainer);
setupCreatedItem(container);
repository.SaveOrUpdate(container);
return(container);
}
public virtual Items.User CreateUser(string username, string password, string email, string passwordQuestion, string passwordAnswer, bool isApproved, object providerUserKey)
{
if (IsEditorOrAdmin(username))
{
throw new ArgumentException("Invalid username.", "username");
}
User u = (User)activator.CreateInstance(userType, GetUserContainer(true));
u.Title = username;
u.Name = username;
u.Password = password;
u.Email = email;
u.PasswordQuestion = passwordQuestion;
u.PasswordAnswer = passwordAnswer;
u.IsApproved = isApproved;
Save(u);
return(u);
}
private ContentItem Create(string family, string key, Url url, ContentItem container, Type contentType)
{
string externalUrl = url.RemoveQuery("edit").ToString();
var item = activator.CreateInstance(contentType ?? externalItemType, container);
item.Title = "";
item.Name = key;
item.ZoneName = family;
item["ExternalUrl"] = externalUrl;
persister.Save(item);
return(item);
}
public IEnumerable <TemplateDefinition> GetTemplates(Type contentType)
{
yield return(CreateTemplate(map.GetOrCreateDefinition(contentType)));
foreach (var ta in N2.Web.PathDictionary.GetFinders(contentType).OfType <N2.Web.TemplateAttribute>().Where(ta => ta.SelectableAsDefault))
{
string templateKey = ta.Action;
var definition = map.GetOrCreateDefinition(contentType, templateKey);
var template = CreateTemplate(definition);
template.OriginalFactory = () => null;
template.TemplateFactory = () => activator.CreateInstance(contentType, null, templateKey);
template.Title = ta.TemplateTitle ?? definition.Title;
template.Description = ta.TemplateDescription ?? definition.Description;
template.Name = templateKey;
yield return(template);
}
}
public IEnumerable <TemplateDefinition> GetTemplates(Type contentType)
{
return(GetTemplateDefinitions().Where(d => d.ItemType == contentType).Select(d =>
{
var td = new TemplateDefinition
{
Definition = d,
Description = d.Description,
Name = d.TemplateKey,
OriginalFactory = () => null,
TemplateFactory = () => _activator.CreateInstance(d.ItemType, null, d.TemplateKey),
TemplateUrl = null,
Title = d.Title + '*',
ReplaceDefault = true // causes hiding of base class "ContentPart", see DefinitionManager.GetTemplates
};
return td;
}).ToArray());
}
public void DefaultValues_AreApplied()
{
var master = activator.CreateInstance(typeof(NormalPage), null, null, asProxy: true);
persister.Save(master);
var draft = repository.Save(master);
repository.Repository.Dispose();
var savedDraft = (NormalPage)repository.GetVersion(master).Version;
savedDraft.Width.ShouldBe(2);
}
public T CreateInstance <T>(ContentItem parentItem) where T : ContentItem
{
return(activator.CreateInstance <T>(parentItem));
}
private ContentItem CreateInstance(Dictionary <string, string> attributes)
{
ItemDefinition definition = FindDefinition(attributes);
return(activator.CreateInstance(definition.ItemType, null, null, asProxy: true, invokeBehaviors: false));
}
public void CreateInstance_creates_insatnce_of_given_type()
{
var instance = activator.CreateInstance <Definitions.PersistableItem>(null);
instance.ShouldBeOfType <Definitions.PersistableItem>();
}
public IEnumerable <TemplateDefinition> GetTemplates(Type contentType)
{
var httpContext = httpContextProvider.Get();
if (httpContext == null)
{
logger.Warn("Trying to get templates with no context");
return(Enumerable.Empty <TemplateDefinition>());
}
try
{
httpContext.Request.GetType();
}
catch (Exception ex)
{
logger.Warn("Trying to get templates with invalid context", ex);
return(Enumerable.Empty <TemplateDefinition>());
}
const string cacheKey = "RazorDefinitions";
var definitions = httpContext.Cache[cacheKey] as IEnumerable <ItemDefinition>;
lock (this)
{
if (definitions == null || rebuild)
{
if (registrator.QueuedRegistrations.Count > 0)
{
logger.DebugFormat("Dequeuing {0} registrations", registrator.QueuedRegistrations.Count);
DequeueRegistrations();
}
var vpp = vppProvider.Get();
var descriptions = analyzer.AnalyzeViews(vpp, httpContext, sources).ToList();
if (descriptions.Count > 0)
{
logger.DebugFormat("Got {0} descriptions", descriptions.Count);
definitions = BuildDefinitions(descriptions);
logger.Debug("Built definitions");
var files = descriptions.SelectMany(p => p.Context.TouchedPaths).Distinct().ToList();
if (files.Count > 0)
{
logger.DebugFormat("Setting up cache dependency on {0} files", files.Count);
var cacheDependency = vpp.GetCacheDependency(files.FirstOrDefault(), files, DateTime.UtcNow);
httpContext.Cache.Remove(cacheKey);
httpContext.Cache.Add(cacheKey, definitions, cacheDependency, Cache.NoAbsoluteExpiration,
Cache.NoSlidingExpiration, CacheItemPriority.AboveNormal,
delegate { logger.Debug("Razor template changed"); });
}
}
rebuild = false;
}
}
if (definitions == null)
{
return(Enumerable.Empty <TemplateDefinition>());
}
var templates = definitions.Where(d => d.ItemType == contentType).Select(d =>
{
var td = new TemplateDefinition
{
Definition = d,
Description = d.Description,
Name = d.TemplateKey,
OriginalFactory = () => null,
TemplateFactory = () => activator.CreateInstance(d.ItemType, null, d.TemplateKey),
TemplateUrl = null,
Title = d.Title,
ReplaceDefault = "Index".Equals(d.TemplateKey, StringComparison.InvariantCultureIgnoreCase)
};
return(td);
}).ToArray();
return(templates);
}
public void CreateInstance_Generic_SetsItemState_New()
{
var item = activator.CreateInstance <StatefulItem>(null);
Assert.That(item.State, Is.EqualTo(ContentState.New));
}
