nextcloud/lib/public/util.php

552 lines
17 KiB
PHP
Raw Normal View History

<?php
/**
* ownCloud
*
* @author Frank Karlitschek
* @copyright 2012 Frank Karlitschek frank@owncloud.org
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE
* License as published by the Free Software Foundation; either
* version 3 of the License, or any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU AFFERO GENERAL PUBLIC LICENSE for more details.
*
* You should have received a copy of the GNU Affero General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*/
/**
* Public interface of ownCloud for apps to use.
* Utility Class.
*
*/
// use OCP namespace for all classes that are considered public.
// This means that they should be used by apps instead of the internal ownCloud classes
namespace OCP;
use DateTimeZone;
2012-05-19 12:36:57 +04:00
/**
* This class provides different helper functions to make the life of a developer easier
*/
class Util {
// consts for Logging
const DEBUG=0;
const INFO=1;
const WARN=2;
const ERROR=3;
const FATAL=4;
2012-05-01 23:07:08 +04:00
/**
2013-10-31 22:00:53 +04:00
* get the current installed version of ownCloud
2012-05-01 23:07:08 +04:00
* @return array
*/
2012-09-07 17:22:01 +04:00
public static function getVersion() {
2012-05-01 23:07:08 +04:00
return(\OC_Util::getVersion());
}
/**
2013-10-31 22:00:53 +04:00
* send an email
* @param string $toaddress
* @param string $toname
* @param string $subject
* @param string $mailtext
* @param string $fromaddress
* @param string $fromname
2014-04-21 17:44:54 +04:00
* @param int $html
2013-10-31 22:00:53 +04:00
* @param string $altbody
* @param string $ccaddress
* @param string $ccname
* @param string $bcc
*/
2013-02-11 20:44:02 +04:00
public static function sendMail( $toaddress, $toname, $subject, $mailtext, $fromaddress, $fromname,
$html = 0, $altbody = '', $ccaddress = '', $ccname = '', $bcc = '') {
// call the internal mail class
2013-02-11 20:44:02 +04:00
\OC_MAIL::send($toaddress, $toname, $subject, $mailtext, $fromaddress, $fromname,
$html, $altbody, $ccaddress, $ccname, $bcc);
}
2012-09-08 18:18:47 +04:00
/**
2013-10-31 22:00:53 +04:00
* write a message in the log
2012-05-01 11:39:12 +04:00
* @param string $app
* @param string $message
2012-12-25 21:17:32 +04:00
* @param int $level
2012-09-08 18:18:47 +04:00
*/
public static function writeLog( $app, $message, $level ) {
// call the internal log class
\OC_LOG::write( $app, $message, $level );
}
2012-05-01 11:39:12 +04:00
2013-10-23 12:47:26 +04:00
/**
* write exception into the log
2013-10-31 22:00:53 +04:00
* @param string $app app name
2014-04-21 17:44:54 +04:00
* @param \Exception $ex exception to log
* @param int $level log level, defaults to \OCP\Util::FATAL
2013-10-23 12:47:26 +04:00
*/
public static function logException( $app, \Exception $ex, $level = \OCP\Util::FATAL ) {
$exception = array(
'Message' => $ex->getMessage(),
'Code' => $ex->getCode(),
'Trace' => $ex->getTraceAsString(),
'File' => $ex->getFile(),
'Line' => $ex->getLine(),
);
\OCP\Util::writeLog($app, 'Exception: ' . json_encode($exception), $level);
2013-10-23 12:47:26 +04:00
}
/**
* check if sharing is disabled for the current user
*
* @return boolean
*/
public static function isSharingDisabledForUser() {
return \OC_Util::isSharingDisabledForUser();
}
2013-07-19 13:40:11 +04:00
/**
2013-10-31 22:00:53 +04:00
* get l10n object
* @param string $application
* @param string|null $language
* @return \OC_L10N
2013-07-19 13:40:11 +04:00
*/
public static function getL10N($application, $language = null) {
2014-08-31 12:05:59 +04:00
return \OC::$server->getL10N($application, $language);
2012-09-08 18:18:47 +04:00
}
2012-05-01 11:39:12 +04:00
/**
2013-10-31 22:00:53 +04:00
* add a css file
* @param string $application
* @param string $file
2012-05-01 11:39:12 +04:00
*/
2012-09-07 17:22:01 +04:00
public static function addStyle( $application, $file = null ) {
\OC_Util::addStyle( $application, $file );
2012-09-08 18:18:47 +04:00
}
2012-05-01 23:07:08 +04:00
/**
2013-10-31 22:00:53 +04:00
* add a javascript file
2012-12-25 21:17:32 +04:00
* @param string $application
2013-10-31 22:00:53 +04:00
* @param string $file
2012-05-01 23:07:08 +04:00
*/
2012-09-07 17:22:01 +04:00
public static function addScript( $application, $file = null ) {
\OC_Util::addScript( $application, $file );
2012-09-08 18:18:47 +04:00
}
/**
* Add a translation JS file
* @param string $application application id
* @param string $languageCode language code, defaults to the current locale
*/
public static function addTranslations($application, $languageCode = null) {
\OC_Util::addTranslations($application, $languageCode);
}
2012-05-01 23:07:08 +04:00
/**
2013-10-31 22:00:53 +04:00
* Add a custom element to the header
* If $text is null then the element will be written as empty element.
* So use "" to get a closing tag.
2012-12-25 21:17:32 +04:00
* @param string $tag tag name of the element
2012-05-01 23:07:08 +04:00
* @param array $attributes array of attributes for the element
* @param string $text the text content for the element
*/
public static function addHeader($tag, $attributes, $text=null) {
\OC_Util::addHeader($tag, $attributes, $text);
2012-05-01 23:07:08 +04:00
}
2012-05-01 23:07:08 +04:00
/**
2013-10-31 22:00:53 +04:00
* formats a timestamp in the "right" way
2012-12-25 21:17:32 +04:00
* @param int $timestamp $timestamp
* @param bool $dateOnly option to omit time from the result
* @param DateTimeZone|string $timeZone where the given timestamp shall be converted to
2014-04-21 17:44:54 +04:00
* @return string timestamp
*
* @deprecated Use \OC::$server->query('DateTimeFormatter') instead
2012-05-01 23:07:08 +04:00
*/
public static function formatDate($timestamp, $dateOnly=false, $timeZone = null) {
return(\OC_Util::formatDate($timestamp, $dateOnly, $timeZone));
2012-05-01 23:07:08 +04:00
}
/**
2013-10-31 22:00:53 +04:00
* check if some encrypted files are stored
* @return bool
*/
public static function encryptedFiles() {
return \OC_Util::encryptedFiles();
}
2013-10-31 22:00:53 +04:00
2012-05-02 01:19:39 +04:00
/**
2013-10-31 22:00:53 +04:00
* Creates an absolute url to the given app and file.
2012-12-25 21:17:32 +04:00
* @param string $app app
* @param string $file file
* @param array $args array with param=>value, will be appended to the returned url
2012-09-29 00:27:52 +04:00
* The value of $args will be urlencoded
2013-10-31 22:00:53 +04:00
* @return string the url
2012-05-02 01:19:39 +04:00
*/
public static function linkToAbsolute( $app, $file, $args = array() ) {
return(\OC_Helper::linkToAbsolute( $app, $file, $args ));
2012-05-02 01:19:39 +04:00
}
2012-05-02 00:59:38 +04:00
/**
2013-10-31 22:00:53 +04:00
* Creates an absolute url for remote use.
2012-12-25 21:17:32 +04:00
* @param string $service id
2013-10-31 22:00:53 +04:00
* @return string the url
*/
public static function linkToRemote( $service ) {
return(\OC_Helper::linkToRemote( $service ));
}
2012-08-27 23:46:05 +04:00
/**
2013-10-31 22:00:53 +04:00
* Creates an absolute url for public use
2012-12-25 21:17:32 +04:00
* @param string $service id
2013-10-31 22:00:53 +04:00
* @return string the url
2012-08-27 23:46:05 +04:00
*/
public static function linkToPublic($service) {
return \OC_Helper::linkToPublic($service);
}
2012-06-14 14:57:30 +04:00
/**
2013-10-31 22:00:53 +04:00
* Creates an url using a defined route
* @param string $route
2013-02-09 01:05:13 +04:00
* @param array $parameters
* @internal param array $args with param=>value, will be appended to the returned url
2014-04-21 17:44:54 +04:00
* @return string the url
2013-02-09 01:05:13 +04:00
*/
public static function linkToRoute( $route, $parameters = array() ) {
return \OC_Helper::linkToRoute($route, $parameters);
}
/**
2013-10-31 22:00:53 +04:00
* Creates an url to the given app and file
2012-12-25 21:17:32 +04:00
* @param string $app app
* @param string $file file
* @param array $args array with param=>value, will be appended to the returned url
2012-09-29 00:27:52 +04:00
* The value of $args will be urlencoded
2013-10-31 22:00:53 +04:00
* @return string the url
2012-06-14 14:57:30 +04:00
*/
2012-09-07 17:22:01 +04:00
public static function linkTo( $app, $file, $args = array() ) {
return(\OC_Helper::linkTo( $app, $file, $args ));
2012-05-02 01:19:39 +04:00
}
2012-05-02 00:59:38 +04:00
2012-05-02 01:19:39 +04:00
/**
2013-10-31 22:00:53 +04:00
* Returns the server host, even if the website uses one or more reverse proxy
* @return string the server host
* @deprecated Use \OCP\IRequest::getServerHost
2012-05-02 01:19:39 +04:00
*/
public static function getServerHost() {
return \OC::$server->getRequest()->getServerHost();
2012-05-02 01:19:39 +04:00
}
2012-05-02 00:59:38 +04:00
2012-12-19 04:09:14 +04:00
/**
* Returns the server host name without an eventual port number
2013-10-31 22:00:53 +04:00
* @return string the server hostname
2012-12-19 04:09:14 +04:00
*/
public static function getServerHostName() {
$host_name = self::getServerHost();
// strip away port number (if existing)
$colon_pos = strpos($host_name, ':');
if ($colon_pos != FALSE) {
$host_name = substr($host_name, 0, $colon_pos);
}
return $host_name;
}
/**
2013-10-31 22:00:53 +04:00
* Returns the default email address
2012-12-25 21:17:32 +04:00
* @param string $user_part the user part of the address
2013-10-31 22:00:53 +04:00
* @return string the default email address
2012-12-19 04:09:14 +04:00
*
* Assembles a default email address (using the server hostname
* and the given user part, and returns it
* Example: when given lostpassword-noreply as $user_part param,
* and is currently accessed via http(s)://example.com/,
* it would return 'lostpassword-noreply@example.com'
2014-01-24 17:22:42 +04:00
*
* If the configuration value 'mail_from_address' is set in
* config.php, this value will override the $user_part that
* is passed to this function
2012-12-19 04:09:14 +04:00
*/
public static function getDefaultEmailAddress($user_part) {
$user_part = \OC_Config::getValue('mail_from_address', $user_part);
2012-12-19 04:09:14 +04:00
$host_name = self::getServerHostName();
$host_name = \OC_Config::getValue('mail_domain', $host_name);
$defaultEmailAddress = $user_part.'@'.$host_name;
if (\OC_Mail::validateAddress($defaultEmailAddress)) {
return $defaultEmailAddress;
2012-12-19 04:09:14 +04:00
}
// in case we cannot build a valid email address from the hostname let's fallback to 'localhost.localdomain'
return $user_part.'@localhost.localdomain';
2012-12-19 04:09:14 +04:00
}
/**
* Returns the server protocol. It respects reverse proxy servers and load balancers
2013-10-31 22:00:53 +04:00
* @return string the server protocol
* @deprecated Use \OCP\IRequest::getServerProtocol
*/
public static function getServerProtocol() {
return \OC::$server->getRequest()->getServerProtocol();
}
/**
2013-10-31 22:00:53 +04:00
* Returns the request uri, even if the website uses one or more reverse proxies
2014-04-21 17:44:54 +04:00
* @return string the request uri
* @deprecated Use \OCP\IRequest::getRequestUri
*/
public static function getRequestUri() {
return \OC::$server->getRequest()->getRequestUri();
}
/**
2013-10-31 22:00:53 +04:00
* Returns the script name, even if the website uses one or more reverse proxies
2014-05-11 21:05:28 +04:00
* @return string the script name
* @deprecated Use \OCP\IRequest::getScriptName
*/
public static function getScriptName() {
return \OC::$server->getRequest()->getScriptName();
}
2012-05-02 02:20:45 +04:00
/**
2013-10-31 22:00:53 +04:00
* Creates path to an image
2012-12-25 21:17:32 +04:00
* @param string $app app
* @param string $image image name
2013-10-31 22:00:53 +04:00
* @return string the url
2012-05-02 02:20:45 +04:00
*/
2012-09-08 18:18:47 +04:00
public static function imagePath( $app, $image ) {
2012-05-02 02:20:45 +04:00
return(\OC_Helper::imagePath( $app, $image ));
}
/**
2013-10-31 22:00:53 +04:00
* Make a human file size (2048 to 2 kB)
2012-12-25 21:17:32 +04:00
* @param int $bytes file size in bytes
2013-10-31 22:00:53 +04:00
* @return string a human readable file size
2012-05-02 02:20:45 +04:00
*/
2012-09-07 17:22:01 +04:00
public static function humanFileSize( $bytes ) {
2012-05-02 02:20:45 +04:00
return(\OC_Helper::humanFileSize( $bytes ));
}
/**
2013-10-31 22:00:53 +04:00
* Make a computer file size (2 kB to 2048)
2012-12-25 21:17:32 +04:00
* @param string $str file size in a fancy format
2013-10-31 22:00:53 +04:00
* @return int a file size in bytes
2012-05-02 02:20:45 +04:00
*
* Inspired by: http://www.php.net/manual/en/function.filesize.php#92418
*/
2012-09-07 17:22:01 +04:00
public static function computerFileSize( $str ) {
2012-05-02 02:20:45 +04:00
return(\OC_Helper::computerFileSize( $str ));
}
/**
2013-10-31 22:00:53 +04:00
* connects a function to a hook
2012-12-25 21:17:32 +04:00
* @param string $signalclass class name of emitter
* @param string $signalname name of signal
* @param string $slotclass class name of slot
* @param string $slotname name of slot
2013-10-31 22:00:53 +04:00
* @return bool
*
* This function makes it very easy to connect to use hooks.
*
* TODO: write example
*/
2012-09-07 17:22:01 +04:00
static public function connectHook( $signalclass, $signalname, $slotclass, $slotname ) {
return(\OC_Hook::connect( $signalclass, $signalname, $slotclass, $slotname ));
}
2012-05-02 02:20:45 +04:00
/**
2013-10-31 22:00:53 +04:00
* Emits a signal. To get data from the slot use references!
2012-12-25 21:17:32 +04:00
* @param string $signalclass class name of emitter
* @param string $signalname name of signal
2014-04-21 17:44:54 +04:00
* @param array $params default: array() array with additional data
2013-10-31 22:00:53 +04:00
* @return bool true if slots exists or false if not
*
* TODO: write example
*/
2012-09-07 17:22:01 +04:00
static public function emitHook( $signalclass, $signalname, $params = array()) {
return(\OC_Hook::emit( $signalclass, $signalname, $params ));
}
2012-05-02 00:59:38 +04:00
/**
2012-08-29 22:34:44 +04:00
* Register an get/post call. This is important to prevent CSRF attacks
* TODO: write example
*/
2012-09-07 17:22:01 +04:00
public static function callRegister() {
return(\OC_Util::callRegister());
}
/**
* Check an ajax get/post call if the request token is valid. exit if not.
* Todo: Write howto
*/
2012-09-07 17:22:01 +04:00
public static function callCheck() {
2013-01-07 02:59:02 +04:00
\OC_Util::callCheck();
}
/**
2013-10-31 22:00:53 +04:00
* Used to sanitize HTML
*
2013-02-11 20:44:02 +04:00
* This function is used to sanitize HTML and should be applied on any
* string or array of strings before displaying it on a web page.
*
* @param string|array $value
* @return string|array an array of sanitized strings or a single sinitized string, depends on the input parameter.
*/
2012-09-07 17:22:01 +04:00
public static function sanitizeHTML( $value ) {
return(\OC_Util::sanitizeHTML($value));
}
2013-10-31 22:00:53 +04:00
2013-07-04 20:21:49 +04:00
/**
2013-10-31 22:00:53 +04:00
* Public function to encode url parameters
2013-07-04 20:21:49 +04:00
*
* This function is used to encode path to file before output.
* Encoding is done according to RFC 3986 with one exception:
2013-10-31 22:00:53 +04:00
* Character '/' is preserved as is.
2013-07-04 20:21:49 +04:00
*
* @param string $component part of URI to encode
2013-10-31 22:00:53 +04:00
* @return string
2013-07-04 20:21:49 +04:00
*/
public static function encodePath($component) {
return(\OC_Util::encodePath($component));
}
/**
2013-10-31 22:00:53 +04:00
* Returns an array with all keys from input lowercased or uppercased. Numbered indices are left as is.
*
* @param array $input The array to work on
* @param int $case Either MB_CASE_UPPER or MB_CASE_LOWER (default)
* @param string $encoding The encoding parameter is the character encoding. Defaults to UTF-8
* @return array
*/
2012-09-07 17:22:01 +04:00
public static function mb_array_change_key_case($input, $case = MB_CASE_LOWER, $encoding = 'UTF-8') {
return(\OC_Helper::mb_array_change_key_case($input, $case, $encoding));
}
/**
2013-10-31 22:00:53 +04:00
* replaces a copy of string delimited by the start and (optionally) length parameters with the string given in replacement.
*
* @param string $string The input string. Opposite to the PHP build-in function does not accept an array.
* @param string $replacement The replacement string.
* @param int $start If start is positive, the replacing will begin at the start'th offset into string. If start is negative, the replacing will begin at the start'th character from the end of string.
* @param int $length Length of the part to be replaced
* @param string $encoding The encoding parameter is the character encoding. Defaults to UTF-8
* @return string
*/
public static function mb_substr_replace($string, $replacement, $start, $length = null, $encoding = 'UTF-8') {
return(\OC_Helper::mb_substr_replace($string, $replacement, $start, $length, $encoding));
}
/**
2013-10-31 22:00:53 +04:00
* Replace all occurrences of the search string with the replacement string
*
* @param string $search The value being searched for, otherwise known as the needle. String.
* @param string $replace The replacement string.
* @param string $subject The string or array being searched and replaced on, otherwise known as the haystack.
* @param string $encoding The encoding parameter is the character encoding. Defaults to UTF-8
* @param int $count If passed, this will be set to the number of replacements performed.
* @return string
*/
public static function mb_str_replace($search, $replace, $subject, $encoding = 'UTF-8', &$count = null) {
return(\OC_Helper::mb_str_replace($search, $replace, $subject, $encoding, $count));
}
/**
2013-10-31 22:00:53 +04:00
* performs a search in a nested array
*
* @param array $haystack the array to be searched
* @param string $needle the search string
* @param int $index optional, only search this key name
* @return mixed the key of the matching field, otherwise false
*/
public static function recursiveArraySearch($haystack, $needle, $index = null) {
return(\OC_Helper::recursiveArraySearch($haystack, $needle, $index));
}
2013-01-18 23:09:03 +04:00
/**
2013-10-31 22:00:53 +04:00
* calculates the maximum upload size respecting system settings, free space and user quota
2013-01-18 23:09:03 +04:00
*
* @param string $dir the current folder where the user currently operates
* @param int $free the number of bytes free on the storage holding $dir, if not set this will be received from the storage directly
* @return int number of bytes representing
2013-01-18 23:09:03 +04:00
*/
public static function maxUploadFilesize($dir, $free = null) {
return \OC_Helper::maxUploadFilesize($dir, $free);
2013-01-18 23:09:03 +04:00
}
/**
* Calculate free space left within user quota
2014-04-21 17:44:54 +04:00
* @param string $dir the current folder where the user currently operates
* @return int number of bytes representing
*/
public static function freeSpace($dir) {
return \OC_Helper::freeSpace($dir);
}
/**
* Calculate PHP upload limit
*
* @return int number of bytes representing
*/
public static function uploadLimit() {
return \OC_Helper::uploadLimit();
}
/**
* Returns whether the given file name is valid
* @param string $file file name to check
* @return bool true if the file name is valid, false otherwise
*/
public static function isValidFileName($file) {
return \OC_Util::isValidFileName($file);
}
/**
* Generates a cryptographic secure pseudo-random string
* @param int $length of the random string
* @return string
* @deprecated Use \OC::$server->getSecureRandom()->getMediumStrengthGenerator()->generate($length); instead
*/
public static function generateRandomBytes($length = 30) {
return \OC_Util::generateRandomBytes($length);
}
/**
* Compare two strings to provide a natural sort
* @param string $a first string to compare
* @param string $b second string to compare
* @return -1 if $b comes before $a, 1 if $a comes before $b
* or 0 if the strings are identical
*/
public static function naturalSortCompare($a, $b) {
return \OC\NaturalSort::getInstance()->compare($a, $b);
}
/**
* check if a password is required for each public link
* @return boolean
*/
public static function isPublicLinkPasswordRequired() {
return \OC_Util::isPublicLinkPasswordRequired();
}
/**
* check if share API enforces a default expire date
* @return boolean
*/
public static function isDefaultExpireDateEnforced() {
return \OC_Util::isDefaultExpireDateEnforced();
}
/**
* Checks whether the current version needs upgrade.
*
* @return bool true if upgrade is needed, false otherwise
*/
public static function needUpgrade() {
return \OC_Util::needUpgrade(\OC::$server->getConfig());
}
2012-05-01 23:07:08 +04:00
}