示例#1
0
 public function copyFromDefaultsToPageType(\Concrete\Core\Permission\Key\Key $pk)
 {
     $db = Loader::db();
     $paID = $pk->getPermissionAccessID();
     if ($paID) {
         $db = Loader::db();
         $db->Replace('PageTypePermissionAssignments', array('ptID' => $this->permissionObject->getPageTypeID(), 'paID' => $paID, 'pkID' => $this->getPermissionKeyID()), array('ptID', 'pkID'), true);
     }
 }
示例#2
0
 /**
  * We take any permissions function run on the permissions class and send it into the category object.
  */
 public function __call($f, $a)
 {
     if (!is_object($this->response)) {
         // handles task permissions
         $permission = Loader::helper('text')->uncamelcase($f);
     }
     if (count($a) > 0) {
         if (is_object($this->response)) {
             $r = call_user_func_array(array($this->response, $f), $a);
         } else {
             $pk = PermissionKey::getByHandle($permission);
             $r = call_user_func_array(array($pk, $f), $a);
         }
     } elseif (is_object($this->response)) {
         $r = $this->response->{$f}();
     } else {
         $pk = PermissionKey::getByHandle($permission);
         if (is_object($pk)) {
             $r = $pk->validate();
         } else {
             throw new \Exception(t('Unable to get permission key for %s', $permission));
         }
     }
     if (is_array($r) || is_object($r)) {
         return $r;
     } elseif ($r) {
         return 1;
     } else {
         return 0;
     }
 }
示例#3
0
 public function handlePageUpdate($event)
 {
     $page = $event->getPageObject();
     $pk = PermissionKey::getByHandle('view_page');
     $pk->setPermissionObject($page);
     $list = $pk->getAccessListItems();
     foreach ($list as $pa) {
         $pae = $pa->getAccessEntityObject();
         if ($pae->getAccessEntityTypeHandle() == 'group') {
             if ($pae->getGroupObject()->getGroupID() == GUEST_GROUP_ID) {
                 $pd = $pa->getPermissionDurationObject();
                 if (!is_object($pd)) {
                     $pd = new PermissionDuration();
                 }
                 $publicDate = strtotime($page->getCollectionDatePublic());
                 $pd->setStartDateAllDay(0);
                 $pd->setEndDateAllDay(0);
                 $pd->setStartDate($dateStart = date('Y-m-d H:i:s', $publicDate));
                 $pd->save();
                 $paa = PermissionAccess::getByID($pa->paID, $pk);
                 $paa->addListItem($pae, $pd, PermissionKey::ACCESS_TYPE_INCLUDE);
             }
         }
     }
 }
 public function assignPermissions($userOrGroup, $permissions = [], $accessType = Key::ACCESS_TYPE_INCLUDE, $cascadeToChildren = true)
 {
     if (!$cascadeToChildren) {
         $this->setChildPermissionsToOverride();
     }
     $this->setPermissionsToOverride();
     if (is_array($userOrGroup)) {
         $pe = GroupCombinationEntity::getOrCreate($userOrGroup);
         // group combination
     } elseif ($userOrGroup instanceof User || $userOrGroup instanceof \Concrete\Core\User\UserInfo || $userOrGroup instanceof \Concrete\Core\User\User) {
         $pe = UserEntity::getOrCreate($userOrGroup);
     } elseif ($userOrGroup instanceof Entity) {
         $pe = $userOrGroup;
     } else {
         // group;
         $pe = GroupEntity::getOrCreate($userOrGroup);
     }
     foreach ($permissions as $pkHandle) {
         $pk = Key::getByHandle($pkHandle);
         $pk->setPermissionObject($this);
         $pa = $pk->getPermissionAccessObject();
         if (!is_object($pa)) {
             $pa = Access::create($pk);
         } elseif ($pa->isPermissionAccessInUse()) {
             $pa = $pa->duplicate();
         }
         $pa->addListItem($pe, false, $accessType);
         $pt = $pk->getPermissionAssignmentObject();
         $pt->assignPermissionAccess($pa);
     }
 }
 public function getPermissionAccessObject()
 {
     $cache = Core::make('cache/request');
     $identifier = sprintf('permission/assignment/access/%s/%s', $this->pk->getPermissionKeyHandle(), $this->getPermissionObject()->getPermissionObjectIdentifier());
     $item = $cache->getItem($identifier);
     if (!$item->isMiss()) {
         return $item->get();
     }
     $db = Loader::db();
     $r = $db->GetOne('select paID from PagePermissionAssignments where cID = ? and pkID = ?', array($this->getPermissionObject()->getPermissionsCollectionID(), $this->pk->getPermissionKeyID()));
     $pa = $r ? Access::getByID($r, $this->pk, false) : null;
     if (is_object($pa)) {
         if ($this->getPermissionObject()->isPageDraft() && $this->getPermissionObject()->getCollectionInheritance() == 'PARENT' && is_object($pageType = $this->getPermissionObject()->getPageTypeObject()) && isset($this->inheritedPageTypeDraftPermissions[$this->pk->getPermissionKeyHandle()])) {
             $pk = Key::getByHandle($this->inheritedPageTypeDraftPermissions[$this->pk->getPermissionKeyHandle()]);
             $pk->setPermissionObject($pageType);
             $access = $pk->getPermissionAccessObject();
             if (is_object($access)) {
                 $list_items = $access->getAccessListItems();
                 $pa->setListItems($list_items);
             }
         }
     }
     $cache->save($item->set($pa));
     return $pa;
 }
示例#6
0
 public function getPublishButtonTitle(Page $c)
 {
     if ($c->isPageDraft()) {
         $publishTitle = t('Publish Page');
     } else {
         $publishTitle = t('Publish Changes');
     }
     $pk = Key::getByHandle('approve_page_versions');
     $pk->setPermissionObject($c);
     $pa = $pk->getPermissionAccessObject();
     $workflows = array();
     $canApproveWorkflow = true;
     if (is_object($pa)) {
         $workflows = $pa->getWorkflows();
     }
     foreach ($workflows as $wf) {
         if (!$wf->canApproveWorkflow()) {
             $canApproveWorkflow = false;
         }
     }
     if (count($workflows) > 0 && !$canApproveWorkflow) {
         $publishTitle = t('Submit to Workflow');
     }
     return $publishTitle;
 }
示例#7
0
 /**
  * Begin the runtime.
  */
 public function run()
 {
     $app = $this->app;
     include DIR_APPLICATION . '/bootstrap/app.php';
     if ($this->app->isInstalled()) {
         /*
          * ----------------------------------------------------------------------------
          * Now that we have languages out of the way, we can run our package on_start
          * methods
          * ----------------------------------------------------------------------------
          */
         $app->setupPackages();
         /*
          * ----------------------------------------------------------------------------
          * Legacy Definitions. This has to come after packages because this
          * essentially loads the entity manager, and the entity manager loads classes
          * found in its config, which may be classes that haven't been autoloaded by initialPackages. It also
          * has to come after setupPackages() in case an autoloader is configured in on_start()
          * ----------------------------------------------------------------------------
          */
         $this->initializeLegacyURLDefinitions($app);
         /*
          * Handle automatic updating. Must come after setupPackages() because some things setup autoloaders in on_start() of their package
          * controller
          */
         $app->handleAutomaticUpdates();
         // This is a crappy place for this, but it has to come AFTER the packages because sometimes packages
         // want to replace legacy "tools" URLs with the new MVC, and the tools paths are so greedy they don't
         // work unless they come at the end.
         $this->registerLegacyRoutes();
         /* ----------------------------------------------------------------------------
          * Register legacy routes
          * ----------------------------------------------------------------------------
          */
         $this->registerLegacyRoutes();
         /* ----------------------------------------------------------------------------
          * Register legacy config values
          * ----------------------------------------------------------------------------
          */
         $this->registerLegacyConfigValues();
         /*
          * ----------------------------------------------------------------------------
          * Load all permission keys into our local cache.
          * ----------------------------------------------------------------------------
          */
         Key::loadAll();
     }
     /*
      * ----------------------------------------------------------------------------
      * Fire an event for intercepting the dispatch
      * ----------------------------------------------------------------------------
      */
     Events::dispatch('on_before_dispatch');
     $request = Request::createFromGlobals();
     return $this->server->handleRequest($request);
 }
 public function getUsersToNotify(SubscriptionInterface $subscription, SubjectInterface $subject)
 {
     $key = Key::getByHandle('notify_in_notification_center');
     $users = array();
     if (is_object($key)) {
         $access = $key->getPermissionAssignmentObject()->getPermissionAccessObject();
         if (is_object($access)) {
             /**
              * @var $access Access
              */
             $items = $access->getAccessListItems(Key::ACCESS_TYPE_INCLUDE);
             /**
              * @var $item NotifyInNotificationCenterNotificationListItem
              */
             foreach ($items as $item) {
                 if ($item->getSubscriptionsAllowedPermission() == 'A' || $item->getSubscriptionsAllowedPermission() == 'C' && in_array($subscription, $item->getSubscriptionsAllowedArray())) {
                     /**
                      * @var $entity Entity
                      */
                     $entity = $item->getAccessEntityObject();
                     $users = array_merge($entity->getAccessEntityUsers($access), $users);
                 }
             }
             // Now we loop through the array and remove
             $items = $access->getAccessListItems(Key::ACCESS_TYPE_EXCLUDE);
             /**
              * @var $item NotifyInNotificationCenterNotificationListItem
              */
             $usersToRemove = array();
             foreach ($subject->getUsersToExcludeFromNotification() as $user) {
                 $usersToRemove[] = $user->getUserID();
             }
             foreach ($items as $item) {
                 if ($item->getSubscriptionsAllowedPermission() == 'N' || $item->getSubscriptionsAllowedPermission() == 'C' && in_array($subscription, $item->getSubscriptionsAllowedArray())) {
                     /**
                      * @var $entity Entity
                      */
                     $entity = $item->getAccessEntityObject();
                     foreach ($entity->getAccessEntityUsers($access) as $user) {
                         $usersToRemove[] = $user->getUserID();
                     }
                 }
             }
             $users = array_unique($users);
             $usersToRemove = array_unique($usersToRemove);
             $users = array_filter($users, function ($element) use($usersToRemove) {
                 if (in_array($element->getUserID(), $usersToRemove)) {
                     return false;
                 }
                 return true;
             });
         }
     }
     return $users;
 }
 public function apply($mixed)
 {
     $workflow = Workflow::getByName($this->workflowName);
     $key = Key::getByHandle($this->pkHandle);
     $key->setPermissionObject($mixed->getPermissionObject());
     $assignment = $key->getPermissionAssignmentObject();
     $access = $assignment->getPermissionAccessObject();
     if (is_object($access)) {
         $access->attachWorkflow($workflow);
     }
 }
 public function apply($mixed)
 {
     $key = Key::getByHandle($this->pkHandle);
     $entity = $mixed->getAccessEntity();
     $pa = $key->getPermissionAccessObject();
     if (!is_object($pa)) {
         $pa = Access::create($key);
     }
     $pa->addListItem($entity, false, $this->accessType);
     $pt = $key->getPermissionAssignmentObject();
     $pt->assignPermissionAccess($pa);
 }
示例#11
0
 public function getPermissionAccessObject()
 {
     $db = Database::connection();
     if ($this->permissionObjectToCheck instanceof File) {
         $r = $db->GetOne('select paID from FilePermissionAssignments where fID = ? and pkID = ?', array($this->permissionObject->getFileID(), $this->pk->getPermissionKeyID()));
         if ($r) {
             return Access::getByID($r, $this->pk, false);
         }
     } else {
         if (isset($this->inheritedPermissions[$this->pk->getPermissionKeyHandle()])) {
             $pk = Key::getByHandle($this->inheritedPermissions[$this->pk->getPermissionKeyHandle()]);
             $pk->setPermissionObject($this->permissionObjectToCheck);
             $pae = $pk->getPermissionAccessObject();
             return $pae;
         }
     }
 }
 public function import(\SimpleXMLElement $sx)
 {
     if (isset($sx->permissionkeys)) {
         foreach ($sx->permissionkeys->permissionkey as $pk) {
             if (is_object(Key::getByHandle((string) $pk['handle']))) {
                 continue;
             }
             $pkc = Category::getByHandle((string) $pk['category']);
             $c1 = $pkc->getPermissionKeyClass();
             $pkx = call_user_func(array($c1, 'import'), $pk);
             $assignments = array();
             if (isset($pk->access)) {
                 foreach ($pk->access->children() as $ch) {
                     if ($ch->getName() == 'group') {
                         /*
                          * Legacy
                          */
                         $g = Group::getByName($ch['name']);
                         if (!is_object($g)) {
                             $g = Group::add($g['name'], $g['description']);
                         }
                         $pae = GroupEntity::getOrCreate($g);
                         $assignments[] = $pae;
                     }
                     if ($ch->getName() == 'entity') {
                         $type = Type::getByHandle((string) $ch['type']);
                         $class = $type->getAccessEntityTypeClass();
                         if (method_exists($class, 'configureFromImport')) {
                             $pae = $class::configureFromImport($ch);
                             $assignments[] = $pae;
                         }
                     }
                 }
             }
             if (count($assignments)) {
                 $pa = Access::create($pkx);
                 foreach ($assignments as $pae) {
                     $pa->addListItem($pae);
                 }
                 $pt = $pkx->getPermissionAssignmentObject();
                 $pt->assignPermissionAccess($pa);
             }
         }
     }
 }
示例#13
0
 /**
  * @param UserList $list
  * @param $request
  */
 public function filterList(ItemList $list)
 {
     $gsID = $this->data['gsID'];
     $gs = GroupSet::getByID($gsID);
     $groupsetids = array(-1);
     if (is_object($gs)) {
         $groups = $gs->getGroups();
     }
     $list->addToQuery('left join UserGroups ugs on u.uID = ugs.uID');
     $pk = Key::getByHandle('search_users_in_group');
     foreach ($groups as $g) {
         if ($pk->validate($g) && !in_array($g->getGroupID(), $groupsetids)) {
             $groupsetids[] = $g->getGroupID();
         }
     }
     $instr = 'ugs.gID in (' . implode(',', $groupsetids) . ')';
     $list->filter(false, $instr);
 }
示例#14
0
 public function setUp()
 {
     $this->tables = array_merge($this->tables, array('PermissionAccessList', 'PageTypeComposerFormLayoutSets', 'AttributeSetKeys', 'AttributeSets', 'AttributeKeyCategories', 'PermissionAccessEntityTypes', 'Packages', 'AttributeKeys', 'AttributeTypes', 'PageFeeds'));
     parent::setUp();
     \Concrete\Core\Permission\Access\Entity\Type::add('page_owner', 'Page Owner');
     \Concrete\Core\Permission\Category::add('page');
     \Concrete\Core\Permission\Key\Key::add('page', 'view_page', 'View Page', '', 0, 0);
     PageTemplate::add('left_sidebar', 'Left Sidebar');
     PageTemplate::add('right_sidebar', 'Right Sidebar');
     PageType::add(array('handle' => 'alternate', 'name' => 'Alternate'));
     PageType::add(array('handle' => 'another', 'name' => 'Another'));
     foreach ($this->pageData as $data) {
         $c = call_user_func_array(array($this, 'createPage'), $data);
         $c->reindex();
     }
     $this->list = new \Concrete\Core\Page\PageList();
     $this->list->ignorePermissions();
 }
 public function execute(Batch $batch)
 {
     $keys = $batch->getObjectCollection('permission_key');
     if (!$keys) {
         return;
     }
     foreach ($keys->getKeys() as $key) {
         if (!$key->getPublisherValidator()->skipItem()) {
             $pkg = null;
             if ($key->getPackage()) {
                 $pkg = \Package::getByHandle($key->getPackage());
             }
             $p = Key::add($key->getCategory(), $key->getHandle(), $key->getName(), $key->getDescription(), $key->getCanTriggerWorkflow(), $key->getHasCustomClass(), $pkg);
             foreach ($key->getAccessEntities() as $entity) {
                 $publisher = $entity->getPublisher();
                 $publisher->publish($p, $entity);
             }
         }
     }
 }
示例#16
0
 public static function getByID($paID, PermissionKey $pk, $checkPA = true)
 {
     $cache = Core::make('cache/request');
     $identifier = sprintf('permission/access/%s/%s', $pk->getPermissionKeyID(), $paID);
     $item = $cache->getItem($identifier);
     if (!$item->isMiss()) {
         return $item->get();
     }
     $db = Database::connection();
     $handle = $pk->getPermissionKeyCategoryHandle();
     if ($pk->permissionKeyHasCustomClass()) {
         $handle = $pk->getPermissionKeyHandle() . '_' . $handle;
     }
     $class = '\\Core\\Permission\\Access\\' . Core::make('helper/text')->camelcase($handle) . 'Access';
     $class = core_class($class, $pk->getPackageHandle());
     $obj = null;
     if ($checkPA) {
         $row = $db->GetRow('select paID, paIsInUse from PermissionAccess where paID = ?', array($paID));
         if ($row && $row['paID']) {
             $obj = Core::make($class);
             $obj->setPropertiesFromArray($row);
         }
     } else {
         // we got here from an assignment object so we already know its in use.
         $obj = Core::make($class);
         $obj->paID = $paID;
         $obj->paIsInUse = true;
     }
     if (isset($obj)) {
         $obj->setPermissionKey($pk);
     }
     $item->set($obj);
     return $obj;
 }
 /**
  * @inheritdoc
  */
 public function collection(Collection $collection, $code = Response::HTTP_OK, $headers = array())
 {
     if (!$this->app) {
         throw new \RuntimeException('Cannot resolve collections without a reference to the application');
     }
     $request = $this->request;
     if ($collection->isError() && $collection->getError() == COLLECTION_NOT_FOUND) {
         if ($response = $this->collectionNotFound($collection, $request, $headers)) {
             return $response;
         }
     }
     if ($collection->getCollectionPath() != '/page_not_found') {
         if (!isset($collection->cPathFetchIsCanonical) || !$collection->cPathFetchIsCanonical) {
             // Handle redirect URL (additional page paths)
             /** @var Url $url */
             $url = $this->app->make('url/manager')->resolve([$collection]);
             $query = $url->getQuery();
             $query->modify($request->getQueryString());
             $url = $url->setQuery($query);
             return $this->redirect($url, Response::HTTP_MOVED_PERMANENTLY, $headers);
         }
     }
     // maintenance mode
     if ($collection->getCollectionPath() != '/login') {
         $smm = $this->config->get('concrete.maintenance_mode');
         if ($smm == 1 && !Key::getByHandle('view_in_maintenance_mode')->validate() && ($_SERVER['REQUEST_METHOD'] != 'POST' || Loader::helper('validation/token')->validate() == false)) {
             $v = new View('/frontend/maintenance_mode');
             $router = $this->app->make(RouterInterface::class);
             $tmpTheme = $router->getThemeByRoute('/frontend/maintenance_mode');
             $v->setViewTheme($tmpTheme[0]);
             $v->addScopeItems(['c' => $collection]);
             $request->setCurrentPage($collection);
             if (isset($tmpTheme[1])) {
                 $v->setViewTemplate($tmpTheme[1]);
             }
             return $this->view($v, $code, $headers);
         }
     }
     if ($collection->getCollectionPointerExternalLink() != '') {
         return $this->redirect($collection->getCollectionPointerExternalLink());
     }
     $cp = new Checker($collection);
     if ($cp->isError() && $cp->getError() == COLLECTION_FORBIDDEN) {
         return $this->forbidden($request->getUri(), Response::HTTP_FORBIDDEN, $headers);
     }
     if (!$collection->isActive() && !$cp->canViewPageVersions()) {
         return $this->notFound('', Response::HTTP_NOT_FOUND, $headers);
     }
     $scheduledVersion = Version::get($collection, "SCHEDULED");
     if ($publishDate = $scheduledVersion->cvPublishDate) {
         $datetime = $this->app->make('helper/date');
         $now = $datetime->date('Y-m-d G:i:s');
         if (strtotime($now) >= strtotime($publishDate)) {
             $scheduledVersion->approve();
             $collection->loadVersionObject('ACTIVE');
         }
     }
     if ($cp->canEditPageContents() || $cp->canEditPageProperties() || $cp->canViewPageVersions()) {
         $collection->loadVersionObject('RECENT');
     }
     $vp = new Checker($collection->getVersionObject());
     // returns the $vp object, which we then check
     if (is_object($vp) && $vp->isError()) {
         switch ($vp->getError()) {
             case COLLECTION_NOT_FOUND:
                 return $this->notFound('', Response::HTTP_NOT_FOUND, $headers);
                 break;
             case COLLECTION_FORBIDDEN:
                 return $this->forbidden($request->getUri(), Response::HTTP_FORBIDDEN, $headers);
                 break;
         }
     }
     // Now that we've passed all permissions checks, and we have a page, we check to see if we
     // ought to redirect based on base url or trailing slash settings
     $cms = $this->app;
     $site = $this->app['site']->getSite();
     $response = $cms->handleCanonicalURLRedirection($request, $site);
     if (!$response) {
         $response = $cms->handleURLSlashes($request, $site);
     }
     if (isset($response)) {
         return $response;
     }
     $dl = $cms->make('multilingual/detector');
     if ($dl->isEnabled()) {
         $dl->setupSiteInterfaceLocalization($collection);
     }
     if (!$request->getPath() && $request->isMethod('GET') && !$request->query->has('cID')) {
         // This is a request to the home page –http://www.mysite.com/
         // First, we check to see if we need to redirect to a default multilingual section.
         if ($dl->isEnabled() && $site->getConfigRepository()->get('multilingual.redirect_home_to_default_locale')) {
             // Let's retrieve the default language
             $ms = $dl->getPreferredSection();
             if (is_object($ms)) {
                 return $this->redirect(\URL::to($ms));
             }
         }
         // Otherwise, let's check to see if our home page, which we have loaded already, has a path (like /en)
         // If it does, we'll redirect to the path.
         if ($collection->getCollectionPath() != '') {
             return $this->redirect(\URL::to($collection));
         }
     }
     $request->setCurrentPage($collection);
     $c = $collection;
     // process.php needs this
     require DIR_BASE_CORE . '/bootstrap/process.php';
     $u = new User();
     // On page view event.
     $pe = new Event($collection);
     $pe->setUser($u);
     $pe->setRequest($request);
     $this->app['director']->dispatch('on_page_view', $pe);
     // Core menu items
     $item = new RelationListItem();
     $menu = $this->app->make('helper/concrete/ui/menu');
     $menu->addMenuItem($item);
     $controller = $collection->getPageController();
     // we update the current page with the one bound to this controller.
     $collection->setController($controller);
     return $this->controller($controller);
 }
 public function installMaintenanceModePermission()
 {
     $pk = Key::getByHandle('view_in_maintenance_mode');
     if (!$pk instanceof Key) {
         $pk = Key::add('admin', 'view_in_maintenance_mode', 'View Site in Maintenance Mode', 'Controls whether a user can access the website when its under maintenance.', false, false);
         $pa = $pk->getPermissionAccessObject();
         if (!is_object($pa)) {
             $pa = Access::create($pk);
         }
         $adminGroup = Group::getByID(ADMIN_GROUP_ID);
         if ($adminGroup) {
             $adminGroupEntity = GroupEntity::getOrCreate($adminGroup);
             $pa->addListItem($adminGroupEntity);
             $pt = $pk->getPermissionAssignmentObject();
             $pt->assignPermissionAccess($pa);
         }
     }
 }
示例#19
0
 public function apply_to_site($pThemeID)
 {
     $pk = PermissionKey::getByHandle('customize_themes');
     if ($this->validateAction() && $pk->can()) {
         $vl = $this->getValueListFromRequest($pThemeID);
         $pt = PageTheme::getByID($pThemeID);
         $vl->save();
         $sccRecord = null;
         if ($this->request->request->has('sccRecordID')) {
             $sccRecord = $this->app->make(CustomCssRecordService::class)->getByID($this->request->request->get('sccRecordID'));
         }
         $preset = false;
         if ($this->request->request->has('handle')) {
             $preset = $pt->getThemeCustomizablePreset($this->request->request->get('handle'));
         }
         // reset all custom styles on particular pages
         $pl = new PageList();
         $pl->filterByPagesWithCustomStyles();
         $results = $pl->getResults();
         foreach ($results as $csc) {
             $cscv = $csc->getVersionToModify();
             $cscv->resetCustomThemeStyles();
             $vo = $csc->getVersionObject();
             if ($vo->isApproved()) {
                 $vo = $cscv->getVersionObject();
                 $vo->approve();
             }
         }
         // set the global style object.
         $pt->setCustomStyleObject($vl, $preset, $sccRecord);
         $r = new PageEditResponse();
         $r->setPage($this->page);
         $r->setRedirectURL(URL::to($this->page));
         $r->outputJSON();
     }
 }
 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);
 }
示例#21
0
 public function doOverrideAreaPermissions()
 {
     $db = Loader::db();
     $c = $this->getBlockCollectionObject();
     $v = array($c->getCollectionID(), $c->getVersionID(), $this->bID, $this->arHandle);
     $db->query("update CollectionVersionBlocks set cbOverrideAreaPermissions = 1 where cID = ? and (cvID = ? or cbIncludeAll = 1) and bID = ? and arHandle = ?", $v);
     $v = array($c->getCollectionID(), $c->getVersionID(), $this->bID);
     $db->query("delete from BlockPermissionAssignments where cID = ? and cvID = ? and bID = ?", $v);
     // copy permissions from the page to the area
     $permissions = PermissionKey::getList('block');
     foreach ($permissions as $pk) {
         $pk->setPermissionObject($this);
         $pk->copyFromPageOrAreaToBlock();
     }
 }
示例#22
0
 public function getPackageItems(Package $package)
 {
     return Key::getListByPackage($package);
 }
示例#23
0
 public function up(Schema $schema)
 {
     /* refresh CollectionVersionBlocks, CollectionVersionBlocksCacheSettings tables */
     $cvb = $schema->getTable('CollectionVersionBlocks');
     $cvb->addColumn('cbOverrideBlockTypeCacheSettings', 'boolean', array('default' => 0));
     $cvbcs = $schema->createTable('CollectionVersionBlocksCacheSettings');
     $cvbcs->addColumn('cID', 'integer', array('notnull' => true, 'unsigned' => true, 'default' => 0));
     $cvbcs->addColumn('cvID', 'integer', array('notnull' => true, 'unsigned' => true, 'default' => 1));
     $cvbcs->addColumn('bID', 'integer', array('notnull' => true, 'unsigned' => true, 'default' => 0));
     $cvbcs->addColumn('arHandle', 'string', array('notnull' => false));
     $cvbcs->addColumn('btCacheBlockOutput', 'boolean', array('default' => 0));
     $cvbcs->addColumn('btCacheBlockOutputOnPost', 'boolean', array('default' => 0));
     $cvbcs->addColumn('btCacheBlockOutputForRegisteredUsers', 'boolean', array('default' => 0));
     $cvbcs->addColumn('btCacheBlockOutputLifetime', 'integer', array('notnull' => true, 'unsigned' => true, 'default' => 0));
     $cvbcs->setPrimaryKey(array('cID', 'cvID', 'bId', 'arHandle'));
     /* add permissions lines for edit_block_name and edit_block_cache_settings */
     $ebk = Key::getByHandle('edit_block_name');
     if (!is_object($ebk)) {
         Key::add('block', 'edit_block_name', 'Edit Name', "Controls whether users can change the block's name (rarely used.).", false, false);
     }
     $ebk = Key::getByHandle('edit_block_cache_settings');
     if (!is_object($ebk)) {
         Key::add('block', 'edit_block_cache_settings', 'Edit Cache Settings', "Controls whether users can change the block cache settings for this block instance.", false, false);
     }
     /* Add marketplace single pages */
     $sp = Page::getByPath('/dashboard/extend/connect');
     if (!is_object($sp) || $sp->isError()) {
         $sp = SinglePage::add('/dashboard/extend/connect');
         $sp->update(array('cName' => 'Connect to the Community'));
         $sp->setAttribute('meta_keywords', 'concrete5.org, my account, marketplace');
     }
     $sp = Page::getByPath('/dashboard/extend/themes');
     if (!is_object($sp) || $sp->isError()) {
         $sp = SinglePage::add('/dashboard/extend/themes');
         $sp->update(array('cName' => 'Get More Themes'));
         $sp->setAttribute('meta_keywords', 'buy theme, new theme, marketplace, template');
     }
     $sp = Page::getByPath('/dashboard/extend/addons');
     if (!is_object($sp) || $sp->isError()) {
         $sp = SinglePage::add('/dashboard/extend/addons');
         $sp->update(array('cName' => 'Get More Add-Ons'));
         $sp->setAttribute('meta_keywords', 'buy addon, buy add on, buy add-on, purchase addon, purchase add on, purchase add-on, find addon, new addon, marketplace');
     }
     /* Add auth types ("handle|name") "twitter|Twitter" and "community|concrete5.org" */
     try {
         $community = AuthenticationType::getByHandle('community');
     } catch (Exception $e) {
         $community = AuthenticationType::add('community', 'concrete5.org');
         if (is_object($community)) {
             $community->disable();
         }
     }
     try {
         $twitter = AuthenticationType::getByHandle('twitter');
     } catch (Exception $e) {
         $twitter = AuthenticationType::add('twitter', 'Twitter');
         if (is_object($twitter)) {
             $twitter->disable();
         }
     }
     /* delete customize page themes dashboard single page */
     $customize = Page::getByPath('/dashboard/pages/themes/customize');
     if (is_object($customize) && !$customize->isError()) {
         $customize->delete();
     }
     /* exclude nav from flat view in dashboard */
     $flat = Page::getByPath('/dashboard/sitemap/explore');
     if (is_object($customize) && !$customize->isError()) {
         $flat->setAttribute("exclude_nav", false);
     }
 }
示例#24
0
 /**
     +	 * Returns true if the logged-in user can approve the current workflow
     +	 */
 public function canApproveWorkflow()
 {
     $pk = Key::getByHandle('approve_basic_workflow_action');
     $pk->setPermissionObject($this);
     return $pk->validate();
 }
示例#25
0
文件: Feed.php 项目: ngreimel/kovent
 /**
  * @return \Concrete\Core\Page\PageList
  */
 public function getPageListObject()
 {
     $pl = new PageList();
     $pl->setItemsPerPage($this->itemsPerFeed);
     $pl->sortByPublicDateDescending();
     if (!$this->checkPagePermissions) {
         $pl->ignorePermissions();
     } else {
         $vp = \Concrete\Core\Permission\Key\Key::getByHandle('view_page');
         $guest = \Group::getByID(GUEST_GROUP_ID);
         $access = GroupEntity::getOrCreate($guest);
         // we set page permissions to be Guest group only, because
         // authentication won't work with RSS feeds
         $pl->setPermissionsChecker(function ($page) use($vp, $access) {
             $vp->setPermissionObject($page);
             $pa = $vp->getPermissionAccessObject($page);
             if (!is_object($pa)) {
                 return false;
             }
             return $pa->validateAccessEntities(array($access));
         });
     }
     if ($this->cParentID) {
         if ($this->pfIncludeAllDescendents) {
             $parent = \Page::getByID($this->cParentID);
             if (is_object($parent) && !$parent->isError()) {
                 $pl->filterByPath($parent->getCollectionPath());
             }
         } else {
             $pl->filterByParentID($this->cParentID);
         }
     }
     if ($this->pfDisplayAliases) {
         $pl->includeAliases();
     }
     if ($this->ptID) {
         $pl->filterByPageTypeID($this->ptID);
     }
     if ($this->pfDisplayFeaturedOnly) {
         $pl->filterByAttribute('is_featured', true);
     }
     return $pl;
 }
 public function addNotifications()
 {
     $this->output(t('Adding notifications...'));
     $adminGroupEntity = GroupEntity::getOrCreate(\Group::getByID(ADMIN_GROUP_ID));
     $adminUserEntity = UserEntity::getOrCreate(\UserInfo::getByID(USER_SUPER_ID));
     $pk = Key::getByHandle('notify_in_notification_center');
     $pa = Access::create($pk);
     $pa->addListItem($adminUserEntity);
     $pa->addListItem($adminGroupEntity);
     $pt = $pk->getPermissionAssignmentObject();
     $pt->assignPermissionAccess($pa);
 }
 public function up(Schema $schema)
 {
     $ft = FlagType::getByhandle('spam');
     if (!is_object($ft)) {
         FlagType::add('spam');
     }
     $bt = BlockType::getByHandle('image_slider');
     $bt->refresh();
     $types = array(Type::getByHandle('group'), Type::getByHandle('user'), Type::getByHandle('group_set'), Type::getByHandle('group_combination'));
     $categories = array(Category::getByHandle('conversation'), Category::getByHandle('conversation_message'));
     foreach ($categories as $category) {
         foreach ($types as $pe) {
             if (is_object($category) && is_object($pe)) {
                 $category->associateAccessEntityType($pe);
             }
         }
     }
     try {
         $gat = AuthenticationType::getByHandle('google');
     } catch (Exception $e) {
         $gat = AuthenticationType::add('google', 'Google');
         if (is_object($gat)) {
             $gat->disable();
         }
     }
     // fix register page permissions
     $g1 = \Group::getByID(GUEST_GROUP_ID);
     $register = \Page::getByPath('/register', "RECENT");
     $register->assignPermissions($g1, array('view_page'));
     // add new permissions, set it to the same value as edit page permissions on all pages.
     $epk = PermissionKey::getByHandle('edit_page_permissions');
     $msk = PermissionKey::getByHandle('edit_page_multilingual_settings');
     $ptk = PermissionKey::getByHandle('edit_page_page_type');
     if (!is_object($msk)) {
         $msk = PermissionKey::add('page', 'edit_page_multilingual_settings', 'Edit Multilingual Settings', 'Controls whether a user can see the multilingual settings menu, re-map a page or set a page as ignored in multilingual settings.', false, false);
     }
     if (!is_object($ptk)) {
         $ptk = PermissionKey::add('page', 'edit_page_page_type', 'Edit Page Type', 'Change the type of an existing page.', false, false);
     }
     $db = \Database::get();
     $r = $db->Execute('select cID from Pages where cInheritPermissionsFrom = "OVERRIDE" order by cID asc');
     while ($row = $r->FetchRow()) {
         $c = Page::getByID($row['cID']);
         if (is_object($c) && !$c->isError()) {
             $epk->setPermissionObject($c);
             $msk->setPermissionObject($c);
             $ptk->setPermissionObject($c);
             $rpa = $epk->getPermissionAccessObject();
             if (is_object($rpa)) {
                 $pt = $msk->getPermissionAssignmentObject();
                 if (is_object($pt)) {
                     $pt->clearPermissionAssignment();
                     $pt->assignPermissionAccess($rpa);
                 }
                 $pt = $ptk->getPermissionAssignmentObject();
                 if (is_object($pt)) {
                     $pt->clearPermissionAssignment();
                     $pt->assignPermissionAccess($rpa);
                 }
             }
         }
     }
     // add new page type permissions
     $epk = PermissionKey::getByHandle('edit_page_type_permissions');
     $msk = PermissionKey::getByHandle('edit_page_type');
     $dsk = PermissionKey::getByHandle('delete_page_type');
     if (!is_object($msk)) {
         $msk = PermissionKey::add('page_type', 'edit_page_type', 'Edit Page Type', '', false, false);
     }
     if (!is_object($dsk)) {
         $dsk = PermissionKey::add('page_type', 'delete_page_type', 'Delete Page Type', '', false, false);
     }
     $list = \Concrete\Core\Page\Type\Type::getList();
     foreach ($list as $pagetype) {
         $epk->setPermissionObject($pagetype);
         $msk->setPermissionObject($pagetype);
         $dsk->setPermissionObject($pagetype);
         $rpa = $epk->getPermissionAccessObject();
         if (is_object($rpa)) {
             $pt = $msk->getPermissionAssignmentObject();
             if (is_object($pt)) {
                 $pt->clearPermissionAssignment();
                 $pt->assignPermissionAccess($rpa);
             }
             $pt = $dsk->getPermissionAssignmentObject();
             if (is_object($pt)) {
                 $pt->clearPermissionAssignment();
                 $pt->assignPermissionAccess($rpa);
             }
         }
     }
     // add new multilingual tables.
     $sm = $db->getSchemaManager();
     $schemaTables = $sm->listTableNames();
     if (!in_array('MultilingualPageRelations', $schemaTables)) {
         $mpr = $schema->createTable('MultilingualPageRelations');
         $mpr->addColumn('mpRelationID', 'integer', array('notnull' => true, 'unsigned' => true, 'default' => 0));
         $mpr->addColumn('cID', 'integer', array('notnull' => true, 'unsigned' => true, 'default' => 0));
         $mpr->addColumn('mpLanguage', 'string', array('notnull' => true, 'default' => ''));
         $mpr->addColumn('mpLocale', 'string', array('notnull' => true));
         $mpr->setPrimaryKey(array('mpRelationID', 'cID', 'mpLocale'));
     }
     if (!in_array('MultilingualSections', $schemaTables)) {
         $mus = $schema->createTable('MultilingualSections');
         $mus->addColumn('cID', 'integer', array('notnull' => true, 'unsigned' => true, 'default' => 0));
         $mus->addColumn('msLanguage', 'string', array('notnull' => true, 'default' => ''));
         $mus->addColumn('msCountry', 'string', array('notnull' => true, 'default' => ''));
         $mus->setPrimaryKey(array('cID'));
     }
     if (!in_array('MultilingualTranslations', $schemaTables)) {
         $mts = $schema->createTable('MultilingualTranslations');
         $mts->addColumn('mtID', 'integer', array('autoincrement' => true, 'unsigned' => true));
         $mts->addColumn('mtSectionID', 'integer', array('unsigned' => true, 'notnull' => true, 'default' => 0));
         $mts->addColumn('msgid', 'text', array('notnull' => false));
         $mts->addColumn('msgstr', 'text', array('notnull' => false));
         $mts->addColumn('context', 'text', array('notnull' => false));
         $mts->addColumn('comments', 'text', array('notnull' => false));
         $mts->addColumn('reference', 'text', array('notnull' => false));
         $mts->addColumn('flags', 'text', array('notnull' => false));
         $mts->addColumn('updated', 'datetime', array('notnull' => false));
         $mts->setPrimaryKey(array('mtID'));
     }
     // block type
     $bt = BlockType::getByHandle('switch_language');
     if (!is_object($bt)) {
         $bt = BlockType::installBlockType('switch_language');
     }
     // single pages
     $sp = Page::getByPath('/dashboard/system/multilingual');
     if (!is_object($sp) || $sp->isError()) {
         $sp = SinglePage::add('/dashboard/system/multilingual');
         $sp->update(array('cName' => 'Multilingual'));
         $sp->setAttribute('meta_keywords', 'multilingual, localization, internationalization, i18n');
     }
     $sp = Page::getByPath('/dashboard/system/multilingual/setup');
     if (!is_object($sp) || $sp->isError()) {
         $sp = SinglePage::add('/dashboard/system/multilingual/setup');
         $sp->update(array('cName' => 'Multilingual Setup'));
     }
     $sp = Page::getByPath('/dashboard/system/multilingual/page_report');
     if (!is_object($sp) || $sp->isError()) {
         $sp = SinglePage::add('/dashboard/system/multilingual/page_report');
         $sp->update(array('cName' => 'Page Report'));
     }
     $sp = Page::getByPath('/dashboard/system/multilingual/translate_interface');
     if (!is_object($sp) || $sp->isError()) {
         $sp = SinglePage::add('/dashboard/system/multilingual/translate_interface');
         $sp->update(array('cName' => 'Translate Interface'));
     }
     $sp = Page::getByPath('/dashboard/pages/types/attributes');
     if (!is_object($sp) || $sp->isError()) {
         $sp = SinglePage::add('/dashboard/pages/types/attributes');
         $sp->update(array('cName' => 'Page Type Attributes'));
     }
 }
 public function skipItem()
 {
     $key = Key::getByHandle($this->object->getHandle());
     return is_object($key);
 }
示例#29
0
 * Handle automatic updating
 */
$cms->handleAutomaticUpdates();
/**
 * ----------------------------------------------------------------------------
 * Now that we have languages out of the way, we can run our package on_start
 * methods
 * ----------------------------------------------------------------------------
 */
$cms->setupPackages();
/**
 * ----------------------------------------------------------------------------
 * Load all permission keys into our local cache.
 * ----------------------------------------------------------------------------
 */
PermissionKey::loadAll();
/**
 * ----------------------------------------------------------------------------
 * Fire an event for intercepting the dispatch
 * ----------------------------------------------------------------------------
 */
\Events::dispatch('on_before_dispatch');
/**
 * ----------------------------------------------------------------------------
 * Get the response to the current request
 * ----------------------------------------------------------------------------
 */
$response = $cms->dispatch($request);
/**
 * ----------------------------------------------------------------------------
 * Send it to the user
示例#30
0
文件: Type.php 项目: ceko/concrete5-1
 public function duplicate($ptHandle, $ptName)
 {
     $data = array('handle' => $ptHandle, 'name' => $ptName, 'defaultTemplate' => $this->getPageTypeDefaultPageTemplateObject(), 'allowedTemplates' => $this->getPageTypeAllowedPageTemplates(), 'templates' => $this->getPageTypeSelectedPageTemplateObjects(), 'ptLaunchInComposer' => $this->doesPageTypeLaunchInComposer(), 'ptIsFrequentlyAdded' => $this->isPageTypeFrequentlyAdded());
     $new = static::add($data);
     // now copy the edit form
     $sets = FormLayoutSet::getList($this);
     foreach ($sets as $set) {
         $set->duplicate($new);
     }
     // now copy the master pages for defaults and attributes
     $db = \Database::get();
     $r = $db->Execute('select cID from Pages where cIsTemplate = 1 and ptID = ?', array($this->getPageTypeID()));
     $home = Page::getByID(HOME_CID);
     while ($row = $r->FetchRow()) {
         $c = Page::getByID($row['cID']);
         if (is_object($c)) {
             $nc = $c->duplicate($home);
             $nc->setPageType($new);
             $db->update('Pages', array('cParentID' => 0, 'cIsTemplate' => 1), array('cID' => $nc->getCollectionID()));
             $db->insert('PageTypePageTemplateDefaultPages', array('pTemplateID' => $nc->getPageTemplateID(), 'ptID' => $new->getPageTypeID(), 'cID' => $nc->getCollectionID()));
             // clear out output control blocks because they will be pointing to the wrong thing
             $composerBlocksIDs = $db->GetAll('select cvb.bID, cvb.arHandle from btCorePageTypeComposerControlOutput o inner join CollectionVersionBlocks cvb on cvb.bID = o.bID inner join Pages p on cvb.cID = p.cID where p.cID = ?', array($nc->getCollectionID()));
             foreach ($composerBlocksIDs as $row) {
                 $b = \Block::getByID($row['bID'], $nc, $row['arHandle']);
                 $b->deleteBlock();
             }
         }
     }
     // copy permissions from the defaults to the page type
     $list = Key::getList('page_type');
     foreach ($list as $pk) {
         $pk->setPermissionObject($this);
         $rpa = $pk->getPermissionAccessObject();
         if (is_object($rpa)) {
             $pk->setPermissionObject($new);
             $pt = $pk->getPermissionAssignmentObject();
             if (is_object($pt)) {
                 $pt->clearPermissionAssignment();
                 $pt->assignPermissionAccess($rpa);
             }
         }
     }
     // copy permissions from the default page to the page type
     $list = Key::getList('page');
     foreach ($list as $pk) {
         $pk->setPermissionObject($this->getPageTypePageTemplateDefaultPageObject());
         $rpa = $pk->getPermissionAccessObject();
         if (is_object($rpa)) {
             $pk->setPermissionObject($new->getPageTypePageTemplateDefaultPageObject());
             $pt = $pk->getPermissionAssignmentObject();
             if (is_object($pt)) {
                 $pt->clearPermissionAssignment();
                 $pt->assignPermissionAccess($rpa);
             }
         }
     }
     // duplicate the target object.
     $target = $this->getPageTypePublishTargetObject();
     $new->setConfiguredPageTypePublishTargetObject($target);
 }