public function validatePageTypeRequest(Request $request)
{
$e = parent::validatePageTypeRequest($request);
$type = PageType::getByID($request->request->get('ptID'));
if (!$type instanceof PageType) {
$e->add(t('You must choose the type of page these page types are published beneath.'));
}
return $e;
}
public function import(\SimpleXMLElement $sx)
{
if (isset($sx->pagetypepublishtargettypes)) {
foreach ($sx->pagetypepublishtargettypes->type as $th) {
$pkg = static::getPackageObject($th['package']);
$ce = Type::add((string) $th['handle'], (string) $th['name'], $pkg);
}
}
}
public function validatePageTypeRequest(Request $request)
{
$e = parent::validatePageTypeRequest($request);
$page = Page::getByID($request->request->get('cParentID'));
if (!is_object($page) || $page->isError()) {
$e->add(t('You must choose a valid parent page for pages of this type.'));
}
return $e;
}
public function submit()
{
$vs = Loader::helper('validation/strings');
$sec = Loader::helper('security');
$name = $sec->sanitizeString($this->post('ptName'));
$handle = $sec->sanitizeString($this->post('ptHandle'));
if (!$this->token->validate('add_page_type')) {
$this->error->add(t($this->token->getErrorMessage()));
}
if (!$vs->notempty($name)) {
$this->error->add(t('You must specify a valid name for your page type.'));
}
if (!$vs->handle($handle)) {
$this->error->add(t('You must specify a valid handle for your page type.'));
} else {
$_pt = PageType::getByHandle($handle);
if (is_object($_pt)) {
$this->error->add(t('You must specify a unique handle for your page type.'));
}
unset($_pt);
}
$defaultTemplate = PageTemplate::getByID($this->post('ptDefaultPageTemplateID'));
if (!is_object($defaultTemplate)) {
$this->error->add(t('You must choose a valid default page template.'));
}
$templates = array();
if (is_array($_POST['ptPageTemplateID'])) {
foreach ($this->post('ptPageTemplateID') as $pageTemplateID) {
$pt = PageTemplate::getByID($pageTemplateID);
if (is_object($pt)) {
$templates[] = $pt;
}
}
}
if (count($templates) == 0 && $this->post('ptAllowedPageTemplates') == 'C') {
$this->error->add(t('You must specify at least one page template.'));
}
$target = PageTypePublishTargetType::getByID($this->post('ptPublishTargetTypeID'));
if (!is_object($target)) {
$this->error->add(t('Invalid page type publish target type.'));
} else {
$pe = $target->validatePageTypeRequest($this->request);
if ($pe instanceof Error) {
$this->error->add($pe);
}
}
if (!$this->error->has()) {
$data = array('handle' => $handle, 'name' => $name, 'defaultTemplate' => $defaultTemplate, 'ptLaunchInComposer' => $this->post('ptLaunchInComposer'), 'ptIsFrequentlyAdded' => $this->post('ptIsFrequentlyAdded'), 'allowedTemplates' => $this->post('ptAllowedPageTemplates'), 'templates' => $templates);
$pt = PageType::add($data);
$configuredTarget = $target->configurePageTypePublishTarget($pt, $this->post());
$pt->setConfiguredPageTypePublishTargetObject($configuredTarget);
$this->redirect('/dashboard/pages/types', 'page_type_added');
}
}
public function getResults(Request $request)
{
$list = Type::getList();
$items = array();
foreach ($list as $t) {
$item = new \PortlandLabs\Concrete5\MigrationTool\Entity\Export\PageTypePublishTargetType();
$item->setItemId($t->getPageTypePublishTargetTypeID());
$items[] = $item;
}
return $items;
}
public function execute(Batch $batch)
{
$types = $batch->getObjectCollection('page_type_publish_target_type');
if (!$types) {
return;
}
foreach ($types->getTypes() as $type) {
if (!$type->getPublisherValidator()->skipItem()) {
$pkg = false;
if ($type->getPackage()) {
$pkg = \Package::getByHandle($type->getPackage());
}
Type::add($type->getHandle(), $type->getName(), $pkg);
}
}
}
/**
* Returns an array of package items (e.g. blocks, themes)
*/
public function getPackageItems()
{
$items = array();
$items['attribute_categories'] = AttributeKeyCategory::getListByPackage($this);
$items['permission_categories'] = PermissionKeyCategory::getListByPackage($this);
$items['permission_access_entity_types'] = PermissionAccessEntityType::getListByPackage($this);
$items['attribute_keys'] = AttributeKey::getListByPackage($this);
$items['attribute_sets'] = AttributeSet::getListByPackage($this);
$items['group_sets'] = GroupSet::getListByPackage($this);
$items['page_types'] = PageType::getListByPackage($this);
$items['page_templates'] = PageTemplate::getListByPackage($this);
$items['mail_importers'] = MailImporter::getListByPackage($this);
$items['gathering_item_template_types'] = GatheringItemTemplateType::getListByPackage($this);
$items['gathering_item_templates'] = GatheringItemTemplate::getListByPackage($this);
$items['gathering_data_sources'] = GatheringDataSource::getListByPackage($this);
$items['features'] = Feature::getListByPackage($this);
$items['feature_categories'] = FeatureCategory::getListByPackage($this);
$btl = new BlockTypeList();
$btl->filterByPackage($this);
$blocktypes = $btl->get();
$items['block_types'] = $blocktypes;
$items['block_type_sets'] = BlockTypeSet::getListByPackage($this);
$items['page_themes'] = PageTheme::getListByPackage($this);
$items['permissions'] = PermissionKey::getListByPackage($this);
$items['single_pages'] = SinglePage::getListByPackage($this);
$items['attribute_types'] = AttributeType::getListByPackage($this);
$items['captcha_libraries'] = SystemCaptchaLibrary::getListByPackage($this);
$items['content_editor_snippets'] = SystemContentEditorSnippet::getListByPackage($this);
$items['conversation_editors'] = ConversationEditor::getListByPackage($this);
$items['conversation_rating_types'] = ConversationRatingType::getListByPackage($this);
$items['page_type_publish_target_types'] = PageTypePublishTargetType::getListByPackage($this);
$items['page_type_composer_control_types'] = PageTypeComposerControlType::getListByPackage($this);
$items['antispam_libraries'] = SystemAntispamLibrary::getListByPackage($this);
$items['community_point_actions'] = UserPointAction::getListByPackage($this);
$items['jobs'] = Job::getListByPackage($this);
$items['workflow_types'] = WorkflowType::getListByPackage($this);
ksort($items);
return $items;
}
public function run()
{
$this->x = new SimpleXMLElement("<concrete5-cif></concrete5-cif>");
$this->x->addAttribute('version', '1.0');
// First, attribute categories
AttributeKeyCategory::exportList($this->x);
// Features
Feature::exportList($this->x);
FeatureCategory::exportList($this->x);
ConversationEditor::exportList($this->x);
ConversationRatingType::exportList($this->x);
// composer
PageTypePublishTargetType::exportList($this->x);
PageTypeComposerControlType::exportList($this->x);
PageType::exportList($this->x);
// attribute types
AttributeType::exportList($this->x);
// then block types
BlockTypeList::exportList($this->x);
// now block type sets (including user)
BlockTypeSet::exportList($this->x);
// gathering
GatheringDataSource::exportList($this->x);
GatheringItemTemplate::exportList($this->x);
// now attribute keys (including user)
AttributeKey::exportList($this->x);
// now attribute keys (including user)
AttributeSet::exportList($this->x);
PageTemplate::exportList($this->x);
// now theme
PageTheme::exportList($this->x);
// now packages
PackageList::export($this->x);
// permission access entity types
PermissionAccessEntityType::exportList($this->x);
// now task permissions
PermissionKey::exportList($this->x);
// workflow types
WorkflowType::exportList($this->x);
// now jobs
Job::exportList($this->x);
// now single pages
$singlepages = $this->x->addChild("singlepages");
$db = Loader::db();
$r = $db->Execute('select cID from Pages where cFilename is not null and cFilename <> "" and cID not in (select cID from Stacks) order by cID asc');
while ($row = $r->FetchRow()) {
$pc = Page::getByID($row['cID'], 'RECENT');
$pc->export($singlepages);
}
// now stacks/global areas
StackList::export($this->x);
// now content pages
$pages = $this->x->addChild("pages");
$db = Loader::db();
$r = $db->Execute('select Pages.cID from Pages where cIsTemplate = 0 and cFilename is null or cFilename = "" order by cID asc');
while ($row = $r->FetchRow()) {
$pc = Page::getByID($row['cID'], 'RECENT');
if ($pc->getPageTypeHandle() == STACKS_PAGE_TYPE) {
continue;
}
$pc->export($pages);
}
SystemCaptchaLibrary::exportList($this->x);
\Concrete\Core\Sharing\SocialNetwork\Link::exportList($this->x);
\Concrete\Core\Page\Feed::exportList($this->x);
\Concrete\Core\File\Image\Thumbnail\Type\Type::exportList($this->x);
Config::exportList($this->x);
Tree::exportList($this->x);
}
public function getPackageItems(Package $package)
{
return Type::getListByPackage($package);
}
/**
* Add a page type.
*
* @param array $data {
* @var string $handle A string which can be used to identify the page type
* @var string $name A user friendly display name
* @var \PageTemplate $defaultTemplate The default template object
* @var string $allowedTemplates (A|C|X) A for all, C for selected only, X for non-selected only
* @var \PageTemplate[] $templates Array or Iterator of selected templates, see `$allowedTemplates`
* @var bool $internal Is this an internal only page type? Default: `false`
* @var bool $ptLaunchInComposer Does this launch in composer? Default: `false`
* @var bool $ptIsFrequentlyAdded Should this always be displayed in the pages panel? Default: `false`
* }
* @param bool|Package $pkg This should be false if the type is not tied to a package, or a package object
*
* @return static|mixed|null
*/
public static function add($data, $pkg = false)
{
$data = $data + array('defaultTemplate' => null, 'allowedTemplates' => null, 'templates' => null, 'internal' => null, 'ptLaunchInComposer' => null, 'ptIsFrequentlyAdded' => null);
$ptHandle = $data['handle'];
$ptName = $data['name'];
$ptDefaultPageTemplateID = 0;
$ptIsFrequentlyAdded = 0;
$ptLaunchInComposer = 0;
$pkgID = 0;
if (is_object($pkg)) {
$pkgID = $pkg->getPackageID();
}
if (is_object($data['defaultTemplate'])) {
$ptDefaultPageTemplateID = $data['defaultTemplate']->getPageTemplateID();
}
$ptAllowedPageTemplates = 'A';
if ($data['allowedTemplates']) {
$ptAllowedPageTemplates = $data['allowedTemplates'];
}
$templates = array();
if (is_array($data['templates'])) {
$templates = $data['templates'];
}
$ptIsInternal = 0;
if ($data['internal']) {
$ptIsInternal = 1;
}
if ($data['ptLaunchInComposer']) {
$ptLaunchInComposer = 1;
}
if ($data['ptIsFrequentlyAdded']) {
$ptIsFrequentlyAdded = 1;
}
$db = Loader::db();
$ptDisplayOrder = 0;
$count = $db->GetOne('select count(ptID) from PageTypes where ptIsInternal = ?', array($ptIsInternal));
if ($count > 0) {
$ptDisplayOrder = $count;
}
$db->Execute('insert into PageTypes (ptName, ptHandle, ptDefaultPageTemplateID, ptAllowedPageTemplates, ptIsInternal, ptLaunchInComposer, ptDisplayOrder, ptIsFrequentlyAdded, pkgID) values (?, ?, ?, ?, ?, ?, ?, ?, ?)', array($ptName, $ptHandle, $ptDefaultPageTemplateID, $ptAllowedPageTemplates, $ptIsInternal, $ptLaunchInComposer, $ptDisplayOrder, $ptIsFrequentlyAdded, $pkgID));
$ptID = $db->Insert_ID();
if ($ptAllowedPageTemplates != 'A') {
foreach ($templates as $pt) {
$db->Execute('insert into PageTypePageTemplates (ptID, pTemplateID) values (?, ?)', array($ptID, $pt->getPageTemplateID()));
}
}
$ptt = static::getByID($ptID);
// set all type publish target as default
$target = PageTypePublishTargetType::getByHandle('all');
if (is_object($target)) {
$configuredTarget = $target->configurePageTypePublishTarget($ptt, array());
$ptt->setConfiguredPageTypePublishTargetObject($configuredTarget);
}
// copy permissions from the defaults to the page type
$cpk = PermissionKey::getByHandle('access_page_type_permissions');
$permissions = PermissionKey::getList('page_type');
foreach ($permissions as $pk) {
$pk->setPermissionObject($ptt);
$pk->copyFromDefaultsToPageType($cpk);
}
// now we clear the default from edit page drafts
$pk = PermissionKey::getByHandle('edit_page_type_drafts');
if (is_object($pk)) {
$pk->setPermissionObject($ptt);
$pt = $pk->getPermissionAssignmentObject();
if (is_object($pt)) {
$pt->clearPermissionAssignment();
}
// now we assign the page draft owner access entity
$pa = PermissionAccess::create($pk);
$pe = PageOwnerPermissionAccessEntity::getOrCreate();
$pa->addListItem($pe);
$pt->assignPermissionAccess($pa);
return $ptt;
}
}
public function add_page_types()
{
$pt_catalog = PageType::getByHandle('catalog');
if (!is_object($pt_catalog)) {
// catalog pt
$data = array('name' => 'Catalog', 'handle' => 'catalog', 'ptLaunchInComposer' => true, 'ptIsFrequentlyAdded' => true, 'defaultTemplate' => PageTemplate::getByHandle('full'), 'allowedTemplates' => 'C', 'templates' => array(PageTemplate::getByHandle('full')));
$pt = PageType::add($data, $this->pkg);
// configured publishing target
$publishTarget = PublishTargetType::getByHandle('page_type')->configurePageTypePublishTarget($pt, array('ptID' => $pt->getPageTypeID()));
$pt->setConfiguredPageTypePublishTargetObject($publishTarget);
}
// product pt
$pt_catalog = $pt;
$pt_product = PageType::getByHandle('product');
if (!is_object($pt_product)) {
$data = array('name' => 'Product', 'handle' => 'product', 'ptLaunchInComposer' => true, 'ptIsFrequentlyAdded' => true, 'defaultTemplate' => PageTemplate::getByHandle('full'), 'allowedTemplates' => 'C', 'templates' => array(PageTemplate::getByHandle('full')));
$pt = PageType::add($data, $this->pkg);
// configured publishing target
$publishTarget = PublishTargetType::getByHandle('page_type')->configurePageTypePublishTarget($pt, array('ptID' => $pt_catalog->getPageTypeID()));
$pt->setConfiguredPageTypePublishTargetObject($publishTarget);
}
}
/**
* Create a page type and assign defaults and shit
*/
private function createPageType(array $settings)
{
// Cast to an object
$settings = (object) $settings;
// Get the page type if it exists previously
$pageType = PageType::getByHandle($settings->configs['handle']);
// Delete it? Only works if the $pageType isn't assigned to this package already
if (is_object($pageType) && !((int) $pageType->getPackageID() >= 1)) {
$pageType->delete();
}
if (!is_object(PageType::getByHandle($settings->configs['handle']))) {
/** @var $ptPage \Concrete\Core\Page\Type\Type */
$ptPage = PageType::add(array_merge(array('ptIsFrequentlyAdded' => 1, 'ptLaunchInComposer' => 1), $settings->configs), $this->packageObject());
// Set configured publish target
$ptPage->setConfiguredPageTypePublishTargetObject(PublishTargetType::getByHandle('all')->configurePageTypePublishTarget($ptPage, array('ptID' => $ptPage->getPageTypeID())));
/** @var $layoutSet \Concrete\Core\Page\Type\Composer\FormLayoutSet */
$layoutSet = $ptPage->addPageTypeComposerFormLayoutSet('Basics', 'Basics');
// Are we adding composer controls?
if (property_exists($settings, 'controls') && is_array($settings->controls)) {
// Core page properties
$corePageProperties = $settings->controls['core_page_property'];
if (is_array($corePageProperties)) {
/** @var $controlTypeObj \Concrete\Core\Page\Type\Composer\Control\Type\CorePagePropertyType */
$controlTypeObj = \Concrete\Core\Page\Type\Composer\Control\Type\Type::getByHandle('core_page_property');
if (is_object($controlTypeObj)) {
foreach ($corePageProperties as $controlName => $isRequired) {
$control = $controlTypeObj->getPageTypeComposerControlByIdentifier($controlName);
$control->addToPageTypeComposerFormLayoutSet($layoutSet)->updateFormLayoutSetControlRequired($isRequired);
}
}
}
// Blocks
$pageBlocks = $settings->controls['block'];
if (is_array($pageBlocks)) {
/** @var $controlTypeObj \Concrete\Core\Page\Type\Composer\Control\Type\CollectionAttributeType */
$controlTypeObj = \Concrete\Core\Page\Type\Composer\Control\Type\Type::getByHandle('block');
if (is_object($controlTypeObj)) {
foreach ($pageBlocks as $controlName) {
$blockTypeObj = BlockType::getByHandle($controlName);
if (is_object($blockTypeObj)) {
$control = $controlTypeObj->getPageTypeComposerControlByIdentifier($blockTypeObj->getBlockTypeID());
$control->addToPageTypeComposerFormLayoutSet($layoutSet);
}
}
}
}
// Attributes
$pageAttributes = $settings->controls['collection_attribute'];
if (is_array($pageAttributes)) {
/** @var $controlTypeObj \Concrete\Core\Page\Type\Composer\Control\Type\CollectionAttributeType */
$controlTypeObj = \Concrete\Core\Page\Type\Composer\Control\Type\Type::getByHandle('collection_attribute');
if (is_object($controlTypeObj)) {
foreach ($pageAttributes as $controlName) {
$collectionAttrKey = CollectionAttributeKey::getByHandle($controlName);
if (is_object($collectionAttrKey)) {
$control = $controlTypeObj->getPageTypeComposerControlByIdentifier($collectionAttrKey->getAttributeKeyID());
$control->addToPageTypeComposerFormLayoutSet($layoutSet);
}
}
}
}
}
}
}
public function __construct(PageTypePublishTargetType $type)
{
$this->ptPublishTargetTypeID = $type->getPageTypePublishTargetTypeID();
$this->ptPublishTargetTypeHandle = $type->getPageTypePublishTargetTypeHandle();
$this->pkgHandle = $type->getPackageHandle();
}
public function skipItem()
{
$editor = Type::getByHandle($this->object->getHandle());
return is_object($editor);
}
public static function importTargets($node)
{
$ptHandle = (string) $node['handle'];
$db = Loader::db();
$ptID = $db->GetOne('select ptID from PageTypes where ptHandle = ?', array($ptHandle));
$cm = static::getByID($ptID);
if (is_object($cm) && isset($node->target)) {
$target = \Concrete\Core\Page\Type\PublishTarget\Type\Type::importConfiguredPageTypePublishTarget($node->target);
$cm->setConfiguredPageTypePublishTargetObject($target);
}
}
<?php
defined('C5_EXECUTE') or die("Access Denied.");
use Concrete\Core\Page\Type\PublishTarget\Type\Type as PageTypePublishTargetType;
$form = Loader::helper('form');
$templates = array();
$ag = \Concrete\Core\Http\ResponseAssetGroup::get();
$ag->requireAsset('selectize');
$pagetemplates = PageTemplate::getList();
foreach ($pagetemplates as $pt) {
$templates[$pt->getPageTemplateID()] = $pt->getPageTemplateDisplayName();
}
$targetTypes = PageTypePublishTargetType::getList();
$ptName = '';
$ptHandle = '';
$ptPageTemplateID = array();
$ptAllowedPageTemplates = 'A';
$ptDefaultPageTemplateID = 0;
$ptLaunchInComposer = 0;
$ptIsFrequentlyAdded = 1;
$token = 'add_page_type';
if (is_object($pagetype)) {
$token = 'update_page_type';
$siteType = $pagetype->getSiteTypeObject();
$ptName = $pagetype->getPageTypeName();
$ptHandle = $pagetype->getPageTypeHandle();
$ptLaunchInComposer = $pagetype->doesPageTypeLaunchInComposer();
$ptDefaultPageTemplateID = $pagetype->getPageTypeDefaultPageTemplateID();
$ptAllowedPageTemplates = $pagetype->getPageTypeAllowedPageTemplates();
$ptIsFrequentlyAdded = $pagetype->isPageTypeFrequentlyAdded();
$selectedtemplates = $pagetype->getPageTypeSelectedPageTemplateObjects();
public function add_blog_page($pkg)
{
/*
* Add new Post template
*/
//$tmplt = Template::add('pb_post', 'ProBlog Post', 'right_sidebar.png', $pkg);
$tmplt = Template::getByHandle('right_sidebar');
/*
* Add new Post Page Type using new Template
*/
$setBlogAt = Page::getByPath('/blog');
$type = CollectionType::add(array('handle' => 'pb_post', 'name' => 'ProBlog Post', 'defaultTemplate' => $tmplt, 'allowedTemplates' => 'C', 'templates' => array($tmplt), 'ptLaunchInComposer' => 1, 'ptIsFrequentlyAdded' => 1), $pkg);
/*
* Add our new blog_section PublishTarget Type
*/
$pt_target = PublishTarget::add('blog_section', 'Choose From Blog Section Pages', $pkg);
$configuration = new BlogSectionConfiguration($pt_target);
/*
* Set Post Page Type to use Parent Page Configuration
*/
$type->setConfiguredPageTypePublishTargetObject($configuration);
/*
* Create Post Page Type Form Layout Sets
*/
$info = $type->addPageTypeComposerFormLayoutSet('General Info', 'Basic Blog Post Information');
$post = $type->addPageTypeComposerFormLayoutSet('Post Content', 'Your Post Content');
$metas = $type->addPageTypeComposerFormLayoutSet('Post Metas', 'Your Post Meta Data');
$options = $type->addPageTypeComposerFormLayoutSet('Post Options', 'Your Post Options');
/*
* Create Post Page Type Form Layout Controls
*/
$core_att_controls = PageTypeComposerControlType::getByHandle('core_page_property');
$page_att_controls = PageTypeComposerControlType::getByHandle('collection_attribute');
$block_controls = PageTypeComposerControlType::getByHandle('block');
/*
* ++++++++++++++++++++++
* Info Tab
* ++++++++++++++++++++++
*/
/* Post Title */
$name = $core_att_controls->getPageTypeComposerControlByIdentifier('name');
$name->setPageTypeComposerControlName(t('Post Title'));
$name->addToPageTypeComposerFormLayoutSet($info);
/* Post Slug */
$slug = $core_att_controls->getPageTypeComposerControlByIdentifier('url_slug');
$slug->setPageTypeComposerControlName(t('Post Slug'));
$slug->addToPageTypeComposerFormLayoutSet($info);
/* Post Author */
$control_id = CollectionAttributeKey::getByHandle('blog_author')->getAttributeKeyID();
$blog_author = $page_att_controls->getPageTypeComposerControlByIdentifier($control_id);
$blog_author->addToPageTypeComposerFormLayoutSet($info);
/* Post Thumbnail */
$control_id = CollectionAttributeKey::getByHandle('thumbnail')->getAttributeKeyID();
$thumbnail = $page_att_controls->getPageTypeComposerControlByIdentifier($control_id);
$thumbnail->addToPageTypeComposerFormLayoutSet($info);
/* Post Description */
$description = $core_att_controls->getPageTypeComposerControlByIdentifier('description');
$description->addToPageTypeComposerFormLayoutSet($info);
/*
* ++++++++++++++++++++++
* Post Tab
* ++++++++++++++++++++++
*/
/* Event Content */
$control_id = BlockType::getByHandle('content')->getBlockTypeID();
$post_content = $block_controls->getPageTypeComposerControlByIdentifier($control_id);
$post_content->addToPageTypeComposerFormLayoutSet($post);
/*
* ++++++++++++++++++++++
* Metas Tab
* ++++++++++++++++++++++
*/
/* Meta Title */
$control_id = CollectionAttributeKey::getByHandle('meta_title')->getAttributeKeyID();
$meta_title = $page_att_controls->getPageTypeComposerControlByIdentifier($control_id);
$meta_title->addToPageTypeComposerFormLayoutSet($metas);
/* Meta Description */
$control_id = CollectionAttributeKey::getByHandle('meta_description')->getAttributeKeyID();
$meta_description = $page_att_controls->getPageTypeComposerControlByIdentifier($control_id);
$meta_description->addToPageTypeComposerFormLayoutSet($metas);
/* Meta Keywords */
$control_id = CollectionAttributeKey::getByHandle('meta_keywords')->getAttributeKeyID();
$meta_keywords = $page_att_controls->getPageTypeComposerControlByIdentifier($control_id);
$meta_keywords->addToPageTypeComposerFormLayoutSet($metas);
/*
* ++++++++++++++++++++++
* Options Tab
* ++++++++++++++++++++++
*/
/* Post Location */
$target = $core_att_controls->getPageTypeComposerControlByIdentifier('publish_target');
$target->addToPageTypeComposerFormLayoutSet($options);
/* Post Date */
$public = $core_att_controls->getPageTypeComposerControlByIdentifier('date_time');
$public->addToPageTypeComposerFormLayoutSet($options);
/* Post Tags */
$control_id = CollectionAttributeKey::getByHandle('tags')->getAttributeKeyID();
$tags = $page_att_controls->getPageTypeComposerControlByIdentifier($control_id);
$tags->addToPageTypeComposerFormLayoutSet($options);
/* Post Blog Category */
$control_id = CollectionAttributeKey::getByHandle('blog_category')->getAttributeKeyID();
$blog_category = $page_att_controls->getPageTypeComposerControlByIdentifier($control_id);
$blog_category->addToPageTypeComposerFormLayoutSet($options);
/* Send to subscribers */
$control_id = CollectionAttributeKey::getByHandle('send_subscription')->getAttributeKeyID();
$send_subscribe = $page_att_controls->getPageTypeComposerControlByIdentifier($control_id);
$send_subscribe->addToPageTypeComposerFormLayoutSet($options);
/* Post To Twitter */
$control_id = CollectionAttributeKey::getByHandle('post_to_twitter')->getAttributeKeyID();
$twitter = $page_att_controls->getPageTypeComposerControlByIdentifier($control_id);
$twitter->addToPageTypeComposerFormLayoutSet($options);
/* Composer Optimize */
$control_id = CollectionAttributeKey::getByHandle('composer_optimizer')->getAttributeKeyID();
$composer_optimize = $page_att_controls->getPageTypeComposerControlByIdentifier($control_id);
$composer_optimize->addToPageTypeComposerFormLayoutSet($options);
$db = Loader::db();
$cocID = $db->getOne("SELECT ptComposerOutputControlID FROM PageTypeComposerOutputControls WHERE pTemplateID = ? AND ptID = ?", array($tmplt->getPageTemplateID(), $type->getPageTypeID()));
$this->install_pb_page_defaults($pkg, $cocID);
}
