_id
stringlengths 2
7
| title
stringlengths 3
151
| partition
stringclasses 3
values | text
stringlengths 33
8k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q200
|
Term.getOneWhere
|
train
|
public static function getOneWhere($args = array())
{
$args['number'] = 1;
$result = static::getWhere($args);
|
php
|
{
"resource": ""
}
|
q201
|
Term.find
|
train
|
public static function find($term_id)
{
$instance = Post\Factory::create(get_called_class());
|
php
|
{
"resource": ""
}
|
q202
|
Loader.loadAll
|
train
|
public static function loadAll()
{
global $taxonomies_infos;
// Classes
$subclasses = self::getSubclasses();
foreach ($subclasses as $class) {
$instance = new $class;
$taxonomies_infos = array_merge(
|
php
|
{
"resource": ""
}
|
q203
|
Loader.load
|
train
|
public static function load($class)
{
$instance = new $class;
$post_type = $instance->getPostType();
// WordPress has a limit of 20 characters per
if (strlen($post_type) > 20) {
throw new \Exception('Post Type name exceeds maximum 20 characters: '.$post_type);
}
// This might happen if you're introducing a middle class between your post type and TacoPost
// Ex: Foo extends \ClientTacoPost extends Taco\Post
if (!$post_type) {
return false;
}
//add_action('init', array($instance, 'registerPostType'));
$instance->registerPostType();
add_action('save_post', array($instance, 'addSaveHooks'));
if (is_admin()) {
// If we're in the edit screen, we want the post loaded
// so that TacoPost::getFields knows which post it's working with.
// This helps if you want TacoPost::getFields to use conditional logic
// based on which post is currently being edited.
$is_edit_screen = (
is_array($_SERVER)
&& preg_match('/post.php\?post=[\d]{1,}/i', $_SERVER['REQUEST_URI'])
&& !Arr::iterable($_POST)
);
$is_edit_save = (
preg_match('/post.php/i', $_SERVER['REQUEST_URI'])
&& Arr::iterable($_POST)
);
$post = null;
if ($is_edit_screen && array_key_exists('post', $_GET)) {
$post = get_post($_GET['post']);
} elseif ($is_edit_save) {
$post = get_post($_POST['post_ID']);
}
if ($post && $post->post_type === $instance->getPostType()) {
$instance->load($post);
}
add_action('admin_menu', array($instance, 'addMetaBoxes'));
add_action(sprintf('manage_%s_posts_columns', $post_type), array($instance, 'addAdminColumns'), 10, 2);
add_action(sprintf('manage_%s_posts_custom_column', $post_type), array($instance,
|
php
|
{
"resource": ""
}
|
q204
|
Loader.getSubclasses
|
train
|
public static function getSubclasses()
{
$subclasses = array();
foreach (get_declared_classes() as $class) {
if (method_exists($class, 'isLoadable') && $class::isLoadable() === false) {
continue;
}
|
php
|
{
"resource": ""
}
|
q205
|
Haversine.calculate
|
train
|
public function calculate(N\LatLong $point1, N\LatLong $point2) {
$celestialBody = $this->getCelestialBody();
$deltaLat = $point2->getLatitude()->get() - $point1->getLatitude()->get();
$deltaLong = $point2->getLongitude()->get() - $point1->getLongitude()->get();
$a = sin($deltaLat / 2) * sin($deltaLat /
|
php
|
{
"resource": ""
}
|
q206
|
Participant.update
|
train
|
public function update($params = [])
{
$response = Guzzle::put("tournaments/{$this->tournament_slug}/participants/{$this->id}",
|
php
|
{
"resource": ""
}
|
q207
|
Transformer.transform
|
train
|
public function transform($object)
{
if (($collection = $this->normalize($object)) instanceof Collection) {
return $this->transformCollection($collection);
}
// If there are relations setup, transform it along with the object.
if ($this->relatedCount) {
return $this->transformWithRelated($object);
}
|
php
|
{
"resource": ""
}
|
q208
|
Transformer.normalize
|
train
|
protected function normalize($object)
{
// If its a paginator instance, create a collection with its items.
if ($object instanceof Paginator) {
return collect($object->items());
} elseif (is_array($object)) {
|
php
|
{
"resource": ""
}
|
q209
|
Transformer.transformWithRelated
|
train
|
public function transformWithRelated($item)
{
$transformedItem = $this->getTransformation($item);
|
php
|
{
"resource": ""
}
|
q210
|
Transformer.with
|
train
|
public function with($relation)
{
$this->reset();
if (func_num_args() > 1) {
return $this->with(func_get_args());
}
if (is_array($relation)) {
$this->related = array_merge($this->related, $relation);
} else {
|
php
|
{
"resource": ""
}
|
q211
|
Transformer.setTransformation
|
train
|
public function setTransformation($transformation)
{
if (is_callable($transformation)) {
$this->transformationMethod = $transformation;
return $this;
}
// replace just to avoid wrongly passing the name containing "Transformation".
$methodName = str_replace('Transformation', '', $transformation) . "Transformation";
if (! method_exists($this, $methodName)) {
|
php
|
{
"resource": ""
}
|
q212
|
Transformer.transformRelated
|
train
|
protected function transformRelated($itemTransformation, $item)
{
foreach ($this->related as $relation) {
// get direct relation name.
$relationName = explode('.', $relation, 2)[0];
|
php
|
{
"resource": ""
}
|
q213
|
Transformer.getRelatedTransformation
|
train
|
protected function getRelatedTransformation($item, $relation)
{
// get nested relations separated by the dot notation.
// we only get one relation at a time because recursion handles the remaining relations.
$nestedRelations = explode('.', $relation, 2);
$relation = $nestedRelations[0];
$result = $item->{$relation};
$related = $result;
$transformer = null;
if (! is_object($related)) {
return $related;
}
// if its a collection switch the object to the first item.
if ($related instanceof Collection) {
if ($related->count()) {
$result = $result[0];
} else {
return [];
}
}
$transformer = $this->resolveTransformer($result);
// If no transformer was resolved.
|
php
|
{
"resource": ""
}
|
q214
|
GreatCircle.calculate
|
train
|
public function calculate(N\LatLong $point1, N\LatLong $point2) {
$celestialBody = $this->getCelestialBody();
$degrees = acos(sin($point1->getLatitude()->get()) *
sin($point2->getLatitude()->get()) +
cos($point1->getLatitude()->get()) *
cos($point2->getLatitude()->get()) *
|
php
|
{
"resource": ""
}
|
q215
|
Gravatar.image
|
train
|
public static function image($sEmail, $iSize = null, $sDefaultImage = null, $sRating = null, $sExtension = null, $bForceDefault = false)
{
$gravatarImage = (new Image())
->setEmail($sEmail)
->setSize($iSize)
|
php
|
{
"resource": ""
}
|
q216
|
Gravatar.images
|
train
|
public static function images(array $aEmail, $iSize = null, $sDefaultImage = null, $sRating = null, $sExtension = null, $bForceDefault = false)
{
$aImages = [];
foreach ($aEmail as $sEmail) {
$gravatarImage = (new Image())
->setEmail($sEmail)
|
php
|
{
"resource": ""
}
|
q217
|
Gravatar.profiles
|
train
|
public static function profiles(array $aEmail, $sFormat = null)
{
$aProfils = [];
foreach ($aEmail as $sEmail) {
$gravatarProfil = (new Profile())
->setEmail($sEmail)
|
php
|
{
"resource": ""
}
|
q218
|
Gravatar.email
|
train
|
public function email($sEmail = null)
{
if (null === $sEmail) {
return $this->getEmail();
|
php
|
{
"resource": ""
}
|
q219
|
Factory.create
|
train
|
public static function create($post, $load_terms = true)
{
// Ex: Taco\Post\Factory::create('Video')
if (is_string($post) && class_exists($post)) {
return new $post;
}
$original_post = $post;
if (!is_object($post)) {
$post = get_post($post);
}
if (!is_object($post)) {
throw new \Exception(sprintf('Post %s not
|
php
|
{
"resource": ""
}
|
q220
|
Factory.createMultiple
|
train
|
public static function createMultiple($posts, $load_terms = true)
{
if (!Arr::iterable($posts)) {
return $posts;
}
$out = array();
foreach ($posts as $k => $post) {
if (!get_post_status($post)) {
|
php
|
{
"resource": ""
}
|
q221
|
Dm_Image.draw
|
train
|
public function draw(Dm_Image $image,$x=0,$y=0,$width=null,$height=null)
{
$srcImageResource = $image->getImageResource();
if (is_null($width)) $width = $image->getWidth();
if (is_null($height)) $height
|
php
|
{
"resource": ""
}
|
q222
|
Dm_Image.saveTo
|
train
|
public function saveTo($path , $type='png', $quality=null)
{
if (!$path) return false;
|
php
|
{
"resource": ""
}
|
q223
|
Dm_Image.destroy
|
train
|
public function destroy()
{
imagedestroy($this->_imageResource);
$this->graphics->destroy();
|
php
|
{
"resource": ""
}
|
q224
|
Dm_Image.toDataSchemeURI
|
train
|
public function toDataSchemeURI()
{
$md5 = md5(microtime(1).rand(10000, 99999));
$filePath = $this->tempDirPath() . DIRECTORY_SEPARATOR . "temp".$md5.".png";
|
php
|
{
"resource": ""
}
|
q225
|
Server.serve
|
train
|
public function serve($salt = '')
{
$protocol = isset($_SERVER['SERVER_PROTOCOL'])
? $_SERVER['SERVER_PROTOCOL']
: 'HTTP/1.0';
if ($input = $this->findInput()) {
$output = $this->cacheName($salt . $input);
$etag = $noneMatch = trim($this->getIfNoneMatchHeader(), '"');
if ($this->needsCompile($output, $etag)) {
try {
list($css, $etag) = $this->compile($input, $output);
$lastModified = gmdate('D, d M Y H:i:s', filemtime($output)) . ' GMT';
header('Last-Modified: ' . $lastModified);
header('Content-type: text/css');
header('ETag: "' . $etag . '"');
echo $css;
} catch (\Exception $e) {
if ($this->showErrorsAsCSS) {
header('Content-type: text/css');
echo $this->createErrorCSS($e);
} else {
header($protocol . ' 500 Internal Server Error');
header('Content-type: text/plain');
echo 'Parse error: ' . $e->getMessage() . "\n";
}
}
return;
}
header('X-SCSS-Cache: true');
header('Content-type: text/css');
header('ETag: "' . $etag . '"');
if ($etag === $noneMatch) {
|
php
|
{
"resource": ""
}
|
q226
|
Base.getPrefixGroupedMetaBoxes
|
train
|
public function getPrefixGroupedMetaBoxes()
{
$fields = $this->getFields();
// Just group by the field key prefix
// Ex: home_foo would go in the Home section by default
$groups = array();
foreach ($fields as $k => $field) {
$prefix = current(explode('_', $k));
|
php
|
{
"resource": ""
}
|
q227
|
Base.replaceMetaBoxGroupMatches
|
train
|
public function replaceMetaBoxGroupMatches($meta_boxes)
{
if (!Arr::iterable($meta_boxes)) {
return $meta_boxes;
}
foreach ($meta_boxes as $k => $group) {
$group = (is_array($group)) ? $group : array($group);
if (array_key_exists('fields', $group)) {
continue;
}
$fields = $this->getFields();
$new_group = array();
foreach ($group as $pattern_key => $pattern) {
if (!preg_match('/\*$/', $pattern)) {
$new_group[] = $pattern;
continue;
}
$prefix = preg_replace('/\*$/', '', $pattern);
$regex = sprintf('/^%s/', $prefix);
|
php
|
{
"resource": ""
}
|
q228
|
Base.getMetaBoxConfig
|
train
|
public function getMetaBoxConfig($config, $key = null)
{
// allow shorthand
if (!array_key_exists('fields', $config)) {
$fields = array();
foreach ($config as $field) {
// Arbitrary HTML is allowed
if (preg_match('/^\</', $field) && preg_match('/\>$/', $field)) {
$fields[md5(mt_rand())] = array(
'type'=>'html',
'label'=>null,
'value'=>$field,
);
continue;
}
$fields[$field] = $this->getField($field);
}
$config = array('fields'=>$fields);
}
if (Arr::iterable($config['fields'])) {
$fields = array();
foreach ($config['fields'] as $k => $v) {
if (is_array($v)) {
$fields[$k] = $v;
|
php
|
{
"resource": ""
}
|
q229
|
Base.assign
|
train
|
public function assign($vals)
{
if (count($vals) === 0) {
return 0;
}
|
php
|
{
"resource": ""
}
|
q230
|
Base.isValid
|
train
|
public function isValid($vals)
{
$fields = $this->getFields();
if (!Arr::iterable($fields)) {
return true;
}
$result = true;
// validate each field
foreach ($fields as $k => $field) {
// check if required
if ($this->isRequired($field)) {
if (!array_key_exists($k, $vals)
|| is_null($vals[$k])
|| $vals[$k] === ''
|| $vals[$k] === false
|| ($field['type'] === 'checkbox' && empty($vals[$k]))
) {
$result = false;
$this->_messages[$k] = $this->getFieldRequiredMessage($k);
continue;
}
}
// check maxlength
if (array_key_exists('maxlength', $field)) {
if (strlen($vals[$k]) > $field['maxlength']) {
$result = false;
$this->_messages[$k] = 'Value too long';
continue;
}
}
// after this point, we're only checking values based on type
if (!array_key_exists($k, $vals)) {
continue;
}
if (!array_key_exists('type', $field)) {
continue;
}
// Select
if ($field['type'] === 'select') {
if (!array_key_exists($vals[$k], $field['options'])) {
$result = false;
$this->_messages[$k] = 'Invalid option';
}
continue;
|
php
|
{
"resource": ""
}
|
q231
|
Base.getMetaBoxTitle
|
train
|
public function getMetaBoxTitle($key = null)
{
return ($key) ? Str::human($key) :
|
php
|
{
"resource": ""
}
|
q232
|
Base.scrubAttributes
|
train
|
private static function scrubAttributes($field, $type = null)
{
$invalid_keys = [
'default',
'description',
'label',
'options',
];
if ($type && $type ==='textarea') {
$invalid_keys[] = 'value';
|
php
|
{
"resource": ""
}
|
q233
|
Base.getCheckboxDisplay
|
train
|
public function getCheckboxDisplay($column_name)
{
$displays = $this->getCheckboxDisplays();
if (array_key_exists($column_name, $displays)) {
|
php
|
{
"resource": ""
}
|
q234
|
Base.renderAdminColumn
|
train
|
public function renderAdminColumn($column_name, $item_id)
{
$columns = $this->getAdminColumns();
if (!in_array($column_name, $columns)) {
return;
}
$field = $this->getField($column_name);
if (is_array($field)) {
$class = get_called_class();
$entry = new $class;
$entry->load($item_id);
$out = $entry->get($column_name);
if (isset($field['type'])) {
switch ($field['type']) {
case 'checkbox':
$checkbox_display = $entry->getCheckboxDisplay($column_name);
$out = ($entry->get($column_name))
? reset($checkbox_display)
: end($checkbox_display);
break;
case 'image':
$out = Html::image($entry->get($column_name), $entry->get($column_name), array('class'=>'thumbnail'));
|
php
|
{
"resource": ""
}
|
q235
|
Base.makeAdminColumnsSortable
|
train
|
public function makeAdminColumnsSortable($columns)
{
$admin_columns = $this->getAdminColumns();
if (!Arr::iterable($admin_columns)) {
|
php
|
{
"resource": ""
}
|
q236
|
Base.getPlural
|
train
|
public function getPlural()
{
$singular = $this->getSingular();
if (preg_match('/y$/', $singular)) {
|
php
|
{
"resource": ""
}
|
q237
|
Base.getThe
|
train
|
public function getThe($key, $convert_value = false, $return_wrapped = true)
{
if ($return_wrapped) {
return apply_filters('the_content', $this->get($key, $convert_value));
}
// Apply the_content filter without wrapping lines in <p> tags
|
php
|
{
"resource": ""
}
|
q238
|
Base.getLabelText
|
train
|
public function getLabelText($field_key)
{
$field = $this->getField($field_key);
if (!is_array($field)) {
return null;
}
return (array_key_exists('label', $field))
|
php
|
{
"resource": ""
}
|
q239
|
Base.getRenderLabel
|
train
|
public function getRenderLabel($field_key, $required_mark = ' <span class="required">*</span>')
{
return sprintf(
'<label for="%s">%s%s</label>',
$field_key,
|
php
|
{
"resource": ""
}
|
q240
|
Base.isRequired
|
train
|
public function isRequired($field_key)
{
$field = (is_array($field_key)) ? $field_key : $this->getField($field_key);
|
php
|
{
"resource": ""
}
|
q241
|
DmsParser.parse
|
train
|
public function parse($coord) {
$coordinate = null;
$matches = array();
preg_match($this->input_format, $coord, $matches);
if (count($matches) == 5) {
$degrees = $matches[1];
$minutes = $matches[2] * (1 / 60);
$seconds = $matches[3] * (1 / 60 * 1 / 60);
$coordinate = '';
if (isset($matches[4])) {
if ($matches[4] == 'S' or $matches[4] == 'W') {
|
php
|
{
"resource": ""
}
|
q242
|
DmsParser.get
|
train
|
public function get($coord) {
$coord = rad2deg($coord);
$degrees = (integer) $coord;
$compass = '';
if ($this->direction == N::LAT) {
if ($degrees < 0)
$compass = 'S';
elseif ($degrees > 0)
$compass = 'N';
}elseif ($this->direction == N::LONG) {
if ($degrees < 0)
|
php
|
{
"resource": ""
}
|
q243
|
SqlTable.convertRow
|
train
|
protected function convertRow(array $row, Connection $connection, Table $table)
{
$result = [];
foreach ($row as $key => $value) {
$type = $table->getColumn($key)->getType();
$val = $type->convertToPHPValue($value, $connection->getDatabasePlatform());
if ($type instanceof Types\DateTimeType) {
$val = $val->format(\DateTime::RFC3339);
} elseif ($type instanceof Types\DateTimeTzType) {
$val = $val->format(\DateTime::RFC3339_EXTENDED);
} elseif ($type instanceof Types\TimeType) {
|
php
|
{
"resource": ""
}
|
q244
|
LoadRegisterViewHelper.renderStatic
|
train
|
public static function renderStatic(array $arguments, \Closure $renderChildrenClosure, RenderingContextInterface $renderingContext): string
{
$key = $arguments['key'];
$value = $arguments['value'];
array_push($GLOBALS['TSFE']->registerStack, $GLOBALS['TSFE']->register);
$GLOBALS['TSFE']->register[$key] = $value;
$content = $renderChildrenClosure();
if ($content) {
|
php
|
{
"resource": ""
}
|
q245
|
Coordinate.guessParser
|
train
|
public function guessParser($coord) {
if (!is_numeric($coord) and !is_null($coord))
|
php
|
{
"resource": ""
}
|
q246
|
TranslatableUtility.Master
|
train
|
public function Master()
{
if (Translatable::get_current_locale() != Translatable::default_locale()) {
|
php
|
{
"resource": ""
}
|
q247
|
Factory.create
|
train
|
public static function create($term, $taxonomy = null)
{
// Ex: Taco\Term\Factory::create('Keyword')
if (is_string($term) && class_exists($term)) {
return new $term;
}
if (!is_object($term)) {
$term = get_term($term, $taxonomy);
}
// TODO Refactor how this works to be more explicit and less guess
|
php
|
{
"resource": ""
}
|
q248
|
Factory.createMultiple
|
train
|
public static function createMultiple($terms, $taxonomy = null)
{
if (!Arr::iterable($terms)) {
return $terms;
}
$out = array();
foreach ($terms as $term) {
|
php
|
{
"resource": ""
}
|
q249
|
RegistersUsers.signupUpdate
|
train
|
public function signupUpdate(Request $request)
{
$this->middleware('auth:api');
$data = $request->all();
$validator = Validator::make($data, [
'firstname' => 'sometimes|required|max:255',
'surname' => 'sometimes|required|max:255',
'email' => 'sometimes|required|email|max:255|unique:users',
'mobile_number' => 'sometimes|min:10|unique:signup_data',
'password' => 'sometimes|required|min:6',
'gender' => 'sometimes|required',
'user_id' => 'required|integer',
]);
if (!empty($validator->errors()->messages())) {
return new Response([
'status' => 'FAIL',
'message' => 'Fail to update user signup data',
'Errors' => $validator->errors()
], 500);
} else {
try {
unset($data['_method']);
|
php
|
{
"resource": ""
}
|
q250
|
JSON.encode
|
train
|
public static function encode($value, $options = 0, $depth = 512)
{
// multi-characters supported by default
$options |= JSON_UNESCAPED_UNICODE;
$data = version_compare(PHP_VERSION, '5.5.0', '>=')
? json_encode($value, $options, $depth)
: json_encode($value, $options);
if (JSON_ERROR_NONE !== json_last_error()) {
|
php
|
{
"resource": ""
}
|
q251
|
ConfigurationUtility.getExtensionConfig
|
train
|
public static function getExtensionConfig(): array
{
$supportedMimeTypes = self::DEFAULT_SUPPORTED_MIME_TYPES;
$desktopWidth = self::DEFAULT_DESKTOP_WIDTH;
$tabletWidth = self::DEFAULT_TABLET_WIDTH;
$smartphoneWidth = self::DEFAULT_SMARTPHONE_WIDTH;
if (isset($GLOBALS['TYPO3_CONF_VARS']['EXTENSIONS']['responsive_images'])) {
$supportedMimeTypes = $GLOBALS['TYPO3_CONF_VARS']['EXTENSIONS']['responsive_images']['supportedMimeTypes'] ?? self::DEFAULT_SUPPORTED_MIME_TYPES;
$desktopWidth = (int)$GLOBALS['TYPO3_CONF_VARS']['EXTENSIONS']['responsive_images']['maxDesktopImageWidth'] ?? self::DEFAULT_DESKTOP_WIDTH;
$tabletWidth = (int)$GLOBALS['TYPO3_CONF_VARS']['EXTENSIONS']['responsive_images']['maxTabletImageWidth'] ?? self::DEFAULT_TABLET_WIDTH;
$smartphoneWidth = (int)$GLOBALS['TYPO3_CONF_VARS']['EXTENSIONS']['responsive_images']['maxSmartphoneImageWidth'] ?? self::DEFAULT_SMARTPHONE_WIDTH;
} elseif (isset($GLOBALS['TYPO3_CONF_VARS']['EXT']['extConf']['responsive_images'])) {
try {
$extConfig = unserialize($GLOBALS['TYPO3_CONF_VARS']['EXT']['extConf']['responsive_images']);
if (!empty($extConfig['supportedMimeTypes'])) {
$supportedMimeTypes = $extConfig['supportedMimeTypes'];
}
if (isset($extConfig['maxDesktopImageWidth']) && is_numeric($extConfig['maxDesktopImageWidth'])) {
|
php
|
{
"resource": ""
}
|
q252
|
Loader.load
|
train
|
public static function load($class)
{
$instance = new $class;
$taxonomy_key = $instance->getTaxonomyKey();
if (is_admin()) {
add_action(sprintf('created_%s', $taxonomy_key), array($instance, 'addSaveHooks'));
add_action(sprintf('edited_%s', $taxonomy_key), array($instance, 'addSaveHooks'));
add_action(sprintf('%s_add_form_fields', $taxonomy_key), array($instance, 'addMetaBoxes'));
add_action(sprintf('%s_edit_form_fields', $taxonomy_key), array($instance, 'addMetaBoxes'));
add_action(sprintf('manage_edit-%s_columns', $taxonomy_key), array($instance, 'addAdminColumns'), 10, 3);
|
php
|
{
"resource": ""
}
|
q253
|
CompletePurchaseResponse.calculateHash
|
train
|
private function calculateHash()
{
$hashType = $this->getHashType();
if ($hashType == 'sign') {
throw new InvalidResponseException('Control sign forming method "SIGN" is not supported');
} elseif ($hashType == null) {
throw new InvalidResponseException('Invalid signature type');
}
return strtoupper(hash(
$hashType,
$this->data['LMI_PAYEE_PURSE'].
$this->data['LMI_PAYMENT_AMOUNT'].
$this->data['LMI_PAYMENT_NO'].
|
php
|
{
"resource": ""
}
|
q254
|
Post.load
|
train
|
public function load($id, $load_terms = true)
{
$info = (is_object($id)) ? $id : get_post($id);
if (!is_object($info)) {
return false;
}
// Handle how WordPress converts special chars out of the DB
// b/c even when you pass 'raw' as the 3rd partam to get_post,
// WordPress will still encode the values.
if (isset($info->post_title) && preg_match('/[&]{1,}/', $info->post_title)) {
$info->post_title = html_entity_decode($info->post_title);
}
$this->_info = (array) $info;
// meta
$meta = get_post_meta($this->_info[self::ID]);
|
php
|
{
"resource": ""
}
|
q255
|
Post.loadTerms
|
train
|
public function loadTerms()
{
$taxonomy_keys = $this->getTaxonomyKeys();
if (!Arr::iterable($taxonomy_keys)) {
return false;
}
// TODO Move this to somewhere more efficient
// Check if this should be an instance of TacoTerm.
// If not, the object will just be a default WP object from wp_get_post_terms below.
$taxonomies_subclasses = array();
$subclasses = Term\Loader::getSubclasses();
foreach ($subclasses as $subclass) {
$term_instance = new $subclass;
$term_instance_taxonomy_key = $term_instance->getKey();
foreach ($taxonomy_keys as $taxonomy_key) {
if (array_key_exists($taxonomy_key, $taxonomies_subclasses)) {
continue;
}
if ($term_instance_taxonomy_key !== $taxonomy_key) {
continue;
}
$taxonomies_subclasses[$taxonomy_key] = $subclass;
|
php
|
{
"resource": ""
}
|
q256
|
Post.getDefaults
|
train
|
public function getDefaults()
{
global $user;
return array(
'post_type' => $this->getPostType(),
'post_author' => (is_object($user)) ? $user->ID : null,
|
php
|
{
"resource": ""
}
|
q257
|
Post.registerPostType
|
train
|
public function registerPostType()
{
$config = $this->getPostTypeConfig();
|
php
|
{
"resource": ""
}
|
q258
|
Post.getTaxonomy
|
train
|
public function getTaxonomy($key)
{
$taxonomies = $this->getTaxonomies();
if (!Arr::iterable($taxonomies)) {
return false;
}
$taxonomy = (array_key_exists($key, $taxonomies)) ? $taxonomies[$key] : false;
if (!$taxonomy) {
return false;
}
// Handle all of these:
// return array('one', 'two', 'three');
// return array('one'=>'One Category', 'two', 'three');
// return array(
// 'one'=>array('label'=>'One Category'),
// 'two'=>array('rewrite'=>array('slug'=>'foobar')),
// 'three'
// );
if (is_string($taxonomy)) {
$taxonomy = (is_numeric($key))
|
php
|
{
"resource": ""
}
|
q259
|
Post.getTaxonomyKeys
|
train
|
public function getTaxonomyKeys()
{
$taxonomies = $this->getTaxonomies();
if (!Arr::iterable($taxonomies)) {
return array();
}
$out = array();
foreach ($taxonomies as $k => $taxonomy) {
|
php
|
{
"resource": ""
}
|
q260
|
Post.getTaxonomyKey
|
train
|
public function getTaxonomyKey($key, $taxonomy = array())
{
if (is_string($key)) {
return $key;
}
if (is_array($taxonomy) && array_key_exists('label', $taxonomy)) {
|
php
|
{
"resource": ""
}
|
q261
|
Post.getTaxonomiesInfo
|
train
|
public function getTaxonomiesInfo()
{
$taxonomies = $this->getTaxonomies();
if (!Arr::iterable($taxonomies)) {
return array();
}
$out = array();
foreach ($taxonomies as $k => $taxonomy) {
|
php
|
{
"resource": ""
}
|
q262
|
Post.getPostTypeConfig
|
train
|
public function getPostTypeConfig()
{
if (in_array($this->getPostType(), array('post', 'page'))) {
return null;
}
return array(
'labels' => array(
'name' => _x($this->getPlural(), 'post type general name'),
'singular_name' => _x($this->getSingular(), 'post type singular name'),
'add_new' => _x('Add New', $this->getSingular()),
'add_new_item' => __(sprintf('Add New %s', $this->getSingular())),
'edit_item' => __(sprintf('Edit %s', $this->getSingular())),
'new_item' => __(sprintf('New %s', $this->getPlural())),
'view_item' => __(sprintf('View %s', $this->getSingular())),
'search_items' => __(sprintf('Search %s', $this->getPlural())),
'not_found' => __(sprintf('No %s found', $this->getPlural())),
'not_found_in_trash'=> __(sprintf('No %s found in Trash', $this->getPlural())),
'parent_item_colon' => ''
),
'hierarchical'
|
php
|
{
"resource": ""
}
|
q263
|
Post.getMenuIcon
|
train
|
public function getMenuIcon()
{
// Look for these files by default
// If your plugin directory contains an [post-type].png file, that will by default be the icon
// Ex: hot-sauce.png
$reflector = new \ReflectionClass(get_called_class());
$dir = basename(dirname($reflector->getFileName()));
$post_type = $this->getPostType();
$fnames = array(
$post_type.'.png',
$post_type.'.gif',
$post_type.'.jpg'
);
|
php
|
{
"resource": ""
}
|
q264
|
Post.sortAdminColumns
|
train
|
public function sortAdminColumns($vars)
{
if (!isset($vars['orderby'])) {
return $vars;
}
$admin_columns = $this->getAdminColumns();
if (!Arr::iterable($admin_columns)) {
return $vars;
}
foreach ($admin_columns as $k) {
if ($vars['orderby'] !== $k) {
continue;
}
|
php
|
{
"resource": ""
}
|
q265
|
Post.makeAdminTaxonomyColumnsSortable
|
train
|
public function makeAdminTaxonomyColumnsSortable($clauses, $wp_query)
{
global $wpdb;
// Not sorting at all? Get out.
if (!array_key_exists('orderby', $wp_query->query)) {
return $clauses;
}
if ($wp_query->query['orderby'] !== 'meta_value') {
return $clauses;
}
if (!array_key_exists('meta_key', $wp_query->query)) {
return $clauses;
}
// No taxonomies defined? Get out.
$taxonomies = $this->getTaxonomies();
if (!Arr::iterable($taxonomies)) {
return $clauses;
}
// Not sorting by a taxonomy? Get out.
$sortable_taxonomy_key = null;
foreach ($taxonomies as $taxonomy_key => $taxonomy) {
$taxonomy_key = (is_int($taxonomy_key)) ? $taxonomy : $taxonomy_key;
if ($wp_query->query['meta_key'] !== $taxonomy_key) {
continue;
}
|
php
|
{
"resource": ""
}
|
q266
|
Post.getHideTitleFromAdminColumns
|
train
|
public function getHideTitleFromAdminColumns()
{
if (in_array('title', $this->getAdminColumns())) {
return false;
}
$supports = $this->getSupports();
|
php
|
{
"resource": ""
}
|
q267
|
Post.getPostType
|
train
|
public function getPostType()
{
$called_class_segments = explode('\\', get_called_class());
$class_name = end($called_class_segments);
return (is_null($this->post_type))
|
php
|
{
"resource": ""
}
|
q268
|
Post.getPairs
|
train
|
public static function getPairs($args = array())
{
$called_class = get_called_class();
$instance = Post\Factory::create($called_class);
// Optimize the query if no args
// Unfortunately, WP doesn't provide a clean way to specify which columns to select
// If WP allowed that, this custom SQL wouldn't be necessary
if (!Arr::iterable($args)) {
global $wpdb;
$sql = sprintf(
"SELECT
p.ID,
p.post_title
FROM $wpdb->posts p
WHERE p.post_type = '%s'
AND (p.post_status = 'publish')
ORDER BY p.post_title ASC",
$instance->getPostType()
);
$results = $wpdb->get_results($sql);
if (!Arr::iterable($results)) {
return array();
}
return array_combine(
Collection::pluck($results, 'ID'),
|
php
|
{
"resource": ""
}
|
q269
|
Post.getWhere
|
train
|
public static function getWhere($args = array(), $load_terms = true)
{
$instance = Post\Factory::create(get_called_class());
// Allow sorting both by core fields and custom fields
// See: http://codex.wordpress.org/Class_Reference/WP_Query#Order_.26_Orderby_Parameters
$default_orderby = $instance->getDefaultOrderBy();
$default_order = $instance->getDefaultOrder();
$default_args = array(
'post_type' => $instance->getPostType(),
'numberposts'=> -1,
'orderby' => $default_orderby,
'order' => $default_order,
);
// Sometimes you will specify a default orderby using getDefaultOrderBy
if ($default_orderby !== 'menu_order') {
$fields = $instance->getFields();
if (array_key_exists($default_orderby, $fields)) {
$default_args['meta_key'] = $default_orderby;
// Number fields should be sorted numerically, not alphabetically
// Of course, this currently requires you to use type=number to achieve numeric sorting
$default_args['orderby'] = ($fields[$default_orderby]['type'] === 'number')
? 'meta_value_num'
: 'meta_value';
|
php
|
{
"resource": ""
}
|
q270
|
Post.getByTerm
|
train
|
public static function getByTerm($taxonomy, $terms, $field = 'slug', $args = array(), $load_terms = true)
{
$args = array_merge($args, array(
'tax_query'=>array(
|
php
|
{
"resource": ""
}
|
q271
|
Post.getOneByTerm
|
train
|
public static function getOneByTerm($taxonomy, $terms, $field = 'slug', $args = array(), $load_terms = true)
{
$args['numberposts'] = 1;
$result = static::getByTerm($taxonomy,
|
php
|
{
"resource": ""
}
|
q272
|
Post.getPage
|
train
|
public static function getPage($page = 1, $args = array(), $load_terms = true)
{
$instance = Post\Factory::create(get_called_class());
$criteria = array(
'post_type' => $instance->getPostType(),
|
php
|
{
"resource": ""
}
|
q273
|
Post.setTerms
|
train
|
public function setTerms($term_ids, $taxonomy = null, $append = false)
{
$taxonomy = ($taxonomy) ? $taxonomy : 'post_tag';
if (!is_array($this->_terms)) {
$this->_terms = array();
}
if (!array_key_exists($taxonomy, $this->_terms)) {
$this->_terms[$taxonomy] = array();
|
php
|
{
"resource": ""
}
|
q274
|
Post.getTerms
|
train
|
public function getTerms($taxonomy = null)
{
if ($taxonomy) {
return (array_key_exists($taxonomy, $this->_terms))
?
|
php
|
{
"resource": ""
}
|
q275
|
Post.hasTerm
|
train
|
public function hasTerm($term_id)
{
$taxonomy_terms = $this->getTerms();
if (!Arr::iterable($taxonomy_terms)) {
return false;
}
foreach ($taxonomy_terms as $taxonomy_key => $terms) {
if (!Arr::iterable($terms)) {
continue;
}
foreach ($terms as $term) {
|
php
|
{
"resource": ""
}
|
q276
|
Post.getPostAttachment
|
train
|
public function getPostAttachment($size = 'full', $property = null)
{
$post_id = $this->get('ID');
if (!has_post_thumbnail($post_id)) {
return false;
}
$attachment_id = get_post_thumbnail_id($post_id);
$image_properties = array(
'url',
'width',
'height',
'is_resized'
);
$image_array =
|
php
|
{
"resource": ""
}
|
q277
|
Post.getRenderPublicField
|
train
|
public function getRenderPublicField($key, $field = null, $load_value = true)
{
$class = get_called_class();
if ($key === self::KEY_CLASS) {
$attribs = array('type'=>'hidden', 'name'=>$key, 'value'=>$class);
return Html::tag('input', null, $attribs);
}
if ($key === self::KEY_NONCE) {
|
php
|
{
"resource": ""
}
|
q278
|
Post.getPublicFormKey
|
train
|
public function getPublicFormKey($suffix = null)
{
$val = sprintf('%s_public_form', $this->getPostType());
|
php
|
{
"resource": ""
}
|
q279
|
Post.find
|
train
|
public static function find($post_id, $load_terms = true)
{
$instance = Post\Factory::create(get_called_class());
|
php
|
{
"resource": ""
}
|
q280
|
Post.getLinkURL
|
train
|
public function getLinkURL($field)
{
$link_attr = self::decodeLinkObject($this->get($field));
if(!is_object($link_attr)) {
return $this->get($field);
}
if(!(strlen($link_attr->href) && strlen($link_attr->title) && strlen($link_attr->target))) {
|
php
|
{
"resource": ""
}
|
q281
|
Post.linkAttribsToHTMLString
|
train
|
public function linkAttribsToHTMLString($link_attr, $body = '', $classes = '', $id = '', $styles = '')
{
$link_text = null;
if (strlen($link_attr->title)) {
$link_text = $link_attr->title;
} elseif (strlen($body)) {
$link_text = $body;
} else {
$link_text = $link_attr->href;
}
return Html::link(
$link_attr->href,
$link_text,
|
php
|
{
"resource": ""
}
|
q282
|
Post.getLinkHTMLFromObject
|
train
|
public static function getLinkHTMLFromObject($object_string, $body = '', $classes = '', $id = '', $styles = '')
{
return self::linkAttribsToHTMLString(
self::decodeLinkObject($object_string),
|
php
|
{
"resource": ""
}
|
q283
|
Passwordless.generateToken
|
train
|
public function generateToken($save = false)
{
$attributes = [
'token' => str_random(16),
'is_used' => false,
'user_id' => $this->id,
'created_at' => time()
];
|
php
|
{
"resource": ""
}
|
q284
|
QueryBuilderVisitor.enterExpression
|
train
|
public function enterExpression(Expression $expr)
{
$hash = spl_object_hash($expr);
if ($expr instanceof Key) {
if (!count($this->hashes)) {
$this->qb->andWhere($this->toExpr($expr));
} else {
$lastHash = end($this->hashes);
$this->map[$lastHash][] = $this->toExpr($expr);
}
} elseif ($expr instanceof OrX) {
$this->hashes[] =
|
php
|
{
"resource": ""
}
|
q285
|
QueryBuilderVisitor.leaveExpression
|
train
|
public function leaveExpression(Expression $expr)
{
if ($expr instanceof OrX || $expr instanceof AndX) {
$hash = spl_object_hash($expr);
if ($expr instanceof OrX) {
$composite = $this->qb->expr()->orX();
$composite->addMultiple($this->map[$hash]);
} else {
$composite = $this->qb->expr()->andX();
$composite->addMultiple($this->map[$hash]);
}
unset($this->hashes[array_search($hash, $this->hashes)]);
|
php
|
{
"resource": ""
}
|
q286
|
QueryBuilderVisitor.shouldJoin
|
train
|
public function shouldJoin($key, $prefix = null)
{
$parts = explode('.', $key);
if (!$prefix) {
$prefix = $this->getRootAlias();
}
if (!in_array($parts[0], $this->qb->getAllAliases())) {
$this->qb->leftJoin($prefix.'.'.$parts[0], $parts[0]);
}
// If the key consists of multiple . parts, we also need to add joins for the
|
php
|
{
"resource": ""
}
|
q287
|
Rsa.validateKey
|
train
|
private function validateKey($key)
{
$details = openssl_pkey_get_details($key);
if (!isset($details['key']) || $details['type'] !== OPENSSL_KEYTYPE_RSA) {
throw
|
php
|
{
"resource": ""
}
|
q288
|
DownloadsBlockService.downloadMediaAction
|
train
|
public function downloadMediaAction($filename)
{
$media = $this->mediaManager->getRepository()->findOneByReference($filename);
$provider = $this->container->get('opifer.media.provider.pool')->getProvider($media->getProvider());
$mediaUrl = $provider->getUrl($media);
$fileSystem = $provider->getFileSystem();
$file = $fileSystem->read($media->getReference());
|
php
|
{
"resource": ""
}
|
q289
|
DisplayLogicType.getDisplayLogicPrototypes
|
train
|
protected function getDisplayLogicPrototypes(BlockInterface $block)
{
$collection = new PrototypeCollection([
new OrXPrototype(),
new AndXPrototype(),
new EventPrototype('click_event', 'Click Event', 'event.type.click'),
new TextPrototype('dom_node_id', 'DOM Node Id', 'node.id')
]);
$owner = $block->getOwner();
if ($owner) {
// Avoid trying to add display logic for blocks when the current block has no owner (e.g. shared blocks)
$blockChoices = [];
foreach ($owner->getBlocks() as $member) {
try {
$properties = $member->getProperties();
if ($member instanceof ChoiceFieldBlock) {
if (empty($member->getName())) {
continue;
}
if (!isset($properties['options'])) {
continue;
}
$choices = [];
foreach ($properties['options'] as $option) {
if (empty($option['key'])) {
continue;
}
$choices[] = new Choice($option['key'], $option['value']);
}
$collection->add(new SelectPrototype($member->getName(), $properties['label'], $member->getName(), $choices));
} elseif
|
php
|
{
"resource": ""
}
|
q290
|
AuthenticationSuccessHandler.onAuthenticationSuccess
|
train
|
public function onAuthenticationSuccess(Request $request, TokenInterface $token)
{
if ($user = $token->getUser()) {
if (!$user->getFirstName() || !$user->getLastName()) {
|
php
|
{
"resource": ""
}
|
q291
|
Deserializer.fromBase64URL
|
train
|
public function fromBase64URL($data)
{
if ($remainder = strlen($data) % 4) {
$data .= str_repeat('=', 4 -
|
php
|
{
"resource": ""
}
|
q292
|
MailPlusProvider.synchronise
|
train
|
public function synchronise(Subscription $subscription)
{
try {
$contact = [
'update' => true,
'purge' => false,
'contact' => [
'externalId' => $subscription->getId(),
'properties' => [
'email' => $subscription->getEmail(),
],
],
];
$response = $this->post('contact', $contact);
if ($response->getStatusCode() == '204') { //Contact added successfully status code
$this->subscriptionManager->updateStatus($subscription, Subscription::STATUS_SYNCED);
|
php
|
{
"resource": ""
}
|
q293
|
Token.getHeader
|
train
|
public function getHeader($name, $default = null)
{
if ($this->hasHeader($name)) {
return $this->getHeaderValue($name);
}
if ($default === null) {
throw
|
php
|
{
"resource": ""
}
|
q294
|
Token.getHeaderValue
|
train
|
private function getHeaderValue($name)
{
$header = $this->headers[$name];
if ($header instanceof Claim) {
|
php
|
{
"resource": ""
}
|
q295
|
Token.getClaim
|
train
|
public function getClaim($name, $default = null)
{
if ($this->hasClaim($name)) {
return $this->claims[$name]->getValue();
}
if ($default === null) {
throw
|
php
|
{
"resource": ""
}
|
q296
|
Token.verify
|
train
|
public function verify(Signer $signer, $key)
{
if ($this->signature === null) {
throw new \BadMethodCallException('This token is not signed');
}
if ($this->headers['alg'] !== $signer->getAlgorithmId()) {
|
php
|
{
"resource": ""
}
|
q297
|
Token.validate
|
train
|
public function validate(ValidationData $data)
{
foreach ($this->getValidatableClaims() as $claim) {
if (!$claim->validate($data)) {
|
php
|
{
"resource": ""
}
|
q298
|
Token.getValidatableClaims
|
train
|
private function getValidatableClaims()
{
$claims = array();
foreach ($this->claims as $claim)
|
php
|
{
"resource": ""
}
|
q299
|
Issue.create
|
train
|
public function create($projectKey, $issueTypeName)
{
$fieldsMetadata = $this->getCreateMetadataFields($projectKey, $issueTypeName);
$fluentIssueCreate = new FluentIssueCreate($this->client, $fieldsMetadata);
|
php
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.