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); }