/** * @ignore */ function vs($dummy, $vars) { // This internal function is used by assertions to put debugging information about the variables that are defined // at the point of a failing assertion and the object's properties at that point into a string to subsequently log // it into a file, send it by mail to the administrator etc. if (assert_options(ASSERT_ACTIVE) !== 1) { // Assertions are disabled, so nothing to do. return; } return CDebug::definedVarsToString($vars); }
/** * Sorts the elements in an array by comparing return values from a specified method being called on each element. * * For example, if you had an array of UserClass objects and UserClass had a public method named `numPosts` that * would return an integer value, you could sort the users by the number of posts they've made by calling this * method with "numPosts" as the value of `$onMethodName` parameter. * * If you want to pass any custom arguments to the method that the array needs to be sorted on, just add them after * the comparator parameter when calling this method and the custom arguments will be passed to that method in the * same order. * * The method on which the array needs to be sorted can be static and, in this case, every element for which that * method is called is passed to that method as the first argument, in front of any custom arguments if they are * used. * * You can use your own comparator for the comparison of return values for the elements in the array, but the * default comparators, such as `CComparator::ORDER_ASC` and `CComparator::ORDER_DESC`, have got you covered when * sorting by scalar values, such as `string`, `int`, `float`, and `bool` in the ascending or descending order * respectively. And the default comparators are smart enough to know how to compare objects of those classes that * conform to the IEqualityAndOrder interface (static or not), including CArray and CMap. See the * [CComparator](CComparator.html) class for more on this. * * @param array $array The array to be sorted. * @param string $onMethodName The name of the method on which the elements are to be sorted. * @param callable $comparator **OPTIONAL. Default is** `CComparator::ORDER_ASC`. The function or method to be * used for the comparison of any two return values. If this parameter is provided, the comparator should take two * parameters, which are the return values for the two elements being compared, and return `-1` if the first * element needs to go before the second element in the sorted array, `1` if the other way around, and `0` if the * two elements are considered equal based on the return values. * * @return void * * @link CComparator.html CComparator */ public static function sortOn($array, $onMethodName, $comparator = CComparator::ORDER_ASC) { assert('is_carray($array) && is_cstring($onMethodName) && is_callable($comparator)', vs(isset($this), get_defined_vars())); $array = splarray($array); static $s_methodArgsStartPos = 3; $methodArgs = func_num_args() == $s_methodArgsStartPos ? [] : array_slice(func_get_args(), $s_methodArgsStartPos); $useComparator = function ($element0, $element1) use($onMethodName, $comparator, $methodArgs) { $className; $typeIsNonScalar = phred_classify_duo($element0, $element1, $className); if (CDebug::isDebugModeOn()) { // Except for a few special cases, any two elements being compared must be objects of the same // class. assert('$typeIsNonScalar', vs(isset($this), get_defined_vars())); $className0; $className1; phred_classify($element0, $className0); phred_classify($element1, $className1); assert('CString::equals($className0, $className1)', vs(isset($this), get_defined_vars())); } $reflClass = new ReflectionClass($className); assert('$reflClass->hasMethod($onMethodName)', vs(isset($this), get_defined_vars())); $reflMethod = $reflClass->getMethod($onMethodName); assert('$reflMethod->isPublic()', vs(isset($this), get_defined_vars())); $methodInvokeRes0; $methodInvokeRes1; if (!$reflMethod->isStatic()) { if (empty($methodArgs)) { $methodInvokeRes0 = $reflMethod->invoke($element0); $methodInvokeRes1 = $reflMethod->invoke($element1); } else { $methodInvokeRes0 = $reflMethod->invokeArgs($element0, $methodArgs); $methodInvokeRes1 = $reflMethod->invokeArgs($element1, $methodArgs); } } else { if (empty($methodArgs)) { $methodInvokeRes0 = $reflMethod->invoke(null, $element0); $methodInvokeRes1 = $reflMethod->invoke(null, $element1); } else { $methodInvokeRes0 = $reflMethod->invokeArgs(null, $element0, $methodArgs); $methodInvokeRes1 = $reflMethod->invokeArgs(null, $element1, $methodArgs); } } return call_user_func($comparator, $methodInvokeRes0, $methodInvokeRes1); }; self::sort($array, $useComparator); }
/** * @ignore */ public static function initializeFramework() { $currEnv; if (!$GLOBALS["PHRED_TESTS"]) { // Try to get the name of the environment in which the application is currently running without the risk of // encountering an error or triggering an assertion, which could otherwise reveal sensitive debugging // information if "display_errors" happens to be enabled in php.ini. $appConfigFp = $GLOBALS["PHRED_PATH_TO_APP"] . "/Configuration" . "/Application.json"; if (file_exists($appConfigFp)) { $appConfig = file_get_contents($appConfigFp); if (is_string($appConfig)) { $matches; $res = preg_match("/^\\h*\"environment\"\\s*:\\s*\"(\\w+)\"/m", $appConfig, $matches); if ($res === 1) { $currEnv = $matches[1]; } } } } else { $currEnv = "tst"; } if (isset($currEnv)) { // Based on the current environment, set some debugging options to temporary values for the time while the // configuration is not yet read. if (strcasecmp($currEnv, "dev") == 0) { // Development. ini_set("display_errors", "On"); CDebug::setAssertionsLevel1(true); CDebug::setAssertionsLevel2(false); } else { if (strcasecmp($currEnv, "pro") == 0) { // Production. ini_set("display_errors", "Off"); CDebug::setAssertionsLevel1(false); CDebug::setAssertionsLevel2(false); } else { if (strcasecmp($currEnv, "tst") == 0) { // Testing. ini_set("display_errors", "On"); CDebug::setAssertionsLevel1(true); CDebug::setAssertionsLevel2(true); } else { // Unknown environment. error_reporting(E_ALL); ini_set("display_errors", "On"); } } } } else { error_reporting(E_ALL); ini_set("display_errors", "On"); trigger_error("Could not read the name of the current environment.", E_USER_ERROR); } // Read all the configuration options. CConfiguration::initialize(); // Set whether error messages should be shown is the output. if (CConfiguration::option("debug.displayErrors")) { ini_set("display_errors", "On"); } else { ini_set("display_errors", "Off"); } // Set the error reporting level. $errorReportingLevel = constant(CConfiguration::option("debug.errorReportingLevel")); error_reporting($errorReportingLevel); // Process the configuration options that are related to debugging. $debug = CConfiguration::option("debug"); // Assertions and the conditions on which they get active. $assertionsAreActive = false; $assertionsAreEnabled = $debug["enableAssertions"]; if ($assertionsAreEnabled) { $assertionsAreActiveBasedOn = $debug["assertionsAreActiveBasedOn"]; if (CString::equalsCi($assertionsAreActiveBasedOn, "always")) { // Always. $assertionsAreActive = true; } else { // Reference time zone. $refTimeZone; $timeZoneName = $debug["referenceTimeZone"]; if (!CString::isEmpty($timeZoneName)) { $refTimeZone = new CTimeZone($timeZoneName); } else { $refTimeZone = CTimeZone::makeUtc(); } if (CString::equalsCi($assertionsAreActiveBasedOn, "hour")) { // Current time. $currTime = CTime::now(); // Hour. $hourRanges = $debug["assertionsAreActiveWithinHourRange"]; $currHour = $currTime->hourInTimeZone($refTimeZone); if (!is_carray($hourRanges[0])) { $hourRanges = CArray::fromElements($hourRanges); } $len = CArray::length($hourRanges); for ($i = 0; $i < $len; $i++) { $range = $hourRanges[$i]; assert('is_int($range[0]) && is_int($range[1])', vs(isset($this), get_defined_vars())); if ($range[0] <= $currHour && $currHour <= $range[1]) { $assertionsAreActive = true; break; } } } else { if (CString::equalsCi($assertionsAreActiveBasedOn, "dayOfWeek")) { // Current time. $currTime = CTime::now(); // Day of week. $daysOfWeek = $debug["assertionsAreActiveOnDaysOfWeek"]; if (!is_carray($daysOfWeek)) { $daysOfWeek = CArray::fromElements($daysOfWeek); } $currDayOfWeek = $currTime->dayOfWeekInTimeZone($refTimeZone); $currDayOfWeekShort; switch ($currDayOfWeek) { case CTime::SUNDAY: $currDayOfWeekShort = "sun"; break; case CTime::MONDAY: $currDayOfWeekShort = "mon"; break; case CTime::TUESDAY: $currDayOfWeekShort = "tue"; break; case CTime::WEDNESDAY: $currDayOfWeekShort = "wed"; break; case CTime::THURSDAY: $currDayOfWeekShort = "thu"; break; case CTime::FRIDAY: $currDayOfWeekShort = "fri"; break; case CTime::SATURDAY: $currDayOfWeekShort = "sat"; break; } $len = CArray::length($daysOfWeek); for ($i = 0; $i < $len; $i++) { $dow = $daysOfWeek[$i]; assert('!CString::isEmpty($dow)', vs(isset($this), get_defined_vars())); if (CString::equalsCi($currDayOfWeekShort, $dow)) { $assertionsAreActive = true; break; } } } else { if (CString::equalsCi($assertionsAreActiveBasedOn, "dayOfYear")) { // Day of year. $multiplier = $debug["assertionsAreActiveOnEveryDayOfYearMultipleOf"]; assert('is_int($multiplier)', vs(isset($this), get_defined_vars())); $currDayOfYear = CTime::currentDayOfYearInTimeZone($refTimeZone); if ($currDayOfYear % $multiplier == 0) { $assertionsAreActive = true; } } else { assert('false', vs(isset($this), get_defined_vars())); } } } } } if ($assertionsAreActive) { // Enable level 1 assertions. CDebug::setAssertionsLevel1(true); $enableAssertionsLevel2 = $debug["enableAssertionsLevel2"]; if ($enableAssertionsLevel2) { // Enable level 2 assertions. CDebug::setAssertionsLevel2(true); } } else { CDebug::setAssertionsLevel1(false); CDebug::setAssertionsLevel2(false); } // Logging. $logging = $debug["logging"]; $loggingIsEnabled = $logging["enable"]; if ($loggingIsEnabled) { $logFp = $logging["logFilePath"]; assert('!CString::isEmpty($logFp)', vs(isset($this), get_defined_vars())); $logFp = CFilePath::frameworkPath($logFp); CDebug::setLogging($logFp); } // Mailing. $mailing = $debug["mailing"]; $mailingIsEnabled = $mailing["enable"]; if ($mailingIsEnabled) { $adminMail = CConfiguration::option("admin.mail"); $to = $adminMail["to"]; $from = $adminMail["from"]; $transport = $adminMail["transport"]; assert('!CString::isEmpty($to) && !CString::isEmpty($from) && !CString::isEmpty($transport)', vs(isset($this), get_defined_vars())); $minTimeBetweenSendMailHours = $mailing["minTimeBetweenSendMailHours"]; assert('is_int($minTimeBetweenSendMailHours)', vs(isset($this), get_defined_vars())); $mail; if (CString::equalsCi($transport, "smtp")) { $smtpOutgoingServer = $adminMail["smtpOutgoingServer"]; $smtpUsername = $adminMail["smtpUsername"]; $smtpPassword = $adminMail["smtpPassword"]; assert('!CString::isEmpty($smtpOutgoingServer) && !CString::isEmpty($smtpUsername) && ' . '!CString::isEmpty($smtpPassword)', vs(isset($this), get_defined_vars())); $mail = CMail::makeSmtp($smtpOutgoingServer, $smtpUsername, $smtpPassword, $from, $to); } else { if (CString::equalsCi($transport, "system")) { $mail = CMail::makeSystem($from, $to); } else { assert('false', vs(isset($this), get_defined_vars())); } } CDebug::setMailing($mail, $minTimeBetweenSendMailHours); } }
/** * Determines the order in which two values should appear in a place where it matters, assuming the ascending * order. * * If the values are objects of your custom class, the class should conform to the * [IEqualityAndOrder](IEqualityAndOrder.html) interface. * * @param mixed $value0 The first value for comparison. * @param mixed $value1 The second value for comparison. * * @return int A negative value (typically `-1`) if the first value should go before the second value, a positive * value (typically `1`) if the other way around, and `0` if the two values are equal. * * @link IEqualityAndOrder.html IEqualityAndOrder */ public static function orderAsc($value0, $value1) { if (CDebug::isDebugModeOn()) { if (!(is_cstring($value0) && is_cstring($value1) || is_carray($value0) && is_carray($value1) || is_cmap($value0) && is_cmap($value1))) { // With the above exceptions, the two values should be both either scalars or objects of the same // class. assert('is_object($value0) == is_object($value1)', vs(isset($this), get_defined_vars())); assert('!is_object($value0) || CString::equals(get_class($value0), get_class($value1))', vs(isset($this), get_defined_vars())); } } $className; if (!phred_classify_duo($value0, $value1, $className)) { // Compare the values as scalars. assert('(is_scalar($value0) || is_null($value0)) && (is_scalar($value1) || is_null($value1))', vs(isset($this), get_defined_vars())); return $value0 === $value1 ? 0 : ($value0 < $value1 ? -1 : 1); } else { // Compare the values as objects that may conform to one of the comparison interfaces. $reflClass = new ReflectionClass($className); if ($reflClass->implementsInterface("IEqualityAndOrderStatic")) { $res = call_user_func([$className, "compare"], $value0, $value1); assert('is_int($res)', vs(isset($this), get_defined_vars())); return $res; } if ($reflClass->implementsInterface("IEqualityAndOrder")) { $res = call_user_func([$value0, "compare"], $value1); assert('is_int($res)', vs(isset($this), get_defined_vars())); return $res; } // The class of the objects being compared does not implement any applicable comparison interfaces. assert('false', vs(isset($this), get_defined_vars())); } }
/** * Sets the options for an FTP request. * * @param bool $createMissingDirectoriesForUpload Tells whether to try creating missing directories when * uploading a file. * @param bool $appendUpload **OPTIONAL. Default is** `false`. Tells whether the data from the file being * uploaded should be appended to the data of the existing file, if any. * @param array $quoteCommands **OPTIONAL. Default is** *none*. The (S)FTP commands to be run before the transfer. * @param array $postQuoteCommands **OPTIONAL. Default is** *none*. The (S)FTP commands to be run after the * transfer. * @param bool $useEpsv **OPTIONAL. Default is** `true`. Tells whether to use EPSV. * @param string $activeModeBackAddress **OPTIONAL. Default is** *cURL's default*. The client-side address to * which the destination server should try connecting back. * @param bool $useEprt **OPTIONAL. Default is** `true`. Tells whether to use EPRT. * * @return void */ public function setFtpOptions($createMissingDirectoriesForUpload, $appendUpload = false, $quoteCommands = null, $postQuoteCommands = null, $useEpsv = true, $activeModeBackAddress = null, $useEprt = true) { assert('is_bool($createMissingDirectoriesForUpload) && is_bool($appendUpload) && ' . '(!isset($quoteCommands) || is_carray($quoteCommands)) && (!isset($postQuoteCommands) || ' . 'is_carray($postQuoteCommands)) && is_bool($useEpsv) && (!isset($activeModeBackAddress) || ' . 'is_cstring($activeModeBackAddress)) && is_bool($useEprt)', vs(isset($this), get_defined_vars())); assert('$this->isFtp()', vs(isset($this), get_defined_vars())); if (CDebug::isDebugModeOn()) { if (isset($quoteCommands)) { $len = CArray::length($quoteCommands); for ($i = 0; $i < $len; $i++) { assert('is_cstring($quoteCommands[$i])', vs(isset($this), get_defined_vars())); } } if (isset($postQuoteCommands)) { $len = CArray::length($postQuoteCommands); for ($i = 0; $i < $len; $i++) { assert('is_cstring($postQuoteCommands[$i])', vs(isset($this), get_defined_vars())); } } } $this->m_ftpCreateMissingDirectoriesForUpload = $createMissingDirectoriesForUpload; $this->m_ftpAppendUpload = $appendUpload; $this->m_ftpQuoteCommands = $quoteCommands; $this->m_ftpPostQuoteCommands = $postQuoteCommands; $this->m_ftpUseEpsv = $useEpsv; $this->m_ftpActiveModeBackAddress = $activeModeBackAddress; $this->m_ftpUseEprt = $useEprt; }
public static function setMailing(CMail $mail, $minTimeBetweenSendMailHours = self::DEFAULT_MIN_TIME_BETWEEN_SEND_MAIL_HOURS) { // Enables mailing about encountered errors with the provided CMail object. assert('is_int($minTimeBetweenSendMailHours)', vs(isset($this), get_defined_vars())); assert('$minTimeBetweenSendMailHours >= 0', vs(isset($this), get_defined_vars())); self::$ms_mailing = true; self::$ms_mail = $mail; self::$ms_minTimeBetweenSendMailHours = $minTimeBetweenSendMailHours; self::registerHandlers(); }
public function query($sSQL, $sNombreTabla = "") { $sDbType = $this->_sType; $arTabla = array(); switch ($sDbType) { case "mysql": $arTabla = $this->query_mysql($sSQL, $sNombreTabla); break; case "sqlserver": $arTabla = $this->query_mssql($sSQL, $sNombreTabla); default: break; } CDebug::set_sql($sSQL, count($sSQL)); return $arTabla; }
/** * Adds a field to a URL query. * * Query strings allow for field values to be arrays and maps that can contain not only strings but also other * arrays and maps, and so on. If the field's value is a string, the characters in it should be represented * literally and no characters should be percent-encoded. * * @param string $fieldName The name of the field. The characters in the string should be represented literally * and no characters should be percent-encoded. * @param mixed $value The value of the field. This can be a string (the most common case), a `bool`, an `int`, a * `float`, an array, or a map. * * @return void */ public function addField($fieldName, $value) { assert('is_cstring($fieldName) && (is_cstring($value) || ' . 'is_bool($value) || is_int($value) || is_float($value) || is_collection($value))', vs(isset($this), get_defined_vars())); if (CDebug::isDebugModeOn()) { self::recurseFieldValidation($value, 0); } $this->m_query[$fieldName] = $value; }
/** * Encodes the map or array provided earlier to the encoder into a JSON string and returns it. * * @return CUStringObject The resulting JSON string. */ public function encode() { assert('is_cmap($this->m_source) || is_carray($this->m_source)', vs(isset($this), get_defined_vars())); $source = $this->m_source; if (CDebug::assertionsLevel2()) { // Check character encodings in string values. self::recurseStringValidation($source, 0); } $source = self::recurseValueBeforeEncoding($source, 0); $options = 0; if (!$this->m_escapeNonAsciiChars) { $options |= JSON_UNESCAPED_UNICODE; } if (!$this->m_escapeForwardSlashes) { $options |= JSON_UNESCAPED_SLASHES; } if ($this->m_escapeAngleBrackets) { $options |= JSON_HEX_TAG; } if ($this->m_escapeAmpersands) { $options |= JSON_HEX_AMP; } if ($this->m_escapeSingleQuotes) { $options |= JSON_HEX_APOS; } if ($this->m_escapeDoubleQuotes) { $options |= JSON_HEX_QUOT; } if ($this->m_prettyPrint) { $options |= JSON_PRETTY_PRINT; } $encodedValue = json_encode($source, $options, self::$ms_maxRecursionDepth); assert('is_cstring($encodedValue) && !CString::isEmpty($encodedValue)', vs(isset($this), get_defined_vars())); return $encodedValue; }