Datasets:

---

CM

/

codexglue_code2text_php

like 1

[ "public", "function", "registerShortcodes", "(", ")", "{", "if", "(", "!", "function_exists", "(", "'add_shortcode'", ")", ")", "{", "return", ";", "}", "$", "this", "->", "shortcodes", "->", "rewind", "(", ")", ";", "while", "(", "$", "this", "->", "shortcodes", "->", "valid", "(", ")", ")", "{", "$", "shortcode", "=", "$", "this", "->", "shortcodes", "->", "current", "(", ")", ";", "add_shortcode", "(", "$", "shortcode", "->", "getName", "(", ")", ",", "array", "(", "$", "shortcode", ",", "'getCallback'", ")", ")", ";", "$", "this", "->", "shortcodes", "->", "next", "(", ")", ";", "}", "}" ]

[ "Registers", "all", "shortcodes", "added" ]

[ "public", "function", "subscribe", "(", "IObserver", "$", "observer", ")", ":", "IObservable", "{", "if", "(", "!", "\\", "in_array", "(", "$", "observer", ",", "$", "this", "->", "_observers", ",", "true", ")", ")", "{", "$", "this", "->", "_observers", "[", "]", "=", "$", "observer", ";", "}", "return", "$", "this", ";", "}" ]

[ "Subscribe", "a", "new", "observer", "to", "this", "observable", "implementation", "." ]

[ "public", "function", "notify", "(", "$", "extras", "=", "null", ")", ":", "IObservable", "{", "if", "(", "1", "<", "\\", "count", "(", "$", "this", "->", "_cache", ")", ")", "{", "$", "this", "->", "_cache", "[", "]", "=", "$", "extras", ";", "}", "else", "{", "$", "this", "->", "_cache", "=", "$", "extras", ";", "}", "foreach", "(", "$", "this", "->", "_observers", "as", "$", "ob", ")", "{", "$", "ob", "->", "onUpdate", "(", "$", "this", ",", "$", "this", "->", "_cache", ")", ";", "}", "$", "this", "->", "_cache", "=", "[", "]", ";", "return", "$", "this", ";", "}" ]

[ "Notify", "all", "subscribed", "observers" ]

[ "public", "function", "isFirstCall", "(", ")", "{", "if", "(", "!", "$", "this", "->", "stepAction", "&&", "$", "this", "->", "stepCollection", "->", "isFirst", "(", "$", "this", "->", "stepCollectionIterator", "->", "current", "(", ")", ")", ")", "return", "true", ";", "else", "return", "false", ";", "}" ]

[ "checks", "if", "the", "wizard", "is", "first", "time", "called" ]

[ "public", "function", "process", "(", ")", "{", "/* @var $currentStep StepController */", "/* @var $ancestorStep StepController */", "/* @var $descendantStep StepController */", "$", "currentStep", "=", "$", "this", "->", "stepCollectionIterator", "->", "current", "(", ")", ";", "if", "(", "$", "this", "->", "stepAction", "==", "self", "::", "WIZARD_STEP_ACTION_PREV", "&&", "!", "$", "this", "->", "stepCollection", "->", "isFirst", "(", "$", "this", "->", "stepCollectionIterator", "->", "current", "(", ")", ")", ")", "{", "$", "currentStep", "->", "leaveToAncestorStep", "(", ")", ";", "$", "this", "->", "stepCollectionIterator", "->", "previous", "(", ")", ";", "$", "ancestorStep", "=", "$", "this", "->", "stepCollectionIterator", "->", "current", "(", ")", ";", "$", "ancestorStep", "->", "enterFromDescendant", "(", ")", ";", "$", "this", "->", "resultContent", "=", "$", "this", "->", "prepareNextStepView", "(", "$", "ancestorStep", ")", ";", "}", "elseif", "(", "$", "this", "->", "stepAction", "==", "self", "::", "WIZARD_STEP_ACTION_PREV", "&&", "$", "this", "->", "stepCollection", "->", "isFirst", "(", "$", "this", "->", "stepCollectionIterator", "->", "current", "(", ")", ")", ")", "{", "$", "this", "->", "resultContent", "=", "new", "ResponseConfigurator", "(", ")", ";", "}", "if", "(", "$", "this", "->", "stepAction", "==", "self", "::", "WIZARD_STEP_ACTION_NEXT", ")", "{", "$", "currentStep", "->", "preProcess", "(", ")", ";", "if", "(", "$", "currentStep", "->", "process", "(", "$", "currentStep", "->", "standardClosureArguments", "(", ")", ")", ")", "{", "$", "currentStep", "->", "postProcess", "(", ")", ";", "$", "currentStep", "->", "leaveStep", "(", ")", ";", "$", "this", "->", "stepCollectionIterator", "->", "next", "(", ")", ";", "$", "descendantStep", "=", "$", "this", "->", "stepCollectionIterator", "->", "current", "(", ")", ";", "$", "descendantStep", "->", "enterStep", "(", ")", ";", "$", "this", "->", "resultContent", "=", "$", "this", "->", "prepareNextStepView", "(", "$", "descendantStep", ")", ";", "}", "else", "{", "$", "this", "->", "resultContent", "=", "$", "this", "->", "prepareNextStepView", "(", "$", "currentStep", ")", ";", "$", "this", "->", "resultContent", "->", "setVariable", "(", "\"errorMessage\"", ",", "$", "currentStep", "->", "getProcessErrorMessage", "(", ")", ")", ";", "}", "}", "}" ]

[ "processing", "the", "step" ]

[ "private", "function", "createBreadcrumbItems", "(", "StepController", "$", "step", ")", "{", "$", "viewModel", "=", "new", "ViewModel", "(", ")", ";", "$", "viewModel", "->", "setTemplate", "(", "$", "this", "->", "breadcrumbTemplatePath", ")", ";", "$", "viewModel", "->", "setVariable", "(", "\"breadcrumbTitle\"", ",", "$", "step", "->", "getBreadCrumbTitle", "(", ")", ")", ";", "$", "viewModel", "->", "setVariable", "(", "\"stepNumber\"", ",", "$", "step", "->", "getBreadCrumbTitle", "(", ")", ")", ";", "return", "$", "viewModel", ";", "}" ]

[ "generate", "one", "elementView", "for", "the", "breadcrumb", "path" ]

[ "private", "function", "initStepViewModel", "(", ")", "{", "#first start of Wizard", "#load template from first step", "$", "currentStep", "=", "$", "this", "->", "stepCollectionIterator", "->", "current", "(", ")", ";", "$", "isFirstStep", "=", "$", "this", "->", "getSteps", "(", ")", "->", "isFirst", "(", "$", "currentStep", ")", ";", "if", "(", "$", "isFirstStep", ")", "{", "$", "firstStep", "=", "$", "this", "->", "getSteps", "(", ")", "->", "getFirst", "(", ")", ";", "$", "this", "->", "viewModel", "->", "addChild", "(", "$", "firstStep", "->", "getViewModel", "(", ")", ",", "\"wizardContent\"", ")", ";", "$", "firstStepFormName", "=", "$", "firstStep", "->", "getViewModel", "(", ")", "->", "getVariable", "(", "\"formName\"", ",", "false", ")", ";", "if", "(", "empty", "(", "$", "firstStepFormName", ")", ")", "throw", "new", "\\", "Exception", "(", "\"viewModel variable 'formName' must set for Step '\"", ".", "$", "firstStep", "->", "getName", "(", ")", ".", "\"'\"", ")", ";", "}", "if", "(", "!", "(", "$", "this", "->", "prevButtonDisabled", "&&", "$", "isFirstStep", ")", ")", "{", "$", "this", "->", "prevButtonViewModel", "=", "new", "ViewModel", "(", ")", ";", "$", "this", "->", "prevButtonViewModel", "->", "setTemplate", "(", "\"wizard/wizardButton\"", ")", ";", "$", "this", "->", "prevButtonViewModel", "->", "setVariable", "(", "\"stepActionDirection\"", ",", "\"prev\"", ")", ";", "$", "this", "->", "prevButtonViewModel", "->", "setVariable", "(", "\"id\"", ",", "\"prevButton\"", ")", ";", "}", "$", "this", "->", "nextButtonViewModel", "=", "new", "ViewModel", "(", ")", ";", "$", "this", "->", "nextButtonViewModel", "->", "setTemplate", "(", "\"wizard/wizardButton\"", ")", ";", "$", "this", "->", "nextButtonViewModel", "->", "setVariable", "(", "\"stepActionDirection\"", ",", "\"next\"", ")", ";", "$", "this", "->", "nextButtonViewModel", "->", "setVariable", "(", "\"id\"", ",", "\"nextButton\"", ")", ";", "/**\n * creates breadcrumbPath\n */", "$", "stepIterator", "=", "$", "this", "->", "getSteps", "(", ")", "->", "getIterator", "(", ")", ";", "while", "(", "$", "stepIterator", "->", "valid", "(", ")", ")", "{", "$", "view", "=", "$", "this", "->", "createBreadcrumbItems", "(", "$", "stepIterator", "->", "current", "(", ")", ")", ";", "$", "this", "->", "getSteps", "(", ")", "->", "isFirst", "(", "$", "stepIterator", "->", "current", "(", ")", ")", "?", "$", "view", "->", "setVariable", "(", "\"extendCssClass\"", ",", "\"active first\"", ")", ":", "false", ";", "$", "this", "->", "getSteps", "(", ")", "->", "isLast", "(", "$", "stepIterator", "->", "current", "(", ")", ")", "?", "$", "view", "->", "setVariable", "(", "\"extendCssClass\"", ",", "\"last\"", ")", ":", "false", ";", "$", "view", "->", "setVariable", "(", "\"breadcrumbStepName\"", ",", "$", "stepIterator", "->", "current", "(", ")", "->", "getName", "(", ")", ")", ";", "$", "this", "->", "viewModel", "->", "addChild", "(", "$", "view", ",", "\"breadcrumbNavigation\"", ",", "true", ")", ";", "$", "stepIterator", "->", "next", "(", ")", ";", "}", "$", "this", "->", "resultContent", "=", "$", "this", "->", "viewModel", ";", "$", "this", "->", "process", "(", ")", ";", "}" ]

[ "init", "the", "ViewModel", "for", "the", "wizard" ]

[ "private", "function", "toggleStandardWizardButtons", "(", "$", "show", "=", "true", ")", "{", "$", "this", "->", "prevButtonViewModel", "->", "setVariable", "(", "\"btnClass_extend\"", ",", "(", "!", "$", "show", "?", "\"hide\"", ":", "\"\"", ")", ",", "true", ")", ";", "$", "this", "->", "nextButtonViewModel", "->", "setVariable", "(", "\"btnClass_extend\"", ",", "(", "!", "$", "show", "?", "\"hide\"", ":", "\"\"", ")", ",", "true", ")", ";", "}" ]

[ "toggle", "the", "visibility", "of", "the", "wizardbutton", "depending", "on", "wether", "the", "step", "is", "the", "last", "one", "or", "not" ]

[ "public", "static", "function", "assertLooselyEquals", "(", "$", "actual", ",", "$", "expected", ",", "Throwable", "$", "exception", ")", "{", "/** @noinspection TypeUnsafeComparisonInspection This assertion is wanted to be unsafe type. */", "static", "::", "makeAssertion", "(", "$", "actual", "==", "$", "expected", ",", "$", "exception", ")", ";", "return", "$", "actual", ";", "}" ]

[ "Asserts", "that", "the", "given", "values", "are", "loosely", "equals", "." ]

[ "public", "static", "function", "assertEquals", "(", "$", "actual", ",", "$", "expected", ",", "Throwable", "$", "exception", ")", "{", "static", "::", "makeAssertion", "(", "$", "actual", "===", "$", "expected", ",", "$", "exception", ")", ";", "return", "$", "actual", ";", "}" ]

[ "Asserts", "that", "the", "given", "values", "are", "strictly", "equals", "." ]

[ "public", "static", "function", "assertLooselyNotEquals", "(", "$", "actual", ",", "$", "expected", ",", "Throwable", "$", "exception", ")", "{", "/** @noinspection TypeUnsafeComparisonInspection This assertion is wanted to be unsafe type. */", "static", "::", "makeAssertion", "(", "$", "actual", "!=", "$", "expected", ",", "$", "exception", ")", ";", "return", "$", "actual", ";", "}" ]

[ "Asserts", "that", "the", "given", "values", "are", "loosely", "not", "equals", "." ]

[ "public", "static", "function", "assertNotEquals", "(", "$", "actual", ",", "$", "expected", ",", "Throwable", "$", "exception", ")", "{", "static", "::", "makeAssertion", "(", "$", "actual", "!==", "$", "expected", ",", "$", "exception", ")", ";", "return", "$", "actual", ";", "}" ]

[ "Asserts", "that", "the", "given", "values", "are", "strictly", "not", "equals", "." ]

[ "public", "static", "function", "assertGreaterThanOrEquals", "(", "$", "actual", ",", "$", "expected", ",", "Throwable", "$", "exception", ")", ":", "bool", "{", "static", "::", "makeAssertion", "(", "$", "actual", ">=", "$", "expected", ",", "$", "exception", ")", ";", "return", "true", ";", "}" ]

[ "Asserts", "that", "the", "given", "actual", "value", "is", "greater", "than", "or", "equals", "the", "expected", "value", "." ]

[ "public", "static", "function", "assertGreaterThan", "(", "$", "actual", ",", "$", "expected", ",", "Throwable", "$", "exception", ")", ":", "bool", "{", "static", "::", "makeAssertion", "(", "$", "actual", ">", "$", "expected", ",", "$", "exception", ")", ";", "return", "true", ";", "}" ]

[ "Asserts", "that", "the", "given", "actual", "value", "is", "strictly", "greater", "than", "the", "expected", "value", "." ]

[ "public", "static", "function", "assertLessThanOrEquals", "(", "$", "actual", ",", "$", "expected", ",", "Throwable", "$", "exception", ")", ":", "bool", "{", "static", "::", "makeAssertion", "(", "$", "actual", "<=", "$", "expected", ",", "$", "exception", ")", ";", "return", "true", ";", "}" ]

[ "Asserts", "that", "the", "given", "actual", "value", "is", "less", "than", "or", "equals", "the", "expected", "value", "." ]

[ "public", "static", "function", "assertLessThan", "(", "$", "actual", ",", "$", "expected", ",", "Throwable", "$", "exception", ")", ":", "bool", "{", "static", "::", "makeAssertion", "(", "$", "actual", "<", "$", "expected", ",", "$", "exception", ")", ";", "return", "true", ";", "}" ]

[ "Asserts", "that", "the", "given", "actual", "value", "is", "strictly", "less", "than", "the", "expected", "value", "." ]

[ "public", "function", "output", "(", "$", "type", "=", "null", ")", "{", "$", "session", "=", "$", "this", "->", "_di", "->", "getService", "(", "\"session\"", ")", ";", "/**\r\n * Get the messages from the session\r\n */", "$", "messages", "=", "$", "session", "->", "get", "(", "\"__flash__\"", ")", ";", "/**\r\n\t\t * If there are no messages to output -> exit early\r\n\t\t */", "if", "(", "$", "messages", "==", "null", ")", "{", "return", ";", "}", "/**\r\n * If a type is specified -> implode and return the type messages\r\n */", "if", "(", "isset", "(", "$", "type", ")", ")", "{", "/**\r\n * Get the messages of the type\r\n */", "$", "messages_type", "=", "implode", "(", "$", "messages", "[", "$", "type", "]", ")", ";", "/**\r\n * Clear the type messages in the flash session\r\n */", "$", "messages", "[", "$", "type", "]", "=", "array", "(", ")", ";", "$", "session", "->", "set", "(", "\"__flash__\"", ",", "$", "messages", ")", ";", "return", "$", "messages_type", ";", "}", "/**\r\n * Create a string with all messages\r\n */", "$", "all_messages_str", "=", "\"\"", ";", "foreach", "(", "$", "messages", "as", "$", "messages_type", ")", "{", "$", "all_messages_str", ".=", "implode", "(", "$", "messages_type", ")", ";", "}", "/**\r\n * When all the messages have been output -> clear all the messages in the flash session\r\n */", "$", "session", "->", "set", "(", "\"__flash__\"", ",", "array", "(", ")", ")", ";", "return", "$", "all_messages_str", ";", "}" ]

[ "Returns", "the", "messages" ]

[ "public", "function", "contentUriAction", "(", ")", "{", "$", "actual", "=", "$", "this", "->", "getSubDomainModel", "(", ")", "->", "findActual", "(", ")", ";", "if", "(", "empty", "(", "$", "actual", ")", ")", "{", "$", "this", "->", "getResponse", "(", ")", "->", "setStatusCode", "(", "404", ")", ";", "return", ";", "}", "$", "uri", "=", "$", "this", "->", "params", "(", ")", "->", "fromRoute", "(", "'uri'", ")", ";", "// prevent \"Invalid Encoding Attack\"", "if", "(", "!", "mb_check_encoding", "(", "$", "uri", ",", "'UTF-8'", ")", ")", "{", "$", "this", "->", "getResponse", "(", ")", "->", "setStatusCode", "(", "404", ")", ";", "return", ";", "}", "$", "structure", "=", "$", "this", "->", "getUriModel", "(", ")", "->", "findBySubdomainUri", "(", "$", "actual", "->", "id", ",", "$", "uri", ")", ";", "if", "(", "empty", "(", "$", "structure", ")", ")", "{", "$", "this", "->", "paragraphLayout", "(", ")", ";", "$", "this", "->", "getResponse", "(", ")", "->", "setStatusCode", "(", "404", ")", ";", "return", ";", "}", "if", "(", "!", "$", "structure", "->", "default", ")", "{", "$", "default", "=", "$", "this", "->", "getUriModel", "(", ")", "->", "findDefaultByContentSubdomain", "(", "$", "structure", "->", "contentId", ",", "$", "actual", "->", "id", ",", "$", "structure", "->", "locale", ")", ";", "if", "(", "$", "default", "->", "uri", "!=", "$", "structure", "->", "uri", ")", "// Avoid infinite redirect circles", "{", "$", "response", "=", "$", "this", "->", "getResponse", "(", ")", ";", "$", "response", "->", "getHeaders", "(", ")", "->", "addHeaderLine", "(", "'Location'", ",", "'/'", ".", "$", "default", "->", "safeUri", ")", ";", "// Permanent redirect: for \"old\" uris", "return", "$", "response", "->", "setStatusCode", "(", "301", ")", ";", "}", "}", "if", "(", "!", "empty", "(", "$", "structure", "->", "locale", ")", ")", "{", "$", "this", "->", "getServiceLocator", "(", ")", "->", "get", "(", "'Locale'", ")", "->", "setCurrent", "(", "$", "structure", "->", "locale", ")", ";", "}", "return", "$", "this", "->", "forward", "(", ")", "->", "dispatch", "(", "'Grid\\Paragraph\\Controller\\Render'", ",", "array", "(", "'controller'", "=>", "'Grid\\Paragraph\\Controller\\Render'", ",", "'action'", "=>", "'paragraph'", ",", "'locale'", "=>", "(", "string", ")", "$", "this", "->", "locale", "(", ")", ",", "'paragraphId'", "=>", "$", "structure", "->", "contentId", ")", ")", ";", "}" ]

[ "Content", "-", "uri", "action" ]

[ "public", "function", "method", "(", "$", "name", ")", "{", "$", "method", "=", "new", "Method", "(", "$", "name", ")", ";", "$", "this", "->", "container", "->", "put", "(", "$", "name", ",", "$", "method", ")", ";", "return", "$", "method", ";", "}" ]

[ "Define", "a", "new", "mock", "method", "." ]

[ "public", "function", "parse", "(", "interfaces", "\\", "Tokens", "$", "input", ",", "values", "\\", "Arguments", "$", "arguments", ",", "values", "\\", "Options", "$", "options", ")", ":", "void", "{", "$", "isParsingOptions", "=", "true", ";", "// Grab all tokens. Can't iterate directly over the Collection as we need to easily determine", "// which tokens are left to be processed (thus array_shift() below).", "$", "input", "=", "$", "input", "->", "all", "(", ")", ";", "// Loop through the input given.", "while", "(", "null", "!==", "$", "token", "=", "array_shift", "(", "$", "input", ")", ")", "{", "if", "(", "$", "isParsingOptions", ")", "{", "// When '--' is present as a token, it forces us to treat", "// everything following it as arguments.", "if", "(", "'--'", "===", "$", "token", ")", "{", "$", "isParsingOptions", "=", "false", ";", "continue", ";", "}", "// Full options (token beginning with two hyphens).", "if", "(", "0", "===", "strpos", "(", "$", "token", ",", "'--'", ")", ")", "{", "$", "this", "->", "parseLongOption", "(", "$", "token", ",", "$", "options", ",", "$", "input", ")", ";", "continue", ";", "}", "// Shortcuts (token beginning with exactly one hyphen).", "if", "(", "'-'", "===", "$", "token", "[", "0", "]", ")", "{", "$", "this", "->", "parseShortOption", "(", "$", "token", ",", "$", "options", ",", "$", "input", ")", ";", "continue", ";", "}", "}", "// In any other case treat the token as an argument.", "$", "arguments", "->", "push", "(", "$", "token", ")", ";", "}", "}" ]

[ "Fill", "the", "given", "Input", "Arguments", "and", "Options", "based", "on", "their", "definitions", "and", "the", "Argv", "input", "given", "." ]

[ "protected", "function", "parseLongOption", "(", "string", "$", "token", ",", "values", "\\", "Options", "$", "options", ",", "array", "&", "$", "input", ")", ":", "void", "{", "// Remove the two starting hyphens.", "$", "name", "=", "substr", "(", "$", "token", ",", "2", ")", ";", "$", "value", "=", "null", ";", "// If the token contains a value for the option, we need to split the token accordingly.", "if", "(", "false", "!==", "$", "pos", "=", "strpos", "(", "$", "name", ",", "'='", ")", ")", "{", "$", "value", "=", "substr", "(", "$", "name", ",", "$", "pos", "+", "1", ")", ";", "$", "name", "=", "substr", "(", "$", "name", ",", "0", ",", "$", "pos", ")", ";", "}", "// If the option didn't have a value assigned using the 'equals' sign, the value may be contained in", "// the next token, *if* the Option accepts values to begin with.", "// Note: It's possible that no Definition for the given Option even exists, but we're deferring", "// Exception throwing to parameters\\Options::set() to avoid some duplicate code.", "/* @var input\\Option $definition */", "if", "(", "!", "isset", "(", "$", "value", ")", "&&", "$", "definition", "=", "$", "options", "->", "definitions", "(", ")", "->", "get", "(", "$", "name", ")", "and", "$", "definition", "->", "hasValue", "(", ")", ")", "{", "// $input[0][0] is the first character of the first token in the $input array.", "// Ensure the token does not begin with a hyphen, which would indicate it's another Option,", "// and not a value for the Option we are processing.", "if", "(", "isset", "(", "$", "input", "[", "0", "]", ")", "&&", "'-'", "!==", "$", "input", "[", "0", "]", "[", "0", "]", ")", "{", "$", "value", "=", "array_shift", "(", "$", "input", ")", ";", "}", "}", "$", "options", "->", "set", "(", "$", "name", ",", "$", "value", ")", ";", "}" ]

[ "Parses", "the", "given", "token", "as", "a", "long", "option", "and", "adds", "it", "to", "the", "Options", "set", "." ]

[ "protected", "function", "parseShortOption", "(", "$", "token", ",", "values", "\\", "Options", "$", "options", ",", "array", "&", "$", "input", ")", ":", "void", "{", "// Remove the starting hyphen.", "// If it's just a hyphen and nothing else, ignore it since it's most likely a mistype.", "if", "(", "empty", "(", "$", "shortcut", "=", "substr", "(", "$", "token", ",", "1", ")", ")", ")", "{", "return", ";", "}", "foreach", "(", "$", "this", "->", "resolveShortOption", "(", "$", "shortcut", ",", "$", "options", ")", "as", "$", "name", "=>", "$", "value", ")", "{", "$", "options", "->", "set", "(", "$", "name", ",", "$", "value", ")", ";", "}", "}" ]

[ "Parses", "the", "given", "token", "as", "a", "short", "option", "and", "adds", "it", "to", "the", "Options", "set", "." ]

[ "private", "function", "resolveShortOptionSet", "(", "string", "$", "shortcut", ",", "definitions", "\\", "Options", "$", "definitions", ")", ":", "array", "{", "$", "length", "=", "strlen", "(", "$", "shortcut", ")", ";", "$", "result", "=", "[", "]", ";", "// Loop through the string, character by character.", "for", "(", "$", "i", "=", "0", ";", "$", "i", "<", "$", "length", ";", "$", "i", "++", ")", "{", "$", "definition", "=", "$", "definitions", "->", "getByShortcut", "(", "$", "shortcut", "[", "$", "i", "]", ")", ";", "// The last shortcut in a set may have a value appended afterwards.", "if", "(", "$", "definition", "->", "hasValue", "(", ")", ")", "{", "$", "result", "[", "$", "definition", "->", "getName", "(", ")", "]", "=", "$", "i", "===", "$", "length", "-", "1", "?", "null", ":", "substr", "(", "$", "shortcut", ",", "$", "i", "+", "1", ")", ";", "break", ";", "}", "$", "result", "[", "$", "definition", "->", "getName", "(", ")", "]", "=", "null", ";", "}", "return", "$", "result", ";", "}" ]

[ "Takes", "a", "set", "of", "short", "options", "contained", "in", "a", "string", "and", "resolves", "them", "to", "full", "options", "and", "their", "values", "depending", "on", "the", "Definitions", "given", "." ]

[ "public", "function", "update", "(", "$", "other", ")", "{", "if", "(", "is_array", "(", "$", "other", ")", ")", "{", "$", "this", "->", "_array", "=", "$", "other", ";", "return", "$", "this", ";", "}", "$", "this", "->", "_array", "=", "array", "(", ")", ";", "foreach", "(", "$", "other", "as", "$", "key", "=>", "$", "value", ")", "{", "$", "this", "->", "_array", "[", "$", "key", "]", "=", "$", "value", ";", "}", "return", "$", "this", ";", "}" ]

[ "Updates", "the", "values", "of", "this", "hash", "with", "the", "values", "of", "other", "." ]

[ "public", "static", "function", "fromKeys", "(", "$", "keys", ")", "{", "$", "hash", "=", "new", "Dictionary", "(", ")", ";", "foreach", "(", "$", "keys", "as", "$", "key", ")", "{", "$", "hash", "[", "$", "key", "]", "=", "NULL", ";", "}", "return", "$", "hash", ";", "}" ]

[ "Constructs", "a", "Hash", "with", "the", "passed", "keys" ]

[ "public", "function", "getAllowedMethods", "(", ")", "{", "$", "result", "=", "[", "]", ";", "if", "(", "$", "this", "->", "get", ")", "{", "$", "result", "[", "]", "=", "HttpMethods", "::", "GET", ";", "}", "if", "(", "$", "this", "->", "post", ")", "{", "$", "result", "[", "]", "=", "HttpMethods", "::", "POST", ";", "}", "if", "(", "$", "this", "->", "put", ")", "{", "$", "result", "[", "]", "=", "HttpMethods", "::", "PUT", ";", "}", "if", "(", "$", "this", "->", "path", ")", "{", "$", "result", "[", "]", "=", "HttpMethods", "::", "PATCH", ";", "}", "if", "(", "$", "this", "->", "delete", ")", "{", "$", "result", "[", "]", "=", "HttpMethods", "::", "DELETE", ";", "}", "if", "(", "$", "this", "->", "head", ")", "{", "$", "result", "[", "]", "=", "HttpMethods", "::", "HEAD", ";", "}", "if", "(", "$", "this", "->", "options", ")", "{", "$", "result", "[", "]", "=", "HttpMethods", "::", "OPTIONS", ";", "}", "return", "$", "result", ";", "}" ]

[ "Get", "array", "of", "allowed", "methods", "for", "this", "action" ]

[ "public", "function", "login", "(", "Request", "$", "request", ")", "{", "$", "this", "->", "validateLogin", "(", "$", "request", ")", ";", "// If the class is using the ThrottlesLogins trait, we can automatically throttle", "// the login attempts for this application. We'll key this by the username and", "// the IP address of the client making these requests into this application.", "if", "(", "$", "this", "->", "hasTooManyLoginAttempts", "(", "$", "request", ")", ")", "{", "$", "this", "->", "fireLockoutEvent", "(", "$", "request", ")", ";", "return", "$", "this", "->", "sendLockoutResponse", "(", "$", "request", ")", ";", "}", "// If the login attempt was unsuccessful we will increment the number of attempts", "// to login and redirect the user back to the login form. Of course, when this", "// user surpasses their maximum number of attempts they will get locked out.", "$", "this", "->", "incrementLoginAttempts", "(", "$", "request", ")", ";", "if", "(", "!", "$", "this", "->", "attemptLogin", "(", "$", "request", ")", ")", "{", "return", "HCLog", "::", "info", "(", "'AUTH-002'", ",", "trans", "(", "'HCACL::users.errors.login'", ")", ")", ";", "}", "// check if user is not activated", "if", "(", "auth", "(", ")", "->", "user", "(", ")", "->", "isNotActivated", "(", ")", ")", "{", "$", "user", "=", "auth", "(", ")", "->", "user", "(", ")", ";", "$", "this", "->", "logout", "(", "$", "request", ")", ";", "$", "response", "=", "$", "this", "->", "activation", "->", "sendActivationMail", "(", "$", "user", ")", ";", "return", "HCLog", "::", "info", "(", "'AUTH-003'", ",", "$", "response", ")", ";", "}", "//TODO update providers?", "auth", "(", ")", "->", "user", "(", ")", "->", "updateLastLogin", "(", ")", ";", "//redirect to intended url", "return", "response", "(", "[", "'success'", "=>", "true", ",", "'redirectURL'", "=>", "session", "(", ")", "->", "pull", "(", "'url.intended'", ",", "url", "(", "'/'", ")", ")", "]", ")", ";", "}" ]

[ "Function", "which", "login", "users" ]

[ "public", "function", "showActivation", "(", "string", "$", "token", ")", "{", "$", "message", "=", "null", ";", "$", "tokenRecord", "=", "DB", "::", "table", "(", "'hc_users_activations'", ")", "->", "where", "(", "'token'", ",", "$", "token", ")", "->", "first", "(", ")", ";", "if", "(", "is_null", "(", "$", "tokenRecord", ")", ")", "{", "$", "message", "=", "trans", "(", "'HCACL::users.activation.token_not_exists'", ")", ";", "}", "else", "{", "if", "(", "strtotime", "(", "$", "tokenRecord", "->", "created_at", ")", "+", "60", "*", "60", "*", "24", "<", "time", "(", ")", ")", "{", "$", "message", "=", "trans", "(", "'HCACL::users.activation.token_expired'", ")", ";", "}", "}", "return", "hcview", "(", "'HCACL::auth.activation'", ",", "[", "'token'", "=>", "$", "token", ",", "'message'", "=>", "$", "message", "]", ")", ";", "}" ]

[ "Show", "activation", "page" ]

[ "public", "function", "send", "(", ")", "{", "if", "(", "!", "static", "::", "isSent", "(", ")", ")", "{", "static", "::", "call", "(", "'send'", ",", "$", "this", ")", ";", "foreach", "(", "$", "this", "->", "headers", "as", "$", "header", "=>", "$", "value", ")", "{", "$", "this", "->", "setHttpHeader", "(", "$", "header", ",", "$", "value", ")", ";", "}", "http_response_code", "(", "$", "this", "->", "status", ")", ";", "echo", "$", "this", "->", "body", ";", "static", "::", "$", "sent", "=", "true", ";", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "Bastelt", "den", "Response", "zusammen", "und", "sendet", "diesen", "ab", "sofern", "er", "noch", "nicht", "abgesendet", "wurde", "." ]

[ "protected", "function", "isAllModulesLoaded", "(", "array", "$", "modules", ")", "{", "foreach", "(", "$", "modules", "as", "$", "module", ")", "{", "if", "(", "!", "$", "this", "->", "isModuleLoaded", "(", "$", "module", ")", ")", "{", "return", "false", ";", "}", "}", "return", "true", ";", "}" ]

[ "Is", "all", "modules", "loaded" ]

[ "public", "function", "isModulesLoaded", "(", "$", "modules", ")", "{", "if", "(", "$", "modules", "instanceof", "Traversable", ")", "{", "$", "modules", "=", "ArrayUtils", "::", "iteratorToArray", "(", "$", "modules", ")", ";", "}", "if", "(", "!", "is_array", "(", "$", "modules", ")", ")", "{", "$", "modules", "=", "preg_split", "(", "'/\\|{1,2}/'", ",", "(", "string", ")", "$", "modules", ")", ";", "}", "foreach", "(", "$", "modules", "as", "$", "module", ")", "{", "if", "(", "!", "is_array", "(", "$", "module", ")", ")", "{", "$", "module", "=", "preg_split", "(", "'/&{1,2}/'", ",", "(", "string", ")", "$", "module", ")", ";", "}", "if", "(", "$", "this", "->", "isAllModulesLoaded", "(", "$", "module", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Is", "any", "modules", "loaded" ]

[ "public", "static", "function", "factory", "(", "$", "type", ")", "{", "if", "(", "$", "type", "instanceof", "TypeInterface", ")", "return", "$", "type", ";", "if", "(", "strpos", "(", "$", "type", ",", "\"\\\\\"", ")", "===", "false", ")", "{", "$", "type", "=", "ucfirst", "(", "trim", "(", "strval", "(", "$", "type", ")", ")", ")", ";", "if", "(", "strripos", "(", "strrev", "(", "$", "type", ")", ",", "strrev", "(", "'type'", ")", ")", "===", "false", ")", "$", "type", ".=", "'Type'", ";", "$", "type", "=", "\"DataEntity\\\\Type\\\\\"", ".", "$", "type", ";", "}", "if", "(", "!", "class_exists", "(", "$", "type", ")", "||", "!", "in_array", "(", "\"DataEntity\\\\TypeInterface\"", ",", "class_implements", "(", "$", "type", ")", ")", ")", "throw", "new", "\\", "InvalidArgumentException", "(", "'Type '", ".", "$", "type", ".", "' is invalid.'", ")", ";", "return", "new", "$", "type", ";", "}" ]

[ "Builds", "type", "objects" ]

[ "public", "static", "function", "to_assoc", "(", "$", "start", "=", "1", ")", "{", "$", "segments", "=", "array_slice", "(", "static", "::", "segments", "(", ")", ",", "(", "$", "start", "-", "1", ")", ")", ";", "count", "(", "$", "segments", ")", "%", "2", "and", "$", "segments", "[", "]", "=", "null", ";", "return", "\\", "Arr", "::", "to_assoc", "(", "$", "segments", ")", ";", "}" ]

[ "Converts", "the", "current", "URI", "segments", "to", "an", "associative", "array", ".", "If", "the", "URI", "has", "an", "odd", "number", "of", "segments", "an", "empty", "value", "will", "be", "added", "." ]

[ "public", "static", "function", "create", "(", "$", "uri", "=", "null", ",", "$", "variables", "=", "array", "(", ")", ",", "$", "get_variables", "=", "array", "(", ")", ",", "$", "secure", "=", "null", ")", "{", "$", "url", "=", "''", ";", "is_null", "(", "$", "uri", ")", "and", "$", "uri", "=", "static", "::", "string", "(", ")", ";", "// If the given uri is not a full URL", "if", "(", "!", "preg_match", "(", "\"#^(http|https|ftp)://#i\"", ",", "$", "uri", ")", ")", "{", "$", "url", ".=", "\\", "Config", "::", "get", "(", "'base_url'", ")", ";", "if", "(", "$", "index_file", "=", "\\", "Config", "::", "get", "(", "'index_file'", ")", ")", "{", "$", "url", ".=", "$", "index_file", ".", "'/'", ";", "}", "}", "$", "url", ".=", "ltrim", "(", "$", "uri", ",", "'/'", ")", ";", "// stick a url suffix onto it if defined and needed", "if", "(", "$", "url_suffix", "=", "\\", "Config", "::", "get", "(", "'url_suffix'", ",", "false", ")", "and", "substr", "(", "$", "url", ",", "-", "1", ")", "!=", "'/'", ")", "{", "$", "current_suffix", "=", "strrchr", "(", "$", "url", ",", "'.'", ")", ";", "if", "(", "!", "$", "current_suffix", "or", "strpos", "(", "$", "current_suffix", ",", "'/'", ")", "!==", "false", ")", "{", "$", "url", ".=", "$", "url_suffix", ";", "}", "}", "if", "(", "!", "empty", "(", "$", "get_variables", ")", ")", "{", "$", "char", "=", "strpos", "(", "$", "url", ",", "'?'", ")", "===", "false", "?", "'?'", ":", "'&'", ";", "if", "(", "is_string", "(", "$", "get_variables", ")", ")", "{", "$", "url", ".=", "$", "char", ".", "str_replace", "(", "'%3A'", ",", "':'", ",", "$", "get_variables", ")", ";", "}", "else", "{", "$", "url", ".=", "$", "char", ".", "str_replace", "(", "'%3A'", ",", "':'", ",", "http_build_query", "(", "$", "get_variables", ")", ")", ";", "}", "}", "array_walk", "(", "$", "variables", ",", "function", "(", "$", "val", ",", "$", "key", ")", "use", "(", "&", "$", "url", ")", "{", "$", "url", "=", "str_replace", "(", "':'", ".", "$", "key", ",", "$", "val", ",", "$", "url", ")", ";", "}", ")", ";", "is_bool", "(", "$", "secure", ")", "and", "$", "url", "=", "http_build_url", "(", "$", "url", ",", "array", "(", "'scheme'", "=>", "$", "secure", "?", "'https'", ":", "'http'", ")", ")", ";", "return", "$", "url", ";", "}" ]

[ "Creates", "a", "url", "with", "the", "given", "uri", "including", "the", "base", "url" ]

[ "public", "static", "function", "base", "(", "$", "include_index", "=", "true", ")", "{", "$", "url", "=", "\\", "Config", "::", "get", "(", "'base_url'", ")", ";", "if", "(", "$", "include_index", "and", "\\", "Config", "::", "get", "(", "'index_file'", ")", ")", "{", "$", "url", ".=", "\\", "Config", "::", "get", "(", "'index_file'", ")", ".", "'/'", ";", "}", "return", "$", "url", ";", "}" ]

[ "Gets", "the", "base", "URL", "including", "the", "index_file", "if", "wanted", "." ]

[ "public", "static", "function", "build_query_string", "(", ")", "{", "$", "params", "=", "array", "(", ")", ";", "foreach", "(", "func_get_args", "(", ")", "as", "$", "arg", ")", "{", "$", "arg", "=", "is_array", "(", "$", "arg", ")", "?", "$", "arg", ":", "array", "(", "$", "arg", "=>", "'1'", ")", ";", "$", "params", "=", "array_merge", "(", "$", "params", ",", "$", "arg", ")", ";", "}", "return", "http_build_query", "(", "$", "params", ")", ";", "}" ]

[ "Builds", "a", "query", "string", "by", "merging", "all", "array", "and", "string", "values", "passed", ".", "If", "a", "string", "is", "passed", "it", "will", "be", "assumed", "to", "be", "a", "switch", "and", "converted", "to", "string", "=", "1", "." ]

[ "public", "static", "function", "update_query_string", "(", "$", "vars", "=", "array", "(", ")", ",", "$", "uri", "=", "null", ",", "$", "secure", "=", "null", ")", "{", "// unify the input data", "if", "(", "!", "is_array", "(", "$", "vars", ")", ")", "{", "$", "vars", "=", "array", "(", "$", "vars", "=>", "$", "uri", ")", ";", "$", "uri", "=", "null", ";", "}", "// if we have a custom URI, use that", "if", "(", "$", "uri", "===", "null", ")", "{", "// use the current URI if not is passed", "$", "uri", "=", "static", "::", "current", "(", ")", ";", "// merge them with the existing query string data", "$", "vars", "=", "array_merge", "(", "\\", "Input", "::", "get", "(", ")", ",", "$", "vars", ")", ";", "}", "// return the updated uri", "return", "static", "::", "create", "(", "$", "uri", ",", "array", "(", ")", ",", "$", "vars", ",", "$", "secure", ")", ";", "}" ]

[ "Updates", "the", "query", "string", "of", "the", "current", "or", "passed", "URL", "with", "the", "data", "passed" ]

[ "public", "function", "get_segment", "(", "$", "segment", ",", "$", "default", "=", "null", ")", "{", "if", "(", "isset", "(", "$", "this", "->", "segments", "[", "$", "segment", "-", "1", "]", ")", ")", "{", "return", "$", "this", "->", "segments", "[", "$", "segment", "-", "1", "]", ";", "}", "return", "\\", "Fuel", "::", "value", "(", "$", "default", ")", ";", "}" ]

[ "Get", "the", "specified", "URI", "segment", "return", "default", "if", "it", "doesn", "t", "exist", "." ]

[ "public", "static", "function", "enablePdoConnection", "(", ")", "{", "if", "(", "is_null", "(", "self", "::", "$", "instance", ")", ")", "{", "global", "$", "wpdb", ";", "$", "capsule", "=", "new", "self", "(", ")", ";", "$", "capsule", "->", "addConnection", "(", "[", "'driver'", "=>", "'mysql'", ",", "'host'", "=>", "DB_HOST", ",", "'database'", "=>", "DB_NAME", ",", "'username'", "=>", "DB_USER", ",", "'password'", "=>", "DB_PASSWORD", ",", "'charset'", "=>", "'utf8mb4'", ",", "'collation'", "=>", "'utf8mb4_general_ci'", ",", "]", ")", ";", "$", "capsule", "->", "setAsGlobal", "(", ")", ";", "$", "capsule", "->", "bootEloquent", "(", ")", ";", "}", "}" ]

[ "Enable", "PDO", "for", "eloquent" ]

[ "public", "function", "getRequest", "(", ")", "{", "if", "(", "null", "===", "$", "this", "->", "request", ")", "{", "$", "this", "->", "setRequest", "(", "$", "this", "->", "getController", "(", ")", "->", "getRequest", "(", ")", ")", ";", "}", "return", "$", "this", "->", "request", ";", "}" ]

[ "Get", "request", "to", "be", "authenticated" ]

[ "public", "function", "getAuthenticationAdapter", "(", ")", "{", "if", "(", "null", "===", "$", "this", "->", "authenticationAdapter", ")", "{", "$", "authenticationAdapter", "=", "$", "this", "->", "getAuthenticationService", "(", ")", "->", "getAdapter", "(", ")", ";", "$", "this", "->", "setAuthenticationAdapter", "(", "$", "authenticationAdapter", ")", ";", "}", "return", "$", "this", "->", "authenticationAdapter", ";", "}" ]

[ "Get", "authentication", "adapter" ]

[ "public", "static", "function", "toUriString", "(", "Request", "$", "request", ")", "{", "$", "uri", "=", "clone", "$", "request", "->", "getUri", "(", ")", ";", "$", "uri", "->", "setQuery", "(", "array_merge", "(", "$", "uri", "->", "getQueryAsArray", "(", ")", ",", "$", "request", "->", "getQuery", "(", ")", "->", "toArray", "(", ")", ")", ")", ";", "return", "$", "uri", "->", "toString", "(", ")", ";", "}" ]

[ "Converts", "the", "request", "into", "a", "url", "." ]

[ "public", "function", "attach", "(", "ReaderInterface", "$", "reader", ",", "$", "last", "=", "true", ")", "{", "if", "(", "$", "last", ")", "{", "// Add to the end (i.e. read this last, highest merge priority)", "$", "this", "->", "readers", "[", "]", "=", "$", "reader", ";", "}", "else", "{", "// Add to the beginning (i.e. read this first, lowest merge priority)", "array_unshift", "(", "$", "this", "->", "readers", ",", "$", "reader", ")", ";", "}", "// Clear any cached groups", "$", "this", "->", "groups", "=", "[", "]", ";", "}" ]

[ "Attach", "a", "new", "config", "reader" ]

[ "public", "function", "detach", "(", "ReaderInterface", "$", "reader", ")", "{", "if", "(", "(", "$", "key", "=", "array_search", "(", "$", "reader", ",", "$", "this", "->", "readers", ")", ")", "!==", "false", ")", "{", "unset", "(", "$", "this", "->", "readers", "[", "$", "key", "]", ")", ";", "}", "// Clear any cached groups", "$", "this", "->", "groups", "=", "[", "]", ";", "}" ]

[ "Detach", "a", "config", "reader" ]

[ "public", "function", "load", "(", "$", "groupName", ")", "{", "if", "(", "!", "count", "(", "$", "this", "->", "readers", ")", ")", "{", "throw", "new", "\\", "RuntimeException", "(", "'No config readers attached'", ")", ";", "}", "if", "(", "!", "$", "groupName", ")", "{", "throw", "new", "\\", "InvalidArgumentException", "(", "'No config group specified'", ")", ";", "}", "if", "(", "!", "is_string", "(", "$", "groupName", ")", ")", "{", "throw", "new", "\\", "InvalidArgumentException", "(", "'Config group must be a string'", ")", ";", "}", "if", "(", "isset", "(", "$", "this", "->", "groups", "[", "$", "groupName", "]", ")", ")", "{", "return", "$", "this", "->", "groups", "[", "$", "groupName", "]", ";", "}", "$", "config", "=", "[", "]", ";", "foreach", "(", "$", "this", "->", "readers", "as", "$", "reader", ")", "{", "if", "(", "$", "groupConfig", "=", "$", "reader", "->", "load", "(", "$", "groupName", ")", ")", "{", "$", "config", "=", "array_replace_recursive", "(", "$", "config", ",", "$", "groupConfig", ")", ";", "}", "}", "$", "this", "->", "groups", "[", "$", "groupName", "]", "=", "$", "config", ";", "return", "$", "this", "->", "groups", "[", "$", "groupName", "]", ";", "}" ]

[ "Load", "configuration", "for", "a", "group" ]

[ "public", "function", "registerCall", "(", "$", "name", ",", "array", "$", "arguments", "=", "[", "]", ")", "{", "$", "name", "=", "strtolower", "(", "preg_replace", "(", "\"/([A-Z]{1})/\"", ",", "\"_$0\"", ",", "$", "name", ")", ")", ";", "$", "this", "->", "calls", "=", "array_merge", "(", "$", "this", "->", "calls", ",", "array_filter", "(", "explode", "(", "\"_\"", ",", "$", "name", ")", ")", ")", ";", "if", "(", "count", "(", "$", "arguments", ")", ">", "0", ")", "{", "$", "lastIndex", "=", "count", "(", "$", "this", "->", "calls", ")", "-", "1", ";", "$", "this", "->", "calls", "[", "$", "lastIndex", "]", "=", "[", "$", "this", "->", "calls", "[", "$", "lastIndex", "]", ",", "$", "arguments", "]", ";", "}", "}" ]

[ "Registers", "a", "call", "." ]

[ "protected", "function", "findTemplateFile", "(", "$", "file", ")", "{", "//Add missing extension", "$", "ext", "=", "pathinfo", "(", "$", "file", ",", "PATHINFO_EXTENSION", ")", ";", "$", "file", "=", "(", "$", "ext", "===", "''", ")", "?", "$", "file", ".", "'.'", ".", "$", "this", "->", "getExtension", "(", ")", ":", "$", "file", ";", "$", "found", "=", "false", ";", "foreach", "(", "$", "this", "->", "locations", "as", "$", "location", ")", "{", "if", "(", "is_file", "(", "$", "location", ".", "'/'", ".", "$", "file", ")", ")", "{", "$", "found", "=", "true", ";", "$", "file", "=", "$", "location", ".", "'/'", ".", "$", "file", ";", "continue", ";", "}", "}", "if", "(", "!", "$", "found", ")", "{", "throw", "new", "TemplateNotFoundException", "(", "'This template was not found in any of the registered locations: '", ".", "$", "file", ")", ";", "}", "return", "$", "file", ";", "}" ]

[ "Finds", "the", "file", "by", "looping", "through", "locations" ]

[ "public", "function", "validateAuth", "(", ")", "{", "// Send a get request to the API", "$", "response", "=", "$", "this", "->", "uniRequest", "->", "get", "(", "implode", "(", "[", "$", "this", "->", "authURL", ",", "'validate/'", "]", ")", ",", "$", "this", "->", "headers", ")", ";", "// Check that we get 20X back", "if", "(", "in_array", "(", "$", "response", "->", "code", ",", "$", "this", "->", "validCodes", ")", ")", "{", "// Return the response", "return", "$", "response", ";", "}", "else", "{", "// If we did not get 20X throw an exception", "throw", "new", "Exception", "(", "$", "response", "->", "body", "->", "message", ",", "$", "response", "->", "code", ")", ";", "}", "}" ]

[ "Validate", "Authenticated", "Session" ]

[ "public", "function", "all", "(", ")", "{", "$", "this", "->", "resumeOrStartSession", "(", ")", ";", "return", "isset", "(", "$", "_SESSION", "[", "$", "this", "->", "name", "]", ")", "?", "$", "_SESSION", "[", "$", "this", "->", "name", "]", ":", "[", "]", ";", "}" ]

[ "Get", "all", "of", "the", "session", "data", "." ]

[ "public", "function", "remove", "(", "$", "key", ")", "{", "if", "(", "isset", "(", "$", "_SESSION", "[", "$", "this", "->", "name", "]", "[", "$", "key", "]", ")", ")", "{", "$", "value", "=", "$", "_SESSION", "[", "$", "this", "->", "name", "]", "[", "$", "key", "]", ";", "unset", "(", "$", "_SESSION", "[", "$", "this", "->", "name", "]", "[", "$", "key", "]", ")", ";", "return", "$", "value", ";", "}", "return", "null", ";", "}" ]

[ "Remove", "an", "item", "from", "the", "session", "returning", "its", "value", "." ]

[ "public", "function", "rollback", "(", ")", ":", "bool", "{", "$", "sql", "=", "'ROLLBACK'", ";", "if", "(", "!", "$", "this", "->", "transactionStarted", ")", "{", "$", "event", "=", "new", "TimerEvent", "(", "'db.query'", ")", ";", "$", "this", "->", "emitQueryEvent", "(", "$", "event", ",", "null", ",", "$", "sql", ")", ";", "throw", "new", "QueryException", "(", "$", "this", ",", "$", "sql", ",", "\"Can't rollback unstarted transaction\"", ")", ";", "}", "$", "this", "->", "query", "(", "$", "sql", ")", ";", "$", "this", "->", "transactionStarted", "=", "false", ";", "$", "this", "->", "instanceDispatcher", "(", ")", "->", "emit", "(", "new", "Event", "(", "'db.rollback'", ")", ")", ";", "return", "true", ";", "}" ]

[ "Rollback", "a", "sql", "transaction", "." ]

[ "public", "function", "&", "__get", "(", "$", "property", ")", "{", "$", "getter", "=", "'get'", ".", "\\", "ucfirst", "(", "$", "property", ")", ";", "if", "(", "\\", "in_array", "(", "$", "property", ",", "array", "(", "'alerts'", ",", "'cfg'", ",", "'status'", ")", ")", ")", "{", "return", "$", "this", "->", "{", "$", "property", "}", ";", "}", "elseif", "(", "\\", "method_exists", "(", "$", "this", ",", "$", "getter", ")", ")", "{", "$", "return", "=", "$", "this", "->", "{", "$", "getter", "}", "(", ")", ";", "return", "$", "return", ";", "}", "elseif", "(", "isset", "(", "$", "this", "->", "status", "[", "$", "property", "]", ")", ")", "{", "return", "$", "this", "->", "status", "[", "$", "property", "]", ";", "}", "else", "{", "$", "this", "->", "debug", "->", "log", "(", "'property'", ",", "$", "property", ")", ";", "}", "}" ]

[ "Get", "protected", "properties" ]

[ "public", "function", "getField", "(", "$", "fieldName", ")", "{", "$", "this", "->", "debug", "->", "group", "(", "__METHOD__", ",", "$", "fieldName", ")", ";", "$", "field", "=", "false", ";", "if", "(", "\\", "preg_match", "(", "'|^(.*?)[/.](.*)$|'", ",", "$", "fieldName", ",", "$", "matches", ")", ")", "{", "$", "pageName", "=", "$", "matches", "[", "1", "]", ";", "$", "fieldName", "=", "$", "matches", "[", "2", "]", ";", "}", "else", "{", "$", "pageName", "=", "$", "this", "->", "status", "[", "'currentPageName'", "]", ";", "}", "if", "(", "$", "pageName", "==", "$", "this", "->", "status", "[", "'currentPageName'", "]", "&&", "isset", "(", "$", "this", "->", "currentFields", "[", "$", "fieldName", "]", ")", ")", "{", "$", "field", "=", "&", "$", "this", "->", "currentFields", "[", "$", "fieldName", "]", ";", "if", "(", "!", "\\", "is_object", "(", "$", "field", ")", ")", "{", "$", "field", "[", "'pageI'", "]", "=", "$", "this", "->", "persist", "->", "get", "(", "'i'", ")", ";", "$", "this", "->", "currentFields", "[", "$", "fieldName", "]", "=", "$", "this", "->", "buildField", "(", "$", "field", ",", "$", "fieldName", ")", ";", "}", "}", "elseif", "(", "isset", "(", "$", "this", "->", "cfg", "[", "'pages'", "]", "[", "$", "pageName", "]", ")", ")", "{", "$", "pages", "=", "$", "this", "->", "persist", "->", "get", "(", "'pages'", ")", ";", "foreach", "(", "$", "pages", "as", "$", "pageI", "=>", "$", "page", ")", "{", "if", "(", "$", "page", "[", "'name'", "]", "!=", "$", "pageName", ")", "{", "continue", ";", "}", "foreach", "(", "$", "this", "->", "cfg", "[", "'pages'", "]", "[", "$", "pageName", "]", "as", "$", "k", "=>", "$", "fieldProps", ")", "{", "if", "(", "$", "k", "===", "$", "fieldName", "||", "isset", "(", "$", "fieldProps", "[", "'attribs'", "]", "[", "'name'", "]", ")", "&&", "$", "fieldProps", "[", "'attribs'", "]", "[", "'name'", "]", "==", "$", "fieldName", "||", "isset", "(", "$", "fieldProps", "[", "'name'", "]", ")", "&&", "$", "fieldProps", "[", "'name'", "]", "==", "$", "fieldName", ")", "{", "$", "this", "->", "debug", "->", "info", "(", "'found field'", ")", ";", "$", "fieldProps", "[", "'pageI'", "]", "=", "$", "pageI", ";", "$", "field", "=", "$", "this", "->", "buildField", "(", "$", "fieldProps", ",", "$", "k", ")", ";", "$", "val", "=", "$", "this", "->", "getValue", "(", "$", "fieldName", ",", "$", "pageI", ")", ";", "$", "field", "->", "val", "(", "$", "val", ",", "false", ")", ";", "break", "2", ";", "}", "}", "break", ";", "}", "}", "$", "this", "->", "debug", "->", "groupEnd", "(", ")", ";", "return", "$", "field", ";", "}" ]

[ "Get", "form", "field" ]

[ "public", "function", "getInvalidFields", "(", ")", "{", "$", "invalidFields", "=", "array", "(", ")", ";", "foreach", "(", "$", "this", "->", "currentFields", "as", "$", "field", ")", "{", "if", "(", "!", "$", "field", "->", "isValid", ")", "{", "$", "invalidFields", "[", "]", "=", "$", "field", ";", "}", "}", "return", "$", "invalidFields", ";", "}" ]

[ "Get", "list", "of", "invalid", "fields" ]

[ "public", "function", "setCurrentFields", "(", "$", "i", "=", "null", ")", "{", "$", "this", "->", "debug", "->", "groupCollapsed", "(", "__METHOD__", ",", "$", "i", ")", ";", "$", "this", "->", "debug", "->", "groupUncollapse", "(", ")", ";", "$", "cfg", "=", "&", "$", "this", "->", "cfg", ";", "$", "status", "=", "&", "$", "this", "->", "status", ";", "if", "(", "isset", "(", "$", "i", ")", ")", "{", "$", "this", "->", "status", "[", "'submitted'", "]", "=", "false", ";", "$", "this", "->", "persist", "->", "set", "(", "'i'", ",", "$", "i", ")", ";", "}", "$", "this", "->", "resetStatus", "(", ")", ";", "// $this->debug->warn('currentPageName', $status['currentPageName']);", "// $this->debug->log('persist', $this->persist);", "// $this->debug->info('status', $status);", "// $this->debug->log('cfg', $cfg);", "$", "this", "->", "currentFields", "=", "isset", "(", "$", "cfg", "[", "'pages'", "]", "[", "$", "status", "[", "'currentPageName'", "]", "]", ")", "?", "$", "cfg", "[", "'pages'", "]", "[", "$", "status", "[", "'currentPageName'", "]", "]", ":", "array", "(", ")", ";", "$", "this", "->", "debug", "->", "log", "(", "'count(currentFields)'", ",", "\\", "count", "(", "$", "this", "->", "currentFields", ")", ")", ";", "$", "this", "->", "currentValues", "=", "$", "this", "->", "persist", "->", "get", "(", "'currentPage.values'", ")", ";", "// $this->debug->warn('currentValues', $this->currentValues);", "if", "(", "!", "empty", "(", "$", "cfg", "[", "'pre'", "]", ")", "&&", "\\", "is_callable", "(", "$", "cfg", "[", "'pre'", "]", ")", ")", "{", "$", "return", "=", "\\", "call_user_func", "(", "$", "cfg", "[", "'pre'", "]", ",", "$", "this", ")", ";", "if", "(", "$", "return", "===", "false", ")", "{", "$", "status", "[", "'error'", "]", "=", "'pre error'", ";", "}", "}", "$", "this", "->", "buildFields", "(", ")", ";", "$", "this", "->", "debug", "->", "groupEnd", "(", ")", ";", "return", ";", "}" ]

[ "Set", "current", "page" ]

[ "protected", "function", "buildField", "(", "$", "fieldProps", ",", "$", "nameDefault", "=", "null", ")", "{", "$", "this", "->", "debug", "->", "group", "(", "__METHOD__", ",", "$", "nameDefault", ")", ";", "if", "(", "!", "isset", "(", "$", "fieldProps", "[", "'attribs'", "]", "[", "'name'", "]", ")", "&&", "!", "isset", "(", "$", "fieldProps", "[", "'name'", "]", ")", ")", "{", "$", "fieldProps", "[", "'attribs'", "]", "[", "'name'", "]", "=", "$", "nameDefault", ";", "}", "if", "(", "!", "empty", "(", "$", "fieldProps", "[", "'newPage'", "]", ")", ")", "{", "$", "fieldProps", "[", "'attribs'", "]", "[", "'type'", "]", "=", "'newPage'", ";", "$", "fieldProps", "[", "'attribs'", "]", "[", "'value'", "]", "=", "$", "fieldProps", "[", "'newPage'", "]", ";", "unset", "(", "$", "fieldProps", "[", "'newPage'", "]", ")", ";", "}", "$", "field", "=", "$", "this", "->", "fieldFactory", "->", "build", "(", "$", "fieldProps", ")", ";", "if", "(", "$", "this", "->", "status", "[", "'submitted'", "]", "&&", "$", "field", "->", "attribs", "[", "'type'", "]", "!=", "'newPage'", ")", "{", "$", "pageI", "=", "$", "this", "->", "persist", "->", "get", "(", "'i'", ")", ";", "$", "value", "=", "$", "this", "->", "persist", "->", "get", "(", "'pages/'", ".", "$", "pageI", ".", "'/values/'", ".", "$", "field", "->", "attribs", "[", "'name'", "]", ")", ";", "$", "field", "->", "val", "(", "$", "value", ",", "false", ")", ";", "}", "$", "this", "->", "debug", "->", "groupEnd", "(", ")", ";", "return", "$", "field", ";", "}" ]

[ "Build", "field", "object" ]

[ "protected", "function", "buildFields", "(", ")", "{", "$", "this", "->", "debug", "->", "groupCollapsed", "(", "__METHOD__", ")", ";", "$", "status", "=", "&", "$", "this", "->", "status", ";", "$", "persist", "=", "$", "this", "->", "persist", ";", "$", "pageI", "=", "$", "this", "->", "persist", "->", "get", "(", "'i'", ")", ";", "$", "submitFieldCount", "=", "0", ";", "$", "keys", "=", "\\", "array_keys", "(", "$", "this", "->", "currentFields", ")", ";", "foreach", "(", "$", "keys", "as", "$", "k", ")", "{", "$", "field", "=", "$", "this", "->", "currentFields", "[", "$", "k", "]", ";", "unset", "(", "$", "this", "->", "currentFields", "[", "$", "k", "]", ")", ";", "if", "(", "!", "\\", "is_object", "(", "$", "field", ")", ")", "{", "$", "field", "=", "$", "this", "->", "buildField", "(", "$", "field", ",", "$", "k", ")", ";", "}", "$", "field", "->", "pageI", "=", "$", "pageI", ";", "if", "(", "$", "field", "->", "attribs", "[", "'type'", "]", "==", "'newPage'", ")", "{", "$", "this", "->", "debug", "->", "info", "(", "'possible new page'", ",", "$", "field", "->", "attribs", "[", "'value'", "]", ")", ";", "if", "(", "$", "field", "->", "isRequired", "(", ")", ")", "{", "$", "this", "->", "debug", "->", "log", "(", "'adding new page'", ",", "$", "field", "->", "attribs", "[", "'value'", "]", ")", ";", "$", "status", "[", "'additionalPages'", "]", "[", "]", "=", "$", "field", ";", "}", "continue", ";", "}", "elseif", "(", "$", "field", "->", "attribs", "[", "'type'", "]", "==", "'submit'", ")", "{", "$", "submitFieldCount", "++", ";", "}", "elseif", "(", "$", "field", "->", "attribs", "[", "'type'", "]", "==", "'file'", ")", "{", "$", "status", "[", "'multipart'", "]", "=", "true", ";", "}", "$", "k", "=", "\\", "is_int", "(", "$", "k", ")", "?", "$", "field", "->", "attribs", "[", "'name'", "]", ":", "$", "k", ";", "$", "this", "->", "currentFields", "[", "$", "k", "]", "=", "$", "field", ";", "}", "if", "(", "$", "submitFieldCount", "<", "1", ")", "{", "$", "this", "->", "debug", "->", "info", "(", "'submit field not set'", ")", ";", "$", "fieldArray", "=", "array", "(", "'type'", "=>", "'submit'", ",", "'label'", "=>", "(", "!", "empty", "(", "$", "status", "[", "'additionalPages'", "]", ")", "||", "$", "persist", "->", "pageCount", "(", ")", ">", "$", "persist", "->", "pageCount", "(", "true", ")", "+", "1", ")", "?", "'Continue'", ":", "'Submit'", ",", "'attribs'", "=>", "array", "(", "'class'", "=>", "array", "(", "'btn btn-primary'", ",", "'replace'", ")", ")", ",", "'tagOnly'", "=>", "true", ",", ")", ";", "$", "this", "->", "currentFields", "[", "'submit'", "]", "=", "$", "this", "->", "fieldFactory", "->", "build", "(", "$", "fieldArray", ")", ";", "$", "this", "->", "debug", "->", "log", "(", "'array_keys(currentFields)'", ",", "\\", "array_keys", "(", "$", "this", "->", "currentFields", ")", ")", ";", "}", "if", "(", "$", "status", "[", "'multipart'", "]", ")", "{", "$", "this", "->", "debug", "->", "log", "(", "'<a target=\"_blank\" href=\"http://www.php.net/manual/en/ini.php\">post_max_size</a> = '", ".", "Str", "::", "getBytes", "(", "\\", "ini_get", "(", "'post_max_size'", ")", ")", ")", ";", "$", "this", "->", "debug", "->", "log", "(", "'<a target=\"_blank\" href=\"http://www.php.net/manual/en/ini.php\">upload_max_filesize</a> = '", ".", "Str", "::", "getBytes", "(", "\\", "ini_get", "(", "'upload_max_filesize'", ")", ")", ")", ";", "}", "$", "this", "->", "debug", "->", "groupEnd", "(", ")", ";", "}" ]

[ "Build", "current", "fields" ]

[ "private", "function", "initPersist", "(", ")", "{", "$", "this", "->", "debug", "->", "groupCollapsed", "(", "__METHOD__", ")", ";", "$", "this", "->", "persist", "=", "new", "Persist", "(", "$", "this", "->", "cfg", "[", "'name'", "]", ",", "array", "(", "'persist'", "=>", "$", "this", "->", "cfg", "[", "'persist'", "]", ",", "'trashCollectable'", "=>", "$", "this", "->", "cfg", "[", "'trashCollectable'", "]", ",", "'userKey'", "=>", "$", "this", "->", "cfg", "[", "'verifyKey'", "]", "?", "(", "isset", "(", "$", "_REQUEST", "[", "'_key_'", "]", ")", "?", "$", "_REQUEST", "[", "'_key_'", "]", ":", "null", ")", ":", "false", ",", ")", ")", ";", "if", "(", "!", "$", "this", "->", "persist", "->", "pageCount", "(", ")", ")", "{", "$", "this", "->", "debug", "->", "info", "(", "'persist just created... add first page'", ")", ";", "$", "firstPageName", "=", "\\", "key", "(", "$", "this", "->", "cfg", "[", "'pages'", "]", ")", ";", "$", "this", "->", "persist", "->", "appendPages", "(", "array", "(", "$", "firstPageName", ")", ")", ";", "}", "$", "this", "->", "debug", "->", "groupEnd", "(", ")", ";", "}" ]

[ "Initialize", "persist", "object" ]

[ "private", "function", "pagesAddEnd", "(", "$", "pagesEnd", "=", "array", "(", ")", ")", "{", "$", "this", "->", "debug", "->", "groupCollapsed", "(", "__METHOD__", ")", ";", "$", "this", "->", "persist", "->", "appendPages", "(", "$", "pagesEnd", ")", ";", "$", "this", "->", "debug", "->", "groupEnd", "(", ")", ";", "}" ]

[ "Add", "pages", "to", "end", "of", "form" ]

[ "private", "function", "pagesAddNext", "(", "$", "pagesNext", "=", "array", "(", ")", ")", "{", "$", "this", "->", "debug", "->", "groupCollapsed", "(", "__METHOD__", ")", ";", "$", "pagesNext", "=", "\\", "array_values", "(", "$", "pagesNext", ")", ";", "$", "pages", "=", "$", "this", "->", "persist", "->", "get", "(", "'pages'", ")", ";", "$", "iCur", "=", "$", "this", "->", "persist", "->", "get", "(", "'i'", ")", ";", "$", "currentPage", "=", "$", "pages", "[", "$", "iCur", "]", ";", "// offset is where we will insert pagesNext", "$", "offset", "=", "$", "iCur", "+", "\\", "count", "(", "$", "currentPage", "[", "'addPages'", "]", ")", "+", "1", ";", "foreach", "(", "$", "pages", "as", "$", "k", "=>", "$", "page", ")", "{", "foreach", "(", "$", "page", "[", "'addPages'", "]", "as", "$", "k2", "=>", "$", "i", ")", "{", "if", "(", "$", "i", ">=", "$", "offset", ")", "{", "$", "pages", "[", "$", "k", "]", "[", "'addPages'", "]", "[", "$", "k2", "]", "+=", "\\", "count", "(", "$", "pagesNext", ")", ";", "}", "}", "}", "foreach", "(", "$", "pagesNext", "as", "$", "i", "=>", "$", "pageName", ")", "{", "$", "pages", "[", "$", "k", "]", "[", "'addPages'", "]", "[", "]", "=", "$", "offset", "+", "$", "i", ";", "\\", "array_splice", "(", "$", "pages", ",", "$", "offset", "+", "$", "i", ",", "0", ",", "array", "(", "array", "(", "'name'", "=>", "$", "pageName", ",", "'completed'", "=>", "false", ",", "'values'", "=>", "array", "(", ")", ",", "'addPages'", "=>", "array", "(", ")", ",", ")", ")", ")", ";", "}", "$", "this", "->", "persist", "->", "set", "(", "'pages'", ",", "$", "pages", ")", ";", "$", "this", "->", "debug", "->", "groupEnd", "(", ")", ";", "}" ]

[ "Add", "pages", "to", "be", "seen", "immediately", "after", "current", "page" ]

[ "private", "function", "processSubmit", "(", ")", "{", "$", "this", "->", "debug", "->", "group", "(", "__METHOD__", ")", ";", "$", "this", "->", "debug", "->", "groupUncollapse", "(", ")", ";", "$", "cfg", "=", "&", "$", "this", "->", "cfg", ";", "$", "status", "=", "&", "$", "this", "->", "status", ";", "if", "(", "$", "status", "[", "'submitted'", "]", ")", "{", "$", "this", "->", "validate", "(", ")", ";", "if", "(", "\\", "is_callable", "(", "$", "cfg", "[", "'post'", "]", ")", ")", "{", "$", "return", "=", "\\", "call_user_func", "(", "$", "cfg", "[", "'post'", "]", ",", "$", "this", ")", ";", "if", "(", "$", "return", "===", "false", ")", "{", "$", "status", "[", "'error'", "]", "=", "true", ";", "}", "// $this->updateInvalid();", "}", "if", "(", "$", "status", "[", "'error'", "]", ")", "{", "// $this->debug->log('status[error]', $status['error']);", "$", "this", "->", "alerts", "->", "add", "(", "$", "cfg", "[", "'messages'", "]", "[", "'errorAlert'", "]", ")", ";", "}", "elseif", "(", "$", "invalidFields", "=", "$", "this", "->", "getInvalidFields", "(", ")", ")", "{", "// $this->debug->log('invalidFields', $invalidFields);", "$", "alert", "=", "$", "cfg", "[", "'messages'", "]", "[", "'invalidAlert'", "]", ";", "foreach", "(", "$", "invalidFields", "as", "$", "field", ")", "{", "if", "(", "!", "\\", "strlen", "(", "$", "field", "->", "attribs", "[", "'value'", "]", ")", ")", "{", "$", "alert", "=", "$", "cfg", "[", "'messages'", "]", "[", "'unansweredAlert'", "]", ";", "break", ";", "}", "}", "$", "this", "->", "alerts", "->", "add", "(", "$", "alert", ")", ";", "}", "else", "{", "$", "this", "->", "debug", "->", "info", "(", "'completed '", ",", "$", "status", "[", "'currentPageName'", "]", ")", ";", "$", "this", "->", "persist", "->", "set", "(", "'currentPage.completed'", ",", "true", ")", ";", "$", "this", "->", "addRemovePages", "(", ")", ";", "if", "(", "$", "this", "->", "persist", "->", "pageCount", "(", "true", ")", "==", "$", "this", "->", "persist", "->", "pageCount", "(", ")", ")", "{", "$", "this", "->", "debug", "->", "info", "(", "'completed all pages'", ")", ";", "$", "status", "[", "'completed'", "]", "=", "true", ";", "$", "complete", "=", "new", "Complete", "(", "$", "this", ")", ";", "$", "return", "=", "$", "complete", "->", "complete", "(", ")", ";", "if", "(", "$", "return", "===", "false", ")", "{", "$", "status", "[", "'error'", "]", "=", "true", ";", "}", "elseif", "(", "\\", "is_string", "(", "$", "return", ")", ")", "{", "$", "cfg", "[", "'messages'", "]", "[", "'completed'", "]", "=", "$", "return", ";", "}", "if", "(", "$", "status", "[", "'error'", "]", ")", "{", "$", "this", "->", "alerts", "->", "add", "(", "$", "this", "->", "cfg", "[", "'messages'", "]", "[", "'errorAlert'", "]", ")", ";", "}", "else", "{", "$", "this", "->", "alerts", "->", "add", "(", "$", "this", "->", "cfg", "[", "'messages'", "]", "[", "'completedAlert'", "]", ")", ";", "}", "if", "(", "$", "this", "->", "status", "[", "'completed'", "]", "&&", "$", "cfg", "[", "'trashOnComplete'", "]", ")", "{", "$", "this", "->", "debug", "->", "warn", "(", "'shutting this whole thing down'", ")", ";", "$", "this", "->", "persist", "->", "remove", "(", ")", ";", "}", "}", "else", "{", "$", "this", "->", "debug", "->", "info", "(", "'more pages to go'", ")", ";", "$", "nextI", "=", "$", "this", "->", "persist", "->", "get", "(", "'nextI'", ")", ";", "$", "this", "->", "setCurrentFields", "(", "$", "nextI", ")", ";", "}", "}", "}", "$", "this", "->", "debug", "->", "groupEnd", "(", ")", ";", "}" ]

[ "Process", "submitted", "values" ]

[ "private", "function", "redirectPost", "(", ")", "{", "if", "(", "!", "isset", "(", "$", "_SERVER", "[", "'REQUEST_URI'", "]", ")", ")", "{", "return", ";", "}", "if", "(", "!", "isset", "(", "$", "_SERVER", "[", "'REQUEST_METHOD'", "]", ")", "||", "$", "_SERVER", "[", "'REQUEST_METHOD'", "]", "!=", "'POST'", ")", "{", "return", ";", "}", "if", "(", "!", "$", "this", "->", "cfg", "[", "'prg'", "]", ")", "{", "return", ";", "}", "if", "(", "!", "$", "this", "->", "status", "[", "'submitted'", "]", ")", "{", "return", ";", "}", "$", "this", "->", "debug", "->", "log", "(", "'redirecting'", ")", ";", "$", "event", "=", "$", "this", "->", "eventManager", "->", "publish", "(", "'page.redirect'", ",", "null", ",", "array", "(", "'location'", "=>", "$", "_SERVER", "[", "'REQUEST_URI'", "]", ")", ")", ";", "$", "location", "=", "$", "event", "[", "'location'", "]", ";", "$", "this", "->", "debug", "->", "log", "(", "'%cLocation:%c <a href=\"%s\">%s</a>'", ",", "'font-weight:bold;'", ",", "''", ",", "$", "location", ",", "$", "location", ")", ";", "if", "(", "\\", "headers_sent", "(", "$", "file", ",", "$", "line", ")", ")", "{", "$", "this", "->", "debug", "->", "warn", "(", "'headers alrady sent from '", ".", "$", "file", ".", "' line '", ".", "$", "line", ")", ";", "return", ";", "}", "if", "(", "$", "event", "->", "isPropagationStopped", "(", ")", ")", "{", "$", "this", "->", "debug", "->", "alert", "(", "'<i class=\"fa fa-external-link fa-lg\" aria-hidden=\"true\"></i> Location: <a class=\"alert-link\" href=\"'", ".", "\\", "htmlspecialchars", "(", "$", "location", ")", ".", "'\">'", ".", "\\", "htmlspecialchars", "(", "$", "location", ")", ".", "'</a>'", ",", "'info'", ")", ";", "}", "else", "{", "\\", "header", "(", "'Location: '", ".", "$", "location", ")", ";", "}", "throw", "new", "\\", "Exception", "(", "'exit'", ")", ";", "}" ]

[ "Stores", "submitted", "values", "in", "persistence", "Redirects", "if", "submoitted", "via", "POST" ]

[ "private", "function", "resetStatus", "(", ")", "{", "$", "this", "->", "debug", "->", "info", "(", "'resetStatus'", ")", ";", "$", "this", "->", "status", "=", "\\", "array_merge", "(", "$", "this", "->", "status", ",", "array", "(", "'currentPageName'", "=>", "$", "this", "->", "persist", "->", "get", "(", "'currentPage.name'", ")", ",", "// 'keyVerified' => false, // don't reset", "// 'submitted' => false, // don't reset", "'completed'", "=>", "false", ",", "'error'", "=>", "false", ",", "'postMaxExceeded'", "=>", "false", ",", "'multipart'", "=>", "false", ",", "// multipart form (file fields)?", "'additionalPages'", "=>", "array", "(", ")", ",", "// 'invalidFields' => array(),", "'idCounts'", "=>", "array", "(", ")", ",", ")", ")", ";", "}" ]

[ "Reset", "form", "status" ]

[ "private", "function", "storeValues", "(", ")", "{", "$", "this", "->", "debug", "->", "groupCollapsed", "(", "__METHOD__", ")", ";", "// if (!$this->status['keyVerified']) {", "if", "(", "!", "$", "this", "->", "status", "[", "'submitted'", "]", ")", "{", "// $this->debug->warn('not submitted');", "$", "this", "->", "debug", "->", "groupEnd", "(", ")", ";", "return", ";", "}", "if", "(", "isset", "(", "$", "_SERVER", "[", "'REQUEST_METHOD'", "]", ")", "&&", "$", "_SERVER", "[", "'REQUEST_METHOD'", "]", "==", "'POST'", ")", "{", "$", "this", "->", "debug", "->", "warn", "(", "'POST method'", ")", ";", "if", "(", "isset", "(", "$", "_SERVER", "[", "'CONTENT_LENGTH'", "]", ")", "&&", "$", "_SERVER", "[", "'CONTENT_LENGTH'", "]", ">", "Str", "::", "getBytes", "(", "\\", "ini_get", "(", "'post_max_size'", ")", ",", "true", ")", ")", "{", "$", "this", "->", "debug", "->", "warn", "(", "'post_max_size exceeded'", ")", ";", "$", "this", "->", "alerts", "->", "add", "(", "'Your upload has exceeded the '", ".", "Str", "::", "getBytes", "(", "\\", "ini_get", "(", "'post_max_size'", ")", ")", ".", "' limit'", ")", ";", "$", "this", "->", "status", "[", "'postMaxExceeded'", "]", "=", "true", ";", "}", "$", "values", "=", "$", "_POST", ";", "foreach", "(", "$", "_FILES", "as", "$", "k", "=>", "$", "file", ")", "{", "if", "(", "$", "file", "[", "'error'", "]", "===", "UPLOAD_ERR_NO_FILE", ")", "{", "continue", ";", "}", "if", "(", "$", "file", "[", "'error'", "]", "===", "UPLOAD_ERR_OK", ")", "{", "// by calling move_uploaded_file, we prevent its automatic deletion", "\\", "move_uploaded_file", "(", "$", "file", "[", "'tmp_name'", "]", ",", "$", "file", "[", "'tmp_name'", "]", ")", ";", "}", "$", "values", "[", "$", "k", "]", "=", "$", "file", ";", "/*\n errors:\n UPLOAD_ERR_OK => 'There is no error, the file uploaded with success',\n UPLOAD_ERR_INI_SIZE => 'The uploaded file exceeds the upload_max_filesize directive in php.ini ('.\\ini_get('upload_max_filesize').')',\n UPLOAD_ERR_FORM_SIZE => 'The uploaded file exceeds the MAX_FILE_SIZE directive that was specified in the HTML form',\n UPLOAD_ERR_PARTIAL => 'The uploaded file was only partially uploaded',\n UPLOAD_ERR_NO_FILE => 'No file was uploaded',\n UPLOAD_ERR_NO_TMP_DIR => 'Missing a temporary folder',\n UPLOAD_ERR_CANT_WRITE => 'Failed to write file to disk.',\n UPLOAD_ERR_EXTENSION => 'A PHP extension stopped the file upload.',\n */", "}", "$", "this", "->", "status", "[", "'submitted'", "]", "=", "true", ";", "$", "this", "->", "persist", "->", "set", "(", "'submitted'", ",", "true", ")", ";", "$", "this", "->", "persist", "->", "set", "(", "'currentPage.values'", ",", "$", "values", ")", ";", "}", "elseif", "(", "\\", "strtolower", "(", "$", "this", "->", "cfg", "[", "'attribs'", "]", "[", "'method'", "]", ")", "==", "'get'", ")", "{", "$", "this", "->", "debug", "->", "warn", "(", "'storing GET vals'", ")", ";", "$", "this", "->", "persist", "->", "set", "(", "'currentPage.values'", ",", "$", "_GET", ")", ";", "}", "$", "this", "->", "debug", "->", "groupEnd", "(", ")", ";", "}" ]

[ "Copies", "request", "params", "to", "persist", "for", "storage" ]

[ "private", "function", "produceExchangeInstance", "(", "$", "exchangeName", ")", "{", "if", "(", "isset", "(", "$", "this", "->", "declaredExchangeInstances", "[", "$", "exchangeName", "]", ")", ")", "{", "return", "$", "this", "->", "declaredExchangeInstances", "[", "$", "exchangeName", "]", ";", "}", "if", "(", "isset", "(", "$", "this", "->", "usedExchangeInstances", "[", "$", "exchangeName", "]", ")", ")", "{", "return", "$", "this", "->", "usedExchangeInstances", "[", "$", "exchangeName", "]", ";", "}", "$", "this", "->", "ensureChannel", "(", ")", ";", "$", "exchange", "=", "new", "AMQPExchange", "(", "$", "this", "->", "channel", ")", ";", "$", "exchange", "->", "setName", "(", "$", "exchangeName", ")", ";", "$", "this", "->", "usedExchangeInstances", "[", "$", "exchangeName", "]", "=", "$", "exchange", ";", "return", "$", "exchange", ";", "}" ]

[ "It", "returns", "a", "cached", "exchange", "or", "a", "new", "one", "if", "none", "exists", "." ]

[ "private", "function", "produceQueueInstance", "(", "$", "queueName", ")", "{", "if", "(", "isset", "(", "$", "this", "->", "declaredQueueInstances", "[", "$", "queueName", "]", ")", ")", "{", "return", "$", "this", "->", "declaredQueueInstances", "[", "$", "queueName", "]", ";", "}", "if", "(", "isset", "(", "$", "this", "->", "usedQueueInstances", "[", "$", "queueName", "]", ")", ")", "{", "return", "$", "this", "->", "usedQueueInstances", "[", "$", "queueName", "]", ";", "}", "$", "this", "->", "ensureChannel", "(", ")", ";", "$", "queue", "=", "new", "AMQPQueue", "(", "$", "this", "->", "channel", ")", ";", "$", "queue", "->", "setName", "(", "$", "queueName", ")", ";", "$", "this", "->", "usedQueueInstances", "[", "$", "queueName", "]", "=", "$", "queue", ";", "return", "$", "queue", ";", "}" ]

[ "It", "returns", "a", "cached", "queue", "or", "a", "new", "one", "if", "none", "exists", "." ]

[ "public", "function", "actionLogin", "(", "$", "view", "=", "'login'", ",", "$", "partial", "=", "false", ")", "{", "if", "(", "!", "\\", "Yii", "::", "$", "app", "->", "user", "->", "isGuest", ")", "{", "return", "$", "this", "->", "goHome", "(", ")", ";", "}", "$", "model", "=", "new", "LoginForm", "(", ")", ";", "if", "(", "$", "model", "->", "load", "(", "Yii", "::", "$", "app", "->", "request", "->", "post", "(", ")", ")", "&&", "$", "model", "->", "login", "(", ")", ")", "{", "return", "$", "this", "->", "redirect", "(", "$", "this", "->", "getLoginRedirect", "(", ")", ")", ";", "}", "if", "(", "\\", "Yii", "::", "$", "app", "->", "request", "->", "isAjax", "||", "$", "partial", ")", "{", "return", "$", "this", "->", "renderAjax", "(", "$", "view", ",", "compact", "(", "'model'", ")", ")", ";", "}", "return", "$", "this", "->", "render", "(", "$", "view", ",", "compact", "(", "'model'", ")", ")", ";", "}" ]

[ "Renders", "login", "form", "." ]

[ "public", "function", "actionRegister", "(", ")", "{", "if", "(", "!", "\\", "Yii", "::", "$", "app", "->", "user", "->", "isGuest", ")", "{", "return", "$", "this", "->", "goHome", "(", ")", ";", "}", "$", "model", "=", "new", "RegisterForm", "(", ")", ";", "if", "(", "$", "model", "->", "load", "(", "Yii", "::", "$", "app", "->", "request", "->", "post", "(", ")", ")", "&&", "$", "model", "->", "save", "(", ")", ")", "{", "Yii", "::", "$", "app", "->", "session", "->", "setFlash", "(", "\"success\"", ",", "Yii", "::", "$", "app", "->", "user", "->", "isGuest", "?", "Yii", "::", "t", "(", "'modules/user'", ",", "'Please confirm registration email!'", ")", ":", "Yii", "::", "t", "(", "'modules/user'", ",", "'Registration completed!'", ")", ")", ";", "return", "(", "(", "$", "url", "=", "$", "this", "->", "getLoginRedirect", "(", ")", ")", "&&", "!", "Yii", "::", "$", "app", "->", "user", "->", "isGuest", ")", "?", "$", "this", "->", "redirect", "(", "$", "url", ")", ":", "$", "this", "->", "goBack", "(", ")", ";", "}", "return", "$", "this", "->", "render", "(", "'register'", ",", "compact", "(", "'model'", ")", ")", ";", "}" ]

[ "Registers", "user", "." ]

[ "public", "function", "actionConfirm", "(", "$", "auth_key", ")", "{", "$", "model", "=", "$", "this", "->", "findModel", "(", "true", ")", ";", "/**\n * @var User $user\n */", "if", "(", "$", "auth_key", "&&", "(", "$", "user", "=", "$", "model", "::", "findOne", "(", "compact", "(", "'auth_key'", ")", ")", ")", ")", "{", "Yii", "::", "$", "app", "->", "session", "->", "setFlash", "(", "\"success\"", ",", "Yii", "::", "t", "(", "'modules/user'", ",", "\"You have successfully completed your registration. Please set your password.\"", ")", ")", ";", "Yii", "::", "$", "app", "->", "user", "->", "login", "(", "$", "user", ")", ";", "$", "user", "->", "activate", "(", ")", ";", "}", "else", "{", "Yii", "::", "$", "app", "->", "session", "->", "setFlash", "(", "\"error\"", ",", "Yii", "::", "t", "(", "'modules/user'", ",", "\"Your auth link is invalid.\"", ")", ")", ";", "return", "$", "this", "->", "goHome", "(", ")", ";", "}", "$", "this", "->", "redirect", "(", "[", "'update'", "]", ")", ";", "}" ]

[ "For", "registration", "confirmation", "by", "email", "auth", "link", "." ]

[ "public", "function", "findModel", "(", "$", "new", "=", "false", ")", "{", "$", "class", "=", "\\", "Yii", "::", "$", "app", "->", "user", "->", "identityClass", ";", "return", "$", "new", "===", "true", "?", "new", "$", "class", "(", ")", ":", "Yii", "::", "$", "app", "->", "user", "->", "identity", ";", "}" ]

[ "Finds", "user", "model", "." ]

[ "public", "function", "fetch", "(", ")", "{", "$", "ret", "=", "array", "(", ")", ";", "$", "pos", "=", "0", ";", "$", "len", "=", "count", "(", "$", "this", "->", "_arguments", ")", ";", "foreach", "(", "$", "this", "->", "_descriptors", "as", "$", "name", "=>", "$", "descriptor", ")", "{", "$", "value", "=", "$", "descriptor", "->", "getDefault", "(", ")", ";", "for", "(", "$", "i", "=", "$", "pos", ";", ";", "$", "i", "++", ")", "{", "if", "(", "$", "i", "<", "$", "len", "&&", "$", "descriptor", "->", "match", "(", "$", "this", "->", "_arguments", "[", "$", "i", "]", ")", ")", "{", "$", "value", "=", "$", "this", "->", "_arguments", "[", "$", "i", "]", ";", "$", "pos", "=", "$", "i", "+", "1", ";", "break", ";", "}", "else", "{", "if", "(", "$", "descriptor", "->", "isRequired", "(", ")", ")", "{", "throw", "new", "InvalidArgumentException", "(", "\"Argument is required: `$name`\"", ")", ";", "}", "if", "(", "$", "i", ">", "$", "len", "-", "1", ")", "{", "break", ";", "}", "}", "}", "$", "ret", "[", "$", "name", "]", "=", "$", "value", ";", "}", "return", "$", "ret", ";", "}" ]

[ "Fetches", "elements", "from", "the", "arguments", "that", "matches", "specific", "descriptors", "." ]

[ "public", "function", "replaceKeys", "(", "FilterResponseEvent", "$", "event", ")", "{", "if", "(", "!", "$", "event", "->", "isMasterRequest", "(", ")", ")", "{", "return", ";", "}", "if", "(", "$", "this", "->", "controller", "!==", "$", "event", "->", "getRequest", "(", ")", "->", "attributes", "->", "get", "(", "'_controller'", ")", ")", "{", "return", ";", "}", "$", "response", "=", "$", "event", "->", "getResponse", "(", ")", ";", "$", "content", "=", "preg_replace", "(", "$", "this", "->", "pattern", ",", "$", "this", "->", "replacement", ",", "$", "response", "->", "getContent", "(", ")", ")", ";", "$", "response", "->", "setContent", "(", "$", "content", ")", ";", "}" ]

[ "Replace", "Sylius", "translation", "keys", "." ]

[ "private", "function", "uriKeyExists", "(", "$", "nextUriPart", ",", "array", "$", "pageMap", ")", "{", "if", "(", "array_key_exists", "(", "$", "nextUriPart", ",", "$", "pageMap", ")", ")", "{", "return", "$", "nextUriPart", ";", "}", "$", "keys", "=", "array_keys", "(", "$", "pageMap", ")", ";", "$", "variableParts", "=", "array_values", "(", "preg_grep", "(", "'/\\{(.*)\\}/'", ",", "$", "keys", ")", ")", ";", "$", "variablePartsCount", "=", "count", "(", "$", "variableParts", ")", ";", "if", "(", "$", "variablePartsCount", "===", "0", ")", "{", "return", "null", ";", "}", "elseif", "(", "$", "variablePartsCount", ">", "1", ")", "{", "throw", "new", "RoutingException", "(", "'Single node has more than one variable key'", ")", ";", "}", "$", "variablePartRaw", "=", "$", "variableParts", "[", "0", "]", ";", "$", "variablePart", "=", "preg_replace", "(", "[", "'/\\{/'", ",", "'/\\}/'", "]", ",", "''", ",", "$", "variablePartRaw", ")", ";", "if", "(", "array_key_exists", "(", "$", "variablePart", ",", "$", "this", "->", "uriVariables", ")", ")", "{", "throw", "new", "RoutingException", "(", "'a key named '", ".", "$", "variablePart", ".", "' appears more than once on a single route'", ")", ";", "}", "$", "this", "->", "uriVariables", "[", "$", "variablePart", "]", "=", "$", "nextUriPart", ";", "return", "$", "variablePartRaw", ";", "}" ]

[ "Checks", "if", "there", "is", "a", "key", "in", "the", "page", "map", "for", "the", "given", "uri", "part", ".", "If", "there", "is", "a", "wildcard", "in", "the", "url", "it", "will", "save", "the", "wildcard", "+", "it", "s", "value" ]

[ "public", "function", "getFullPath", "(", ")", "{", "$", "key", "=", "'template.templatePath'", ";", "if", "(", "$", "this", "->", "type", "===", "self", "::", "PART_BODY", ")", "{", "$", "key", "=", "'template.viewPath'", ";", "}", "$", "path", "=", "Configuration", "::", "get", "(", "$", "key", ",", "null", ")", ";", "if", "(", "$", "path", "===", "null", ")", "{", "// @codeCoverageIgnore", "throw", "new", "ConfigurationException", "(", "\"The template.templatePath or template.viewPath isn't configured right or doesn't exists!\"", ")", ";", "// @codeCoverageIgnore", "}", "// @codeCoverageIgnore", "$", "foundView", "=", "false", ";", "try", "{", "AppManager", "::", "getInstance", "(", ")", "->", "initApps", "(", ")", ";", "}", "catch", "(", "\\", "Exception", "$", "exception", ")", "{", "}", "foreach", "(", "AppManager", "::", "getInstance", "(", ")", "->", "getApps", "(", ")", "as", "$", "app", ")", "{", "$", "testPath", "=", "$", "app", "->", "getAppDirectory", "(", ")", ".", "DS", ".", "$", "path", ".", "DS", ".", "$", "this", "->", "getPath", "(", ")", ";", "if", "(", "is_file", "(", "$", "testPath", ")", ")", "{", "$", "path", "=", "$", "testPath", ";", "$", "foundView", "=", "true", ";", "}", "}", "if", "(", "!", "$", "foundView", ")", "{", "throw", "new", "NotFoundException", "(", "'Template or view file not found in any apps!'", ")", ";", "}", "return", "$", "path", ";", "}" ]

[ "Get", "full", "path", "of", "view", "file", "." ]

[ "private", "function", "writeMessage", "(", "string", "$", "level", ",", "string", "$", "message", ",", "string", "$", "tag", ",", "string", "$", "file", ",", "int", "$", "line", ",", "array", "$", "target_loggers", ")", "{", "if", "(", "!", "$", "this", "->", "logger_config", "->", "isLogEnabled", "(", ")", ")", "{", "return", ";", "}", "// determine log level filter", "$", "log_level_filter", "=", "'E'", ";", "foreach", "(", "$", "this", "->", "logger_config", "->", "getLogLevelFilters", "(", ")", "as", "$", "path", "=>", "$", "lv", ")", "{", "if", "(", "$", "this", "->", "route_context", "===", "$", "path", "||", "strpos", "(", "$", "this", "->", "route_context", ",", "$", "path", ")", "===", "0", ")", "{", "$", "log_level_filter", "=", "$", "lv", ";", "}", "}", "// do not output message when log level does not meet the filter level", "$", "cmp", "=", "self", "::", "compareLogLevel", "(", "$", "level", ",", "$", "log_level_filter", ")", ";", "if", "(", "$", "cmp", ">", "0", ")", "{", "return", ";", "}", "// ignore different tags", "$", "log_tag_filters", "=", "$", "this", "->", "logger_config", "->", "getTagFilters", "(", ")", ";", "if", "(", "is_array", "(", "$", "log_tag_filters", ")", "&&", "!", "empty", "(", "$", "log_tag_filters", ")", ")", "{", "if", "(", "!", "in_array", "(", "$", "tag", ",", "$", "log_tag_filters", ")", ")", "{", "return", ";", "}", "}", "$", "msg", "=", "new", "LogMessage", "(", "$", "level", ",", "$", "message", ",", "$", "tag", ",", "$", "file", ",", "$", "line", ")", ";", "foreach", "(", "$", "target_loggers", "as", "$", "key", ")", "{", "if", "(", "isset", "(", "$", "this", "->", "loggers", "[", "$", "key", "]", ")", "&&", "in_array", "(", "$", "key", ",", "$", "target_loggers", ")", ")", "{", "$", "this", "->", "loggers", "[", "$", "key", "]", "->", "writeln", "(", "$", "msg", ")", ";", "}", "}", "}" ]

[ "write", "a", "message" ]

[ "public", "function", "terminate", "(", ")", "{", "if", "(", "$", "this", "->", "loggers", ")", "{", "foreach", "(", "$", "this", "->", "loggers", "as", "$", "key", "=>", "$", "logger", ")", "{", "$", "logger", "->", "writeFooter", "(", ")", ";", "$", "logger", "->", "terminate", "(", ")", ";", "unset", "(", "$", "this", "->", "loggers", "[", "$", "key", "]", ")", ";", "}", "$", "this", "->", "loggers", "=", "NULL", ";", "}", "}" ]

[ "shutdown", "all", "loggers" ]

[ "public", "function", "trace", "(", "string", "$", "file", ",", "int", "$", "line", ",", "string", "$", "target", ",", "string", "$", "message", ",", "string", "$", "tag", "=", "NULL", ")", "{", "self", "::", "log", "(", "$", "file", ",", "$", "line", ",", "\"T:$target\"", ",", "$", "message", ",", "$", "tag", ")", ";", "}" ]

[ "write", "trace", "log" ]

[ "private", "function", "_getLevelAndTargetLoggers", "(", "$", "target", ")", "{", "$", "target", "=", "strpos", "(", "$", "target", ",", "':'", ")", "!==", "false", "?", "explode", "(", "':'", ",", "$", "target", ")", ":", "[", "''", ",", "'*'", "]", ";", "list", "(", "$", "level", ",", "$", "target_loggers", ")", "=", "$", "target", ";", "$", "target_loggers", "=", "explode", "(", "','", ",", "$", "target_loggers", ")", ";", "$", "target_loggers", "=", "array_map", "(", "'trim'", ",", "$", "target_loggers", ")", ";", "if", "(", "in_array", "(", "'*'", ",", "$", "target_loggers", ")", ")", "{", "$", "target_loggers", "=", "array_keys", "(", "$", "this", "->", "loggers", ")", ";", "}", "return", "array", "(", "$", "level", ",", "$", "target_loggers", ")", ";", "}" ]

[ "Split", "target", "loggers", "and", "levels", "from", "target", "list" ]

[ "public", "static", "function", "instance", "(", "$", "object", ")", "{", "if", "(", "!", "is_object", "(", "$", "object", ")", ")", "{", "throw", "new", "\\", "InvalidArgumentException", "(", "'Only objects are allowed to be passed to the helper.'", ")", ";", "}", "$", "response", "=", "new", "self", "(", ")", ";", "$", "response", "->", "origin", "=", "$", "object", ";", "$", "response", "->", "target", "=", "new", "ReflectionClass", "(", "$", "object", ")", ";", "return", "$", "response", ";", "}" ]

[ "Creates", "and", "returns", "the", "wrapper", ".", "Only", "objects", "are", "allowed", "to", "be", "passed", "else", "an", "exception", "will", "be", "thrown", ".", "Store", "the", "input", "object", "to", "the", "created", "wrapper", "." ]

[ "public", "function", "parsePath", "(", "?", "string", "$", "path", "=", "null", ")", ":", "?", "string", "{", "if", "(", "$", "path", "===", "null", ")", "{", "return", "null", ";", "}", "$", "path", "=", "\\", "str_replace", "(", "'%DOCUMENT_ROOT%'", ",", "$", "this", "->", "documentRoot", ",", "$", "path", ")", ";", "$", "path", "=", "\\", "str_replace", "(", "[", "'\\\\'", ",", "'/'", "]", ",", "DIRECTORY_SEPARATOR", ",", "$", "path", ")", ";", "return", "$", "path", ";", "}" ]

[ "Replaces", "predefined", "constants", "in", "path", "string", "to", "document", "and", "framework", "root" ]

[ "public", "function", "register", "(", "$", "eventType", ",", "callable", "$", "filter", ")", "{", "if", "(", "!", "isset", "(", "$", "this", "->", "handlers", "[", "$", "eventType", "]", ")", ")", "{", "$", "this", "->", "handlers", "[", "$", "eventType", "]", "=", "[", "]", ";", "}", "$", "this", "->", "handlers", "[", "$", "eventType", "]", "[", "]", "=", "$", "filter", ";", "}" ]

[ "Registers", "a", "filter", "function", "." ]

[ "public", "function", "start", "(", "int", "$", "maxRuntimeInSec", "=", "60", "*", "15", ")", ":", "void", "{", "\\", "pcntl_signal", "(", "SIGTERM", ",", "function", "(", ")", "{", "$", "this", "->", "shouldTerminate", "=", "true", ";", "$", "this", "->", "logger", "->", "debug", "(", "'Caught SIGTERM, worker goes into termination.'", ")", ";", "}", ")", ";", "$", "this", "->", "startedTime", "=", "\\", "time", "(", ")", ";", "$", "this", "->", "logger", "->", "info", "(", "'Worker started: '", ".", "$", "this", "->", "name", ")", ";", "while", "(", "!", "$", "this", "->", "shouldTerminate", "||", "0", "<", "\\", "count", "(", "$", "this", "->", "runningJobs", ")", ")", "{", "\\", "pcntl_signal_dispatch", "(", ")", ";", "$", "this", "->", "checkRunningJobs", "(", ")", ";", "if", "(", "!", "$", "this", "->", "shouldTerminate", ")", "{", "if", "(", "\\", "count", "(", "$", "this", "->", "runningJobs", ")", "<", "$", "this", "->", "maxJobs", "&&", "null", "!==", "$", "job", "=", "$", "this", "->", "queue", "->", "dequeue", "(", ")", ")", "{", "$", "this", "->", "handleDequeuedJob", "(", "$", "job", ")", ";", "}", "if", "(", "\\", "time", "(", ")", ">", "$", "this", "->", "startedTime", "+", "$", "maxRuntimeInSec", ")", "{", "$", "this", "->", "shouldTerminate", "=", "true", ";", "$", "this", "->", "logger", "->", "debug", "(", "'Elapsed maximum runtime, worker goes into termination.'", ")", ";", "}", "}", "\\", "usleep", "(", "500000", ")", ";", "}", "}" ]

[ "Starts", "polling", "to", "run", "jobs", "." ]

[ "public", "function", "show", "(", ")", "{", "//get the global $config array for site title", "global", "$", "config", ";", "//set the title variable", "$", "title", "=", "$", "config", "[", "'title'", "]", ";", "//the variable to be populated with the error message", "$", "msg", "=", "$", "this", "->", "getCode", "(", ")", ".", "': Error on line '", ".", "$", "this", "->", "getLine", "(", ")", ".", "' in '", ".", "$", "this", "->", "getFile", "(", ")", ".", "': <b> \"'", ".", "$", "this", "->", "getMessage", "(", ")", ".", "' \" </b> '", ";", "//load the template file", "include", "Path", "::", "sys", "(", ")", ".", "'Exceptions'", ".", "DIRECTORY_SEPARATOR", ".", "'index.php'", ";", "//stop further output", "exit", "(", ")", ";", "}" ]

[ "This", "method", "displays", "the", "error", "message" ]

[ "public", "static", "function", "add", "(", "array", "&", "$", "array", ",", "string", "$", "key", ",", "$", "value", ",", "string", "$", "delimiter", "=", "null", ")", "{", "if", "(", "null", "===", "static", "::", "get", "(", "$", "array", ",", "$", "key", ",", "null", ",", "$", "delimiter", ")", ")", "{", "static", "::", "set", "(", "$", "array", ",", "$", "key", ",", "$", "value", ",", "$", "delimiter", ")", ";", "}", "}" ]

[ "Adds", "an", "element", "to", "the", "given", "array", "but", "only", "if", "it", "does", "not", "yet", "exist", "." ]

[ "public", "static", "function", "collapse", "(", "array", "$", "array", ")", ":", "array", "{", "$", "results", "=", "[", "]", ";", "foreach", "(", "$", "array", "as", "$", "key", "=>", "$", "item", ")", "{", "// Nested arrays will be merged in (non-recursively).", "if", "(", "is_array", "(", "$", "item", ")", ")", "{", "$", "results", "=", "array_merge", "(", "$", "results", ",", "$", "item", ")", ";", "continue", ";", "}", "// Values with numeric keys will be appended in any case.", "if", "(", "is_int", "(", "$", "key", ")", ")", "{", "$", "results", "[", "]", "=", "$", "item", ";", "continue", ";", "}", "// Non-numeric keys. If we've got the given key in $results already, it means it was merged", "// in from one of the nested arrays and those are meant to overwrite the initial values on collisions -", "// thus we're not going to do anything in that case.", "if", "(", "!", "array_key_exists", "(", "$", "key", ",", "$", "results", ")", ")", "{", "$", "results", "[", "$", "key", "]", "=", "$", "item", ";", "}", "}", "return", "$", "results", ";", "}" ]

[ "Collapses", "an", "array", "of", "arrays", "into", "a", "single", "array", ".", "Not", "recursive", "ie", ".", "only", "the", "first", "dimension", "of", "arrays", "will", "be", "collapsed", "down", "." ]

[ "public", "static", "function", "contains", "(", "array", "$", "haystack", ",", "$", "needle", ",", "bool", "$", "strict", "=", "true", ")", "{", "foreach", "(", "$", "haystack", "as", "$", "value", ")", "{", "if", "(", "(", "!", "$", "strict", "&&", "$", "needle", "==", "$", "value", ")", "||", "$", "needle", "===", "$", "value", ")", "{", "return", "true", ";", "}", "if", "(", "is_array", "(", "$", "value", ")", "&&", "static", "::", "contains", "(", "$", "needle", ",", "$", "value", ",", "$", "strict", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Checks", "whether", "the", "given", "value", "is", "contained", "within", "the", "given", "array", ".", "Equivalent", "of", "a", "recursive", "in_array", ".", "When", "you", "are", "sure", "you", "are", "dealing", "with", "a", "1", "-", "dimensional", "array", "use", "in_array", "instead", "to", "avoid", "the", "overhead", "." ]

[ "public", "static", "function", "delimit", "(", "array", "$", "array", ",", "string", "$", "prepend", "=", "''", ",", "string", "$", "delimiter", "=", "null", ")", "{", "// Results holder.", "$", "results", "=", "[", "]", ";", "// Which string delimiter should we use?", "if", "(", "null", "===", "$", "delimiter", ")", "{", "$", "delimiter", "=", "static", "::", "$", "delimiter", ";", "}", "foreach", "(", "$", "array", "as", "$", "key", "=>", "$", "value", ")", "{", "if", "(", "is_array", "(", "$", "value", ")", "&&", "!", "empty", "(", "$", "value", ")", ")", "{", "$", "results", "=", "array_merge", "(", "$", "results", ",", "static", "::", "delimit", "(", "$", "value", ",", "$", "prepend", ".", "$", "key", ".", "$", "delimiter", ")", ")", ";", "}", "else", "{", "$", "results", "[", "$", "prepend", ".", "$", "key", "]", "=", "$", "value", ";", "}", "}", "return", "$", "results", ";", "}" ]

[ "Flattens", "a", "multi", "-", "dimensional", "array", "using", "the", "given", "delimiter", "." ]

[ "public", "static", "function", "fetch", "(", "array", "$", "array", ",", "string", "$", "key", ",", "string", "$", "delimiter", "=", "null", ")", ":", "array", "{", "// Results holder.", "$", "results", "=", "[", "]", ";", "// Which string delimiter should we use?", "if", "(", "null", "===", "$", "delimiter", ")", "{", "$", "delimiter", "=", "static", "::", "$", "delimiter", ";", "}", "foreach", "(", "explode", "(", "$", "delimiter", ",", "$", "key", ")", "as", "$", "segment", ")", "{", "$", "results", "=", "[", "]", ";", "foreach", "(", "$", "array", "as", "$", "value", ")", "{", "$", "value", "=", "(", "array", ")", "$", "value", ";", "$", "results", "[", "]", "=", "$", "value", "[", "$", "segment", "]", ";", "}", "$", "array", "=", "array_values", "(", "$", "results", ")", ";", "}", "return", "array_values", "(", "$", "results", ")", ";", "}" ]

[ "Fetches", "a", "flattened", "array", "of", "an", "element", "nested", "in", "the", "initial", "array", "." ]

[ "public", "static", "function", "find", "(", "array", "$", "array", ",", "callable", "$", "callback", ",", "$", "default", "=", "null", ")", "{", "foreach", "(", "$", "array", "as", "$", "key", "=>", "$", "value", ")", "{", "if", "(", "$", "callback", "(", "$", "value", ",", "$", "key", ")", ")", "{", "return", "$", "value", ";", "}", "}", "return", "$", "default", ";", "}" ]

[ "Returns", "the", "first", "value", "which", "passes", "the", "given", "truth", "test", "." ]

[ "public", "static", "function", "get", "(", "array", "$", "array", ",", "$", "key", "=", "null", ",", "$", "default", "=", "null", ",", "string", "$", "delimiter", "=", "null", ")", "{", "// Make loops easier for the end-user - return the initial array if the key is null instead of forcing", "// a valid value.", "if", "(", "!", "isset", "(", "$", "key", ")", ")", "{", "return", "$", "array", ";", "}", "// Which string delimiter should we use?", "if", "(", "!", "isset", "(", "$", "delimiter", ")", ")", "{", "$", "delimiter", "=", "static", "::", "$", "delimiter", ";", "}", "// If the key is string delimited, we need to explode it into an array of segments.", "$", "segments", "=", "is_array", "(", "$", "key", ")", "?", "$", "key", ":", "explode", "(", "$", "delimiter", ",", "$", "key", ")", ";", "// One dimension at a time.", "while", "(", "$", "segment", "=", "array_shift", "(", "$", "segments", ")", ")", "{", "// If the current segment is a wildcard, make sure the it points to an array", "// and pluck the remaining segments from it.", "if", "(", "$", "segment", "===", "'*'", ")", "{", "return", "is_array", "(", "$", "array", ")", "?", "static", "::", "pluck", "(", "$", "array", ",", "$", "segments", ",", "$", "delimiter", ")", ":", "$", "default", ";", "}", "// Note: isset() is the cheapest condition to check for while being rather probable at the same time,", "// thus the seemingly unintuitive condition ordering.", "if", "(", "isset", "(", "$", "array", "->", "{", "$", "segment", "}", ")", ")", "{", "$", "array", "=", "$", "array", "->", "{", "$", "segment", "}", ";", "}", "elseif", "(", "is_array", "(", "$", "array", ")", "&&", "array_key_exists", "(", "$", "segment", ",", "$", "array", ")", ")", "{", "$", "array", "=", "$", "array", "[", "$", "segment", "]", ";", "}", "else", "{", "return", "$", "default", ";", "}", "}", "return", "$", "array", ";", "}" ]

[ "Returns", "a", "string", "delimited", "key", "from", "an", "array", "with", "a", "default", "value", "if", "the", "given", "key", "does", "not", "exist", ".", "If", "null", "is", "given", "instead", "of", "a", "key", "the", "whole", "initial", "array", "will", "be", "returned", "." ]

[ "public", "static", "function", "has", "(", "array", "$", "array", ",", "string", "$", "key", ",", "string", "$", "delimiter", "=", "null", ")", "{", "// Which string delimiter should we use?", "if", "(", "null", "===", "$", "delimiter", ")", "{", "$", "delimiter", "=", "static", "::", "$", "delimiter", ";", "}", "foreach", "(", "explode", "(", "$", "delimiter", ",", "$", "key", ")", "as", "$", "segment", ")", "{", "if", "(", "!", "is_array", "(", "$", "array", ")", "||", "!", "array_key_exists", "(", "$", "segment", ",", "$", "array", ")", ")", "{", "return", "false", ";", "}", "$", "array", "=", "$", "array", "[", "$", "segment", "]", ";", "}", "return", "true", ";", "}" ]

[ "Checks", "whether", "the", "given", "string", "delimited", "key", "exists", "in", "the", "array", "." ]

[ "public", "static", "function", "pull", "(", "&", "$", "array", ",", "string", "$", "key", ",", "string", "$", "delimiter", "=", "null", ")", "{", "$", "value", "=", "static", "::", "get", "(", "$", "array", ",", "$", "key", ",", "null", ",", "$", "delimiter", ")", ";", "static", "::", "remove", "(", "$", "array", ",", "$", "key", ",", "$", "delimiter", ")", ";", "return", "$", "value", ";", "}" ]

[ "Returns", "the", "value", "for", "a", "string", "delimited", "key", "from", "an", "array", "and", "then", "removes", "it", "." ]

[ "public", "static", "function", "remove", "(", "array", "&", "$", "array", ",", "string", "$", "key", ",", "string", "$", "delimiter", "=", "null", ")", "{", "// Which string delimiter should we use?", "if", "(", "!", "isset", "(", "$", "delimiter", ")", ")", "{", "$", "delimiter", "=", "static", "::", "$", "delimiter", ";", "}", "// Explode the key according to that delimiter.", "$", "keys", "=", "explode", "(", "$", "delimiter", ",", "$", "key", ")", ";", "while", "(", "$", "key", "=", "array_shift", "(", "$", "keys", ")", ")", "{", "if", "(", "!", "isset", "(", "$", "array", "[", "$", "key", "]", ")", "||", "!", "is_array", "(", "$", "array", "[", "$", "key", "]", ")", ")", "{", "return", ";", "}", "$", "array", "=", "&", "$", "array", "[", "$", "key", "]", ";", "}", "unset", "(", "$", "array", "[", "array_shift", "(", "$", "keys", ")", "]", ")", ";", "}" ]

[ "Removes", "a", "string", "delimited", "key", "from", "the", "given", "array", "." ]

[ "protected", "function", "_sendRequest", "(", "array", "$", "parameters", ")", "{", "$", "this", "->", "_curlInfo", "=", "[", "]", ";", "// Merge defined parameters with default parameters", "$", "parameters", "=", "array_merge", "(", "static", "::", "DEFAULT_REQUEST_PARAMS", ",", "$", "parameters", ")", ";", "// close existing curl handle if defined", "$", "this", "->", "_closeCurl", "(", ")", ";", "// Init the curl handle", "$", "this", "->", "_initCurl", "(", "$", "parameters", ")", ";", "// If output should be redirected to a file, set the option", "$", "toFilePointer", "=", "null", ";", "if", "(", "isset", "(", "$", "parameters", "[", "'toFile'", "]", ")", ")", "{", "$", "toFilePointer", "=", "@", "\\", "fopen", "(", "$", "parameters", "[", "'toFile'", "]", ",", "'wb'", ")", ";", "if", "(", "!", "$", "toFilePointer", ")", "{", "(", "$", "this", "->", "_onError", ")", "(", "'HTTPClient can not open file \"'", ".", "$", "parameters", "[", "'toFile'", "]", ".", "'\" for writing!'", ")", ";", "return", "false", ";", "}", "\\", "curl_setopt", "(", "$", "this", "->", "_curlHandle", ",", "CURLOPT_FILE", ",", "$", "toFilePointer", ")", ";", "}", "// Do the HTTP request while success or error", "do", "{", "$", "response", "=", "\\", "curl_exec", "(", "$", "this", "->", "_curlHandle", ")", ";", "}", "while", "(", "false", "===", "$", "response", "&&", "0", "!==", "--", "$", "parameters", "[", "'attemptsMax'", "]", "&&", "false", "!==", "\\", "sleep", "(", "$", "parameters", "[", "'attemptsDelay'", "]", ")", ")", ";", "// Close to file pointer if defined", "if", "(", "null", "!==", "$", "toFilePointer", ")", "{", "\\", "fclose", "(", "$", "toFilePointer", ")", ";", "// delete the to file if no valid response exists", "if", "(", "false", "===", "$", "response", ")", "{", "\\", "unlink", "(", "$", "parameters", "[", "'toFile'", "]", ")", ";", "}", "}", "$", "error", "=", "@", "\\", "curl_error", "(", "$", "this", "->", "_curlHandle", ")", ";", "$", "this", "->", "_curlInfo", "=", "@", "\\", "curl_getinfo", "(", "$", "this", "->", "_curlHandle", ")", ";", "if", "(", "!", "empty", "(", "$", "error", ")", ")", "{", "(", "$", "this", "->", "_onError", ")", "(", "$", "error", ")", ";", "return", "false", ";", "}", "if", "(", "false", "===", "$", "response", ")", "{", "(", "$", "this", "->", "_onError", ")", "(", "'HTTPClient can not get a response from \"'", ".", "$", "parameters", "[", "'url'", "]", ".", "'\"!'", ")", ";", "return", "false", ";", "}", "// Saving response content into lastpageFile", "if", "(", "null", "!==", "$", "this", "->", "_lastResponseToFile", ")", "{", "\\", "file_put_contents", "(", "$", "this", "->", "_lastResponseToFile", ",", "$", "response", ")", ";", "}", "return", "$", "response", ";", "}" ]

[ "Runs", "the", "request", "and", "return", "the", "response", "." ]

[ "public", "final", "function", "getCookies", "(", ")", ":", "array", "{", "if", "(", "!", "$", "this", "->", "getCookieFile", "(", ")", ")", "{", "return", "[", "]", ";", "}", "unset", "(", "$", "this", "->", "_curlHandle", ")", ";", "$", "text", "=", "\\", "file_get_contents", "(", "$", "this", "->", "getCookieFile", "(", ")", ")", ";", "$", "cookies", "=", "[", "]", ";", "foreach", "(", "\\", "explode", "(", "\"\\n\"", ",", "$", "text", ")", "as", "$", "line", ")", "{", "$", "parts", "=", "explode", "(", "\"\\t\"", ",", "$", "line", ")", ";", "if", "(", "7", "===", "\\", "count", "(", "$", "parts", ")", ")", "{", "$", "cookies", "[", "$", "parts", "[", "5", "]", "]", "=", "$", "parts", "[", "6", "]", ";", "}", "}", "return", "$", "cookies", ";", "}" ]

[ "Gets", "the", "current", "cookies", "." ]

[ "public", "function", "setLastResponseToFile", "(", "?", "string", "$", "lastResponseToFile", ")", ":", "Client", "{", "$", "this", "->", "_lastResponseToFile", "=", "$", "lastResponseToFile", "??", "''", ";", "if", "(", "''", "===", "\\", "trim", "(", "$", "this", "->", "_lastResponseToFile", ")", ")", "{", "$", "this", "->", "_lastResponseToFile", "=", "null", ";", "}", "return", "$", "this", ";", "}" ]

[ "If", "here", "a", "valid", "file", "path", "is", "defined", "the", "last", "response", "is", "stored", "inside", "the", "file", "." ]

[ "public", "function", "sendHead", "(", "string", "$", "url", ",", "array", "$", "parameters", "=", "[", "]", ",", "array", "$", "options", "=", "[", "]", ")", "{", "// The request URL", "$", "options", "[", "'url'", "]", "=", "$", "this", "->", "_buildUrl", "(", "$", "url", ",", "$", "parameters", ")", ";", "// Getting the headers", "$", "options", "[", "'header'", "]", "=", "true", ";", "// Get no body", "$", "options", "[", "'nobody'", "]", "=", "true", ";", "return", "$", "this", "->", "_sendRequest", "(", "$", "options", ")", ";", "}" ]

[ "Executes", "a", "HEAD", "HTTP", "request", "to", "get", "all", "response", "headers", "." ]

[ "public", "function", "sendGet", "(", "string", "$", "url", ",", "array", "$", "parameters", "=", "[", "]", ",", "array", "$", "options", "=", "[", "]", ")", "{", "// The request URL", "$", "options", "[", "'url'", "]", "=", "$", "this", "->", "_buildUrl", "(", "$", "url", ",", "$", "parameters", ")", ";", "return", "$", "this", "->", "_sendRequest", "(", "$", "options", ")", ";", "}" ]

[ "Executes", "GET", "HTTP", "request", "." ]

[ "public", "function", "sendPost", "(", "string", "$", "url", ",", "array", "$", "data", "=", "[", "]", ",", "array", "$", "options", "=", "[", "]", ")", "{", "$", "options", "[", "'url'", "]", "=", "$", "this", "->", "_buildUrl", "(", "$", "url", ")", ";", "$", "options", "[", "'post'", "]", "=", "$", "data", ";", "return", "$", "this", "->", "_sendRequest", "(", "$", "options", ")", ";", "}" ]

[ "Executes", "a", "POST", "HTTP", "request", "." ]

[ "public", "function", "sendDownload", "(", "string", "$", "url", ",", "string", "$", "destinationFile", ",", "array", "$", "options", "=", "[", "]", ")", "{", "$", "options", "[", "'url'", "]", "=", "$", "this", "->", "_buildUrl", "(", "$", "url", ")", ";", "$", "options", "[", "'toFile'", "]", "=", "$", "destinationFile", ";", "return", "$", "this", "->", "_sendRequest", "(", "$", "options", ")", ";", "}" ]

[ "Downloads", "file", "to", "specified", "destination", "file", "." ]