private void finalizeCodeActivity_Finalize_ExecuteCode(object sender, EventArgs e)
        {
            Type selectedMetaDataType             = this.GetBinding <Type>(SelectedTypeBindingName);
            DataTypeDescriptor dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(selectedMetaDataType.GetImmutableTypeId());

            PageMetaDataDescription dataAssociationVisabilityRule = this.GetBinding <PageMetaDataDescription>(DataAssociationVisabilityDescriptionBindingName);
            Guid   metaDataContainerId     = this.GetBinding <Guid>(SelectedContainerBindingName);
            string metaDataDefinitionName  = this.GetBinding <string>(FieldGroupNameBindingName);
            string metaDataDefinitionLabel = this.GetBinding <string>(FieldGroupLabelBindingName);

            IData newDataTemplate = null;

            if (IsAnyPagesAffected())
            {
                DataTypeDescriptorFormsHelper helper = new DataTypeDescriptorFormsHelper(dataTypeDescriptor);

                GeneratedTypesHelper generatedTypesHelper = new GeneratedTypesHelper(dataTypeDescriptor);
                helper.AddReadOnlyFields(generatedTypesHelper.NotEditableDataFieldDescriptorNames);

                newDataTemplate = DataFacade.BuildNew(selectedMetaDataType);
                helper.BindingsToObject(this.Bindings, newDataTemplate);
            }


            using (TransactionScope transactionScope = TransactionsFacade.CreateNewScope())
            {
                IPage page = GetCurrentPage();

                page.AddMetaDataDefinition(metaDataDefinitionName, metaDataDefinitionLabel, selectedMetaDataType.GetImmutableTypeId(), metaDataContainerId, dataAssociationVisabilityRule.StartLevel, dataAssociationVisabilityRule.Levels);

                if (newDataTemplate != null)
                {
                    page.AddNewMetaDataToExistingPages(metaDataDefinitionName, newDataTemplate);
                }

                transactionScope.Complete();
            }

            ParentTreeRefresher parentTreeRefresher = this.CreateParentTreeRefresher();

            parentTreeRefresher.PostRefreshMesseges(this.EntityToken);
        }
        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);
            }
        }