private List <Guid> GetOldAffectedPageIds()
{
Pair <string, Type> metaDataPair = this.GetBinding <Pair <string, Type> >("SelectedMetaDataDefinition");
IPageMetaDataDefinition pageMetaDataDefinition = PageMetaDataFacade.GetMetaDataDefinition(GetCurrentPageId(), metaDataPair.First);
IPage page = GetCurrentPage();
return(page.GetMetaDataAffectedPages(pageMetaDataDefinition.StartLevel, pageMetaDataDefinition.Levels).Select(f => f.Id).ToList());
}
public static IEnumerable <KeyValuePair <Type, string> > DataTypesList()
{
IEnumerable <Type> generatedInterfaces = DataFacade.GetGeneratedInterfaces().OrderBy(t => t.FullName);
//all type expept metatypes
generatedInterfaces = generatedInterfaces.Except(PageMetaDataFacade.GetAllMetaDataTypes());
generatedInterfaces = generatedInterfaces.OrderBy(t => t.FullName);
return(generatedInterfaces.Select(type => new KeyValuePair <Type, string>(type, type.FullName)).ToList());
}
private void saveCodeActivity_Save_ExecuteCode(object sender, EventArgs e)
{
IPageTypeMetaDataTypeLink pageTypeMetaDataTypeLink = this.GetDataItemFromEntityToken <IPageTypeMetaDataTypeLink>();
string metaDataDescriptionLabel = this.GetBinding <string>("CompositionDescriptionLabel");
Guid containerId = this.GetBinding <Guid>("CompositionContainerId");
PageMetaDataFacade.UpdateDefinition(pageTypeMetaDataTypeLink.PageTypeId, pageTypeMetaDataTypeLink.Name, metaDataDescriptionLabel, containerId);
SetSaveStatus(true);
this.RefreshCurrentEntityToken();
}
public void Pack(PackageCreator creator)
{
if (Id == _pagesName)
{
#region All Pages
HashSet <Guid> pages;
using (var scope = new DataScope(DataScopeIdentifier.Administrated))
{
pages = DataFacade.GetData <IPage>().Select(p => p.Id).ToHashSet();
}
creator.AddData(typeof(IPage), DataScopeIdentifier.Public, d => pages.Contains((d as IPage).Id));
creator.AddData(typeof(IPage), DataScopeIdentifier.Administrated, d => pages.Contains((d as IPage).Id));
creator.AddData(typeof(IPagePlaceholderContent), DataScopeIdentifier.Public, d => pages.Contains((d as IPagePlaceholderContent).PageId));
creator.AddData(typeof(IPagePlaceholderContent), DataScopeIdentifier.Administrated, d => pages.Contains((d as IPagePlaceholderContent).PageId));
creator.AddData(typeof(IPageStructure), DataScopeIdentifier.Public, d => pages.Contains((d as IPageStructure).Id));
#endregion
}
else if (Id == _mediasName)
{
creator.AddData(typeof(IMediaFileData));
creator.AddData(typeof(IMediaFolderData));
creator.AddFilesInDirectory(@"App_Data\Media\");
}
else if (Id == _datatypesName)
{
IEnumerable <Type> pageDataTypeInterfaces = PageFolderFacade.GetAllFolderTypes();
IEnumerable <Type> pageMetaTypeInterfaces = PageMetaDataFacade.GetAllMetaDataTypes();
foreach (var pageDataType in pageDataTypeInterfaces)
{
creator.AddDataTypeData(pageDataType);
}
foreach (var pageMetaType in pageMetaTypeInterfaces)
{
creator.AddDataTypeData(pageMetaType);
}
}
else if (Id == _applicationsName)
{
creator.AddData <IDataItemTreeAttachmentPoint>();
}
else if (Id == _metatypesName)
{
IEnumerable <Type> pageMetaTypeInterfaces = PageMetaDataFacade.GetAllMetaDataTypes();
foreach (var pageMetaType in pageMetaTypeInterfaces)
{
creator.AddDataTypeData(pageMetaType);
}
}
return;
}
private void ValidateMetaDataName(object sender, ConditionalEventArgs e)
{
IPageTypeMetaDataTypeLink pageTypeMetaDataTypeLink = this.GetBinding<IPageTypeMetaDataTypeLink>("NewMetaDataTypeLink");
string metaDataDefinitionName = this.GetBinding<string>("CompositionDescriptionName");
string metaDataDefinitionLabel = this.GetBinding<string>("CompositionDescriptionLabel");
e.Result = PageMetaDataFacade.IsDefinitionAllowed(pageTypeMetaDataTypeLink.PageTypeId, metaDataDefinitionName, metaDataDefinitionLabel, pageTypeMetaDataTypeLink.DataTypeId);
if (e.Result == false)
{
ShowFieldMessage("CompositionDescriptionName", "${Composite.Plugins.PageTypeElementProvider, PageType.AddPageTypeMetaDataFieldWorkflow.ValidationError.MetaDataFieldNameAlreadyUsed}");
}
}
internal static void DeleteType(string providerName, DataTypeDescriptor dataTypeDescriptor, bool makeAFlush)
{
using (GlobalInitializerFacade.CoreLockScope)
{
PageFolderFacade.RemoveAllFolderDefinitions(dataTypeDescriptor.DataTypeId, false);
PageMetaDataFacade.RemoveAllDefinitions(dataTypeDescriptor.DataTypeId, false);
_generatedTypesFacade.DeleteType(providerName, dataTypeDescriptor, makeAFlush);
if (_deleteTypeDelegate != null)
{
DeleteTypeDelegate deleteDelegate = _deleteTypeDelegate;
deleteDelegate(new DeleteTypeEventArgs());
}
}
}
private void finalizeCodeActivity_Finalize_ExecuteCode(object sender, EventArgs e)
{
IPageTypeMetaDataTypeLink pageTypeMetaDataTypeLink = this.GetDataItemFromEntityToken <IPageTypeMetaDataTypeLink>();
DeleteTreeRefresher deleteTreeRefresher = this.CreateDeleteTreeRefresher(this.EntityToken);
DataTypeDescriptor dataTypeDescriptor;
if (DynamicTypeManager.TryGetDataTypeDescriptor(pageTypeMetaDataTypeLink.DataTypeId, out dataTypeDescriptor))
{
PageMetaDataFacade.RemoveDefinition(pageTypeMetaDataTypeLink.PageTypeId, pageTypeMetaDataTypeLink.Name);
}
DataFacade.Delete <IPageTypeMetaDataTypeLink>(pageTypeMetaDataTypeLink);
deleteTreeRefresher.PostRefreshMesseges();
}
private void editDefinitionCodeActivity_UpdateBindings_ExecuteCode(object sender, EventArgs e)
{
Pair <string, Type> metaDataPair = this.GetBinding <Pair <string, Type> >("SelectedMetaDataDefinition");
IPageMetaDataDefinition pageMetaDataDefinition = PageMetaDataFacade.GetMetaDataDefinition(GetCurrentPageId(), metaDataPair.First);
this.UpdateBinding("Label", pageMetaDataDefinition.Label);
List <KeyValuePair <Guid, string> > containers = PageMetaDataFacade.GetAllMetaDataContainers();
this.UpdateBinding("MetaDataContainerOptions", containers);
this.UpdateBinding("SelectedMetaDataContainer", pageMetaDataDefinition.MetaDataContainerId);
IPage page = GetCurrentPage();
Dictionary <int, string> startDisplayOptions = new Dictionary <int, string>();
if (page != null)
{
startDisplayOptions.Add(0, StringResourceSystemFacade.GetString("Composite.Management", "AssociatedDataElementProviderHelper.AddMetaDataWorkflow.StartDisplayOption0"));
}
startDisplayOptions.Add(1, StringResourceSystemFacade.GetString("Composite.Management", "AssociatedDataElementProviderHelper.AddMetaDataWorkflow.StartDisplayOption1"));
startDisplayOptions.Add(2, StringResourceSystemFacade.GetString("Composite.Management", "AssociatedDataElementProviderHelper.AddMetaDataWorkflow.StartDisplayOption2"));
startDisplayOptions.Add(3, StringResourceSystemFacade.GetString("Composite.Management", "AssociatedDataElementProviderHelper.AddMetaDataWorkflow.StartDisplayOption3"));
startDisplayOptions.Add(4, StringResourceSystemFacade.GetString("Composite.Management", "AssociatedDataElementProviderHelper.AddMetaDataWorkflow.StartDisplayOption4"));
startDisplayOptions.Add(5, StringResourceSystemFacade.GetString("Composite.Management", "AssociatedDataElementProviderHelper.AddMetaDataWorkflow.StartDisplayOption5"));
this.UpdateBinding("StartDisplayOptions", startDisplayOptions);
this.UpdateBinding("SelectedStartDisplay", pageMetaDataDefinition.StartLevel);
int levels = pageMetaDataDefinition.Levels;
if (levels > 10)
{
levels = 10000;
}
Dictionary <int, string> inheritDisplayOptions = new Dictionary <int, string>();
inheritDisplayOptions.Add(0, StringResourceSystemFacade.GetString("Composite.Management", "AssociatedDataElementProviderHelper.AddMetaDataWorkflow.InheritDisplayOption0"));
inheritDisplayOptions.Add(1, StringResourceSystemFacade.GetString("Composite.Management", "AssociatedDataElementProviderHelper.AddMetaDataWorkflow.InheritDisplayOption1"));
inheritDisplayOptions.Add(2, StringResourceSystemFacade.GetString("Composite.Management", "AssociatedDataElementProviderHelper.AddMetaDataWorkflow.InheritDisplayOption2"));
inheritDisplayOptions.Add(3, StringResourceSystemFacade.GetString("Composite.Management", "AssociatedDataElementProviderHelper.AddMetaDataWorkflow.InheritDisplayOption3"));
inheritDisplayOptions.Add(10000, StringResourceSystemFacade.GetString("Composite.Management", "AssociatedDataElementProviderHelper.AddMetaDataWorkflow.InheritDisplayOption4"));
this.UpdateBinding("InheritDisplayOptions", inheritDisplayOptions);
this.UpdateBinding("SelectedInheritDisplay", levels);
}
private void createFieldGroupCodeActivity_Initialize_ExecuteCode(object sender, EventArgs e)
{
Type type = this.GetBinding <Type>(SelectedTypeBindingName);
string metaDataDefinitionName = type.GetTypeTitle();
int counter = 1;
while (PageMetaDataFacade.IsDefinitionAllowed(GetCurrentPageId(), metaDataDefinitionName, metaDataDefinitionName, type.GetImmutableTypeId()) == false)
{
metaDataDefinitionName = string.Format("{0} {1}", type.GetTypeTitle(), counter++);
}
this.UpdateBinding(FieldGroupNameBindingName, metaDataDefinitionName);
this.UpdateBinding(FieldGroupLabelBindingName, metaDataDefinitionName);
if (this.BindingExist(ContainersBindingName) == false)
{
List <KeyValuePair <Guid, string> > containers = PageMetaDataFacade.GetAllMetaDataContainers();
this.UpdateBinding(ContainersBindingName, containers);
this.UpdateBinding(SelectedContainerBindingName, containers.First().Key);
Dictionary <int, string> startDisplayOptions = new Dictionary <int, string>();
if (GetCurrentPage() != null)
{
startDisplayOptions.Add(0, StringResourceSystemFacade.GetString("Composite.Management", "AssociatedDataElementProviderHelper.AddMetaDataWorkflow.StartDisplayOption0"));
}
startDisplayOptions.Add(1, StringResourceSystemFacade.GetString("Composite.Management", "AssociatedDataElementProviderHelper.AddMetaDataWorkflow.StartDisplayOption1"));
startDisplayOptions.Add(2, StringResourceSystemFacade.GetString("Composite.Management", "AssociatedDataElementProviderHelper.AddMetaDataWorkflow.StartDisplayOption2"));
startDisplayOptions.Add(3, StringResourceSystemFacade.GetString("Composite.Management", "AssociatedDataElementProviderHelper.AddMetaDataWorkflow.StartDisplayOption3"));
startDisplayOptions.Add(4, StringResourceSystemFacade.GetString("Composite.Management", "AssociatedDataElementProviderHelper.AddMetaDataWorkflow.StartDisplayOption4"));
startDisplayOptions.Add(5, StringResourceSystemFacade.GetString("Composite.Management", "AssociatedDataElementProviderHelper.AddMetaDataWorkflow.StartDisplayOption5"));
this.UpdateBinding(StartDisplayOptionsBindingName, startDisplayOptions);
this.UpdateBinding(SelectedStartDisplayBindingName, startDisplayOptions.Keys.First());
Dictionary <int, string> inheritDisplayOptions = new Dictionary <int, string>();
inheritDisplayOptions.Add(0, StringResourceSystemFacade.GetString("Composite.Management", "AssociatedDataElementProviderHelper.AddMetaDataWorkflow.InheritDisplayOption0"));
inheritDisplayOptions.Add(1, StringResourceSystemFacade.GetString("Composite.Management", "AssociatedDataElementProviderHelper.AddMetaDataWorkflow.InheritDisplayOption1"));
inheritDisplayOptions.Add(2, StringResourceSystemFacade.GetString("Composite.Management", "AssociatedDataElementProviderHelper.AddMetaDataWorkflow.InheritDisplayOption2"));
inheritDisplayOptions.Add(3, StringResourceSystemFacade.GetString("Composite.Management", "AssociatedDataElementProviderHelper.AddMetaDataWorkflow.InheritDisplayOption3"));
inheritDisplayOptions.Add(10000, StringResourceSystemFacade.GetString("Composite.Management", "AssociatedDataElementProviderHelper.AddMetaDataWorkflow.InheritDisplayOption4"));
this.UpdateBinding(InheritDisplayOptionsBindingName, inheritDisplayOptions);
this.UpdateBinding(SelectedInheritDisplayBindingName, inheritDisplayOptions.Keys.Last());
}
}
private void initializeCodeActivity_UpdateBindings_ExecuteCode(object sender, EventArgs e)
{
IPageTypeMetaDataTypeLink pageTypeMetaDataTypeLink = this.GetDataItemFromEntityToken <IPageTypeMetaDataTypeLink>();
IPageMetaDataDefinition pageMetaDataDefinition = PageMetaDataFacade.GetMetaDataDefinition(pageTypeMetaDataTypeLink.PageTypeId, pageTypeMetaDataTypeLink.Name);
//this.UpdateBinding("CompositionDescriptionName", compositionDescription.Name);
this.UpdateBinding("CompositionDescriptionLabel", pageMetaDataDefinition.Label);
List <KeyValuePair <Guid, string> > metaDataContainerOptions = PageMetaDataFacade.GetAllMetaDataContainers();
this.Bindings.Add("MetaDataContainerOptions", metaDataContainerOptions);
this.Bindings.Add("CompositionContainerId", pageMetaDataDefinition.MetaDataContainerId);
var dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(pageTypeMetaDataTypeLink.DataTypeId);
this.Bindings.Add("MetaTypeName", dataTypeDescriptor.TypeManagerTypeName);
}
private List <IData> GetMetaData(Guid pageId, Guid versionId, PublicationScope publicationScope, CultureInfo culture)
{
var result = new List <IData>();
using (var conn = new DataConnection(publicationScope, culture))
{
conn.DisableServices();
foreach (var metaDataType in PageMetaDataFacade.GetAllMetaDataTypes()
.Where(type => typeof(IPageMetaData).IsAssignableFrom(type)))
{
result.AddRange(DataFacade.GetData(metaDataType).OfType <IPageMetaData>()
.Where(md => md.PageId == pageId && md.VersionId == versionId));
}
}
return(result);
}
private void finalizeCodeActivity_Finalize_ExecuteCode(object sender, EventArgs e)
{
IPageType pageType = (IPageType)((DataEntityToken)this.EntityToken).Data;
DeleteTreeRefresher deleteTreeRefresher = this.CreateDeleteTreeRefresher(this.EntityToken);
IEnumerable <IPageTypeMetaDataTypeLink> pageTypeMetaDataTypeLinks =
DataFacade.GetData <IPageTypeMetaDataTypeLink>().
Where(f => f.PageTypeId == pageType.Id).
Evaluate();
foreach (IPageTypeMetaDataTypeLink pageTypeMetaDataTypeLink in pageTypeMetaDataTypeLinks)
{
PageMetaDataFacade.RemoveDefinition(pageType.Id, pageTypeMetaDataTypeLink.Name);
}
DataFacade.Delete <IPageType>(pageType);
deleteTreeRefresher.PostRefreshMesseges();
}
private void createFieldGroupCodeActivity_CreateVisabilatiyRule_ExecuteCode(object sender, EventArgs e)
{
string metaDataDefinitionName = this.GetBinding <string>(FieldGroupNameBindingName);
string metaDataDefinitionLabel = this.GetBinding <string>(FieldGroupLabelBindingName);
Type type = this.GetBinding <Type>(SelectedTypeBindingName);
if (PageMetaDataFacade.IsDefinitionAllowed(GetCurrentPageId(), metaDataDefinitionName, metaDataDefinitionLabel, type.GetImmutableTypeId()))
{
int startLevel = this.GetBinding <int>(SelectedStartDisplayBindingName);
int levels = this.GetBinding <int>(SelectedInheritDisplayBindingName);
PageMetaDataDescription dataAssociationVisabilityRule = PageMetaDataDescription.Branch(startLevel, levels);
this.UpdateBinding(DataAssociationVisabilityDescriptionBindingName, dataAssociationVisabilityRule);
}
else
{
this.UpdateBinding(DataAssociationVisabilityDescriptionBindingName, null);
this.ShowFieldMessage(FieldGroupNameBindingName, "${Composite.Management, AssociatedDataElementProviderHelper.AddMetaDataWorkflow.FieldGroupNameNotValid}");
}
}
private Dictionary <Tuple <Guid, Guid>, List <IData> > GetAllMetaData(PublicationScope publicationScope, CultureInfo culture)
{
var result = new Dictionary <Tuple <Guid, Guid>, List <IData> >();
using (var conn = new DataConnection(publicationScope, culture))
{
conn.DisableServices();
foreach (var metaDataType in PageMetaDataFacade.GetAllMetaDataTypes()
.Where(type => typeof(IPageMetaData).IsAssignableFrom(type)))
{
foreach (var dataItem in DataFacade.GetData(metaDataType).OfType <IPageMetaData>())
{
var key = new Tuple <Guid, Guid>(dataItem.PageId, dataItem.VersionId);
var list = result.GetOrAdd(key, () => new List <IData>());
list.Add(dataItem);
}
}
}
return(result);
}
internal void AddDataTypeData(Type type)
{
IEnumerable <Type> globalDataTypeInterfaces = DataFacade
.GetAllInterfaces(UserType.Developer)
.Where(interfaceType => interfaceType.Assembly != typeof(IData).Assembly)
.OrderBy(t => t.FullName)
.Except(PageFolderFacade.GetAllFolderTypes())
.Except(PageMetaDataFacade.GetAllMetaDataTypes());
IEnumerable <Type> pageDataTypeInterfaces = PageFolderFacade.GetAllFolderTypes();
IEnumerable <Type> pageMetaTypeInterfaces = PageMetaDataFacade.GetAllMetaDataTypes();
DataTypeDescriptor dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(type);
var resolvedType = dataTypeDescriptor.GetInterfaceType();
// TODO: make by association
if (globalDataTypeInterfaces.Contains(resolvedType))
{
AddData(type);
}
else if (pageDataTypeInterfaces.Contains(resolvedType))
{
AddData <IPageFolderDefinition>(d => d.FolderTypeId == dataTypeDescriptor.DataTypeId);
AddData(type);
}
else if (pageMetaTypeInterfaces.Contains(resolvedType))
{
foreach (var j in DataFacade.GetData <IPageMetaDataDefinition>(d => d.MetaDataTypeId == dataTypeDescriptor.DataTypeId))
{
//Add only one MetaTypeTab
AddData <ICompositionContainer>(d => d.Id == j.MetaDataContainerId);
}
AddData <IPageMetaDataDefinition>(d => d.MetaDataTypeId == dataTypeDescriptor.DataTypeId);
AddData(type);
}
}
private IEnumerable <Type> GetGlobalDataTypes()
{
Func <Type, bool> typePredicate = f => (f != typeof(IPage)) && (PageFolderFacade.GetAllFolderTypes().Contains(f) == false) && (PageMetaDataFacade.GetAllMetaDataTypes().Contains(f) == false);
return(DataFacade.GetGeneratedInterfaces().Where(typePredicate).OrderBy(t => t.FullName));
}
private IEnumerable <Type> GetAddebleTypes()
{
IEnumerable <Type> accociationTypes = PageMetaDataFacade.GetAllMetaDataTypes();
return(accociationTypes);
}
private void finalizeCodeActivity_Finalize_ExecuteCode(object sender, EventArgs e)
{
using (TransactionScope transactionScope = TransactionsFacade.CreateNewScope())
{
List <Guid> oldPageIds = GetOldAffectedPageIds();
List <Guid> newPageIds = GetNewAffectedPageIds();
Pair <string, Type> metaDataPair = this.GetBinding <Pair <string, Type> >("SelectedMetaDataDefinition");
Guid newMetaDataContainerId = this.GetBinding <Guid>("SelectedMetaDataContainer");
string newLabel = this.GetBinding <string>("Label");
int startLevel = this.GetBinding <int>("SelectedStartDisplay");
int levels = this.GetBinding <int>("SelectedInheritDisplay");
PageMetaDataFacade.UpdateDefinition(GetCurrentPageId(), metaDataPair.First, newLabel, startLevel, levels, newMetaDataContainerId);
IEnumerable <Guid> oldPageIdsToRemove = oldPageIds.Except(newPageIds);
foreach (Guid id in oldPageIdsToRemove)
{
IPage page = Composite.Data.PageManager.GetPageById(id);
bool otherDefinitionExists = page.GetAllowedMetaDataDefinitions().Where(f => f.Name == metaDataPair.First).Any();
if (otherDefinitionExists)
{
continue;
}
using (new DataScope(DataScopeIdentifier.Public))
{
IData dataToDelete = page.GetMetaData(metaDataPair.First, metaDataPair.Second);
if (dataToDelete != null)
{
DataFacade.Delete(dataToDelete);
}
}
using (new DataScope(DataScopeIdentifier.Administrated))
{
IData dataToDelete = page.GetMetaData(metaDataPair.First, metaDataPair.Second);
if (dataToDelete != null)
{
DataFacade.Delete(dataToDelete);
}
}
}
IData newDataTemplate = null;
if (this.BindingExist("NewDataTemplate"))
{
newDataTemplate = this.GetBinding <IData>("NewDataTemplate");
DataTypeDescriptor dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(metaDataPair.Second.GetImmutableTypeId());
DataTypeDescriptorFormsHelper helper = new DataTypeDescriptorFormsHelper(dataTypeDescriptor);
helper.BindingsToObject(this.Bindings, newDataTemplate);
}
IEnumerable <Guid> newPageIdsToAdd = newPageIds.Except(oldPageIds);
foreach (Guid id in newPageIdsToAdd)
{
IPage page = Composite.Data.PageManager.GetPageById(id);
page.AddNewMetaDataToExistingPage(metaDataPair.First, metaDataPair.Second, newDataTemplate);
}
transactionScope.Complete();
}
}
private void editStateCodeActivity_ExecuteCode(object sender, EventArgs e)
{
if (!PermissionsFacade.GetPermissionsForCurrentUser(EntityToken).Contains(PermissionType.Publish))
{
var formData = WorkflowFacade.GetFormData(InstanceId, true);
if (formData.ExcludedEvents == null)
{
formData.ExcludedEvents = new List <string>();
}
formData.ExcludedEvents.Add("SaveAndPublish");
}
IPage selectedPage;
if (!BindingExist("SelectedPage"))
{
selectedPage = GetDataItemFromEntityToken <IPage>();
if (selectedPage.PublicationStatus == GenericPublishProcessController.Published)
{
selectedPage.PublicationStatus = GenericPublishProcessController.Draft;
}
Bindings.Add("SelectedPage", selectedPage);
}
else
{
selectedPage = GetBinding <IPage>("SelectedPage");
}
if (!BindingExist("UrlTitleIsRequired"))
{
var isRootPage = PageManager.GetParentId(selectedPage.Id) == Guid.Empty;
Bindings["UrlTitleIsRequired"] = !isRootPage;
Bindings["IsRootPage"] = isRootPage;
}
IFormMarkupProvider markupProvider = new FormDefinitionFileMarkupProvider(@"\Administrative\EditPage.xml");
XDocument formDocument;
using (var reader = markupProvider.GetReader())
{
formDocument = XDocument.Load(reader);
}
var bindingsXElement = formDocument.Root.Element(DataTypeDescriptorFormsHelper.CmsNamespace + FormKeyTagNames.Bindings);
var layoutXElement = formDocument.Root.Element(DataTypeDescriptorFormsHelper.CmsNamespace + FormKeyTagNames.Layout);
var tabPanelsXElement = layoutXElement.Element(DataTypeDescriptorFormsHelper.MainNamespace + "TabPanels");
IEnumerable <ICompositionContainer> compositionContainers = selectedPage.GetAllowedMetaDataContainers().Evaluate();
var compositionTabs = new Dictionary <Guid, XElement>();
foreach (var compositionContainer in compositionContainers)
{
var element = new XElement(Namespaces.BindingFormsStdUiControls10 + "PlaceHolder");
element.Add(new XAttribute("Label", StringResourceSystemFacade.ParseString(compositionContainer.Label)));
compositionTabs.Add(compositionContainer.Id, element);
}
var clientValidationRules = new Dictionary <string, List <ClientValidationRule> >();
var pageMetaDataDefinitions = selectedPage.GetAllowedMetaDataDefinitions();
foreach (var pageMetaDataDefinition in pageMetaDataDefinitions)
{
var metaDatTypeId = pageMetaDataDefinition.MetaDataTypeId;
var dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(metaDatTypeId);
Verify.IsNotNull(dataTypeDescriptor, "Failed to get meta data type by id '{0}'. If data type was purposely removed, in order to fix this exception you should remove IPageMetaDataDefinition records that reference this data type.", metaDatTypeId);
var metaDataType = TypeManager.TryGetType(dataTypeDescriptor.TypeManagerTypeName);
Verify.IsNotNull(metaDataType, "Failed to get meta data type '{0}', id: {1}. If it has been removed, references from '{2}' have to be removed as well",
dataTypeDescriptor.TypeManagerTypeName, metaDatTypeId, typeof(IPageMetaDataDefinition).Name);
var helper = CreateDataTypeDescriptorFormsHelper(pageMetaDataDefinition, dataTypeDescriptor);
var metaData = selectedPage.GetMetaData(pageMetaDataDefinition.Name, metaDataType);
if (metaData == null)
{
metaData = DataFacade.BuildNew(metaDataType);
PageMetaDataFacade.AssignMetaDataSpecificValues(metaData, pageMetaDataDefinition.Name, selectedPage);
var localizedData = metaData as ILocalizedControlled;
if (localizedData != null)
{
localizedData.SourceCultureName = UserSettings.ActiveLocaleCultureInfo.Name;
}
var publishControlled = metaData as IPublishControlled;
publishControlled.PublicationStatus = GenericPublishProcessController.Draft;
helper.UpdateWithNewBindings(Bindings);
helper.ObjectToBindings(metaData, Bindings);
}
else
{
helper.UpdateWithBindings(metaData, Bindings);
}
bindingsXElement.Add(helper.BindingXml.Elements());
compositionTabs[pageMetaDataDefinition.MetaDataContainerId].Add(helper.PanelXml);
clientValidationRules.AddDictionary(helper.GetBindingsValidationRules(metaData));
}
var previewTabPanel = tabPanelsXElement.Elements().Last();
foreach (var element in compositionTabs.Values)
{
previewTabPanel.AddBeforeSelf(element);
}
IDictionary <string, string> transitionNames = new Dictionary <string, string>();
transitionNames.Add(GenericPublishProcessController.Draft, StringResourceSystemFacade.GetString("Composite.Management", "PublishingStatus.draft"));
transitionNames.Add(GenericPublishProcessController.AwaitingApproval, StringResourceSystemFacade.GetString("Composite.Management", "PublishingStatus.awaitingApproval"));
var username = UserValidationFacade.GetUsername();
var userPermissionDefinitions = PermissionTypeFacade.GetUserPermissionDefinitions(username);
var userGroupPermissionDefinitions = PermissionTypeFacade.GetUserGroupPermissionDefinitions(username);
var currentPermissionTypes = PermissionTypeFacade.GetCurrentPermissionTypes(UserValidationFacade.GetUserToken(), EntityToken, userPermissionDefinitions, userGroupPermissionDefinitions);
foreach (var permissionType in currentPermissionTypes)
{
if (GenericPublishProcessController.AwaitingPublicationActionPermissionType.Contains(permissionType))
{
transitionNames.Add(GenericPublishProcessController.AwaitingPublication, StringResourceSystemFacade.GetString("Composite.Management", "PublishingStatus.awaitingPublication"));
break;
}
}
var contents = DataFacade.GetData <IPagePlaceholderContent>(f => f.PageId == selectedPage.Id && f.VersionId == selectedPage.VersionId).ToList();
var namedXhtmlFragments = contents.ToDictionary(content => content.PlaceHolderId, content => content.Content ?? "");
UpdateBinding("SelectablePageTypeIds", GetSelectablePageTypes());
UpdateBinding("SelectableTemplateIds", GetSelectablePageTemplates());
UpdateBinding("NamedXhtmlFragments", namedXhtmlFragments);
UpdateBinding("StateOptions", transitionNames);
var formDefinition = formDocument.GetDocumentAsString();
DeliverFormData(
selectedPage.Title,
StandardUiContainerTypes.Document,
formDefinition,
Bindings,
clientValidationRules
);
}
internal void CopyPageData(IPage sourcePage, IPage newPage)
{
Guid sourcePageId = sourcePage.Id;
Guid newPageId = newPage.Id;
Guid sourceVersionId = sourcePage.VersionId;
Guid newVersionId = newPage.VersionId;
var newPlaceholders = new List <IPagePlaceholderContent>();
var placeholders =
DataFacade.GetData <IPagePlaceholderContent>(false)
.Where(ph => ph.PageId == sourcePageId &&
ph.VersionId == sourceVersionId)
.ToList();
foreach (var placeholderContent in placeholders)
{
var newPlaceholder = DataFacade.BuildNew <IPagePlaceholderContent>();
newPlaceholder.PageId = newPageId;
newPlaceholder.PlaceHolderId = placeholderContent.PlaceHolderId;
newPlaceholder.Content = placeholderContent.Content;
newPlaceholder.VersionId = newVersionId;
newPlaceholders.Add(newPlaceholder);
}
DataFacade.AddNew <IPagePlaceholderContent>(newPlaceholders);
var sourceMetaData = sourcePage.GetMetaData().Cast <IPageMetaData>()
.Where(d => d.VersionId == sourceVersionId);
foreach (var metaDataItem in sourceMetaData)
{
var metaDataType = metaDataItem.DataSourceId.InterfaceType;
var typeDescriptor = DataMetaDataFacade.GetDataTypeDescriptor(metaDataType.GetImmutableTypeId());
var definition = PageMetaDataFacade.GetMetaDataDefinition(sourcePageId, metaDataItem.GetTypeTitle());
var newDataItem = (IPageMetaData)DataFacade.BuildNew(metaDataType);
var properties = metaDataType.GetPropertiesRecursively().ToDictionary(p => p.Name);
foreach (var field in typeDescriptor.Fields)
{
var propertyInfo = properties[field.Name];
propertyInfo.SetValue(newDataItem, propertyInfo.GetValue(metaDataItem));
}
newDataItem.VersionId = newVersionId;
newDataItem.Id = Guid.NewGuid();
newDataItem.PageId = newPageId;
newDataItem.PublicationStatus = GenericPublishProcessController.Draft;
newDataItem = (IPageMetaData)DataFacade.AddNew((IData)newDataItem);
if (definition != null)
{
string title = newDataItem.GetTypeTitle();
newPage.AddMetaDataDefinition(title, title, newDataItem.GetImmutableTypeId(),
definition.MetaDataContainerId);
}
}
List <string> selectableTreeIds = TreeFacade.AllTrees.Where(
tree => tree.HasAttachmentPoints(sourcePage.GetDataEntityToken()))
.Where(tree => !tree.HasAttachmentPoints(newPage.GetDataEntityToken()))
.Select(tree => tree.TreeId).ToList();
foreach (var selectableTreeId in selectableTreeIds)
{
TreeFacade.AddPersistedAttachmentPoint(selectableTreeId, newPage.DataSourceId.InterfaceType,
newPage.DataSourceId.GetKeyValue());
}
foreach (var dataFolderType in sourcePage.GetDefinedFolderTypes())
{
newPage.AddFolderDefinition(dataFolderType);
}
}
private bool PrepareAddUpdateMetaData(IPage selectedPage, IDictionary <string, IData> dataToAdd, IDictionary <string, IData> dataToUpdate)
{
var isValid = ValidateBindings();
IEnumerable <IPageMetaDataDefinition> pageMetaDataDefinitions = selectedPage.GetAllowedMetaDataDefinitions().Evaluate();
foreach (var pageMetaDataDefinition in pageMetaDataDefinitions)
{
var dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(pageMetaDataDefinition.MetaDataTypeId);
var metaDataType = TypeManager.GetType(dataTypeDescriptor.TypeManagerTypeName);
var helper = CreateDataTypeDescriptorFormsHelper(pageMetaDataDefinition, dataTypeDescriptor);
var metaData = selectedPage.GetMetaData(pageMetaDataDefinition.Name, metaDataType);
if (metaData == null)
{
var newData = DataFacade.BuildNew(metaDataType);
PageMetaDataFacade.AssignMetaDataSpecificValues(newData, pageMetaDataDefinition.Name, selectedPage);
var localizedData = newData as ILocalizedControlled;
if (localizedData != null)
{
localizedData.SourceCultureName = UserSettings.ActiveLocaleCultureInfo.Name;
}
if (!BindAndValidate(helper, newData))
{
isValid = false;
}
dataToAdd.Add(helper.BindingNamesPrefix, newData);
}
else
{
if (!BindAndValidate(helper, metaData))
{
isValid = false;
}
dataToUpdate.Add(helper.BindingNamesPrefix, metaData);
}
}
var pageValidationResults = ValidationFacade.Validate(selectedPage);
if (!pageValidationResults.IsValid)
{
isValid = false;
}
foreach (var kvp in dataToAdd.Concat(dataToUpdate))
{
var validationResults = ValidationFacade.Validate(kvp.Value);
if (!validationResults.IsValid)
{
isValid = false;
foreach (var result in validationResults)
{
ShowFieldMessage(DataTypeDescriptorFormsHelper.GetBindingName(kvp.Key, result.Key), result.Message);
}
}
}
return(isValid);
}
