public function Resize($image, $newWidth, $targetName) { if (!file_exists(PUBLIC_ROOT . $image)) { $image = '/assets/images/not-found.gif'; } $imgInfo = getimagesize(PUBLIC_ROOT . $image); $oldWidth = $imgInfo[0]; $oldHeight = $imgInfo[1]; $changeRatio = $oldWidth / $newWidth; $newHeight = round($oldHeight / $changeRatio); $newImage = imagecreatetruecolor($newWidth, $newHeight); $source = $this->load(PUBLIC_ROOT . $image); if ($this->imageType == IMAGETYPE_PNG) { imagealphablending($newImage, false); imagesavealpha($newImage, true); $transparent = imagecolorallocatealpha($newImage, 255, 255, 255, 127); imagefilledrectangle($newImage, 0, 0, $newWidth, $newHeight, $transparent); } imagecopyresampled($newImage, $this->image, 0, 0, 0, 0, $newWidth, $newHeight, $oldWidth, $oldHeight); header('Content-Type: image/jpeg'); imagejpeg($newImage, $targetName, 100); Debugger::debug($targetName, 'TARGET'); //$this->save($targetName); $this->image = $newImage; imagedestroy($newImage); }
public function processAPI() { Debugger::debug('API_' . ucwords($this->endpoint)); if (class_exists('API_' . ucwords($this->endpoint))) { return $this->_response($this->getResult()); } return $this->_response(array('error' => "Invalid Endpoint: {$this->endpoint}"), 404); }
private static function connect() { try { self::$db = new \PDO('mysql:host=' . self::$dbHost . ';dbname=' . self::$dbName . ';charset=utf8', self::$dbUser, self::$dbPass); self::$db->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION); } catch (PDOException $e) { Debugger::debug('error'); Errors::handle($e, 'sqlerr'); } }
public function curlCall($endpoint, $curlPostData = null) { $curl = curl_init(REST_URL . $endpoint); curl_setopt($curl, CURLOPT_RETURNTRANSFER, true); Debugger::debug($endpoint, '$endpoint'); Debugger::debug($curlPostData, '$curlPostData'); if (!empty($curlPostData)) { Debugger::debug('adding post'); curl_setopt($curl, CURLOPT_POST, true); curl_setopt($curl, CURLOPT_POSTFIELDS, $curlPostData); } $curlResponse = curl_exec($curl); curl_close($curl); Debugger::debug($curlResponse, 'CURL response'); return $curlResponse; }
public function create($params = null) { $result = new API_Response(); if (!empty($_POST)) { $user = new User(); $userId = $user->create($_POST['username'], $_POST['email'], $_POST['password'], $_POST['gender'], $_POST['postcode']); //$valid = false; //echo gettype($userId); \Debugger::debug($userId, 'user id'); if ($userId) { $result->addItem('message', 'User id ' . $userId . ' inserted'); $result->addItem('userId', $userId); $result->addItem('success', true); } else { $result->addItem('message', 'User id inserted'); $result->addItem('success', false); } } else { $result->addItem('message', 'POST missing'); $result->addItem('success', false); } return $result->getResult(); }
/** * Parse a BBCode string and convert it into HTML. * * Core parser. This is where all the magic begins and ends. * Core parsing routine. Call with a BBCode string, and it returns an HTML string. * * @param string $string The BBCode string to parse. * @return string Returns the HTML version of {@link $string}. */ public function parse($string) { Debugger::debug("<b>Parse Begin:</b> input string is " . strlen($string) . " characters long:<br>\n" . "<b>Parse:</b> input: <tt>" . htmlspecialchars(addcslashes($string, "..\\\"'")) . "</tt><br>\n"); // The lexer is responsible for converting individual characters to tokens, // and uses preg_split to do most of its magic. Because it uses preg_split // and not a character-by-character tokenizer, the structure of the input // must be known in advance, which is why the tag marker cannot be changed // during the parse. $this->lexer = new BBCodeLexer($string, $this->tag_marker); $this->lexer->debug = $this->debug; // If we're fuzzily limiting the text length, see if we need to actually // cut it off, or if it's close enough to not be worth the effort. $old_output_limit = $this->output_limit; Debugger::debug("weee"); if ($this->output_limit > 0) { if ($this->debug) { Debugger::debug("<b>Parse:</b> Limiting text length to {$this->output_limit}.<br>\n"); } if (strlen($string) < $this->output_limit) { // Easy case: A short string can't possibly be longer than the output // limit, so just turn off the output limit. $this->output_limit = 0; if ($this->debug) { Debugger::debug("<b>Parse:</b> Not bothering to limit: Text is too short already.<br>\n"); } } else { if ($this->limit_precision > 0) { // We're using fuzzy precision, so make a guess as to how long the text is, // and then decide whether we can let this string slide through based on the // limit precision. $guess_length = $this->lexer->guessTextLength(); if ($this->debug) { Debugger::debug("<b>Parse:</b> Maybe not: Fuzzy limiting enabled, and approximate text length is {$guess_length}.<br>\n"); } if ($guess_length < $this->output_limit * ($this->limit_precision + 1.0)) { if ($this->debug) { Debugger::debug("<b>Parse:</b> Not limiting text; it's close enough to the limit to be acceptable.<br>\n"); } $this->output_limit = 0; } else { if ($this->debug) { Debugger::debug("<b>Parse:</b> Limiting text; it's definitely too long.<br>\n"); } } } } } // The token stack is used to perform a document-tree walk without actually // building the document tree, and is an essential component of our input- // validation algorithm. $this->stack = []; // There are no start tags (yet). $this->start_tags = []; // There are no unmatched start tags (yet). $this->lost_start_tags = []; // There is no text yet. $this->text_length = 0; $this->was_limited = false; // Remove any initial whitespace in pre-trim mode. if (strlen($this->pre_trim) > 0) { $this->cleanupWSByEatingInput($this->pre_trim); } // In plain mode, we generate newlines instead of <br> tags. $newline = $this->plain_mode ? "\n" : "<br>\n"; Debugger::debug("hi"); // This is a fairly straightforward push-down automaton operating in LL(1) mode. For // clarity's sake, we break the tag-processing code into separate functions, but we // keep the text/whitespace/newline code here for performance reasons. while (true) { if (($token_type = $this->lexer->nextToken()) == self::BBCODE_EOI) { break; } if ($this->debug) { Debugger::debug("<b>Parse:</b> Stack contents: <tt>" . $this->dumpStack() . "</tt><br>\n"); } switch ($token_type) { case self::BBCODE_TEXT: // Text is like an arithmetic operand, so just push it onto the stack because we // won't know what to do with it until we reach an operator (e.g., a tag or EOI). if ($this->debug) { Debugger::debug("<hr />\n<b>Internal_ParseTextToken:</b> fixup and push text: <tt>" . htmlspecialchars($this->lexer->text) . "</tt><br>\n"); } // If this token pushes us past the output limit, split it up on a whitespace // boundary, add as much as we can, and then abort. if ($this->output_limit > 0 && $this->text_length + strlen($this->lexer->text) >= $this->output_limit) { $text = $this->limitText($this->lexer->text, $this->output_limit - $this->text_length); if (strlen($text) > 0) { $this->text_length += strlen($text); $this->stack[] = array(self::BBCODE_STACK_TOKEN => self::BBCODE_TEXT, self::BBCODE_STACK_TEXT => $this->fixupOutput($text), self::BBCODE_STACK_TAG => false, self::BBCODE_STACK_CLASS => $this->current_class); } $this->doLimit(); break 2; } $this->text_length += strlen($this->lexer->text); // Push this text token onto the stack. $this->stack[] = array(self::BBCODE_STACK_TOKEN => self::BBCODE_TEXT, self::BBCODE_STACK_TEXT => $this->fixupOutput($this->lexer->text), self::BBCODE_STACK_TAG => false, self::BBCODE_STACK_CLASS => $this->current_class); break; case self::BBCODE_WS: // Whitespace is like an operand too, so just push it onto the stack, but // sanitize it by removing all non-tab non-space characters. if ($this->debug) { Debugger::debug("<hr />\n<b>Internal_ParseWhitespaceToken:</b> fixup and push whitespace<br>\n"); } // If this token pushes us past the output limit, don't process anything further. if ($this->output_limit > 0 && $this->text_length + strlen($this->lexer->text) >= $this->output_limit) { $this->doLimit(); break 2; } $this->text_length += strlen($this->lexer->text); // Push this whitespace onto the stack. $this->stack[] = array(self::BBCODE_STACK_TOKEN => self::BBCODE_WS, self::BBCODE_STACK_TEXT => $this->lexer->text, self::BBCODE_STACK_TAG => false, self::BBCODE_STACK_CLASS => $this->current_class); break; case self::BBCODE_NL: // Newlines are really like tags in disguise: They insert a replaced // element into the output, and are actually more-or-less like plain text. if ($this->debug) { Debugger::debug("<hr />\n<b>Internal_ParseNewlineToken:</b> got a newline.<br>\n"); } if ($this->ignore_newlines) { if ($this->debug) { Debugger::debug("<b>Internal_ParseNewlineToken:</b> push newline as whitespace.<br>\n"); } // If this token pushes us past the output limit, don't process anything further. if ($this->output_limit > 0 && $this->text_length + 1 >= $this->output_limit) { $this->doLimit(); break 2; } $this->text_length += 1; // In $ignore_newlines mode, we simply push the newline as whitespace. // Note that this can yield output that's slightly different than the // input: For example, a "\r\n" input will produce a "\n" output; but // this should still be acceptable, since we're working with text, not // binary data. $this->stack[] = array(self::BBCODE_STACK_TOKEN => self::BBCODE_WS, self::BBCODE_STACK_TEXT => "\n", self::BBCODE_STACK_TAG => false, self::BBCODE_STACK_CLASS => $this->current_class); } else { // Any whitespace before a newline isn't worth outputting, so if there's // whitespace sitting on top of the stack, remove it so that it doesn't // get outputted. $this->cleanupWSByPoppingStack("s", $this->stack); if ($this->debug) { Debugger::debug("<b>Internal_ParseNewlineToken:</b> push newline.<br>\n"); } // If this token pushes us past the output limit, don't process anything further. if ($this->output_limit > 0 && $this->text_length + 1 >= $this->output_limit) { $this->doLimit(); break 2; } $this->text_length += 1; // Add the newline to the stack. $this->stack[] = array(self::BBCODE_STACK_TOKEN => self::BBCODE_NL, self::BBCODE_STACK_TEXT => $newline, self::BBCODE_STACK_TAG => false, self::BBCODE_STACK_CLASS => $this->current_class); // Any whitespace after a newline is meaningless, so if there's whitespace // lingering on the input after this, remove it now. $this->cleanupWSByEatingInput("s"); } break; case self::BBCODE_TAG: // Use a separate function to handle tags, because they're complicated. $this->parseStartTagToken(); break; case self::BBCODE_ENDTAG: // Use a separate function to handle end tags, because they're complicated. $this->parseEndTagToken(); break; default: break; } } if ($this->debug) { Debugger::debug("<hr />\n<b>Parse Done:</b> done main parse; packing stack as text string.<br>\n"); } // Remove any trailing whitespace in post-trim mode. if (strlen($this->post_trim) > 0) { $this->cleanupWSByPoppingStack($this->post_trim, $this->stack); } // Everything left on the stack should be HTML (or broken tags), so pop it // all off as plain text, concatenate it, and return it. $result = $this->generateOutput(0); $result = $this->collectTextReverse($result, count($result) - 1); // If we changed the limit (in fuzzy-limit mode), set it back. $this->output_limit = $old_output_limit; // In plain mode, we do just a *little* more cleanup on the whitespace to shorten // the output as much as possible. if ($this->plain_mode) { // Turn all non-newline whitespace characters into single spaces. $result = preg_replace("/[\\x00-\\x09\\x0B-\\x20]+/", " ", $result); // Turn multiple newlines into at most two newlines. $result = preg_replace("/(?:[\\x20]*\\n){2,}[\\x20]*/", "\n\n", $result); // Strip off all surrounding whitespace. $result = trim($result); } if ($this->debug) { Debugger::debug("<b>Parse:</b> return: <tt>" . htmlspecialchars(addcslashes($result, "..\\\"'")) . "</tt><br>\n"); } return $result; }
public function load404() { global $module, $page; $module = '404'; $page = '404'; $e = new Exception('directing to 404'); Debugger::debug('dump', 'REDIRECT', null, true); return '404'; //Redirect::handle('/' . ((Site::isAdmin()) ? 'admin/' : '') . '404'); }
/** * Format a [url] tag by producing an <a>...</a> element. * * The URL only allows http, https, mailto, and ftp protocols for safety. * * @param BBCode $bbcode The {@link BBCode} object doing the parsing. * @param int $action The current action being performed on the tag. * @param string $name The name of the tag. * @param string $default The default value passed to the tag in the form: `[tag=default]`. * @param array $params All of the parameters passed to the tag. * @param string $content The content of the tag. Only available when {@link $action} is **BBCODE_OUTPUT**. * @return string Returns the full HTML url. */ public function doURL(BBCode $bbcode, $action, $name, $default, $params, $content) { // We can't check this with BBCODE_CHECK because we may have no URL // before the content has been processed. if ($action == BBCode::BBCODE_CHECK) { return true; } $url = is_string($default) ? $default : $bbcode->unHTMLEncode(strip_tags($content)); if ($bbcode->isValidURL($url)) { if ($bbcode->debug) { Debugger::debug('ISVALIDURL'); } if ($bbcode->getURLTargetable() !== false && isset($params['target'])) { $target = ' target="' . htmlspecialchars($params['target']) . '"'; } else { $target = ''; } if ($bbcode->getURLTarget() !== false && empty($target)) { $target = ' target="' . htmlspecialchars($bbcode->getURLTarget()) . '"'; } // If $detect_urls is on, it's possble the $content is already // enclosed in an <a href> tag. Remove that if that is the case. $content = preg_replace('/^\\<a [^\\>]*\\>(.*?)<\\/a>$/', "\\1", $content); return $bbcode->fillTemplate($bbcode->getURLTemplate(), array("url" => $url, "target" => $target, "content" => $content)); } else { return htmlspecialchars($params['_tag']) . $content . htmlspecialchars($params['_endtag']); } }
require_once "classes/Debugger.php"; require_once "classes/SignupGadget.php"; require_once "classes/CommonTools.php"; /* Implementations of the most critical classes */ $configurations = new Configurations(); $page = new Page(1); $debugger = new Debugger(); $database = new Database(); /* The code */ $signupGadgets = new SignupGadgets(); // Check if the search was performed $searchString = CommonTools::GET('search'); $year = CommonTools::GET('year'); // Is the search performed? if ($searchString != null && $searchString != "") { $debugger->debug("Searching signup gadgets using search string {$searchString}", "index.php"); $signupGadgets->selectSearchSignupGadget($searchString); } else { if ($year != null && $year != "") { $signupGadgets->selectSignupGadgetsByYear($year); } else { $signupGadgets->selectOpenGadgetsOrClosedDuringLastDays(7); } } // Get all selected gadgets to array $signupGadgets_array = $signupGadgets->getSignupGadgets(); // Print table headers $page->addContent("<table id=\"signup-gadgets\">"); $page->addContent("<tr id=\"signup-header-row\">"); $page->addContent("<th id=\"signup-name-header\">Ilmo</th><th>Avautuu</th><th>Sulkeutuu</th><th>Tila</th><th>Muokkaa</th><th>Poista</th><th>Muuta tilaa</th>"); $page->addContent("</tr>");
} else { if ($action == "continueandcancelold") { $user = new User($signupid); $user->cancelUnconfirmedSignupAndRefreshSession(); header("Location: " . $configurations->webRoot . "confirm/" . $user->getNewSignupId()); } else { // Check that signup is open $newSignupGadget = new SignupGadget($signupid); $user = null; if ($newSignupGadget->isOpen()) { $user = new User($signupid); } else { $debugger->error("Ilmoittautuminen ei ole avoinna.", "queue.php"); } if ($user->getUnconfirmedSignupExists()) { $debugger->debug("Unconfirmed signup exists", "queue.php"); if ($user->getUnconfirmedSignupIsNotTheSameAsThis()) { $debugger->debug("Unconfirmed signup exists, but it is not this one", "queue.php"); $signupgadget = new SignupGadget($user->getOldSignupId()); $page->addContent("<p><b>Huom!</b> Olet ilmoittautunut jo ilmomasiinassa <b>" . $signupgadget->getTitle() . "</b>, muttet ole vahvistanut ilmoittautumista. " . "Ennen kuin voit ilmoittautua toiseen ilmomasiinaan sinun pitää vahvistaa tai peruuttaa" . " aikasemmat vahvistamattomat ilmoittautumiset.</p>"); $page->addContent("<p>Valitse mitä haluat tehdä:</p>"); $page->addContent("<p> >> <a href=\"" . $configurations->webRoot . "continueandcancelold/" . $user->getNewSignupId() . "\">Peruuta aiempi vahvistamaton ilmoittautuminen ja " . "siirry eteenpäin</a></p>"); $page->addContent("<p> >> <a href=\"" . $configurations->webRoot . "confirmold/" . $user->getOldSignupId() . "\">Siirry vahvistamaan aiempi ilmoittautuminen</a></p>"); $page->printPage(); } else { header("Location: " . $configurations->webRoot . "confirm/" . $user->getNewSignupId()); } } else { header("Location: " . $configurations->webRoot . "confirm/" . $user->getNewSignupId()); } }
/** * Given a string containing a complete [tag] (including its brackets), break it down into its components and return them as an array. * * @param string $tag The tag to decode. * @return array Returns the array representation of the tag. */ protected function decodeTag($tag) { Debugger::debug("<b>Lexer::InternalDecodeTag:</b> input: " . htmlspecialchars($tag) . "<br />\n"); // Create the initial result object. $result = ['_tag' => $tag, '_endtag' => '', '_name' => '', '_hasend' => false, '_end' => false, '_default' => false]; // Strip off the [brackets] around the tag, leaving just its content. $tag = substr($tag, 1, strlen($tag) - 2); // The starting bracket *must* be followed by a non-whitespace character. $ch = ord(substr($tag, 0, 1)); if ($ch >= 0 && $ch <= 32) { return $result; } // Break it apart into words, quoted text, whitespace, and equal signs. $pieces = preg_split("/(\\\"[^\\\"]+\\\"|\\'[^\\']+\\'|=|[\\x00-\\x20]+)/", $tag, -1, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY); $ptr = 0; // Handle malformed (empty) tags correctly. if (count($pieces) < 1) { return $result; } // The first piece should be the tag name, whatever it is. If it starts with a / // we remove the / and mark it as an end tag. if (!empty($pieces[$ptr]) && substr($pieces[$ptr], 0, 1) === '/') { $result['_name'] = strtolower(substr($pieces[$ptr++], 1)); $result['_end'] = true; } else { $result['_name'] = strtolower($pieces[$ptr++]); $result['_end'] = false; } // Skip whitespace after the tag name. while (($type = $this->classifyPiece($ptr, $pieces)) == ' ') { $ptr++; } $params = []; // If the next piece is an equal sign, then the tag's default value follows. if ($type != '=') { $result['_default'] = false; $params[] = ['key' => '', 'value' => '']; } else { $ptr++; // Skip whitespace after the initial equal-sign. while (($type = $this->classifyPiece($ptr, $pieces)) == ' ') { $ptr++; } // Examine the next (real) piece, and see if it's quoted; if not, we need to // use heuristics to guess where the default value begins and ends. if ($type == "\"") { $value = $this->stripQuotes($pieces[$ptr++]); } else { // Collect pieces going forward until we reach an = sign or the end of the // tag; then rewind before whatever comes before the = sign, and everything // between here and there becomes the default value. This allows tags like // [font=Times New Roman size=4] to make sense even though the font name is // not quoted. Note, however, that there's a special initial case, where // any equal-signs before whitespace are considered to be part of the parameter // as well; this allows an ugly tag like [url=http://foo?bar=baz target=my_window] // to behave in a way that makes (tolerable) sense. $after_space = false; $start = $ptr; while (($type = $this->classifyPiece($ptr, $pieces)) != -1) { if ($type == ' ') { $after_space = true; } if ($type == '=' && $after_space) { break; } $ptr++; } if ($type == -1) { $ptr--; } // We've now found the first (appropriate) equal-sign after the start of the // default value. (In the example above, that's the "=" after "target".) We // now have to rewind back to the last whitespace to find where the default // value ended. if ($type == '=') { // Rewind before = sign. $ptr--; // Rewind before any whitespace before = sign. while ($ptr > $start && $this->classifyPiece($ptr, $pieces) == ' ') { $ptr--; } // Rewind before any text elements before that. while ($ptr > $start && $this->classifyPiece($ptr, $pieces) != ' ') { $ptr--; } } // The default value is everything from $start to $ptr, inclusive. $value = ""; for (; $start <= $ptr; $start++) { if ($this->classifyPiece($start, $pieces) == ' ') { $value .= " "; } else { $value .= $this->stripQuotes($pieces[$start]); } } $value = trim($value); $ptr++; } $result['_default'] = $value; $params[] = ['key' => '', 'value' => $value]; } // The rest of the tag is composed of either floating keys or key=value pairs, so walk through // the tag and collect them all. Again, we have the nasty special case where an equal sign // in a parameter but before whitespace counts as part of that parameter. while (($type = $this->classifyPiece($ptr, $pieces)) != -1) { // Skip whitespace before the next key name. while ($type === ' ') { $ptr++; $type = $this->classifyPiece($ptr, $pieces); } // Decode the key name. if ($type === 'A' || $type === '"') { if (isset($pieces[$ptr])) { $key = strtolower($this->stripQuotes($pieces[$ptr])); } else { $key = ''; } $ptr++; } elseif ($type === '=') { $ptr++; continue; } elseif ($type === -1) { break; } // Skip whitespace after the key name. while (($type = $this->classifyPiece($ptr, $pieces)) == ' ') { $ptr++; } // If an equal-sign follows, we need to collect a value. Otherwise, we // take the key itself as the value. if ($type !== '=') { $value = $this->stripQuotes($key); } else { $ptr++; // Skip whitespace after the equal sign. while (($type = $this->classifyPiece($ptr, $pieces)) == ' ') { $ptr++; } if ($type === '"') { // If we get a quoted value, take that as the only value. $value = $this->stripQuotes($pieces[$ptr++]); } elseif ($type !== -1) { // If we get a non-quoted value, consume non-quoted values // until we reach whitespace. $value = $pieces[$ptr++]; while (($type = $this->classifyPiece($ptr, $pieces)) != -1 && $type != ' ') { $value .= $pieces[$ptr++]; } } else { $value = ""; } } // Record this in the associative array if it's a legal public identifier name. // Legal *public* identifier names must *not* begin with an underscore. if (substr($key, 0, 1) !== '_') { $result[$key] = $value; } // Record this in the parameter list always. $params[] = ['key' => $key, 'value' => $value]; } // Add the parameter list as a member of the associative array. $result['_params'] = $params; // In debugging modes, output the tag as we collected it. Debugger::debug("<b>Lexer::InternalDecodeTag:</b> output: "); Debugger::debug(htmlspecialchars(print_r($result, true)) . "<br />\n"); // Save the resulting parameters, and return the whole shebang. return $result; }
* * 11: Mikko Koski * 12: mikko.koski@tkk.fi * 13: Normaali ruokavalio * 14-0: Tykkään kahvista * 14-1: Tykkään suklaasta * 14-2: Tykkään pähkinästä * 15: Punaviini * ilmo_id: 56 * user_id: 143 * question_ids: 11,12,13,14-0,14-1,14-2,15 */ $signupId = CommonTools::POST("signupid"); $userId = CommonTools::POST("userid"); $user = new User($signupId); $debugger->debug("UserID: " + $userId, "save.php"); $signupGadget = new SignupGadget($signupId); $questions = $signupGadget->getAllQuestions(); $answers = array(); // This is for debugging. It's easy to see from here the variable names that // the form sends $debugger->listDefinedPostAndGetVars("save.php"); foreach ($questions as $question) { $answer = null; // Checkbox is a bit more complicated if ($question->getType() == "checkbox") { $answer = parseCheckboxAnswer($question); } else { $answer = parseNormalAnswer($question); } array_push($answers, $answer);
/** * Debugger Function * * To support a debug in any position of the code, * regardless the possibility of a template engine, * this must be text-based * * @param $mixed * @param $element */ function debug($mixed, $element = '#content') { //TODO: Use Termination function echo Debugger::debug($mixed, $element); exit; }