public function index()
{
$between = $this->fetchParam('between', false, false, false, false);
if ($between) {
// Expanded mode lets you set the number of times a value is repeated
$expanded_mode = strstr($between, ':');
/*
|--------------------------------------------------------------------------
| Unique Hash
|--------------------------------------------------------------------------
|
| Here we create a unique hash based on the parameters to provide
| users a method of using multiple switch tags in a single template
|
*/
$hash = md5(implode(",", $this->attributes));
if (!isset(self::$container[$hash])) {
// Instance counter
self::$container[$hash] = 0;
}
$switch_vars = Helper::explodeOptions($between);
// Expand those thangs!
if ($expanded_mode) {
$switch_vars = $this->expand($switch_vars);
}
$switch = $switch_vars[self::$container[$hash] % count($switch_vars)];
// Iterate!
self::$container[$hash]++;
return $switch;
}
return null;
}
public function index()
{
$between = $this->fetchParam('between', false, false, false, false);
if ($between) {
# create unique instance key
# using all parameters to allow a workaround
# for duplicate switch tags
$hash = md5(implode(",", $this->attributes));
if (!isset(self::$container[$hash])) {
# setup unique, per-instance counter
self::$container[$hash] = 0;
}
$switch_vars = Helper::explodeOptions($between);
$switch_count = count($switch_vars);
$switch = $switch_vars[self::$container[$hash] % $switch_count];
self::$container[$hash]++;
return $switch;
}
return null;
}
public function index()
{
$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);
$url = Path::resolve($from);
$tree = Statamic::get_content_tree($url, 1, $max_depth, $folders_only, $include_entries, true, $include_content);
# exclude a pipe-delimited set of urls
if ($exclude) {
$exclude_items = Helper::explodeOptions($exclude);
foreach ($tree as $key => $item) {
if (in_array($item['url'], $exclude_items) || in_array(trim($item['url'], '/'), $exclude_items)) {
unset($tree[$key]);
}
}
}
if (count($tree) > 0) {
return Parse::tagLoop($this->content, $tree);
}
return FALSE;
}
public function password_form()
{
// fetch parameters
$return = $this->fetch('return', filter_input(INPUT_GET, 'return', FILTER_SANITIZE_STRING), null, false, false);
$attr = $this->fetchParam('attr', false);
// set up data to be parsed into content
$data = array('error' => $this->flash->get('error', ''), 'field_name' => 'password');
// determine form attributes
$attr_string = '';
if ($attr) {
$attributes_array = Helper::explodeOptions($attr, true);
foreach ($attributes_array as $key => $value) {
$attr_string .= ' ' . $key . '="' . $value . '"';
}
}
// build the form
$html = '<form action="' . Path::tidy(Config::getSiteRoot() . '/TRIGGER/protect/password') . '" method="post"' . $attr_string . '>';
$html .= '<input type="hidden" name="return" value="' . $return . '">';
$html .= '<input type="hidden" name="token" value="' . $this->tokens->create() . '">';
$html .= Parse::template($this->content, $data);
$html .= '</form>';
// return the HTML
return $html;
}
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 '';
}
public function login()
{
// deprecation warning
$this->log->warn("Use of `login` is deprecated. Use `login_form` instead.");
$site_root = Config::getSiteRoot();
$return = $this->fetchParam('return', $site_root);
/*
|--------------------------------------------------------------------------
| Form HTML
|--------------------------------------------------------------------------
|
| The login form writes a hidden field to the form to set the return url.
| Form attributes are accepted as colon/piped options:
| Example: attr="class:form|id:contact-form"
|
| Note: The content of the tag pair is inserted back into the template
|
*/
$attributes_string = '';
if ($attr = $this->fetchParam('attr', false)) {
$attributes_array = Helper::explodeOptions($attr, true);
foreach ($attributes_array as $key => $value) {
$attributes_string .= " {$key}='{$value}'";
}
}
$html = "<form method='post' action='" . Path::tidy($site_root . "/TRIGGER/member/login") . "' {$attributes_string}>";
$html .= "<input type='hidden' name='return' value='{$return}' />";
$html .= $this->content;
$html .= "</form>";
return $html;
}
public function reset_password_form()
{
$data = array();
$errors = array();
// parse parameters and vars
$attr_string = '';
$site_root = Config::getSiteRoot();
$logged_in_redirect = $this->fetchParam('logged_in_redirect', $this->fetchConfig('member_home', $site_root), null, false, false);
$attr = $this->fetchParam('attr', false);
$hash = filter_input(INPUT_GET, 'H', FILTER_SANITIZE_URL);
// is user already logged in? forward as needed
if (Auth::isLoggedIn()) {
URL::redirect($logged_in_redirect, 302);
}
// no hash in URL?
if (!$hash) {
$errors[] = Localization::fetch('reset_password_url_invalid');
$data['url_invalid'] = true;
}
if (count($errors) == 0) {
// cache file doesn't exist or is too old
if (!$this->cache->exists($hash) || $this->cache->getAge($hash) > $this->fetchConfig('reset_password_age_limit') * 60) {
$errors[] = Localization::fetch('reset_password_url_expired');
$data['expired'] = true;
}
// flash errors
if ($flash_error = $this->flash->get('reset_password_error')) {
$errors[] = $flash_error;
}
}
// set up attributes
if ($attr) {
$attributes_array = Helper::explodeOptions($attr, true);
foreach ($attributes_array as $key => $value) {
$attr_string .= ' ' . $key . '="' . $value . '"';
}
}
// errors
$data['errors'] = $errors;
// set up form HTML
$html = '<form method="post" action="' . Path::tidy($site_root . "/TRIGGER/member/reset_password") . '" ' . $attr_string . '>';
$html .= '<input type="hidden" name="token" value="' . $this->tokens->create() . '">';
$html .= '<input type="hidden" name="hash" value="' . $hash . '">';
$html .= Parse::template($this->content, $data);
$html .= '</form>';
// return that HTML
return $html;
}
/**
* Raven form tag pair
*
* {{ raven:form }} {{ /raven:form }}
*
* @return string
*/
public function form()
{
/*
|--------------------------------------------------------------------------
| Formset
|--------------------------------------------------------------------------
|
| Raven really needs a formset to make it useful and secure. We may even
| write a form decorator in the future to generate forms from formsets.
|
*/
$formset = $this->fetchParam('formset', false);
$return = $this->fetchParam('return', URL::getCurrent());
$error_return = $this->fetchParam('error_return', URL::getCurrent());
$multipart = ($this->fetchParam('files', false)) ? "enctype='multipart/form-data'" : '';
$old_values = array();
// Fetch the content if in edit mode
if ($edit = $this->fetchParam('edit')) {
$old_values = Content::get($edit, false, false);
// Throw exception if there's an invalid URL
if (count($old_values) == 0) {
throw new FatalException('Invalid URL for editing');
}
$entry_hash = Helper::encrypt($edit);
}
// Merge old values
$old_values = array_merge($this->flash->get('old_values', array()), $old_values);
// Sanitize data before returning it for display
// $old_values = array_map_deep($old_values, 'htmlspecialchars');
// Set old values to re-populate the form
$data = array();
array_set($data, 'value', $old_values);
array_set($data, 'old_values', $old_values);
/*
|--------------------------------------------------------------------------
| Form HTML
|--------------------------------------------------------------------------
|
| Raven writes a few hidden fields to the form to help processing data go
| more smoothly. Form attributes are accepted as colon/piped options:
| Example: attr="class:form|id:contact-form"
|
| Note: The content of the tag pair is inserted back into the template
|
*/
$form_id = $this->fetchParam('id', true);
$attributes_string = '';
if ($attr = $this->fetchParam('attr', false, null, false, false)) {
$attributes_array = Helper::explodeOptions($attr, true);
foreach ($attributes_array as $key => $value) {
$attributes_string .= " {$key}='{$value}'";
}
}
$html = "<form method='post' {$multipart} {$attributes_string}>\n";
$html .= "<input type='hidden' name='hidden[raven]' value='{$form_id}' />\n";
$html .= "<input type='hidden' name='hidden[formset]' value='{$formset}' />\n";
$html .= "<input type='hidden' name='hidden[return]' value='{$return}' />\n";
$html .= "<input type='hidden' name='hidden[error_return]' value='{$error_return}' />\n";
if ($edit) {
$html .= "<input type='hidden' name='hidden[edit]' value='{$entry_hash}' />\n";
}
/*
|--------------------------------------------------------------------------
| Hook: Form Begin
|--------------------------------------------------------------------------
|
| Occurs in the middle the form allowing additional fields to be added.
| Has access to the current fieldset. Must return HTML.
|
*/
$html .= Hook::run('raven', 'inside_form', 'cumulative', '');
/*
|--------------------------------------------------------------------------
| Hook: Content Preparse
|--------------------------------------------------------------------------
|
| Allows the modification of the tag data inside the form. Also has access
| to the current formset.
|
*/
$html .= Hook::run('raven', 'content_preparse', 'replace', $this->content, $this->content);
$html .= "</form>";
return Parse::template($html, $data, array('statamic_view', 'callback'), $this->context);
}
public function index()
{
/*
|--------------------------------------------------------------------------
| Check for image
|--------------------------------------------------------------------------
|
| Transform just needs the path to an image to get started. If it exists,
| the fun begins.
|
*/
$image_src = $this->fetchParam('src', null, false, false, false);
// Set full system path
$image_path = Path::standardize(Path::fromAsset($image_src));
// Check if image exists before doing anything.
if (!File::isImage($image_path)) {
Log::error("Could not find requested image to transform: " . $image_path, "core", "Transform");
return;
}
/*
|--------------------------------------------------------------------------
| Resizing and cropping options
|--------------------------------------------------------------------------
|
| The first transformations we want to run is for size to reduce the
| memory usage for future effects.
|
*/
$width = $this->fetchParam('width', null, 'is_numeric');
$height = $this->fetchParam('height', null, 'is_numeric');
// resize specific
$ratio = $this->fetchParam('ratio', true, false, true);
$upsize = $this->fetchParam('upsize', true, false, true);
// crop specific
$pos_x = $this->fetchParam('pos_x', 0, 'is_numeric');
$pos_y = $this->fetchParam('pos_y', 0, 'is_numeric');
$quality = $this->fetchParam('quality', '75', 'is_numeric');
/*
|--------------------------------------------------------------------------
| Action
|--------------------------------------------------------------------------
|
| Available actions: resize, crop, and guess.
|
| "Guess" will find the best fitting aspect ratio of your given width and
| height on the current image automatically, cut it out and resize it to
| the given dimension.
|
*/
$action = $this->fetchParam('action', 'resize');
/*
|--------------------------------------------------------------------------
| Extra bits
|--------------------------------------------------------------------------
|
| Delicious and probably rarely used options.
|
*/
$angle = $this->fetchParam('rotate', false);
$flip_side = $this->fetchParam('flip', false);
$blur = $this->fetchParam('blur', false, 'is_numeric');
$pixelate = $this->fetchParam('pixelate', false, 'is_numeric');
$greyscale = $this->fetchParam(array('greyscale', 'grayscale'), false, false, true);
/*
|--------------------------------------------------------------------------
| Assemble filename and check for duplicate
|--------------------------------------------------------------------------
|
| We need to make sure we don't already have this image created, so we
| defer any action until we've processed the parameters, which create
| a unique filename.
|
*/
// Late modified time of original image
$last_modified = File::getLastModified($image_path);
// Find .jpg, .png, etc
$extension = File::getExtension($image_path);
// Filename with the extension removed so we can append our unique filename flags
$stripped_image_path = str_replace('.' . $extension, '', $image_path);
// The possible filename flags
$parameter_flags = array('width' => $width, 'height' => $height, 'quality' => $quality, 'rotate' => $angle, 'flip' => $flip_side, 'pos_x' => $pos_x, 'pos_y' => $pos_y, 'blur' => $blur, 'pixelate' => $pixelate, 'greyscale' => $greyscale, 'modified' => $last_modified);
// Start with a 1 character action flag
$file_breadcrumbs = '-' . $action[0];
foreach ($parameter_flags as $param => $value) {
if ($value) {
$flag = is_bool($value) ? '' : $value;
// don't show boolean flags
$file_breadcrumbs .= '-' . $param[0] . $flag;
}
}
// Allow converting filetypes (jpg, png, gif)
$extension = $this->fetchParam('type', $extension);
// Allow saving in a different directory
$destination = $this->fetchParam('destination', Config::get('transform_destination', false), false, false, false);
if ($destination) {
$destination = Path::tidy(BASE_PATH . '/' . $destination);
// Method checks to see if folder exists before creating it
Folder::make($destination);
$stripped_image_path = Path::tidy($destination . '/' . basename($stripped_image_path));
}
// Reassembled filename with all flags filtered and delimited
$new_image_path = $stripped_image_path . $file_breadcrumbs . '.' . $extension;
// Check if we've already built this image before
if (File::exists($new_image_path)) {
return Path::toAsset($new_image_path);
}
/*
|--------------------------------------------------------------------------
| Create Image
|--------------------------------------------------------------------------
|
| Transform just needs the path to an image to get started. The image is
| created in memory so we can start manipulating it.
|
*/
$image = Image::make($image_path);
/*
|--------------------------------------------------------------------------
| Perform Actions
|--------------------------------------------------------------------------
|
| This is fresh transformation. Time to work the magic!
|
*/
if ($action === 'resize' && ($width || $height)) {
$image->resize($width, $height, $ratio, $upsize);
}
if ($action === 'crop' && $width && $height) {
$image->crop($width, $height, $pos_x, $pos_y);
}
if ($action === 'smart') {
$image->grab($width, $height);
}
$resize = $this->fetchParam('resize', null);
if ($resize) {
$resize_options = Helper::explodeOptions($resize, true);
$image->resize(array_get($resize_options, 'width'), array_get($resize_options, 'height'), array_get($resize_options, 'ratio', true), array_get($resize_options, 'upsize', true));
}
$crop = $this->fetchParam('crop', null);
if ($crop) {
$crop_options = Helper::explodeOptions($crop, true);
$image->crop(array_get($crop_options, 'width'), array_get($crop_options, 'height'), array_get($crop_options, 'x'), array_get($crop_options, 'y'));
}
if ($angle) {
$image->rotate($angle);
}
if ($flip_side === 'h' || $flip_side === 'v') {
$image->flip($flip_side);
}
if ($greyscale) {
$image->greyscale();
}
if ($blur) {
$image->blur($blur);
}
if ($pixelate) {
$image->pixelate($pixelate);
}
/*
|--------------------------------------------------------------------------
| Save
|--------------------------------------------------------------------------
|
| Get out of dodge!
|
*/
try {
$image->save($new_image_path, $quality);
} catch (Exception $e) {
Log::fatal('Could not write new images. Try checking your file permissions.', 'core', 'Transform');
throw new Exception('Could not write new images. Try checking your file permissions.');
}
return File::cleanURL($new_image_path);
}
/**
* Explodes options into an array
*
* @deprecated Use $this->explodeOptions instead
*
* @param string $string String to explode
* @param bool $keyed Are options keyed?
* @return array
*/
public function explode_options($string, $keyed = FALSE)
{
$this->log->warn('Use of $this->explode_options() is deprecated. Use Helper::explodeOptions() instead.');
return Helper::explodeOptions($string, $keyed);
}
public function index()
{
/*
|--------------------------------------------------------------------------
| Paramers
|--------------------------------------------------------------------------
|
| Match overrides Extension. Exclusion applies in both cases.
|
*/
$match = $this->fetchParam('match', false);
$exclude = $this->fetchParam('exclude', false);
$extension = $this->fetchParam('extension', false);
$in = $this->fetchParam('in', false);
$not_in = $this->fetchParam('not_in', false);
$file_size = $this->fetchParam('file_size', false);
$file_date = $this->fetchParam('file_date', false);
$depth = $this->fetchParam('depth', false);
if ($file_size) {
$file_size = Helper::explodeOptions($file_size);
}
if ($extension) {
$extension = Helper::explodeOptions($extension);
}
/*
|--------------------------------------------------------------------------
| Finder
|--------------------------------------------------------------------------
|
| Get_Files implements most of the Symfony Finder component as a clean
| tag wrapper mapped to matched filenames.
|
*/
$finder = new Finder();
$finder->in($in);
// Finder doesn't respect multiple glob options,
// so this will need to wait until later.
//
// $match = str_replace('{{', '{', $match);
// $match = str_replace('}}', '}', $match);
/*
|--------------------------------------------------------------------------
| Name
|--------------------------------------------------------------------------
|
| Match is the "native" Finder name() method, which is supposed to
| implement string, glob, and regex. The glob support is only partial,
| so "extension" is a looped *single* glob rule iterator.
|
*/
if ($match) {
$finder->name($match);
} elseif ($extension) {
foreach ($extension as $ext) {
$finder->name("*.{$ext}");
}
}
/*
|--------------------------------------------------------------------------
| Exclude
|--------------------------------------------------------------------------
|
| Exclude directories from matching. Remapped to "not in" to allow more
| intuitive differentiation between filename and directory matching.
|
*/
if ($not_in) {
$finder->exclude($not_in);
}
/*
|--------------------------------------------------------------------------
| Not Name
|--------------------------------------------------------------------------
|
| Exclude files matching a given pattern: string, regex, or glob.
|
*/
if ($exclude) {
$finder->notName($exclude);
}
/*
|--------------------------------------------------------------------------
| File Size
|--------------------------------------------------------------------------
|
| Restrict files by size. Can be chained and allows comparison operators.
|
*/
if ($file_size) {
foreach ($file_size as $size) {
$finder->size($size);
}
}
/*
|--------------------------------------------------------------------------
| File Date
|--------------------------------------------------------------------------
|
| Restrict files by last modified date. Can use comparison operators, and
| since/after is aliased to >, and until/before to <.
|
*/
if ($file_date) {
$finder->date($file_date);
}
/*
|--------------------------------------------------------------------------
| Depth
|--------------------------------------------------------------------------
|
| Recursively traverse directories, starting at 0.
|
*/
if ($depth) {
$finder->depth($depth);
}
$matches = $finder->files();
/*
|--------------------------------------------------------------------------
| Return and Parse
|--------------------------------------------------------------------------
|
| This tag returns the matched filenames mapped to {{ file }}.
|
*/
$files = array();
foreach ($matches as $file) {
$files[] = array('file' => '/' . $in . '/' . $file->getRelativePathname());
// $files[] = YAML::parse($file->getContents());
}
return Parse::tagLoop($this->content, $files);
}
public static function get_content_list($folder = null, $limit = null, $offset = 0, $future = false, $past = true, $sort_by = 'date', $sort_dir = 'desc', $conditions = null, $switch = null, $skip_status = false, $parse = true, $since = null, $until = null, $location = null, $distance_from = null)
{
$folder_list = Helper::explodeOptions($folder);
$list = array();
foreach ($folder_list as $list_item) {
$results = self::get_content_all($list_item, $future, $past, $conditions, $skip_status, $parse, $since, $until, $location, $distance_from);
// if $location was set, filter out results that don't work
if (!is_null($location)) {
foreach ($results as $result => $variables) {
try {
foreach ($variables as $key => $value) {
// checks for $location variables, and that it has a latitude and longitude within it
if (strtolower($location) == strtolower($key)) {
if (!is_array($value) || !isset($value['latitude']) || !$value['latitude'] || !isset($value['longitude']) || !$value['longitude']) {
throw new Exception("nope");
}
}
}
} catch (Exception $e) {
unset($results[$result]);
}
}
}
$list = $list + $results;
}
// default sort is by date
if ($sort_by == 'date') {
uasort($list, 'statamic_sort_by_datetime');
} elseif ($sort_by == 'title') {
uasort($list, "statamic_sort_by_title");
} elseif ($sort_by == 'random') {
shuffle($list);
} elseif ($sort_by == 'numeric' || $sort_by == 'number') {
uasort($list, function ($a, $b) {
return Helper::compareValues($a['numeric'], $b['numeric']);
});
} elseif ($sort_by == 'distance' && !is_null($location) && !is_null($distance_from) && preg_match(Pattern::COORDINATES, trim($distance_from))) {
uasort($list, "statamic_sort_by_distance");
} elseif ($sort_by != 'date') {
# sort by any other field
uasort($list, function ($a, $b) use($sort_by) {
if (isset($a[$sort_by]) && isset($b[$sort_by])) {
return strcmp($b[$sort_by], $a[$sort_by]);
}
});
}
// default sort is asc
if ($sort_dir == 'desc') {
$list = array_reverse($list);
}
// handle offset/limit
if ($offset > 0) {
$list = array_splice($list, $offset);
}
if ($limit) {
$list = array_splice($list, 0, $limit);
}
if ($switch) {
$switch_vars = explode('|', $switch);
$switch_count = count($switch_vars);
$count = 1;
foreach ($list as $key => $post) {
$list[$key]['switch'] = $switch_vars[($count - 1) % $switch_count];
$count++;
}
}
return $list;
}
public function index()
{
/*
|--------------------------------------------------------------------------
| Paramers
|--------------------------------------------------------------------------
|
| Match overrides Extension. Exclusion applies in both cases.
|
*/
$match = $this->fetchParam('match', false);
$exclude = $this->fetchParam('exclude', false);
$extension = $this->fetchParam(array('extension', 'type'), false);
$in = $this->fetchParam(array('in', 'folder', 'from'), false);
$not_in = $this->fetchParam('not_in', false);
$file_size = $this->fetchParam('file_size', false);
$file_date = $this->fetchParam('file_date', false);
$depth = $this->fetchParam('depth', false);
$sort_by = $this->fetchParam(array('sort_by', 'order_by'), false);
$sort_dir = $this->fetchParam(array('sort_dir', 'sort_direction'), 'asc');
$limit = $this->fetchParam('limit', false);
if ($in) {
$in = Helper::explodeOptions($in);
}
if ($not_in) {
$not_in = Helper::explodeOptions($not_in);
}
if ($file_size) {
$file_size = Helper::explodeOptions($file_size);
}
if ($extension) {
$extension = Helper::explodeOptions($extension);
}
/*
|--------------------------------------------------------------------------
| Finder
|--------------------------------------------------------------------------
|
| Get_Files implements most of the Symfony Finder component as a clean
| tag wrapper mapped to matched filenames.
|
*/
$finder = new Finder();
if ($in) {
foreach ($in as $location) {
$finder->in(Path::fromAsset($location));
}
}
/*
|--------------------------------------------------------------------------
| Name
|--------------------------------------------------------------------------
|
| Match is the "native" Finder name() method, which is supposed to
| implement string, glob, and regex. The glob support is only partial,
| so "extension" is a looped *single* glob rule iterator.
|
*/
if ($match) {
$finder->name($match);
} elseif ($extension) {
foreach ($extension as $ext) {
$finder->name("*.{$ext}");
}
}
/*
|--------------------------------------------------------------------------
| Exclude
|--------------------------------------------------------------------------
|
| Exclude directories from matching. Remapped to "not in" to allow more
| intuitive differentiation between filename and directory matching.
|
*/
if ($not_in) {
foreach ($not_in as $location) {
$finder->exclude($location);
}
}
/*
|--------------------------------------------------------------------------
| Not Name
|--------------------------------------------------------------------------
|
| Exclude files matching a given pattern: string, regex, or glob.
| By default we don't allow looking for PHP files. Be smart.
|
*/
if ($this->fetchParam('allow_php', false) !== TRUE) {
$finder->notName("*.php");
}
if ($exclude) {
$finder->notName($exclude);
}
/*
|--------------------------------------------------------------------------
| File Size
|--------------------------------------------------------------------------
|
| Restrict files by size. Can be chained and allows comparison operators.
|
*/
if ($file_size) {
foreach ($file_size as $size) {
$finder->size($size);
}
}
/*
|--------------------------------------------------------------------------
| File Date
|--------------------------------------------------------------------------
|
| Restrict files by last modified date. Can use comparison operators, and
| since/after is aliased to >, and until/before to <.
|
*/
if ($file_date) {
$finder->date($file_date);
}
/*
|--------------------------------------------------------------------------
| Depth
|--------------------------------------------------------------------------
|
| Recursively traverse directories, starting at 0.
|
*/
if ($depth) {
$finder->depth($depth);
}
/*
|--------------------------------------------------------------------------
| Sort By
|--------------------------------------------------------------------------
|
| Sort by name, file, or type
|
*/
if ($sort_by) {
if ($sort_by === 'file' || $sort_by === 'name') {
$finder->sortByName();
} elseif ($sort_by === 'type') {
$finder->sortByType();
}
}
/*
|--------------------------------------------------------------------------
| Assemble File Array
|--------------------------------------------------------------------------
|
| Select the important bits of data on the list of files.
|
*/
$matches = $finder->files()->followLinks();
$files = array();
foreach ($matches as $file) {
$files[] = array('extension' => $file->getExtension(), 'filename' => $file->getFilename(), 'file' => Path::toAsset($file->getPathname()), 'name' => Path::toAsset($file->getPathname()), 'size' => File::getHumanSize($file->getSize()), 'size_bytes' => $file->getSize(), 'size_kilobytes' => number_format($file->getSize() / 1024, 2), 'size_megabytes' => number_format($file->getSize() / 1048576, 2), 'size_gigabytes' => number_format($file->getSize() / 1073741824, 2), 'is_image' => File::isImage($file->getPathname()));
}
/*
|--------------------------------------------------------------------------
| Sort Direction
|--------------------------------------------------------------------------
|
| Set the sort direction, defaulting to "asc" (ascending)
|
*/
if ($sort_dir === 'desc') {
$files = array_reverse($files);
}
/*
|--------------------------------------------------------------------------
| Randomizing
|--------------------------------------------------------------------------
|
| You can't sort randomly using Symfony finder, so we'll do it manually.
|
*/
if ($sort_by === 'random') {
shuffle($files);
}
/*
|--------------------------------------------------------------------------
| Limit Files
|--------------------------------------------------------------------------
|
| Limit the number of files returned. Needs to be run after sort_dir to
| ensure consistency.
|
*/
if ($limit) {
$files = array_slice($files, 0, $limit);
}
return Parse::tagLoop($this->content, $files, true, $this->context);
}
public static function explode_options($string, $keyed = FALSE)
{
Log::warn("Use of Statamic_Helper::explode_options() is deprecated. Use Helper::explodeOptions() instead.", "core", "Statamic_Helper");
return Helper::explodeOptions($string, $keyed);
}
function cleanFoldersList($folder_params)
{
$folder_params_array = Helper::explodeOptions($folder_params, false);
foreach ($folder_params_array as $part) {
$folders[] = '/_content' . Path::resolve($part) . '/';
}
return $folders;
}
