protected internal virtual void UpdatePageTypePropertyDefinitions(IPageType pageType, PageTypeDefinition pageTypeDefinition)
{
IEnumerable<PageTypePropertyDefinition> definitions =
pageTypePropertyDefinitionLocator.GetPageTypePropertyDefinitions(pageType, pageTypeDefinition.Type);
foreach (PageTypePropertyDefinition propertyDefinition in definitions)
{
PageDefinition pageDefinition = GetExistingPageDefinition(pageType, propertyDefinition);
if (pageDefinition == null)
{
using (new TimingsLogger(string.Format("Creating new page definition '{0}' for page type {1}: ", propertyDefinition.Name, pageType.Name)))
{
pageDefinitionUpdater.CreateNewPageDefinition(propertyDefinition);
pageDefinition = GetExistingPageDefinition(pageType, propertyDefinition);
}
}
else
{
pageDefinitionUpdater.UpdateExistingPageDefinition(pageDefinition, propertyDefinition);
}
pageDefinitionSpecificPropertySettingsUpdater.UpdatePropertySettings(pageTypeDefinition, propertyDefinition, pageDefinition);
}
}
void UpdatePageDefinitionsLocalPropertySettings(PageTypePropertyDefinition propertyDefinition, PageTypeDefinition pageTypeDefinition, PropertySettingsContainer container)
{
List<PropertySettingsUpdater> settingsUpdaters = GetPropertySettingsUpdaters(pageTypeDefinition, propertyDefinition);
settingsUpdaters.ForEach(updater =>
{
var wrapper = container.GetSetting(updater.SettingsType);
if (wrapper == null)
{
wrapper = new PropertySettingsWrapper();
container.Settings[updater.SettingsType.FullName] = wrapper;
//TODO: Add spec validating that exception is thrown with the below uncommented (An item with the same key has already been added.)
//container.Settings.Add(updater.SettingsType.FullName, wrapper);
}
bool settingsAlreadyExists = true;
if (wrapper.PropertySettings == null)
{
wrapper.PropertySettings = ((IPropertySettings)Activator.CreateInstance(updater.SettingsType)).GetDefaultValues();
settingsAlreadyExists = false;
}
if (settingsAlreadyExists && !updater.OverWriteExisting)
return;
int hashBeforeUpdate = updater.GetSettingsHashCode(wrapper.PropertySettings);
updater.UpdateSettings(wrapper.PropertySettings);
int hashAfterUpdate = updater.GetSettingsHashCode(wrapper.PropertySettings);
if (hashBeforeUpdate != hashAfterUpdate || !settingsAlreadyExists)
{
propertySettingsRepository.Save(container);
}
});
}
protected internal virtual IPageType CreateNewPageType(PageTypeDefinition definition)
{
IPageType pageType = PageTypeRepository.CreateNew();
PageTypeAttribute attribute = definition.Attribute;
string name = attribute.Name;
if (name == null)
{
name = definition.Type.Name;
}
pageType.Name = name;
if (definition.Attribute.Guid.HasValue)
pageType.GUID = definition.Attribute.Guid.Value;
string filename = attribute.Filename;
if (string.IsNullOrEmpty(filename))
{
filename = DefaultFilename;
}
pageType.FileName = filename;
PageTypeRepository.Save(pageType);
return pageType;
}
protected internal virtual void UpdatePropertySettings(PageTypeDefinition pageTypeDefinition, PageTypePropertyDefinition propertyDefinition, PageDefinition pageDefinition)
{
PropertySettingsContainer container = GetPropertySettingsContainer(pageDefinition);
UpdatePageDefinitionsGlobalPropertySettings(propertyDefinition, pageTypeDefinition, container);
UpdatePageDefinitionsLocalPropertySettings(propertyDefinition, pageTypeDefinition, container);
}
protected internal virtual IPageType CreateNewPageType(PageTypeDefinition definition)
{
IPageType pageType = PageTypeRepository.CreateNew();
PageTypeAttribute attribute = definition.Attribute;
string name = attribute.Name;
if (name == null)
{
name = definition.Type.Name;
}
pageType.Name = name;
if (definition.Attribute.Guid.HasValue)
pageType.GUID = definition.Attribute.Guid.Value;
string filename = attribute.Filename;
Version version = typeof(PageData).Assembly.GetName().Version;
bool cms6R2AndAbove = version.Major >= 6 && version.Minor >= 1;
if (string.IsNullOrEmpty(filename) && cms6R2AndAbove)
filename = DefaultFilename;
pageType.FileName = filename;
PageTypeRepository.Save(pageType);
NewlyCreatedPageTypes.Add(pageType);
return pageType;
}
public virtual void ValidatePageTypeDefinition(PageTypeDefinition definition, IEnumerable<PageTypeDefinition> allPageTypeDefinitions)
{
ValidateNameLength(definition);
ValidateInheritsFromBasePageType(definition);
ValidateAvailablePageTypes(definition, allPageTypeDefinitions);
ValidateExcludedPageTypes(definition, allPageTypeDefinitions);
PropertiesValidator.ValidatePageTypeProperties(definition);
}
protected internal virtual void ValidatePageTypeProperties(PageTypeDefinition definition)
{
ValidateNoClashingPropertiesFromInterfaces(definition.Type);
IEnumerable<PropertyInfo> propertiesForPageType = definition.Type.GetAllValidPageTypePropertiesFromClassAndImplementedInterfaces();
foreach (PropertyInfo propertyInfo in propertiesForPageType)
{
ValidatePageTypeProperty(propertyInfo);
}
}
protected internal virtual void ValidateNameLength(PageTypeDefinition definition)
{
if(definition.GetPageTypeName().Length <= MaximumPageTypeNameLength)
return;
string errorMessage = "The page type class {0} has a name that is longer than {1}. EPiServer does not save more than {1} characters and the name is often used to identify page types.";
errorMessage = string.Format(CultureInfo.InvariantCulture, errorMessage, definition.Type.Name, MaximumPageTypeNameLength);
throw new PageTypeBuilderException(errorMessage);
}
protected internal virtual void ValidateInheritsFromBasePageType(PageTypeDefinition definition)
{
Type typeToCheck = definition.Type;
if (!baseTypeForPageTypes.IsAssignableFrom(typeToCheck))
{
string errorMessage = "The type {0} has a {1} attribute but does not inherit from {2}";
errorMessage = string.Format(CultureInfo.InvariantCulture, errorMessage, typeToCheck.FullName, typeof(PageTypeAttribute).FullName,
baseTypeForPageTypes.FullName);
throw new PageTypeBuilderException(errorMessage);
}
}
public void GivenPageType_UpdatePageTypePropertyDefinitions_CallsGetPageTypePropertyDefinitions()
{
List<PageTypePropertyDefinition> definitions = new List<PageTypePropertyDefinition>();
PageTypePropertyUpdater pageTypePropertyUpdater = CreatePageTypePropertyUpdater(definitions);
IPageType pageType = new NativePageType();
PageTypeDefinition pageTypeDefinition = new PageTypeDefinition();
pageTypePropertyUpdater.UpdatePageTypePropertyDefinitions(pageType, pageTypeDefinition);
pageTypePropertyUpdater.PageTypePropertyDefinitionLocator.AssertWasCalled(
locator => locator.GetPageTypePropertyDefinitions(
pageType, pageTypeDefinition.Type));
}
public void GivenPageTypeDefinition_ValidatePageTypeProperties_ValidatesOk_WhenCollissionsExistsInInterfaceDefinitionsButIsTrumpedByDefinitionInPageTypeDefinition()
{
PageTypeDefinition definition = new PageTypeDefinition
{
Type = typeof(TestPageTypeWithClashingInterfacesWhichAlsoDefinesProperty),
Attribute = new PageTypeAttribute()
};
MockRepository fakes = new MockRepository();
PageTypeDefinitionPropertiesValidator propertiesValidator = fakes.PartialMock<PageTypeDefinitionPropertiesValidator>((PageDefinitionTypeMapper)null);
propertiesValidator.Stub(
validator => validator.ValidatePageTypePropertyType(Arg<PropertyInfo>.Is.Anything));
propertiesValidator.Replay();
propertiesValidator.ValidatePageTypeProperties(definition);
}
protected internal virtual void UpdatePropertySettings(PageTypeDefinition pageTypeDefinition, PageTypePropertyDefinition propertyDefinition, PageDefinition pageDefinition)
{
PropertySettingsContainer container = GetPropertySettingsContainer(pageDefinition);
object[] attributes = GetPropertyAttributes(propertyDefinition, pageTypeDefinition);
var useGlobalSettingsAttribute = attributes.OfType<UseGlobalSettingsAttribute>().FirstOrDefault();
if(useGlobalSettingsAttribute != null)
{
//TODO: Should validate not null and valid type at startup
var globalSettingsUpdater = globalPropertySettingsLocator.GetGlobalPropertySettingsUpdaters().Where(u => u.WrappedInstanceType == useGlobalSettingsAttribute.Type).First();
var wrapper =_propertySettingsRepository.GetGlobals(globalSettingsUpdater.SettingsType)
.Where(w => globalSettingsUpdater.Match(w))
.First();
container.Settings[globalSettingsUpdater.SettingsType.FullName] = wrapper;
//TODO: Add spec validating that exception is thrown with the below uncommented (An item with the same key has already been added.)
//container.Settings.Add(globalSettingsUpdater.SettingsType.FullName, wrapper);
_propertySettingsRepository.Save(container);
}
List<PropertySettingsUpdater> settingsUpdaters = GetPropertySettingsUpdaters(pageTypeDefinition, propertyDefinition, pageDefinition);
settingsUpdaters.ForEach(updater =>
{
var wrapper = container.GetSetting(updater.SettingsType);
if (wrapper == null)
{
wrapper = new PropertySettingsWrapper();
container.Settings[updater.SettingsType.FullName] = wrapper;
//TODO: Add spec validating that exception is thrown with the below uncommented (An item with the same key has already been added.)
//container.Settings.Add(updater.SettingsType.FullName, wrapper);
}
bool settingsAlreadyExists = true;
if (wrapper.PropertySettings == null)
{
wrapper.PropertySettings = ((IPropertySettings)Activator.CreateInstance(updater.SettingsType)).GetDefaultValues();
settingsAlreadyExists = false;
}
if (settingsAlreadyExists && !updater.OverWriteExisting)
return;
int hashBeforeUpdate = updater.GetSettingsHashCode(wrapper.PropertySettings);
updater.UpdateSettings(wrapper.PropertySettings);
int hashAfterUpdate = updater.GetSettingsHashCode(wrapper.PropertySettings);
if (hashBeforeUpdate != hashAfterUpdate || !settingsAlreadyExists)
{
_propertySettingsRepository.Save(container);
}
});
}
public void GivenPageTypeDefinition_ValidatePageTypeProperties_ValidatesNotOk_WhenCollissionsExistsInInterfaceDefinitions()
{
PageTypeDefinition definition = new PageTypeDefinition
{
Type = typeof(TestPageTypeWithClashingInterfaces),
Attribute = new PageTypeAttribute()
};
MockRepository fakes = new MockRepository();
PageTypeDefinitionPropertiesValidator propertiesValidator = fakes.PartialMock<PageTypeDefinitionPropertiesValidator>((PageDefinitionTypeMapper)null);
propertiesValidator.Stub(
validator => validator.ValidatePageTypePropertyType(Arg<PropertyInfo>.Is.Anything));
propertiesValidator.Replay();
Assert.Throws(typeof(PageTypeBuilderException), () => propertiesValidator.ValidatePageTypeProperties(definition));
}
protected internal virtual void UpdatePageTypePropertyDefinitions(IPageType pageType, PageTypeDefinition pageTypeDefinition)
{
IEnumerable<PageTypePropertyDefinition> definitions =
PageTypePropertyDefinitionLocator.GetPageTypePropertyDefinitions(pageType, pageTypeDefinition.Type);
foreach (PageTypePropertyDefinition propertyDefinition in definitions)
{
PageDefinition pageDefinition = GetExistingPageDefinition(pageType, propertyDefinition);
if (pageDefinition == null)
pageDefinition = CreateNewPageDefinition(propertyDefinition);
UpdatePageDefinition(pageDefinition, propertyDefinition);
}
}
public void GivenDefinitionWithASpecifiedGuid_CreateNewPageType_ReturnsPageTypeWithThatGuid()
{
PageTypeDefinition definition = new PageTypeDefinition
{
Type = typeof(object),
Attribute = new PageTypeAttribute(Guid.NewGuid().ToString())
};
PageTypeUpdater pageTypeUpdater = CreatePageTypeUpdater();
SetupPageTypeUpdaterWithFakePageTypeFactory(pageTypeUpdater);
IPageType returnedPageType = pageTypeUpdater.CreateNewPageType(definition);
Assert.Equal<Guid?>(definition.Attribute.Guid, returnedPageType.GUID);
}
public void GivenPageType_UpdatePageTypes_CallsPageTypeUpdaterUpdatePageType()
{
PageTypeSynchronizer synchronizer = PageTypeSynchronizerFactory.Create();
MockRepository fakes = new MockRepository();
PageTypeUpdater pageTypeUpdater = PageTypeUpdaterFactory.Stub(fakes);
PageTypeDefinition definition = new PageTypeDefinition();
pageTypeUpdater.Stub(updater => updater.UpdatePageType(definition));
pageTypeUpdater.Replay();
synchronizer.PageTypeUpdater = pageTypeUpdater;
List<PageTypeDefinition> definitions = new List<PageTypeDefinition> { definition };
synchronizer.UpdatePageTypes(definitions);
pageTypeUpdater.AssertWasCalled(updater => updater.UpdatePageType(definition));
}
public void GivenPageTypeDefinition_ValidatePageTypeProperties_ValidatesOk_WhenNoCollissionsInInterfaceDefinitions()
{
PageTypeDefinition definition = new PageTypeDefinition
{
Type = typeof(TestPageTypeWithInterface),
Attribute = new PageTypeAttribute()
};
MockRepository fakes = new MockRepository();
PageTypeDefinitionPropertiesValidator propertiesValidator = fakes.PartialMock<PageTypeDefinitionPropertiesValidator>((PageDefinitionTypeMapper)null);
propertiesValidator.Stub(
validator => validator.ValidatePageTypePropertyType(Arg<PropertyInfo>.Is.Anything));
propertiesValidator.Replay();
propertiesValidator.ValidatePageTypeProperties(definition);
}
public virtual IPageType GetExistingPageType(PageTypeDefinition definition)
{
IPageType existingPageType = null;
Type type = definition.Type;
PageTypeAttribute attribute = definition.Attribute;
if (attribute.Guid.HasValue)
existingPageType = pageTypeRepository.Load(attribute.Guid.Value);
if (existingPageType == null && attribute.Name != null)
existingPageType = pageTypeRepository.Load(attribute.Name);
if (existingPageType == null)
existingPageType = pageTypeRepository.Load(type.Name);
return existingPageType;
}
void UpdatePageDefinitionsGlobalPropertySettings(PageTypePropertyDefinition propertyDefinition, PageTypeDefinition pageTypeDefinition, PropertySettingsContainer container)
{
object[] attributes = GetPropertyAttributes(propertyDefinition, pageTypeDefinition);
var useGlobalSettingsAttribute = attributes.OfType<UseGlobalSettingsAttribute>().FirstOrDefault();
if (useGlobalSettingsAttribute != null)
{
//TODO: Should validate not null and valid type at startup
var globalSettingsUpdater = globalPropertySettingsLocator.GetGlobalPropertySettingsUpdaters().Where(u => u.WrappedInstanceType == useGlobalSettingsAttribute.Type).First();
var wrapper = propertySettingsRepository.GetGlobals(globalSettingsUpdater.SettingsType)
.Where(w => globalSettingsUpdater.Match(w))
.First();
container.Settings[globalSettingsUpdater.SettingsType.FullName] = wrapper;
//TODO: Add spec validating that exception is thrown with the below uncommented (An item with the same key has already been added.)
//container.Settings.Add(globalSettingsUpdater.SettingsType.FullName, wrapper);
propertySettingsRepository.Save(container);
}
}
protected internal virtual void UpdatePropertySettings(PageTypeDefinition pageTypeDefinition, PageTypePropertyDefinition propertyDefinition, PageDefinition pageDefinition)
{
var prop =
pageTypeDefinition.Type.GetProperties().Where(p => p.Name == propertyDefinition.Name).FirstOrDefault
();
var attributes = prop.GetCustomAttributes(typeof(PropertySettingsAttribute), true);
foreach (var attribute in attributes)
{
PropertySettingsContainer container;
if (pageDefinition.SettingsID == Guid.Empty)
{
pageDefinition.SettingsID = Guid.NewGuid();
PageDefinitionFactory.Save(pageDefinition);
container = new PropertySettingsContainer(pageDefinition.SettingsID);
}
else
{
if (!_propertySettingsRepository.TryGetContainer(pageDefinition.SettingsID, out container))
{
container = new PropertySettingsContainer(pageDefinition.SettingsID);
}
}
var settingsAttribute = (PropertySettingsAttribute) attribute;
var wrapper = container.GetSetting(settingsAttribute.SettingType);
if (wrapper == null)
{
wrapper = new PropertySettingsWrapper();
container.Settings.Add(settingsAttribute.SettingType.FullName, wrapper);
}
bool settingsAlreadyExists = true;
if (wrapper.PropertySettings == null)
{
wrapper.PropertySettings = (IPropertySettings) Activator.CreateInstance(settingsAttribute.SettingType);
settingsAlreadyExists = false;
}
if(settingsAlreadyExists && !settingsAttribute.OverWriteExistingSettings)
return;
if(settingsAttribute.UpdateSettings(wrapper.PropertySettings) || !settingsAlreadyExists)
_propertySettingsRepository.Save(container);
}
}
public void GivenListOfPageTypeDefinitions_ValidatePageTypeDefinitions_ValidatesEachPageType()
{
MockRepository fakes = new MockRepository();
List<PageTypeDefinition> definitions = new List<PageTypeDefinition>();
PageTypeDefinition definition = new PageTypeDefinition
{
Type = typeof(TypedPageData),
Attribute = new PageTypeAttribute()
};
definitions.Add(definition);
PageTypeDefinitionValidator definitionValidator = fakes.PartialMock<PageTypeDefinitionValidator>((PageDefinitionTypeMapper)null);
definitionValidator.Stub(validator => validator.ValidatePageTypeDefinition(definition, definitions));
definitionValidator.Replay();
definitionValidator.ValidatePageTypeDefinitions(definitions);
definitionValidator.AssertWasCalled(validator => validator.ValidatePageTypeDefinition(definition, definitions));
}
public void GivenExistingPageTypeFound_CreateNonExistingPageTypes_PageTypeUpdaterCreateNewPageTypeNotCalled()
{
MockRepository fakes = new MockRepository();
PageTypeUpdater pageTypeUpdater = PageTypeUpdaterFactory.Stub(fakes);
PageTypeDefinition definition = new PageTypeDefinition();
List<PageTypeDefinition> definitions = new List<PageTypeDefinition>();
definitions.Add(definition);
pageTypeUpdater.Replay();
IPageTypeLocator pageTypeLocator = fakes.Stub<IPageTypeLocator>();
pageTypeLocator.Stub(locator => locator.GetExistingPageType(definition)).Return(new NativePageType());
pageTypeLocator.Replay();
PageTypeSynchronizer synchronizer = CreateSynchronizer(pageTypeLocator);
synchronizer.CreateNonExistingPageTypes(definitions);
pageTypeUpdater.AssertWasNotCalled(updater => updater.CreateNewPageType(Arg<PageTypeDefinition>.Is.Anything));
}
public void GivenDefinitionNameLongerThan50Chars_ValidatePageTypeDefinitions_ThrowsException()
{
List<PageTypeDefinition> definitions = new List<PageTypeDefinition>();
PageTypeDefinition invalidTypeDefinition = new PageTypeDefinition
{
Type = typeof(TypedPageData),
Attribute = new PageTypeAttribute() { Name = "123456789123456789123456789123456789123456789123456" }
};
definitions.Add(invalidTypeDefinition);
PageTypeDefinitionValidator definitionValidator = new PageTypeDefinitionValidator(null);
Exception exception =
Record.Exception(
() => definitionValidator.ValidatePageTypeDefinitions(definitions));
Assert.NotNull(exception);
Type exceptionType = exception.GetType();
Assert.Equal<Type>(typeof(PageTypeBuilderException), exceptionType);
}
public virtual IEnumerable<PageTypeDefinition> GetPageTypeDefinitions()
{
List<Type> pageTypes = AttributedTypesUtility.GetTypesWithAttribute(_assemblyLocator, typeof(PageTypeAttribute));
pageTypes = pageTypes.Where(type => !type.IsAbstract).ToList();
List<PageTypeDefinition> pageTypeDefinitions = new List<PageTypeDefinition>();
foreach (Type type in pageTypes)
{
PageTypeAttribute pageTypeAttribute = (PageTypeAttribute)AttributedTypesUtility.GetAttribute(type, typeof(PageTypeAttribute));
PageTypeDefinition definition = new PageTypeDefinition
{
Type = type,
Attribute = pageTypeAttribute
};
pageTypeDefinitions.Add(definition);
}
_pageTypeDefinitions = pageTypeDefinitions;
return _pageTypeDefinitions;
}
public void GivenPageType_UpdatePageTypePropertyDefinitions_CallsPageTypePropertyUpdaterUpdatePageTypePropertyDefinitions()
{
PageTypeDefinition definition = new PageTypeDefinition();
MockRepository fakes = new MockRepository();
PageTypeUpdater pageTypeUpdater = PageTypeUpdaterFactory.Stub(fakes);
IPageType pageType = new NativePageType();
PageDefinitionSynchronizationEngine pageDefinitionSynchronizationEngine = PageDefinitionSynchronizationEngineFactory.Stub(fakes);
pageDefinitionSynchronizationEngine.Stub(updater => updater.UpdatePageTypePropertyDefinitions(pageType, definition));
pageDefinitionSynchronizationEngine.Replay();
IPageTypeLocator pageTypeLocator = fakes.Stub<IPageTypeLocator>();
pageTypeLocator.Stub(locator => locator.GetExistingPageType(definition)).Return(pageType);
pageTypeLocator.Replay();
List<PageTypeDefinition> definitions = new List<PageTypeDefinition> { definition };
PageTypeSynchronizer synchronizer =
PageTypeSynchronizerFactory.Create(pageDefinitionSynchronizationEngine, pageTypeLocator);
synchronizer.PageTypeUpdater = pageTypeUpdater;
synchronizer.UpdatePageTypePropertyDefinitions(definitions);
pageDefinitionSynchronizationEngine.AssertWasCalled(updater => updater.UpdatePageTypePropertyDefinitions(pageType, definition));
}
protected internal virtual void UpdatePageTypePropertyDefinitions(IPageType pageType, PageTypeDefinition pageTypeDefinition)
{
IEnumerable<PageTypePropertyDefinition> definitions =
pageTypePropertyDefinitionLocator.GetPageTypePropertyDefinitions(pageType, pageTypeDefinition.Type);
foreach (PageTypePropertyDefinition propertyDefinition in definitions)
{
PageDefinition pageDefinition = GetExistingPageDefinition(pageType, propertyDefinition);
if (pageDefinition == null)
{
pageDefinitionUpdater.CreateNewPageDefinition(propertyDefinition);
pageDefinition = GetExistingPageDefinition(pageType, propertyDefinition);
}
else
{
pageDefinitionUpdater.UpdateExistingPageDefinition(pageDefinition, propertyDefinition);
}
pageDefinitionSpecificPropertySettingsUpdater.UpdatePropertySettings(pageTypeDefinition, propertyDefinition, pageDefinition);
}
}
public void GivenPageType_UpdatePageTypePropertyDefinitions_CallsGetExistingPageDefinition()
{
List<PageTypePropertyDefinition> definitions = new List<PageTypePropertyDefinition>();
PageTypePropertyDefinition pageTypePropertyDefinition = PageTypePropertyUpdaterTestsUtility.CreatePageTypePropertyDefinition();
definitions.Add(pageTypePropertyDefinition);
PageTypePropertyUpdater pageTypePropertyUpdater = CreatePageTypePropertyUpdater(definitions);
IPageType pageType = new NativePageType();
PageTypeDefinition pageTypeDefinition = new PageTypeDefinition();
pageTypePropertyUpdater.Stub(utility => utility.GetExistingPageDefinition(
pageType, pageTypePropertyDefinition)).Return(new PageDefinition());
pageTypePropertyUpdater.Stub(
utility => utility.UpdatePageDefinition(
Arg<PageDefinition>.Is.Anything, Arg<PageTypePropertyDefinition>.Is.Anything));
pageTypePropertyUpdater.Replay();
pageTypePropertyUpdater.UpdatePageTypePropertyDefinitions(pageType, pageTypeDefinition);
pageTypePropertyUpdater.AssertWasCalled(
utility => utility.GetExistingPageDefinition(
pageType, pageTypePropertyDefinition));
}
protected internal virtual void UpdatePageType(PageTypeDefinition definition)
{
IPageType pageType = GetExistingPageType(definition);
PageTypeAttribute attribute = definition.Attribute;
string oldValueString = SerializeValues(pageType);
UpdateName(pageType, definition);
UpdateFilename(pageType, attribute);
UpdateSortOrder(pageType, attribute);
UpdateDescription(pageType, attribute);
UpdateIsAvailable(pageType, attribute);
UpdateDefaultArchivePageLink(pageType, attribute);
UpdateDefaultChildOrderRule(pageType, attribute);
UpdateDefaultPageName(pageType, attribute);
UpdateDefaultPeerOrder(pageType, attribute);
UpdateDefaultStartPublishOffset(pageType, attribute);
UpdateDefaultStopPublishOffset(pageType, attribute);
UpdateDefaultVisibleInMenu(pageType, attribute);
UpdateFrame(pageType, attribute);
bool availablePageTypesSet = false;
if (CanModifyProperty(pageType, attribute.AvailablePageTypesSet))
{
UpdateAvailablePageTypes(pageType, attribute.AvailablePageTypes);
if (attribute.AvailablePageTypes != null && attribute.AvailablePageTypes.Length > 0)
availablePageTypesSet = true;
}
if (!availablePageTypesSet && CanModifyProperty(pageType, attribute.ExcludedPageTypesSet) && attribute.ExcludedPageTypes != null)
UpdateAvailablePageTypesExcluded(pageType, attribute.ExcludedPageTypes);
string newValuesString = SerializeValues(pageType);
if (newValuesString == oldValueString)
return;
UpdatedPageTypeIds.Add(pageType.ID);
PageTypeRepository.Save(pageType);
}
public void GivenPageTypeWithSpecifiedNameAndNoGuid_GetExistingPageType_ReturnsPageTypeReturnedFromPageTypeFactoryLoad()
{
MockRepository mockRepository = new MockRepository();
Type pageTypeType = typeof(object);
PageTypeDefinition pageTypeDefinition = new PageTypeDefinition
{
Type = pageTypeType,
Attribute = new PageTypeAttribute { Name = Guid.NewGuid().ToString() }
};
PageTypeRepository fakePageTypeRepository = mockRepository.Stub<PageTypeRepository>();
IPageType pageTypeFromFactory = new NativePageType();
pageTypeFromFactory.ID = 1;
fakePageTypeRepository.Expect(factory => factory.Load(pageTypeDefinition.Attribute.Name)).Return(pageTypeFromFactory);
fakePageTypeRepository.Replay();
PageTypeUpdater pageTypeUpdater = PageTypeUpdaterFactory.Create(
PageTypeDefinitionLocatorFactory.Stub(), fakePageTypeRepository);
IPageType returnedPageType = pageTypeUpdater.GetExistingPageType(pageTypeDefinition);
fakePageTypeRepository.AssertWasCalled(factory => factory.Load(pageTypeDefinition.Attribute.Name));
Assert.Equal<int>(pageTypeFromFactory.ID, returnedPageType.ID);
}
protected internal virtual void ValidatePageTypeProperties(PageTypeDefinition definition)
{
List<PropertyInfo> propertiesForPageType = definition.Type.GetPageTypePropertiesOnClass().ToList();
foreach (PropertyInfo propertyInfo in propertiesForPageType)
ValidatePageTypeProperty(propertyInfo);
// validate any page type property group propery defininitions
foreach (PropertyInfo propertyGroupProperty in definition.Type.GetPageTypePropertyGroupProperties())
{
PropertyInfo[] propertyGroupProperties = propertyGroupProperty.PropertyType.GetPublicOrPrivateProperties();
foreach (PropertyInfo property in propertyGroupProperties)
{
PageTypePropertyAttribute attribute = property.GetCustomAttributes<PageTypePropertyAttribute>().FirstOrDefault();
if (attribute == null)
continue;
ValidatePageTypeProperty(property);
}
}
}
public virtual IEnumerable <PageTypeDefinition> GetPageTypeDefinitions()
{
List <Type> pageTypes = AttributedTypesUtility.GetTypesWithAttribute(_assemblyLocator, typeof(PageTypeAttribute));
pageTypes = pageTypes.Where(type => !type.IsAbstract).ToList();
List <PageTypeDefinition> pageTypeDefinitions = new List <PageTypeDefinition>();
foreach (Type type in pageTypes)
{
PageTypeAttribute pageTypeAttribute = (PageTypeAttribute)AttributedTypesUtility.GetAttribute(type, typeof(PageTypeAttribute));
PageTypeDefinition definition = new PageTypeDefinition
{
Type = type,
Attribute = pageTypeAttribute
};
pageTypeDefinitions.Add(definition);
}
_pageTypeDefinitions = pageTypeDefinitions;
return(_pageTypeDefinitions);
}
