public function getCDNWriter() { $stores = $this->contentService->getStoreTypes(); if ($stores && isset($stores[$this->getCDNStore()])) { return $this->contentService->getWriter($this->getCDNStore()); } }
/** * Store the contents of a folder on a CDN. * * If processReferences is set, relative URL references are attempted to be * detected and stored remotely as well, with the file to be stored rewritten * to refer to the CDN value. This really is only useful for CSS * * @param string $folder * @param boolean $processReferences */ public function storeThemeFile($toCdn, $file, $forceUpdate = false, $processReferences = false) { $mtime = @filemtime($file); $relativeName = self::CDN_THEME_PREFIX . '/' . $mtime . '/' . trim(str_replace(Director::baseFolder(), '', $file), '/'); if (!$forceUpdate) { // see if the file already exists, if not we do NOT do an update $reader = $this->contentService->findReaderFor($toCdn, $relativeName); if ($reader && $reader->exists()) { return $reader->getURL(); } } $clear = false; if ($processReferences) { $clear = true; $file = $this->processFileReferences($toCdn, $file, $forceUpdate); } // otherwise, lets get a content writer $writer = $this->contentService->getWriter($toCdn); try { $writer->write($file, $relativeName); } catch (Exception $e) { SS_Log::log($e, SS_Log::WARN); } if ($clear && strpos($file, '.cdn') > 0) { @unlink($file); } $id = $writer->getContentId(); return $writer->getReader()->getURL(); }
public function homeAction() { if ($this->hasParam('pos')) { $pos = $this->getParam('pos'); } else { $pos = 0; } $this->setTitleCurrentPage(array()); $this->saveLastPage(); if ($this->userService->checkRight('CONTENT_EDIT')) { $state = \org\equinox\modules\content\dao\ContentDto::STATE_ALL; } else { $state = \org\equinox\modules\content\dao\ContentDto::STATE_ONLINE; } $list = $this->contentService->listByIdCategory(0, $state, $pos, self::PAGE_STEP + 1, true); if (sizeof($list) == self::PAGE_STEP + 1) { $this->assign('posNext', $pos + self::PAGE_STEP); array_pop($list); } else { $this->assign('posNext', -1); } $this->assign('pos', $pos); $this->assign('posPrec', $pos - self::PAGE_STEP); $this->assign('edito', $this->contentService->getEdito()); $this->assign('listeContent', $list); }
/** * Return the CDN store that this file should be stored into, based on its * parent setting, if no parent is found the ContentService default is returned */ public function targetStore() { if ($this->owner->ParentID) { $store = $this->owner->Parent()->getCDNStore(); return $store; } return $this->contentService->getDefaultStore(); }
/** * @return ContentWriter */ protected function getWriter() { $current = $this->currentThemeCdn(); $writer = $this->contentService->getWriter($current->StoreIn); if (!$writer) { throw new Exception("Invalid writer type " . $current->StoreIn); } return $writer; }
/** * Get the CDN store that this item should be stored in */ public function getCDNStore() { if ($this->owner->StoreInCDN) { return $this->owner->StoreInCDN; } if (!$this->owner->ID || $this->owner->ID === "root" || !$this->owner->ParentID) { return $this->contentService->getDefaultStore(); } if ($this->owner->ParentID) { return $this->owner->Parent()->getCDNStore(); } }
public function testListFolder() { if (file_exists($this->testDir)) { Filesystem::removeFolder($this->testDir); } mkdir($this->testDir); file_put_contents($this->testDir . '/testfile.txt', 'dummy_data'); $reader = $this->contentService->getReader('File:||' . $this->testDir); $list = $reader->getList(); $this->assertEquals(1, count($list)); $file = $list[0]; $writer = $file->getWriter(); $writer->write('new contents'); $this->assertEquals('new contents', file_get_contents($this->testDir . '/testfile.txt')); }
/** * Lists entries based on passed parameters * * @return array|string */ public function getContent($variable) { $urls = array_get($this->context, $variable); if (!$urls) { return null; } // grab common parameters $settings = $this->parseCommonParameters(); // grab content set based on the common parameters // $content_set = $this->getContentSet($settings); $content_set = ContentService::getContentByURL($urls); $content_set->filter(array('show_hidden' => $this->fetchParam('show_hidden', false, null, true, false), 'show_drafts' => $this->fetchParam('show_drafts', false, null, true, false), 'show_past' => $this->fetchParam('show_past', true, null, true), 'show_future' => $this->fetchParam('show_future', false, null, true), 'type' => 'all', 'conditions' => trim($this->fetchParam('conditions', null, false, false, false)))); // limit $limit = $this->fetchParam('limit', null, 'is_numeric'); $offset = $this->fetchParam('offset', 0, 'is_numeric'); if ($limit || $offset) { $content_set->limit($limit, $offset); } // sort $sort_by = $this->fetchParam('sort_by'); $sort_dir = $this->fetchParam('sort_dir'); if ($sort_by || $sort_dir) { $content_set->sort($sort_by, $sort_dir); } // check for results if (!$content_set->count()) { return Parse::template($this->content, array('no_results' => true)); } return Parse::tagLoop($this->content, $content_set->get(), false, $this->context); }
/** * Is the $url in our cache and still valid? * * @param string $url URL to check for cache * @return bool */ public function isPageCached($url) { $cache_length = trim($this->fetchConfig('cache_length', false)); // if no cache-length is set, this feature is off if (!(bool) $cache_length) { return false; } if ($this->fetchConfig('ignore_query_strings', false, null, true)) { $url = $this->removeQueryString($url); } // create the hash now so we don't have to do it many times below $url_hash = Helper::makeHash($url); // we're no longer allowing `on cache update` here, as its a flawed concept: // it only appeared to work because new pages were being hit, however, once // every page is hit and then HTML-cached, the cache will no longer update // because procedurally, that happens *after* we look for and load a version // that has been cached if ($cache_length == 'on cache update' || $cache_length == 'on last modified') { // ignore the cached version if the last modified time of this URL's // content file is newer than when the cached version was made // check that the URL being requested is a content file $bare_url = strpos($url, '?') !== false ? substr($url, 0, strpos($url, '?')) : $url; $data = ContentService::getContent($bare_url); $age = time() - File::getLastModified($data['_file']); // return if the cache file exists and if it's new enough return $this->cache->exists($url_hash) && $this->cache->getAge($url_hash) <= $age; } else { // purge any cache files older than the cache length $this->cache->purgeFromBefore('-' . $cache_length); // return if the file still exists return $this->cache->exists($url_hash); } }
public function control_panel__add_to_head() { if (URL::getCurrent(false) == '/publish') { $file = 'defined-links.json'; $current_content_list = file_get_contents($file, true); $current_content_list = json_decode($current_content_list); $content_set = ContentService::getContentByFolders(array("/*")); $content_set->multisort('url'); $content_set = $content_set->get(); $content_list = []; $content_list[] = ['name' => 'Select...', 'url' => false]; foreach ($content_set as $content) { if (isset($content['url']) && isset($content['title'])) { $name = '[' . $content['url'] . '] ' . $content['title']; $url = $content['url']; $content_list[] = ['name' => $name, 'url' => $url]; } } if ($current_content_list !== $content_list) { $json = json_encode($content_list); file_put_contents($file, $json, FILE_USE_INCLUDE_PATH); } return $this->js->link('definedlinks.js'); } }
public function index() { $from = $this->fetchParam('from', false); if (!$from) { return null; } // account for subfolder if (strpos($from, Config::getSiteRoot()) !== 0) { $from = Path::tidy(Config::getSiteRoot() . $from); } $from = Path::addStartingSlash($from); $content_set = ContentService::getContentByURL($from); // filter $content_set->filter(array('show_hidden' => $this->fetchParam('show_hidden', false, null, true, false), 'show_drafts' => $this->fetchParam('show_drafts', false, null, true, false), 'show_past' => $this->fetchParam('show_past', true, null, true), 'show_future' => $this->fetchParam('show_future', false, null, true), 'type' => 'all', 'conditions' => trim($this->fetchParam('conditions', null, false, false, false)))); // limit $limit = $this->fetchParam('limit', 1, 'is_numeric'); $offset = $this->fetchParam('offset', 0, 'is_numeric'); $content_set->limit($limit, $offset); // check for results if (!$content_set->count()) { return Parse::tagLoop($this->content, array(array('no_results' => true))); } // if content is used in this entries loop, parse it $parse_content = (bool) preg_match(Pattern::USING_CONTENT, $this->content); return Parse::tagLoop($this->content, $content_set->get($parse_content), false, $this->context); }
public function __call($method, $arguments) { // Get all the parameter/filters $filters = $this->attributes; // Default content to context $content = $this->context; // Override content by a specific page if needed if ($from = $this->fetchParam('from')) { $content = current(ContentService::getContentByURL($from)->get()); unset($filters['from']); } // Grab the field data $field_data = array_get($content, $method); // Filter down to what we're looking for $values = array_values(array_filter($field_data, function ($i) use($filters) { foreach ($filters as $key => $val) { $match = array_get($i, $key) == $val; if (!$match) { break; } } return $match; })); // No results? if (empty($values)) { return array('no_results' => true); } // Got something. Yay. Return it. return Parse::tagLoop($this->content, $values, true); }
public function getContent() { $url = URL::assemble(Config::getSiteRoot(), $this->fetchConfig('globals_url', null, null, false, false)); $content = ContentService::getContentByUrl($url); $content = current($content->extract()); return $content; }
public function getCMSFields() { $fields = parent::getCMSFields(); $fields->replaceField('LastSync', new ReadonlyField('LastSync', _t('ThemeCdn.LAST_SYNC', 'Last Sync'))); $config = SiteConfig::current_site_config(); $themes = $config->getAvailableThemes(); $themes = array_merge(array('' => ''), $themes); $fields->replaceField('Theme', new DropdownField('Theme', _t('ThemeCdn.THEME', 'Theme'), $themes)); if ($this->Theme) { // $fields->addFieldToTab('Root.Main', new MultiValue $fields->replaceField('Files', MultiValueCheckboxField::create('Files', _t('ThemeCdn.FILES', 'Files'), $this->getThemeFiles())); } $stores = $this->contentService->getStoreTypes(); if (count($stores)) { $default = array('' => 'No CDN'); $stores = array_merge($default, array_combine(array_keys($stores), array_keys($stores))); $fields->replaceField('StoreIn', DropdownField::create('StoreIn', 'CDN', $stores)); } return $fields; }
public function control_panel__post_publish($publish_data) { // check that caching is turned on if (!$this->core->isEnabled()) { return; } // we only need one key from the hook's value $file = $publish_data['file']; // update the cache _Cache::update(); ContentService::loadCache(true); // grab data $triggers = $this->fetchConfig('publish_invalidation', array(), 'is_array', false, false); $content = Content::find(Path::tidy(str_replace(Config::getContentRoot(), '/', $file))); if ($triggers && $content) { foreach ($triggers as $trigger) { $folders = Parse::pipeList(array_get($trigger, 'folder', null)); $key = array_get($trigger, 'key', null); if (!$folders || !$key) { // not checking this continue; } // check $invalidate = false; foreach ($folders as $folder) { if ($folder === "*" || $folder === "/*") { // include all $invalidate = true; break; } elseif (substr($folder, -1) === "*") { // wildcard check if (strpos($content['_folder'], substr($folder, 0, -1)) === 0) { $invalidate = true; break; } } else { // plain check if ($folder == $content['_folder']) { $invalidate = true; break; } } } // invalidate if needed if ($invalidate) { $this->core->deleteByKey(Parse::pipeList($key)); } } } }
/** Show the content of a category */ public function indexAction() { $this->formStorage->clearDefinition(); if ($this->hasParam('pos')) { $pos = $this->getParam('pos'); } else { $pos = 0; } $id = $this->getParam('idCat', 0); $cat = $this->categoryService->get($id); if ($cat == null) { $this->goHome(); return; } $this->assign('category', $cat); // recuperer la liste de toutes les categories filles $idCatz = $this->categoryService->listIdCategoriesForParent($id); $idCatz[] = $id; $this->assign('idz', $idCatz); $this->setTitleCurrentPage($this->getTitlesForIdCategory($id)); $this->saveLastPage(); if ($this->userService->checkRight('CONTENT_EDIT')) { $state = \org\equinox\modules\content\dao\ContentDto::STATE_ALL; } else { $state = \org\equinox\modules\content\dao\ContentDto::STATE_ONLINE; } $list = $this->contentService->listByIdCategories($idCatz, $state, $pos, self::PAGE_STEP + 1); if (sizeof($list) == self::PAGE_STEP + 1) { $this->assign('posNext', $pos + self::PAGE_STEP); array_pop($list); } else { $this->assign('posNext', -1); } $this->assign('pos', $pos); $this->assign('posPrec', $pos - self::PAGE_STEP); $this->assign('listeContent', $list); }
/** * @Route("/upload_content_image/{contentId}") * @Method({"FILES|POST"}) */ public function uploadContentImage(Request $request, $contentId) { $fileSource = []; /** @var UploadedFile[] $files */ $files = $request->files->get('files'); $absolutePath = $request->server->get('DOCUMENT_ROOT') . "/upload/content"; $file = $files[0]; $imageSize = getimagesize($file); $fileInfo = $file->move($absolutePath, $file->getClientOriginalName()); $resultImage = $this->imageService->resizeImage($fileInfo, $absolutePath . '/', $imageSize[0], $imageSize[1]); $savedUrl = $this->service->editTextById($contentId, '/content/' . $resultImage); unlink($absolutePath . '/' . $fileInfo->getFilename()); $fileSource['file_name'] = $savedUrl['text']; $fileSource['contentId'] = $contentId; return new Response(json_encode($fileSource)); }
/** * Lists entries based on passed parameters * * @return array|string */ public function listing() { $folders = $this->fetchParam('folder', $this->fetchParam('folders', ltrim($this->fetchParam('from', URL::getCurrent()), "/"))); $folders = $folders === "/" ? "" : $folders; if ($this->fetchParam('taxonomy', false, null, true, null)) { $taxonomy_parts = Taxonomy::getCriteria(URL::getCurrent()); $taxonomy_type = $taxonomy_parts[0]; $taxonomy_slug = Config::get('_taxonomy_slugify') ? Slug::humanize($taxonomy_parts[1]) : urldecode($taxonomy_parts[1]); $content_set = ContentService::getContentByTaxonomyValue($taxonomy_type, $taxonomy_slug, $folders); } else { $content_set = ContentService::getContentByFolders($folders); } // filter $content_set->filter(array('show_all' => $this->fetchParam('show_hidden', false, null, true, false), 'since' => $this->fetchParam('since'), 'until' => $this->fetchParam('until'), 'show_past' => $this->fetchParam('show_past', TRUE, NULL, TRUE), 'show_future' => $this->fetchParam('show_future', FALSE, NULL, TRUE), 'type' => 'pages', 'conditions' => trim($this->fetchParam('conditions', "")))); // sort $content_set->sort($this->fetchParam('sort_by', 'order_key'), $this->fetchParam('sort_dir')); // grab total entries for setting later $total_entries = $content_set->count(); // limit $limit = $this->fetchParam('limit', null, 'is_numeric'); $offset = $this->fetchParam('offset', 0, 'is_numeric'); $paginate = $this->fetchParam('paginate', true, null, true, false); if ($limit || $offset) { if ($limit && $paginate && !$offset) { // pagination requested, isolate the appropriate page $content_set->isolatePage($limit, URL::getCurrentPaginationPage()); } else { // just limit $content_set->limit($limit, $offset); } } // manually supplement $content_set->supplement(array('total_found' => $total_entries)); // check for results if (!$content_set->count()) { return array('no_results' => true); } // if content is used in this entries loop, parse it $parse_content = (bool) preg_match(Pattern::USING_CONTENT, $this->content); return Parse::tagLoop($this->content, $content_set->get($parse_content)); }
public function listing() { // grab a taxonomy set from the content service $taxonomy_set = ContentService::getTaxonomiesByType($this->fetchParam('type', null)); // folders $folders = $this->fetchParam('folder', $this->fetchParam('folders', ltrim($this->fetchParam('from', URL::getCurrent()), "/"))); // now filter that down to just what we want $taxonomy_set->filter(array('folders' => $folders, 'show_hidden' => $this->fetchParam('show_hidden', false, null, true, false), 'show_drafts' => $this->fetchParam('show_drafts', false, null, true, false), 'since' => $this->fetchParam('since', null), 'until' => $this->fetchParam('until', null), 'min_count' => $this->fetchParam('min_count', 1, 'is_numeric'), 'show_future' => $this->fetchParam('show_future', false, null, true, false), 'show_past' => $this->fetchParam('show_past', true, null, true, false), 'conditions' => trim($this->fetchParam('conditions', null, false, false, false)), 'where' => trim($this->fetchParam('where', null, false, false, false)))); // sort as needed $taxonomy_set->sort($this->fetchParam('sort_by', 'name'), $this->fetchParam('sort_dir', 'asc')); // trim to limit the number of results $taxonomy_set->limit($this->fetchParam('limit', null, 'is_numeric')); // contextualize the urls to the given folder $taxonomy_set->contextualize($this->fetchParam('folder', null)); $output = $taxonomy_set->get(); // no results found, return so if (!count($output)) { return array('no_results' => true); } // results found, parse the tag loop with our content return Parse::tagLoop($this->content, $output, true, $this->context); }
public function index() { $from = $this->fetchParam('from', false); // defaults to null if (!$from) { return null; } $from = Path::addStartingSlash($from); $from = strlen($from) > 1 ? rtrim($from, "/") : $from; $content_set = ContentService::getContentByURL($from); // filter $content_set->filter(array('show_all' => $this->fetchParam('show_hidden', false, null, true, false), 'show_past' => $this->fetchParam('show_past', true, null, true), 'show_future' => $this->fetchParam('show_future', false, null, true), 'type' => 'all', 'conditions' => trim($this->fetchParam('conditions', null, false, false, false)))); // limit $limit = $this->fetchParam('limit', 1, 'is_numeric'); $offset = $this->fetchParam('offset', 0, 'is_numeric'); $content_set->limit($limit, $offset); // check for results if (!$content_set->count()) { return Parse::tagLoop($this->content, array(array('no_results' => true))); } // if content is used in this entries loop, parse it $parse_content = (bool) preg_match(Pattern::USING_CONTENT, $this->content); return Parse::tagLoop($this->content, $content_set->get($parse_content)); }
/** * Returns a ContentSet object with the appropriate content * * @param array $settings Settings for filtering content and such * @return ContentSet */ private function getContentSet($settings) { // create a unique hash for these settings $content_hash = Helper::makeHash($settings); if ($this->blink->exists($content_hash)) { // blink content exists, use that $content_set = new ContentSet($this->blink->get($content_hash)); } else { // no blink content exists, get data the hard way if ($settings['taxonomy']) { $taxonomy_parts = Taxonomy::getCriteria(URL::getCurrent()); $taxonomy_type = $taxonomy_parts[0]; $taxonomy_slug = Config::get('_taxonomy_slugify') ? Slug::humanize($taxonomy_parts[1]) : urldecode($taxonomy_parts[1]); $content_set = ContentService::getContentByTaxonomyValue($taxonomy_type, $taxonomy_slug, $settings['folders']); } else { $content_set = ContentService::getContentByFolders($settings['folders']); } // filter $content_set->filter($settings); // grab total entries for setting later $total_entries = $content_set->count(); // pre-sort supplement $content_set->supplement(array('total_found' => $total_entries) + $settings); // sort $content_set->multisort($settings['sort']); // post-sort supplement $content_set->supplement(array( 'group_by_date' => trim($this->fetchParam("group_by_date", null, null, false, false)) ), true); // store content as blink content for future use $this->blink->set($content_hash, $content_set->extract()); } return $content_set; }
public function count() { // grab parameters $from = $this->fetchParam('from', URL::getCurrent()); $exclude = $this->fetchParam('exclude', false); $max_depth = $this->fetchParam('max_depth', 1, 'is_numeric'); $include_entries = $this->fetchParam('include_entries', false, false, true); $folders_only = $this->fetchParam('folders_only', true, false, true); $include_content = $this->fetchParam('include_content', false, false, true); $show_hidden = $this->fetchParam('show_hidden', false, null, true); // add in left-/ if not present if (substr($from, 0, 1) !== '/') { $from = '/' . $from; } // if this doesn't start with the site root, add the site root if (!Pattern::startsWith($from, Config::getSiteRoot())) { $from = Path::tidy(Config::getSiteRoot() . '/' . $from); } // standardize excludes if ($exclude && !is_array($exclude)) { $exclude = Helper::explodeOptions($exclude, array()); foreach ($exclude as $key => $value) { $exclude[$key] = Path::tidy(Config::getSiteRoot() . '/' . $value); } } // option hash $hash = Helper::makeHash($from, $exclude, $max_depth, $include_entries, $folders_only, $include_content, $show_hidden); // load the content tree from cache if ($this->blink->exists($hash)) { $tree = $this->blink->get($hash); } else { $tree = ContentService::getContentTree($from, $max_depth, $folders_only, $include_entries, $show_hidden, $include_content, $exclude); $this->blink->set($hash, $tree); } if ($this->content) { return Parse::template($this->content, array('count' => count($tree))); } elseif (count($tree)) { return count($tree); } return ''; }
/** * Returns a ContentSet object with the appropriate content * * @param array $settings Settings for filtering content and such * @return ContentSet */ private function getContentSet($settings) { // create a unique hash for these settings $content_hash = Helper::makeHash($settings); if ($this->blink->exists($content_hash)) { // blink content exists, use that $content_set = new ContentSet($this->blink->get($content_hash)); } else { // no blink content exists, get data the hard way if ($settings['taxonomy']) { $taxonomy_parts = Taxonomy::getCriteria(URL::getCurrent()); $taxonomy_type = $taxonomy_parts[0]; $taxonomy_slug = Config::get('_taxonomy_slugify') ? Slug::humanize($taxonomy_parts[1]) : urldecode($taxonomy_parts[1]); $content_set = ContentService::getContentByTaxonomyValue($taxonomy_type, $taxonomy_slug, $settings['folders']); } else { $content_set = ContentService::getContentByFolders($settings['folders']); } // filter $content_set->filter($settings); // sort $content_set->sort($settings['sort_by'], $settings['sort_dir']); // store content as blink content for future use $this->blink->set($content_hash, $content_set->extract()); } return $content_set; }
/** * Gets cached content for pages for a certain taxonomy type and value * * @param string $taxonomy Taxonomy to use * @param string $values Values to match (single or array) * @param mixed $folders Optionally, folders to filter down by * @return ContentSet */ public static function getContentByTaxonomyValue($taxonomy, $values, $folders = null) { self::loadCache(); $case_sensitive = Config::getTaxonomyCaseSensitive(); if ($folders) { $folders = Parse::pipeList($folders); } // if an array was sent if (is_array($values)) { $files = array(); if (!$case_sensitive) { $values = array_map('strtolower', $values); } // loop through each of the values looking for files foreach ($values as $value) { if (!isset(self::$cache["taxonomies"][$taxonomy][$value])) { continue; } // add these file names to the big file list $files = array_merge($files, self::$cache["taxonomies"][$taxonomy][$value]['files']); } // get unique list of files $files = array_unique($files); // if a single value was sent } else { if (!$case_sensitive) { $values = strtolower($values); } if (!isset(self::$cache["taxonomies"][$taxonomy][$values])) { $files = array(); } else { $files = self::$cache["taxonomies"][$taxonomy][$values]['files']; } } // if no files, abort if (!count($files)) { return new ContentSet(array()); } // still here? grab data from cache $data = array(); foreach ($files as $file) { $data[] = ContentService::getContent($file); } // build a new ContentSet with the data we have $content_set = new ContentSet($data); // if there are folders to filter on, filter if ($folders) { $content_set->filter(array("folders" => $folders)); } return $content_set; }
$app->pass(); } }); } ///////////////////////////////////////////////////////////////////////////////////////////////// // Bundle Asset Pipeline ///////////////////////////////////////////////////////////////////////////////////////////////// $app->get('/_add-ons/(:segments+)', function($segments = array()) use ($app) { // reset any content service caching that's been done ContentService::resetCaches(); // clean segments $segments = URL::sanitize($segments); $file_requested = implode($segments, '/'); $bundle_folder = APP_PATH . "/core/bundles/" . $segments[0]; $file = APP_PATH . "/core/bundles/" . $file_requested; $file = realpath($file); // prevent bad access of files if (strpos($file_requested, '../') !== false || File::getExtension($file) === 'php') { $app->pass(); return; }
private function completeEdit($submission, $config, $entry) { $content_set = ContentService::getContentByURL(Helper::decrypt($entry))->extract(); // Bail if the content doesn't exist. Someone tweaked it. Tsk tsk. if (!count($content_set)) { return; } // Get front-matter from existing submission $content = current($content_set); $yaml = YAML::parseFile($content['_file']); // MERGE!@#! $submission = array_merge($yaml, $submission); // Update the entry $file_content = File::buildContent($submission, ''); File::put($content['_file'], $file_content); // Shall we send? if (array_get($config, 'send_notification_email', false) === true) { $this->sendEmails($submission, $config, 'update'); } // Save data to flash for use in raven:submission $this->flash->set('submission', $submission); }
/** * Gets the target data from the cache * * @param array $config Configuration array * @return array */ public function getData($config) { // load data if ($config['taxonomy']) { $taxonomy_parts = Taxonomy::getCriteria(URL::getCurrent()); $taxonomy_type = $taxonomy_parts[0]; $taxonomy_slug = Config::get('_taxonomy_slugify') ? Slug::humanize($taxonomy_parts[1]) : urldecode($taxonomy_parts[1]); $content_set = ContentService::getContentByTaxonomyValue($taxonomy_type, $taxonomy_slug, $config['folders']); } else { $content_set = ContentService::getContentByFolders($config['folders']); } // filters $content_set->filter($config); // custom filter, remove the 404 page if needed if (!$config['include_404']) { $content_set->customFilter(function ($item) { return $item['url'] !== '/404'; }); } // custom filter, remove any excluded folders if ($config['exclude']) { $excluded = Parse::pipeList($config['exclude']); $content_set->customFilter(function ($item) use($excluded) { foreach ($excluded as $exclude) { if ($exclude === "*" || $exclude === "/*") { // exclude all return false; } elseif (substr($exclude, -1) === "*") { // wildcard check if (strpos($item['_folder'], substr($exclude, 0, -1)) === 0) { return false; } } else { // plain check if ($exclude == $item['_folder']) { return false; } } } return true; }); } $content_set->supplement(array('merge_with_data' => false)); $content_set->prepare($config['include_content']); $data = $content_set->get(); return $data; }
/** * Finds content by path * * @param string $path Path to use to look for content * @return array|false */ public static function find($path) { $hash = Debug::markStart('content', 'finding'); // ensure it starts with / $path = Path::tidy('/' . $path); ContentService::loadCache(); $urls = ContentService::$cache['urls']; foreach ($urls as $url => $data) { if ($data['path'] === $path) { return Content::get($url, false, false); } } Debug::markEnd($hash); return false; }
public function render() { $field_data = $this->field_data; /* |-------------------------------------------------------------------------- | Multi-select |-------------------------------------------------------------------------- | | We need to set an empty array brace [] and add the "multiple" attribute | in the event we want to allow multi-selects. We also change the | plurality of the placeholder content. | */ $max_items = array_get($this->field_config, 'max_items', 'null'); $force_list = array_get($this->field_config, 'force_list', false); $multiple = array_get($this->field_config, 'multiple', true); $allow_blank = array_get($this->field_config, 'allow_blank', false); $placeholder = array_get($this->field_config, 'placeholder', false); if ($max_items === 1 && !$force_list) { $multiple = false; } $multiple_array_holder = $multiple ? '[]' : ''; $multiple_string = $multiple ? "multiple='multiple'" : ''; $placeholder_string = $placeholder ? "placeholder='$placeholder'" : ''; $suggestions = array(); /* |-------------------------------------------------------------------------- | Hardcoded list of options |-------------------------------------------------------------------------- | | Any list can contain a preset list of options available for suggestion, | exactly like how the Select fieldtype works. | */ if (isset($this->field_config['options'])) { $options = $this->field_config['options']; $suggestions = array_merge($suggestions, $options); } /* |-------------------------------------------------------------------------- | Entries & Pages |-------------------------------------------------------------------------- | | Fetch a list of pages and/or entries, using any existing fields as | labels and values | */ if (isset($this->field_config['content'])) { $config = $this->field_config['content']; $value = array_get($config, 'value', 'url'); $label = array_get($config, 'label', 'title'); $folder = array_get($config, 'folder'); $content_set = ContentService::getContentByFolders(array($folder)); $content_set->filter(array( 'show_hidden' => array_get($config, array('show_hidden', 'show_all'), false), // show_all is legacy 'show_drafts' => array_get($config, 'show_drafts', false), 'since' => array_get($config, 'since'), 'until' => array_get($config, 'until'), 'show_past' => array_get($config, 'show_past', true), 'show_future' => array_get($config, 'show_future', true), 'type' => array_get($config, 'type', 'entries'), 'conditions' => trim(array_get($config, 'conditions')) ) ); $entries = $content_set->get(); foreach ($entries as $entry) { $pieces = array(); foreach (Helper::ensureArray($label) as $label_part) { if (isset($entry[$label_part]) && isset($entry[$value])) { $pieces[] = $entry[$label_part]; } } $suggestions[$entry[$value]] = join(' – ', $pieces); } } /* |-------------------------------------------------------------------------- | Taxonomies |-------------------------------------------------------------------------- | | Single taxonomy types can be fetched from any folder. The taxonomy label | and value will be identical to ensure consistency with template logic | */ if (isset($this->field_config['taxonomy'])) { $taxonomy_type = array_get($this->field_config, 'taxonomy:type'); $folder = array_get($this->field_config, 'taxonomy:folder'); $taxonomy_set = ContentService::getTaxonomiesByType($taxonomy_type); // now filter that down to just what we want $taxonomy_set->filter(array( "min_count" => 1, "folders" => array($folder) )); $taxonomy_set->contextualize($folder); $taxonomies = $taxonomy_set->get(); foreach ($taxonomies as $key => $value) { $taxonomies[$key] = $value['name']; } $suggestions = array_merge($suggestions, $taxonomies); } /* |-------------------------------------------------------------------------- | Members |-------------------------------------------------------------------------- | | Fetch a list of members, using any existing fields as labels and values | */ if (isset($this->field_config['members'])) { $config = $this->field_config['members']; $value = array_get($config, 'value', '_uid'); $label = array_get($config, 'label', 'username'); $member_set = MemberService::getMembers(); $member_set->filter(array( 'role' => array_get($config, 'role') )); $members = $member_set->get(); foreach ($members as $key => $member) { if (isset($member[$label]) && isset($member[$value])) { $suggestions[$member[$value]] = $member[$label]; } } } /* |-------------------------------------------------------------------------- | Input HTML |-------------------------------------------------------------------------- | | Generate the HTML for the select field. A single, blank option is | needed if allow blank is true. | */ if ($max_items === null && $multiple === false) { $max_items = 1; } $options = json_encode(array( 'sortField' => 'text', 'maxItems' => $max_items, 'delimiter' => ',', 'create' => array_get($this->field_config, 'create', false), 'persist' => array_get($this->field_config, 'persist', true), 'hideSelected' => array_get($this->field_config, 'hide_selected', true), 'sortDirection' => array_get($this->field_config, 'sort_dir', 'asc'), 'plugins' => array('drag_drop'), 'dropdownParent' => 'body' )); $html = "<div id='$this->field_id' class='suggest-field-container' data-config='$options'>"; $html .= "<select name='{$this->fieldname}{$multiple_array_holder}' tabindex='{$this->tabindex}' $multiple_string $placeholder_string class='suggest'>\n"; $is_indexed = (array_values($suggestions) === $suggestions); // Preserve existing data's order if (is_array($field_data)) { $field_data = array_combine($field_data, $field_data); $suggestions = array_merge($field_data, $suggestions); } if ($allow_blank) { $html .= "<option value=''></option>\n"; } foreach ($suggestions as $value => $label) { $value = $is_indexed ? $label : $value; #allows setting custom values and labels if ($multiple && is_array($field_data) ) { $selected = in_array($value, $field_data) ? " selected " : ''; } else { $selected = $field_data == $value ? " selected " : ''; } $html .= '<option value="'. $value .'" ' . $selected .'>' . $label .'</option>'; } $html .= "</select>"; $html .= "<div class='count-placeholder'></div></div>"; $html .= "<script>$('#{$this->field_id}').statamicSuggest();</script>"; return $html; }
public static function find_relative($current, $folder = null, $future = false, $past = true, $show_hidden = false) { $content_set = ContentService::getContentByFolders($folder); $content_set->filter(array('show_hidden' => $show_hidden, 'show_drafts' => false, 'show_future' => $future, 'show_past' => $past, 'type' => 'entries')); $content_set->sort(); $content = $content_set->get(false, false); $relative = array('prev' => null, 'next' => null); $use_next = false; $prev = false; foreach ($content as $data) { // find previous if (!$prev && $current != $data['url']) { $relative['prev'] = $data['url']; continue; } // we have found the current url // set the currently-set previous url to be `prev` // and mark the next iteration to use its value as `next` if ($current == $data['url']) { $prev = true; $use_next = true; continue; } // we should use this url as `next` if ($use_next) { $relative['next'] = $data['url']; break; } } return $relative; }