Datasets:

---

CM

/

codexglue_code2text_php

like 2

[ "public", "static", "function", "init", "(", ")", "{", "// bail if the CTFW_Widget class is loaded elsewhere", "if", "(", "class_exists", "(", "'CTFW_Widget'", ")", ")", "{", "return", ";", "}", "$", "pluginDir", "=", "untrailingslashit", "(", "plugin_dir_path", "(", "__FILE__", ")", ")", ";", "$", "pluginURL", "=", "untrailingslashit", "(", "plugin_dir_url", "(", "__FILE__", ")", ")", ";", "define", "(", "'CTFW_WIDGETS_INC_DIR'", ",", "$", "pluginDir", ".", "'/includes'", ")", ";", "define", "(", "'CTFW_WIDGETS_CLASS_DIR'", ",", "CTFW_WIDGETS_INC_DIR", ".", "'/classes'", ")", ";", "define", "(", "'CTFW_WIDGETS_ADMIN_DIR'", ",", "CTFW_WIDGETS_INC_DIR", ".", "'/admin'", ")", ";", "define", "(", "'CTFW_WIDGETS_WIDGET_TEMPLATE_DIR'", ",", "CTFW_WIDGETS_INC_DIR", ".", "'/widget-templates'", ")", ";", "define", "(", "'CTFW_WIDGETS_JS_DIR'", ",", "CTFW_WIDGETS_INC_DIR", ".", "'/js'", ")", ";", "define", "(", "'CTFW_WIDGETS_CSS_DIR'", ",", "CTFW_WIDGETS_INC_DIR", ".", "'/css'", ")", ";", "define", "(", "'CTFW_WIDGETS_DIR_URL'", ",", "$", "pluginURL", ")", ";", "define", "(", "'CTFW_WIDGETS_JS_DIR_URL'", ",", "$", "pluginURL", ".", "'/js'", ")", ";", "define", "(", "'CTFW_WIDGETS_CSS_DIR_URL'", ",", "$", "pluginURL", ".", "'/css'", ")", ";", "define", "(", "'CTFW_WIDGETS_VERSION'", ",", "1.0", ")", ";", "add_action", "(", "'plugins_loaded'", ",", "array", "(", "__CLASS__", ",", "'setup'", ")", ")", ";", "}" ]

[ "define", "plugin", "directory" ]

[ "public", "static", "function", "splitSql", "(", "$", "sql", ")", "{", "$", "start", "=", "0", ";", "$", "open", "=", "false", ";", "$", "char", "=", "''", ";", "$", "end", "=", "strlen", "(", "$", "sql", ")", ";", "$", "queries", "=", "[", "]", ";", "for", "(", "$", "i", "=", "0", ";", "$", "i", "<", "$", "end", ";", "$", "i", "++", ")", "{", "$", "current", "=", "substr", "(", "$", "sql", ",", "$", "i", ",", "1", ")", ";", "if", "(", "$", "current", "==", "'\"'", "||", "$", "current", "==", "'\\''", ")", "{", "$", "n", "=", "2", ";", "while", "(", "substr", "(", "$", "sql", ",", "$", "i", "-", "$", "n", "+", "1", ",", "1", ")", "==", "'\\\\'", "&&", "$", "n", "<", "$", "i", ")", "{", "$", "n", "++", ";", "}", "if", "(", "$", "n", "%", "2", "==", "0", ")", "{", "if", "(", "$", "open", ")", "{", "if", "(", "$", "current", "==", "$", "char", ")", "{", "$", "open", "=", "false", ";", "$", "char", "=", "''", ";", "}", "}", "else", "{", "$", "open", "=", "true", ";", "$", "char", "=", "$", "current", ";", "}", "}", "}", "if", "(", "(", "$", "current", "==", "';'", "&&", "!", "$", "open", ")", "||", "$", "i", "==", "$", "end", "-", "1", ")", "{", "$", "queries", "[", "]", "=", "substr", "(", "$", "sql", ",", "$", "start", ",", "(", "$", "i", "-", "$", "start", "+", "1", ")", ")", ";", "$", "start", "=", "$", "i", "+", "1", ";", "}", "}", "return", "$", "queries", ";", "}" ]

[ "Splits", "a", "string", "of", "multiple", "queries", "into", "an", "array", "of", "individual", "queries", "." ]

[ "protected", "function", "splitData", "(", "$", "data", ",", "$", "sectionNames", ")", "{", "$", "sections", "=", "explode", "(", "$", "this", "->", "getDataSeparator", "(", ")", ",", "str_replace", "(", "\"\\n\\r\"", ",", "\"\\n\"", ",", "$", "data", ")", ",", "count", "(", "$", "sectionNames", ")", ")", ";", "try", "{", "$", "parts", "=", "array_combine", "(", "$", "sectionNames", ",", "$", "sections", ")", ";", "}", "catch", "(", "\\", "Exception", "$", "e", ")", "{", "throw", "new", "EntityParseException", ";", "}", "return", "$", "parts", ";", "}" ]

[ "Split", "data", "by", "the", "separator" ]

[ "public", "function", "duplicate", "(", "Model", "$", "Model", ",", "$", "data", ",", "$", "config", "=", "array", "(", ")", ")", "{", "$", "config", "=", "array_merge", "(", "$", "this", "->", "settings", "[", "$", "Model", "->", "alias", "]", ",", "$", "config", ")", ";", "if", "(", "empty", "(", "$", "Model", "->", "id", ")", "&&", "empty", "(", "$", "data", "[", "$", "Model", "->", "alias", "]", "[", "$", "Model", "->", "primaryKey", "]", ")", ")", "{", "throw", "new", "Exception", "(", "__d", "(", "'common'", ",", "\"Missing primary key for duplicatable '%s' data\"", ",", "$", "Model", "->", "name", ")", ")", ";", "}", "$", "id", "=", "$", "Model", "->", "id", "?", "$", "Model", "->", "id", ":", "$", "data", "[", "$", "Model", "->", "alias", "]", "[", "$", "Model", "->", "primaryKey", "]", ";", "$", "conditions", "=", "array", "(", "$", "Model", "->", "primaryKey", "=>", "$", "id", ")", "+", "(", "array", ")", "$", "this", "->", "settings", "[", "$", "Model", "->", "alias", "]", "[", "'scope'", "]", ";", "if", "(", "!", "empty", "(", "$", "this", "->", "settings", "[", "$", "Model", "->", "alias", "]", "[", "'scope'", "]", ")", "&&", "!", "$", "Model", "->", "find", "(", "'count'", ",", "compact", "(", "'conditions'", ")", ")", ")", "{", "return", "false", ";", "}", "$", "duplicateData", "=", "array", "(", "$", "config", "[", "'duplicatedKey'", "]", "=>", "$", "id", ",", "$", "config", "[", "'duplicatedModel'", "]", "=>", "(", "!", "empty", "(", "$", "Model", "->", "plugin", ")", "?", "$", "Model", "->", "plugin", ".", "'.'", ":", "''", ")", ".", "$", "Model", "->", "name", ")", ";", "$", "DuplicateModel", "=", "ClassRegistry", "::", "init", "(", "$", "config", "[", "'model'", "]", ")", ";", "$", "DuplicateModel", "->", "create", "(", ")", ";", "$", "duplicateRecord", "=", "$", "DuplicateModel", "->", "find", "(", "'first'", ",", "array", "(", "'conditions'", "=>", "$", "duplicateData", ",", "'recursive'", "=>", "-", "1", ")", ")", ";", "if", "(", "!", "empty", "(", "$", "duplicateRecord", ")", ")", "{", "$", "DuplicateModel", "->", "id", "=", "$", "duplicateRecord", "[", "$", "DuplicateModel", "->", "alias", "]", "[", "$", "DuplicateModel", "->", "primaryKey", "]", ";", "}", "foreach", "(", "(", "array", ")", "$", "config", "[", "'mapFields'", "]", "as", "$", "field", "=>", "$", "path", ")", "{", "$", "value", "=", "Hash", "::", "extract", "(", "$", "data", ",", "$", "path", ")", ";", "$", "duplicateData", "[", "$", "field", "]", "=", "array_pop", "(", "$", "value", ")", ";", "if", "(", "!", "empty", "(", "$", "duplicateRecord", "[", "$", "DuplicateModel", "->", "alias", "]", "[", "$", "field", "]", ")", "&&", "$", "duplicateRecord", "[", "$", "DuplicateModel", "->", "alias", "]", "[", "$", "field", "]", "===", "$", "duplicateData", "[", "$", "field", "]", ")", "{", "unset", "(", "$", "duplicateData", "[", "$", "field", "]", ")", ";", "}", "}", "if", "(", "(", "empty", "(", "$", "duplicateRecord", ")", "||", "1", "<", "count", "(", "$", "duplicateData", ")", ")", "&&", "(", "!", "empty", "(", "$", "DuplicateModel", "->", "id", ")", "||", "$", "DuplicateModel", "->", "create", "(", "$", "duplicateData", ")", ")", "&&", "!", "$", "DuplicateModel", "->", "save", "(", ")", ")", "{", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "Clone", "model", "s", "data", "." ]

[ "public", "static", "function", "instance", "(", "$", "name", "=", "'default'", ")", "{", "if", "(", "\\", "array_key_exists", "(", "$", "name", ",", "static", "::", "$", "instances", ")", ")", "{", "return", "static", "::", "$", "instances", "[", "$", "name", "]", ";", "}", "if", "(", "empty", "(", "static", "::", "$", "instances", ")", ")", "{", "\\", "Config", "::", "load", "(", "'db'", ",", "true", ")", ";", "}", "if", "(", "!", "(", "$", "config", "=", "\\", "Config", "::", "get", "(", "'db.mongo.'", ".", "$", "name", ")", ")", ")", "{", "throw", "new", "\\", "Mongo_DbException", "(", "'Invalid instance name given.'", ")", ";", "}", "static", "::", "$", "instances", "[", "$", "name", "]", "=", "new", "static", "(", "$", "config", ")", ";", "return", "static", "::", "$", "instances", "[", "$", "name", "]", ";", "}" ]

[ "Acts", "as", "a", "Multiton", ".", "Will", "return", "the", "requested", "instance", "or", "will", "create", "a", "new", "one", "if", "it", "does", "not", "exist", "." ]

[ "public", "function", "apiAction", "(", "Request", "$", "request", ")", "{", "if", "(", "$", "request", "->", "isXmlHttpRequest", "(", ")", "or", "$", "request", "->", "headers", "->", "get", "(", "'Content-Type'", ")", "==", "'application/json'", ")", "{", "$", "pathInfo", "=", "$", "request", "->", "getPathInfo", "(", ")", ";", "if", "(", "!", "$", "this", "->", "getApiRequestAllow", "(", ")", "->", "isAllow", "(", "$", "pathInfo", ")", ")", "{", "throw", "new", "NotFoundHttpException", "(", "'No route allow for \" '", ".", "$", "request", "->", "getMethod", "(", ")", ".", "' '", ".", "$", "pathInfo", ".", "'\"'", ")", ";", "}", "$", "query_string", "=", "null", ";", "if", "(", "$", "request", "->", "server", "->", "get", "(", "'QUERY_STRING'", ")", ")", "{", "$", "query_string", "=", "'?'", ".", "$", "request", "->", "server", "->", "get", "(", "'QUERY_STRING'", ")", ";", "}", "$", "url_api", "=", "$", "pathInfo", ".", "$", "query_string", ";", "/*\n * Only is configurable the first folder\n * internalapi/users/username-available\n * is changed to api/users/username-available\n */", "$", "array", "=", "explode", "(", "\"/\"", ",", "$", "url_api", ")", ";", "unset", "(", "$", "array", "[", "1", "]", ")", ";", "$", "text", "=", "implode", "(", "\"/\"", ",", "$", "array", ")", ";", "$", "url_api", "=", "\"/api\"", ".", "$", "text", ";", "$", "apiUri", "=", "trim", "(", "$", "url_api", ",", "'/'", ")", ";", "try", "{", "return", "$", "this", "->", "container", "->", "get", "(", "'antwebes_chateaclient_bundle.http.api_client'", ")", "->", "sendRequest", "(", "'GET'", ",", "$", "apiUri", ")", ";", "}", "catch", "(", "ClientErrorResponseException", "$", "e", ")", "{", "$", "headersGuzzle", "=", "$", "e", "->", "getResponse", "(", ")", "->", "getHeaders", "(", ")", "->", "toArray", "(", ")", ";", "$", "headersSymfony", "=", "array", "(", ")", ";", "foreach", "(", "$", "headersGuzzle", "as", "$", "key", "=>", "$", "value", ")", "{", "//this header is not suporter in symfony", "if", "(", "$", "key", "!=", "'Transfer-Encoding'", "&&", "$", "value", "!==", "'chunked'", ")", "{", "$", "headersSymfony", "[", "$", "key", "]", "=", "$", "value", "[", "0", "]", ";", "}", "}", "return", "new", "Response", "(", "$", "e", "->", "getResponse", "(", ")", "->", "getBody", "(", "true", ")", ",", "$", "e", "->", "getResponse", "(", ")", "->", "getStatusCode", "(", ")", ",", "$", "headersSymfony", ")", ";", "}", "}", "else", "{", "throw", "new", "NotFoundHttpException", "(", ")", ";", "}", "}" ]

[ "Resolve", "api", "calls" ]

[ "public", "function", "Confirm", "(", "$", "Action", ",", "$", "LogIDs", "=", "''", ")", "{", "$", "this", "->", "Permission", "(", "'Garden.Moderation.Manage'", ")", ";", "$", "this", "->", "Form", "->", "InputPrefix", "=", "''", ";", "$", "this", "->", "Form", "->", "IDPrefix", "=", "'Confirm_'", ";", "if", "(", "trim", "(", "$", "LogIDs", ")", ")", "$", "LogIDArray", "=", "explode", "(", "','", ",", "$", "LogIDs", ")", ";", "else", "$", "LogIDArray", "=", "array", "(", ")", ";", "// We also want to collect the users from the log.", "$", "Logs", "=", "$", "this", "->", "LogModel", "->", "GetIDs", "(", "$", "LogIDArray", ")", ";", "$", "Users", "=", "array", "(", ")", ";", "foreach", "(", "$", "Logs", "as", "$", "Log", ")", "{", "$", "UserID", "=", "$", "Log", "[", "'RecordUserID'", "]", ";", "if", "(", "!", "$", "UserID", ")", "continue", ";", "$", "Users", "[", "$", "UserID", "]", "=", "array", "(", "'UserID'", "=>", "$", "UserID", ")", ";", "}", "Gdn", "::", "UserModel", "(", ")", "->", "JoinUsers", "(", "$", "Users", ",", "array", "(", "'UserID'", ")", ")", ";", "$", "this", "->", "SetData", "(", "'Users'", ",", "$", "Users", ")", ";", "$", "this", "->", "SetData", "(", "'Action'", ",", "$", "Action", ")", ";", "$", "this", "->", "SetData", "(", "'ActionUrl'", ",", "Url", "(", "\"/log/$Action?logids=\"", ".", "urlencode", "(", "$", "LogIDs", ")", ")", ")", ";", "$", "this", "->", "SetData", "(", "'ItemCount'", ",", "count", "(", "$", "LogIDArray", ")", ")", ";", "$", "this", "->", "Render", "(", ")", ";", "}" ]

[ "Confirmation", "page", "." ]

[ "public", "function", "Count", "(", "$", "Operation", ")", "{", "$", "this", "->", "Permission", "(", "'Garden.Moderation.Manage'", ")", ";", "if", "(", "$", "Operation", "==", "'edits'", ")", "$", "Operation", "=", "array", "(", "'edit'", ",", "'delete'", ")", ";", "else", "$", "Operation", "=", "explode", "(", "','", ",", "$", "Operation", ")", ";", "array_map", "(", "'ucfirst'", ",", "$", "Operation", ")", ";", "$", "Count", "=", "$", "this", "->", "LogModel", "->", "GetCountWhere", "(", "array", "(", "'Operation'", "=>", "$", "Operation", ")", ")", ";", "if", "(", "$", "Count", ">", "0", ")", "echo", "'<span class=\"Alert\">'", ",", "$", "Count", ",", "'</span>'", ";", "}" ]

[ "Count", "log", "items", "." ]

[ "public", "function", "Delete", "(", "$", "LogIDs", ")", "{", "$", "this", "->", "Permission", "(", "'Garden.Moderation.Manage'", ")", ";", "// Grab the logs.", "$", "this", "->", "LogModel", "->", "Delete", "(", "$", "LogIDs", ")", ";", "$", "this", "->", "Render", "(", "'Blank'", ",", "'Utility'", ")", ";", "}" ]

[ "Delete", "logs", "." ]

[ "public", "function", "DeleteSpam", "(", "$", "LogIDs", ")", "{", "$", "this", "->", "Permission", "(", "'Garden.Moderation.Manage'", ")", ";", "if", "(", "!", "$", "this", "->", "Request", "->", "IsPostBack", "(", ")", ")", "throw", "PermissionException", "(", "'Javascript'", ")", ";", "$", "LogIDs", "=", "explode", "(", "','", ",", "$", "LogIDs", ")", ";", "// Ban the appropriate users.", "$", "UserIDs", "=", "$", "this", "->", "Form", "->", "GetFormValue", "(", "'UserID'", ",", "array", "(", ")", ")", ";", "if", "(", "!", "is_array", "(", "$", "UserIDs", ")", ")", "$", "UserIDs", "=", "array", "(", ")", ";", "if", "(", "!", "empty", "(", "$", "UserIDs", ")", ")", "{", "// Grab the rest of the log entries.", "$", "OtherLogIDs", "=", "$", "this", "->", "LogModel", "->", "GetWhere", "(", "array", "(", "'Operation'", "=>", "'Spam'", ",", "'RecordUserID'", "=>", "$", "UserIDs", ")", ")", ";", "$", "OtherLogIDs", "=", "ConsolidateArrayValuesByKey", "(", "$", "OtherLogIDs", ",", "'LogID'", ")", ";", "$", "LogIDs", "=", "array_merge", "(", "$", "LogIDs", ",", "$", "OtherLogIDs", ")", ";", "foreach", "(", "$", "UserIDs", "as", "$", "UserID", ")", "{", "Gdn", "::", "UserModel", "(", ")", "->", "Ban", "(", "$", "UserID", ",", "array", "(", "'Reason'", "=>", "'Spam'", ",", "'DeleteContent'", "=>", "TRUE", ",", "'Log'", "=>", "TRUE", ")", ")", ";", "}", "}", "// Grab the logs.", "$", "this", "->", "LogModel", "->", "Delete", "(", "$", "LogIDs", ")", ";", "$", "this", "->", "Render", "(", "'Blank'", ",", "'Utility'", ")", ";", "}" ]

[ "Delete", "spam", "and", "optionally", "delete", "the", "users", "." ]

[ "public", "function", "Initialize", "(", ")", "{", "parent", "::", "Initialize", "(", ")", ";", "Gdn_Theme", "::", "Section", "(", "'Dashboard'", ")", ";", "$", "this", "->", "AddJsFile", "(", "'log.js'", ")", ";", "$", "this", "->", "AddJsFile", "(", "'jquery.expander.js'", ")", ";", "$", "this", "->", "AddJsFile", "(", "'jquery-ui.js'", ")", ";", "$", "this", "->", "Form", "->", "InputPrefix", "=", "''", ";", "}" ]

[ "Always", "triggered", "first", ".", "Add", "Javascript", "files", "." ]

[ "public", "function", "Moderation", "(", "$", "Page", "=", "''", ")", "{", "$", "this", "->", "Permission", "(", "'Garden.Moderation.Manage'", ")", ";", "$", "Where", "=", "array", "(", "'Operation'", "=>", "array", "(", "'Moderate'", ",", "'Pending'", ")", ")", ";", "// Filter by category menu", "if", "(", "$", "CategoryID", "=", "Gdn", "::", "Request", "(", ")", "->", "GetValue", "(", "'CategoryID'", ")", ")", "{", "$", "this", "->", "SetData", "(", "'ModerationCategoryID'", ",", "$", "CategoryID", ")", ";", "$", "Where", "[", "'CategoryID'", "]", "=", "$", "CategoryID", ";", "}", "list", "(", "$", "Offset", ",", "$", "Limit", ")", "=", "OffsetLimit", "(", "$", "Page", ",", "10", ")", ";", "$", "this", "->", "SetData", "(", "'Title'", ",", "T", "(", "'Moderation Queue'", ")", ")", ";", "$", "RecordCount", "=", "$", "this", "->", "LogModel", "->", "GetCountWhere", "(", "$", "Where", ")", ";", "$", "this", "->", "SetData", "(", "'RecordCount'", ",", "$", "RecordCount", ")", ";", "if", "(", "$", "Offset", ">=", "$", "RecordCount", ")", "$", "Offset", "=", "$", "RecordCount", "-", "$", "Limit", ";", "$", "Log", "=", "$", "this", "->", "LogModel", "->", "GetWhere", "(", "$", "Where", ",", "'LogID'", ",", "'Desc'", ",", "$", "Offset", ",", "$", "Limit", ")", ";", "$", "this", "->", "SetData", "(", "'Log'", ",", "$", "Log", ")", ";", "if", "(", "$", "this", "->", "DeliveryType", "(", ")", "==", "DELIVERY_TYPE_VIEW", ")", "$", "this", "->", "View", "=", "'Table'", ";", "$", "this", "->", "AddSideMenu", "(", "'dashboard/log/moderation'", ")", ";", "$", "this", "->", "Render", "(", ")", ";", "}" ]

[ "View", "moderation", "logs", "." ]

[ "public", "function", "Restore", "(", "$", "LogIDs", ")", "{", "$", "this", "->", "Permission", "(", "'Garden.Moderation.Manage'", ")", ";", "// Grab the logs.", "$", "Logs", "=", "$", "this", "->", "LogModel", "->", "GetIDs", "(", "$", "LogIDs", ")", ";", "try", "{", "foreach", "(", "$", "Logs", "as", "$", "Log", ")", "{", "$", "this", "->", "LogModel", "->", "Restore", "(", "$", "Log", ")", ";", "}", "}", "catch", "(", "Exception", "$", "Ex", ")", "{", "$", "this", "->", "Form", "->", "AddError", "(", "$", "Ex", "->", "getMessage", "(", ")", ")", ";", "}", "$", "this", "->", "LogModel", "->", "Recalculate", "(", ")", ";", "$", "this", "->", "Render", "(", "'Blank'", ",", "'Utility'", ")", ";", "}" ]

[ "Restore", "logs", "." ]

[ "public", "function", "Spam", "(", "$", "Page", "=", "''", ")", "{", "$", "this", "->", "Permission", "(", "'Garden.Moderation.Manage'", ")", ";", "list", "(", "$", "Offset", ",", "$", "Limit", ")", "=", "OffsetLimit", "(", "$", "Page", ",", "10", ")", ";", "$", "this", "->", "SetData", "(", "'Title'", ",", "T", "(", "'Spam Queue'", ")", ")", ";", "$", "Where", "=", "array", "(", "'Operation'", "=>", "array", "(", "'Spam'", ")", ")", ";", "$", "RecordCount", "=", "$", "this", "->", "LogModel", "->", "GetCountWhere", "(", "$", "Where", ")", ";", "$", "this", "->", "SetData", "(", "'RecordCount'", ",", "$", "RecordCount", ")", ";", "if", "(", "$", "Offset", ">=", "$", "RecordCount", ")", "$", "Offset", "=", "$", "RecordCount", "-", "$", "Limit", ";", "$", "Log", "=", "$", "this", "->", "LogModel", "->", "GetWhere", "(", "$", "Where", ",", "'LogID'", ",", "'Desc'", ",", "$", "Offset", ",", "$", "Limit", ")", ";", "$", "this", "->", "SetData", "(", "'Log'", ",", "$", "Log", ")", ";", "if", "(", "$", "this", "->", "DeliveryType", "(", ")", "==", "DELIVERY_TYPE_VIEW", ")", "$", "this", "->", "View", "=", "'Table'", ";", "$", "this", "->", "AddSideMenu", "(", "'dashboard/log/spam'", ")", ";", "$", "this", "->", "Render", "(", ")", ";", "}" ]

[ "View", "spam", "logs", "." ]

[ "public", "static", "function", "make", "(", "$", "data", ",", "string", "$", "reason", ",", "?", "\\", "Throwable", "$", "previous", "=", "null", ")", ":", "self", "{", "$", "message", "=", "self", "::", "buildMessage", "(", "$", "data", ",", "$", "reason", ")", ";", "return", "new", "static", "(", "$", "message", ",", "$", "previous", ")", ";", "}" ]

[ "InvalidItemException", "named", "constructor", "." ]

[ "public", "function", "getTokenName", "(", "$", "type", ")", "{", "if", "(", "!", "isset", "(", "$", "this", "->", "tokenNames", "[", "$", "type", "]", ")", ")", "{", "throw", "new", "\\", "RuntimeException", "(", "\"Unknown token $type.\"", ")", ";", "}", "return", "$", "this", "->", "tokenNames", "[", "$", "type", "]", ";", "}" ]

[ "Get", "token", "name" ]

[ "public", "function", "ajouterParcours", "(", "$", "params", "=", "array", "(", ")", ")", "{", "if", "(", "isset", "(", "$", "this", "->", "variablesPost", "[", "'libelleParcours'", "]", ")", "&&", "$", "this", "->", "variablesPost", "[", "'libelleParcours'", "]", "!=", "''", "&&", "isset", "(", "$", "this", "->", "variablesPost", "[", "'dateAjoutParcours'", "]", ")", "&&", "$", "this", "->", "variablesPost", "[", "'dateAjoutParcours'", "]", "!=", "''", ")", "{", "$", "d", "=", "new", "dateObject", "(", ")", ";", "$", "parcoursActif", "=", "'0'", ";", "if", "(", "isset", "(", "$", "this", "->", "variablesPost", "[", "'isActif'", "]", ")", "&&", "$", "this", "->", "variablesPost", "[", "'isActif'", "]", "==", "'1'", ")", "{", "$", "parcoursActif", "=", "'1'", ";", "}", "$", "reqInsert", "=", "\"INSERT INTO parcoursArt (libelleParcours, isActif, dateAjoutParcours,commentaireParcours, idSource ) VALUES (\"", ";", "$", "reqInsert", ".=", "\"\\\"\"", ".", "mysql_real_escape_string", "(", "$", "this", "->", "variablesPost", "[", "'libelleParcours'", "]", ")", ".", "\"\\\",\"", ";", "$", "reqInsert", ".=", "\"'\"", ".", "$", "parcoursActif", ".", "\"',\"", ";", "$", "reqInsert", ".=", "\"'\"", ".", "$", "d", "->", "toBdd", "(", "$", "this", "->", "variablesPost", "[", "'dateAjoutParcours'", "]", ")", ".", "\"',\"", ";", "$", "reqInsert", ".=", "\"\\\"\"", ".", "mysql_real_escape_string", "(", "$", "this", "->", "variablesPost", "[", "'commentaireParcours'", "]", ")", ".", "\"\\\",\"", ";", "$", "reqInsert", ".=", "\"'\"", ".", "$", "this", "->", "variablesPost", "[", "'idSource'", "]", ".", "\"'\"", ";", "$", "reqInsert", ".=", "\")\"", ";", "$", "resInsert", "=", "$", "this", "->", "connexionBdd", "->", "requete", "(", "$", "reqInsert", ")", ";", "}", "}" ]

[ "Ajouter", "un", "parcours" ]

[ "public", "function", "modifierParcours", "(", "$", "params", "=", "array", "(", ")", ")", "{", "if", "(", "isset", "(", "$", "this", "->", "variablesPost", "[", "'idParcours'", "]", ")", "&&", "$", "this", "->", "variablesPost", "[", "'idParcours'", "]", "!=", "''", "&&", "$", "this", "->", "variablesPost", "[", "'idParcours'", "]", "!=", "'0'", "&&", "isset", "(", "$", "this", "->", "variablesPost", "[", "'libelleParcours'", "]", ")", "&&", "$", "this", "->", "variablesPost", "[", "'libelleParcours'", "]", "!=", "''", "&&", "isset", "(", "$", "this", "->", "variablesPost", "[", "'dateAjoutParcours'", "]", ")", "&&", "$", "this", "->", "variablesPost", "[", "'dateAjoutParcours'", "]", "!=", "''", ")", "{", "$", "d", "=", "new", "dateObject", "(", ")", ";", "$", "parcoursActif", "=", "'0'", ";", "if", "(", "isset", "(", "$", "this", "->", "variablesPost", "[", "'isActif'", "]", ")", "&&", "$", "this", "->", "variablesPost", "[", "'isActif'", "]", "==", "'1'", ")", "{", "$", "parcoursActif", "=", "'1'", ";", "}", "$", "reqUpdate", "=", "\"UPDATE parcoursArt set dateAjoutParcours='\"", ".", "$", "d", "->", "toBdd", "(", "$", "this", "->", "variablesPost", "[", "'dateAjoutParcours'", "]", ")", ".", "\"',isActif='\"", ".", "$", "parcoursActif", ".", "\"',libelleParcours=\\\"\"", ".", "mysql_real_escape_string", "(", "$", "this", "->", "variablesPost", "[", "'libelleParcours'", "]", ")", ".", "\"\\\",commentaireParcours=\\\"\"", ".", "mysql_real_escape_string", "(", "$", "this", "->", "variablesPost", "[", "'commentaireParcours'", "]", ")", ".", "\"\\\",idSource='\"", ".", "$", "this", "->", "variablesPost", "[", "'idSource'", "]", ".", "\"', trace='\"", ".", "mysql_escape_string", "(", "$", "this", "->", "variablesPost", "[", "'trace'", "]", ")", ".", "\"', levels='\"", ".", "mysql_escape_string", "(", "$", "this", "->", "variablesPost", "[", "'newLevels'", "]", ")", ".", "\"'\n WHERE idParcours='\"", ".", "$", "this", "->", "variablesPost", "[", "'idParcours'", "]", ".", "\"'\"", ";", "$", "resUpdate", "=", "$", "this", "->", "connexionBdd", "->", "requete", "(", "$", "reqUpdate", ")", ";", "}", "}" ]

[ "Modifier", "un", "parcours" ]

[ "static", "public", "function", "toArray", "(", "$", "args", ",", "$", "type_of", "=", "null", ")", "{", "if", "(", "is_array", "(", "$", "args", ")", ")", "{", "$", "failed", "=", "array_filter", "(", "$", "args", ",", "function", "(", "$", "e", ")", "use", "(", "$", "type_of", ")", "{", "return", "(", "!", "is_object", "(", "$", "e", ")", "||", "!", "$", "e", "instanceof", "$", "type_of", ")", ";", "}", ")", ";", "if", "(", "0", "<", "count", "(", "$", "failed", ")", ")", "{", "throw", "new", "\\", "DomainException", "(", "sprintf", "(", "'You must provide only objects of class %s.'", ",", "$", "type_of", ")", ")", ";", "}", "}", "else", "{", "if", "(", "!", "is_object", "(", "$", "args", ")", "||", "!", "$", "args", "instanceof", "$", "type_of", ")", "{", "throw", "new", "\\", "DomainException", "(", "sprintf", "(", "'You must provide only objects of class %s.'", ",", "$", "type_of", ")", ")", ";", "}", "$", "args", "=", "array", "(", "$", "args", ")", ";", "}", "return", "$", "args", ";", "}" ]

[ "Returns", "an", "array", "of", "objects", "of", "the", "same", "type" ]

[ "private", "function", "manyNestedInThe", "(", "string", "$", "property", ")", ":", "MapsProperty", "{", "if", "(", "null", "!==", "$", "this", "->", "container", "&&", "!", "class_exists", "(", "$", "this", "->", "container", ")", ")", "{", "throw", "NoSuchClass", "::", "couldNotLoadCollection", "(", "$", "this", "->", "container", ")", ";", "}", "return", "$", "this", "->", "addConstraintTo", "(", "HasManyNested", "::", "inPropertyWithDifferentKey", "(", "$", "property", ",", "$", "this", "->", "keyOr", "(", "$", "property", ")", ",", "$", "this", "->", "container", "(", ")", ",", "$", "this", "->", "hydrator", "(", ")", ")", ")", ";", "}" ]

[ "Maps", "an", "eagerly", "loaded", "collection", "from", "a", "nested", "data", "set", "." ]

[ "private", "function", "manyProxiesInThe", "(", "string", "$", "property", ")", ":", "MapsProperty", "{", "if", "(", "null", "===", "$", "this", "->", "loader", ")", "{", "throw", "NoLoaderAvailable", "::", "whilstRequiredFor", "(", "$", "this", "->", "class", ")", ";", "}", "return", "$", "this", "->", "addConstraintTo", "(", "HasManyProxies", "::", "inPropertyWithDifferentKey", "(", "$", "property", ",", "$", "this", "->", "keyOr", "(", "$", "property", ")", ",", "$", "this", "->", "container", "(", ")", ",", "ProxyFactory", "::", "fromThis", "(", "SimpleHydrator", "::", "forThe", "(", "$", "this", "->", "class", ")", ",", "$", "this", "->", "loader", ",", "$", "this", "->", "updaterFactory", "(", ")", ")", ")", ")", ";", "}" ]

[ "Maps", "an", "extra", "lazily", "loaded", "collection", "as", "list", "of", "proxies", "." ]

[ "private", "function", "oneProxyInThe", "(", "string", "$", "property", ")", ":", "MapsProperty", "{", "if", "(", "null", "===", "$", "this", "->", "loader", ")", "{", "throw", "NoLoaderAvailable", "::", "whilstRequiredFor", "(", "$", "this", "->", "class", ")", ";", "}", "if", "(", "null", "===", "$", "this", "->", "container", ")", "{", "throw", "NoContainerAvailable", "::", "whilstRequiredFor", "(", "$", "this", "->", "class", ")", ";", "}", "try", "{", "return", "HasOneProxy", "::", "inProperty", "(", "$", "property", ",", "ProxyFactory", "::", "fromThis", "(", "SimpleHydrator", "::", "forThe", "(", "$", "this", "->", "container", ")", ",", "$", "this", "->", "loader", ",", "new", "PropertyUpdaterFactory", ")", ")", ";", "}", "catch", "(", "CannotInstantiateThis", "$", "problem", ")", "{", "throw", "NoSuchClass", "::", "couldNotLoadCollection", "(", "$", "this", "->", "container", ")", ";", "}", "}" ]

[ "Maps", "a", "lazily", "loaded", "collection", "as", "a", "single", "proxy", "." ]

[ "public", "static", "function", "rgb", "(", "$", "r", "=", "255", ",", "$", "g", "=", "255", ",", "$", "b", "=", "255", ")", "{", "// Check if values are in range.", "static", "::", "validateComp", "(", "'R'", ",", "$", "r", ",", "0", ",", "255", ")", ";", "static", "::", "validateComp", "(", "'G'", ",", "$", "g", ",", "0", ",", "255", ")", ";", "static", "::", "validateComp", "(", "'B'", ",", "$", "b", ",", "0", ",", "255", ")", ";", "return", "new", "static", "(", "$", "r", ",", "$", "g", ",", "$", "b", ")", ";", "}" ]

[ "Creates", "a", "new", "Color", "instance", "from", "RGB", "components", "ranging", "from", "0", "to", "255", "." ]

[ "public", "static", "function", "hex", "(", "$", "hex", ")", "{", "// RGB Hex -> RGB", "static", "::", "hex2rgb", "(", "$", "hex", ",", "$", "r", ",", "$", "g", ",", "$", "b", ")", ";", "return", "static", "::", "rgb", "(", "$", "r", ",", "$", "g", ",", "$", "b", ")", ";", "}" ]

[ "Creates", "a", "new", "Color", "instance", "from", "an", "RGB", "hex", "color", "code", ".", "Both", "six", "digit", "and", "3", "digit", "hex", "codes", "are", "supported", "." ]

[ "public", "static", "function", "rand", "(", "$", "h", "=", "[", "0", ",", "360", "]", ",", "$", "s", "=", "[", "0", ",", "1", "]", ",", "$", "l", "=", "[", "0", ",", "1", "]", ")", "{", "// Validate input criteria", "static", "::", "validateComp", "(", "'H low'", ",", "$", "h", "[", "0", "]", ",", "0", ",", "360", ")", ";", "static", "::", "validateComp", "(", "'S low'", ",", "$", "s", "[", "0", "]", ",", "0", ",", "1", ")", ";", "static", "::", "validateComp", "(", "'L low'", ",", "$", "l", "[", "0", "]", ",", "0", ",", "1", ")", ";", "static", "::", "validateComp", "(", "'H high'", ",", "$", "h", "[", "1", "]", ",", "0", ",", "360", ")", ";", "static", "::", "validateComp", "(", "'S high'", ",", "$", "s", "[", "1", "]", ",", "0", ",", "1", ")", ";", "static", "::", "validateComp", "(", "'L high'", ",", "$", "l", "[", "1", "]", ",", "0", ",", "1", ")", ";", "// Loop until calculated random HSL -> RGB -> HSL value matches params.", "$", "i", "=", "0", ";", "while", "(", "true", ")", "{", "// Random HSL color", "$", "color", "=", "static", "::", "hsl", "(", "static", "::", "randFloat", "(", "$", "h", "[", "0", "]", ",", "$", "h", "[", "1", "]", ",", "1", ")", ",", "static", "::", "randFloat", "(", "$", "s", "[", "0", "]", ",", "$", "s", "[", "1", "]", ",", "0.001", ")", ",", "static", "::", "randFloat", "(", "$", "l", "[", "0", "]", ",", "$", "l", "[", "1", "]", ",", "0.001", ")", ")", ";", "// Check if the HSL matches the input criteria", "$", "hMatch", "=", "$", "color", "->", "h", ">=", "$", "h", "[", "0", "]", "&&", "$", "color", "->", "h", "<=", "$", "h", "[", "1", "]", ";", "$", "sMatch", "=", "$", "color", "->", "s", ">=", "$", "s", "[", "0", "]", "&&", "$", "color", "->", "s", "<=", "$", "s", "[", "1", "]", ";", "$", "lMatch", "=", "$", "color", "->", "l", ">=", "$", "l", "[", "0", "]", "&&", "$", "color", "->", "l", "<=", "$", "l", "[", "1", "]", ";", "if", "(", "$", "hMatch", "&&", "$", "sMatch", "&&", "$", "lMatch", ")", "{", "// Match found...", "break", ";", "}", "elseif", "(", "$", "i", ">", "50", ")", "{", "// Stop if not found by now.", "throw", "new", "Exception", "(", ")", ";", "break", ";", "}", "else", "{", "$", "i", "++", ";", "}", "}", "return", "$", "color", ";", "}" ]

[ "Generates", "a", "random", "color", ".", "Minimum", "and", "maximum", "values", "are", "specified", "for", "all", "of", "the", "HSL", "components", "." ]

[ "public", "static", "function", "parse", "(", "$", "color", ")", "{", "$", "hsl", "=", "'/hsl\\(([0-9]{1,3}),\\s*([0-9]{1,3})%,\\s*([0-9]{1,3})%\\)/'", ";", "$", "rgb", "=", "'/rgb\\(([0-9]{1,3}),\\s*([0-9]{1,3}),\\s*([0-9]{1,3})\\)/'", ";", "// HSL", "if", "(", "preg_match", "(", "$", "hsl", ",", "$", "color", ",", "$", "m", ")", ")", "{", "return", "static", "::", "hsl", "(", "(", "int", ")", "$", "m", "[", "1", "]", ",", "(", "int", ")", "$", "m", "[", "2", "]", "/", "100", ",", "(", "int", ")", "$", "m", "[", "3", "]", "/", "100", ")", ";", "}", "// RGB", "elseif", "(", "preg_match", "(", "$", "rgb", ",", "$", "color", ",", "$", "m", ")", ")", "{", "return", "static", "::", "rgb", "(", "(", "int", ")", "$", "m", "[", "1", "]", ",", "(", "int", ")", "$", "m", "[", "2", "]", ",", "(", "int", ")", "$", "m", "[", "3", "]", ")", ";", "}", "// Hex", "else", "{", "return", "static", "::", "hex", "(", "$", "color", ")", ";", "}", ";", "}" ]

[ "Parses", "an", "HTML", "color", "in", "either", "hex", "hsl", "or", "rgb", "." ]

[ "public", "function", "dist", "(", "Color", "$", "c", ")", "{", "return", "sqrt", "(", "(", "$", "c", "->", "r", "-", "$", "this", "->", "r", ")", "**", "2", "+", "(", "$", "c", "->", "g", "-", "$", "this", "->", "g", ")", "**", "2", "+", "(", "$", "c", "->", "b", "-", "$", "this", "->", "b", ")", "**", "2", ")", ";", "}" ]

[ "Calculates", "the", "distance", "between", "this", "color", "and", "another", "." ]

[ "private", "function", "calcHSL", "(", ")", "{", "// RGB -> HSL", "self", "::", "rgb2hsl", "(", "$", "this", "->", "r", ",", "$", "this", "->", "g", ",", "$", "this", "->", "b", ",", "$", "h", ",", "$", "s", ",", "$", "l", ")", ";", "return", "[", "$", "h", ",", "$", "s", ",", "$", "l", "]", ";", "}" ]

[ "Calculates", "this", "color", "s", "HSL", "components", "." ]

[ "private", "static", "function", "validateComp", "(", "$", "component", ",", "$", "value", ",", "$", "min", ",", "$", "max", ")", "{", "if", "(", "$", "value", "<", "$", "min", "||", "$", "value", ">", "$", "max", ")", "{", "throw", "new", "Exception", "(", "\"{$component} component {$value} must be {$min}-{$max}\"", ")", ";", "}", "}" ]

[ "Validates", "a", "color", "component", "to", "see", "if", "fits", "within", "a", "range", "." ]

[ "private", "static", "function", "rgb2hsl", "(", "$", "r", ",", "$", "g", ",", "$", "b", ",", "&", "$", "h", ",", "&", "$", "s", ",", "&", "$", "l", ")", "{", "$", "r", "/=", "255", ";", "$", "g", "/=", "255", ";", "$", "b", "/=", "255", ";", "$", "min", "=", "min", "(", "[", "$", "r", ",", "$", "g", ",", "$", "b", "]", ")", ";", "$", "max", "=", "max", "(", "[", "$", "r", ",", "$", "g", ",", "$", "b", "]", ")", ";", "$", "l", "=", "(", "$", "min", "+", "$", "max", ")", "/", "2", ";", "$", "l", "=", "round", "(", "$", "l", ",", "2", ")", ";", "if", "(", "$", "min", "==", "$", "max", ")", "{", "$", "s", "=", "0", ";", "$", "h", "=", "0", ";", "return", ";", "}", "if", "(", "$", "l", "<", "0.5", ")", "{", "$", "s", "=", "(", "$", "max", "-", "$", "min", ")", "/", "(", "$", "max", "+", "$", "min", ")", ";", "}", "else", "{", "$", "s", "=", "(", "$", "max", "-", "$", "min", ")", "/", "(", "2.0", "-", "$", "max", "-", "$", "min", ")", ";", "}", "if", "(", "$", "r", "==", "$", "max", ")", "{", "$", "h", "=", "(", "$", "g", "-", "$", "b", ")", "/", "(", "$", "max", "-", "$", "min", ")", ";", "}", "elseif", "(", "$", "g", "==", "$", "max", ")", "{", "$", "h", "=", "2.0", "+", "(", "$", "b", "-", "$", "r", ")", "/", "(", "$", "max", "-", "$", "min", ")", ";", "}", "else", "{", "$", "h", "=", "4.0", "+", "(", "$", "r", "-", "$", "g", ")", "/", "(", "$", "max", "-", "$", "min", ")", ";", "}", "$", "h", "*=", "60", ";", "$", "h", "=", "$", "h", "<", "0", "?", "$", "h", "+", "360", ":", "$", "h", ";", "$", "h", "=", "(", "int", ")", "round", "(", "$", "h", ")", ";", "$", "s", "=", "round", "(", "$", "s", ",", "2", ")", ";", "}" ]

[ "Converts", "RGB", "to", "HSL", "." ]

[ "private", "static", "function", "hex2rgb", "(", "$", "hex", ",", "&", "$", "r", ",", "&", "$", "g", ",", "&", "$", "b", ")", "{", "// Remove hash if present", "$", "hex", "=", "preg_replace", "(", "'/[^a-fA-F0-9]/'", ",", "''", ",", "$", "hex", ")", ";", "if", "(", "strlen", "(", "$", "hex", ")", "==", "6", ")", "{", "// 6-digit hex", "$", "r", "=", "substr", "(", "$", "hex", ",", "0", ",", "2", ")", ";", "$", "g", "=", "substr", "(", "$", "hex", ",", "2", ",", "2", ")", ";", "$", "b", "=", "substr", "(", "$", "hex", ",", "4", ",", "2", ")", ";", "}", "else", "{", "// 3-digit hex, pad to 6 total...", "$", "r", "=", "$", "hex", "[", "0", "]", ".", "$", "hex", "[", "0", "]", ";", "$", "g", "=", "$", "hex", "[", "1", "]", ".", "$", "hex", "[", "1", "]", ";", "$", "b", "=", "$", "hex", "[", "2", "]", ".", "$", "hex", "[", "2", "]", ";", "}", "$", "r", "=", "hexdec", "(", "$", "r", ")", ";", "$", "g", "=", "hexdec", "(", "$", "g", ")", ";", "$", "b", "=", "hexdec", "(", "$", "b", ")", ";", "}" ]

[ "Converts", "an", "RGB", "Hex", "code", "to", "RGB", "." ]

[ "public", "function", "getClone", "(", "$", "withParameters", "=", "true", ")", "{", "$", "clone", "=", "new", "static", "(", "$", "this", "->", "sqlAdapter", ",", "$", "this", "->", "idField", ",", "$", "this", "->", "class", ")", ";", "if", "(", "$", "withParameters", ")", "{", "$", "clone", "->", "parameters", "=", "$", "this", "->", "parameters", ";", "}", "return", "$", "clone", ";", "}" ]

[ "Get", "a", "clone", "of", "current", "request" ]

[ "protected", "function", "get", "(", "$", "parameter", ",", "$", "default", "=", "null", ")", "{", "return", "isset", "(", "$", "this", "->", "parameters", "[", "$", "parameter", "]", ")", "?", "$", "this", "->", "parameters", "[", "$", "parameter", "]", ":", "$", "default", ";", "}" ]

[ "Get", "a", "parameter", "for", "this", "query" ]

[ "public", "function", "getQuery", "(", ")", "{", "$", "output", "=", "$", "this", "->", "get", "(", "'output'", ")", ";", "try", "{", "$", "this", "->", "set", "(", "'output'", ",", "SQLAdapter", "::", "SQLQUERY", ")", ";", "$", "result", "=", "$", "this", "->", "run", "(", ")", ";", "}", "catch", "(", "\\", "Exception", "$", "e", ")", "{", "}", "$", "this", "->", "set", "(", "'output'", ",", "$", "output", ")", ";", "if", "(", "isset", "(", "$", "e", ")", ")", "{", "throw", "$", "e", ";", "}", "return", "$", "result", ";", "}" ]

[ "Get", "the", "query", "as", "string" ]

[ "protected", "function", "formatCacheInfo", "(", "$", "MaxAge", ",", "$", "isPublic", ")", "{", "if", "(", "is_null", "(", "$", "MaxAge", ")", ")", "{", "$", "MaxAge", "=", "0", ";", "}", "return", "array", "(", "self", "::", "MAX_AGE", "=>", "$", "MaxAge", ",", "self", "::", "IS_PUBLIC", "=>", "$", "isPublic", ")", ";", "}" ]

[ "Generate", "a", "CacheInfo" ]

[ "protected", "function", "mergeCacheInfo", "(", "array", "$", "cacheInfo1", ",", "array", "$", "cacheInfo2", ")", "{", "$", "maxAge", "=", "$", "cacheInfo1", "[", "self", "::", "MAX_AGE", "]", ";", "if", "(", "$", "maxAge", "<", "0", "||", "(", "(", "$", "cacheInfo2", "[", "self", "::", "MAX_AGE", "]", "<", "$", "maxAge", ")", ")", "&&", "(", "-", "1", "<", "$", "cacheInfo2", "[", "self", "::", "MAX_AGE", "]", ")", ")", "{", "$", "maxAge", "=", "$", "cacheInfo2", "[", "self", "::", "MAX_AGE", "]", ";", "}", "$", "isPublic", "=", "$", "cacheInfo1", "[", "self", "::", "IS_PUBLIC", "]", "&&", "$", "cacheInfo2", "[", "self", "::", "IS_PUBLIC", "]", ";", "return", "$", "this", "->", "formatCacheInfo", "(", "$", "maxAge", ",", "$", "isPublic", ")", ";", "}" ]

[ "Merge", "two", "CacheInfo" ]

[ "public", "function", "offsetGet", "(", "$", "field", ")", "{", "if", "(", "isset", "(", "$", "this", "->", "values", "[", "$", "field", "]", ")", "||", "$", "this", "->", "load", "(", "$", "field", ")", ")", "{", "return", "$", "this", "->", "values", "[", "$", "field", "]", ";", "}", "return", "NULL", ";", "}" ]

[ "Retrieves", "a", "config", "value", ".", "If", "there", "is", "none", "it", "will", "attempt", "to", "run", "a", "factory", "if", "available", "." ]

[ "protected", "function", "load", "(", "$", "field", ")", "{", "if", "(", "$", "this", "->", "factoryExists", "(", "$", "field", ")", ")", "{", "$", "this", "->", "values", "[", "$", "field", "]", "=", "$", "this", "->", "runFactory", "(", "$", "field", ")", ";", "return", "TRUE", ";", "}", "return", "FALSE", ";", "}" ]

[ "Populates", "a", "config", "field", "with", "the", "result", "of", "a", "factory", "being", "run", "if", "one", "exists", "." ]

[ "protected", "function", "createTable", "(", "SiteCapsuleInterface", "$", "capsule", ",", "array", "$", "parameters", ")", "{", "if", "(", "$", "this", "->", "tableExists", "(", "$", "capsule", ")", ")", "{", "return", ";", "}", "$", "connection", "=", "$", "this", "->", "getConnection", "(", ")", ";", "/** @var AbstractSchemaManager $schemaManager */", "$", "schemaManager", "=", "$", "connection", "->", "getSchemaManager", "(", ")", ";", "$", "table", "=", "$", "this", "->", "buildTable", "(", "$", "capsule", ",", "$", "parameters", ")", ";", "$", "schemaManager", "->", "createTable", "(", "$", "table", ")", ";", "}" ]

[ "Creates", "Table", "needed", "to", "persist", "the", "wished", "response" ]

[ "public", "function", "end_lvl", "(", "&", "$", "output", ",", "$", "depth", "=", "0", ",", "$", "args", "=", "[", "]", ")", "{", "$", "indent", "=", "str_repeat", "(", "' '", ",", "$", "this", "->", "indent", "+", "$", "depth", "+", "1", ")", ";", "$", "output", ".=", "sprintf", "(", "'%s</ul>%s'", ",", "$", "indent", ",", "PHP_EOL", ")", ";", "}" ]

[ "Ends", "the", "list", "of", "after", "the", "elements", "are", "added" ]

[ "public", "function", "end_el", "(", "&", "$", "output", ",", "$", "item", ",", "$", "depth", "=", "0", ",", "$", "args", "=", "[", "]", ")", "{", "if", "(", "$", "depth", "===", "0", "&&", "in_array", "(", "'menu-item-has-children'", ",", "$", "item", "->", "classes", ")", ")", "{", "$", "indent", "=", "str_repeat", "(", "' '", ",", "$", "this", "->", "indent", "+", "$", "depth", ")", ";", "$", "output", ".=", "sprintf", "(", "'%s</li>%s'", ",", "$", "indent", ",", "PHP_EOL", ")", ";", "}", "else", "{", "$", "output", ".=", "sprintf", "(", "'</li>%s'", ",", "PHP_EOL", ")", ";", "}", "}" ]

[ "Ends", "the", "element", "output", "if", "needed" ]

[ "public", "function", "display_element", "(", "$", "element", ",", "&", "$", "children_elements", ",", "$", "max_depth", ",", "$", "depth", ",", "$", "args", ",", "&", "$", "output", ")", "{", "if", "(", "!", "$", "element", ")", "{", "return", ";", "}", "$", "id_field", "=", "$", "this", "->", "db_fields", "[", "'id'", "]", ";", "if", "(", "is_object", "(", "$", "args", "[", "0", "]", ")", ")", "{", "$", "args", "[", "0", "]", "->", "has_children", "=", "!", "empty", "(", "$", "children_elements", "[", "$", "element", "->", "$", "id_field", "]", ")", ";", "}", "return", "parent", "::", "display_element", "(", "$", "element", ",", "$", "children_elements", ",", "$", "max_depth", ",", "$", "depth", ",", "$", "args", ",", "$", "output", ")", ";", "}" ]

[ "Traverse", "elements", "to", "create", "list", "from", "elements" ]

[ "public", "function", "setEncoding", "(", "$", "encoding", "=", "null", ")", "{", "if", "(", "$", "encoding", "!==", "null", ")", "{", "if", "(", "!", "function_exists", "(", "'mb_strtolower'", ")", ")", "{", "throw", "new", "Exception", "\\", "ExtensionNotLoadedException", "(", "sprintf", "(", "'%s requires mbstring extension to be loaded'", ",", "get_class", "(", "$", "this", ")", ")", ")", ";", "}", "$", "encoding", "=", "strtolower", "(", "$", "encoding", ")", ";", "$", "mbEncodings", "=", "array_map", "(", "'strtolower'", ",", "mb_list_encodings", "(", ")", ")", ";", "if", "(", "!", "in_array", "(", "$", "encoding", ",", "$", "mbEncodings", ")", ")", "{", "throw", "new", "Exception", "\\", "InvalidArgumentException", "(", "sprintf", "(", "\"Encoding '%s' is not supported by mbstring extension\"", ",", "$", "encoding", ")", ")", ";", "}", "}", "$", "this", "->", "options", "[", "'encoding'", "]", "=", "$", "encoding", ";", "return", "$", "this", ";", "}" ]

[ "Set", "the", "input", "encoding", "for", "the", "given", "string" ]

[ "public", "function", "getEncoding", "(", ")", "{", "if", "(", "$", "this", "->", "options", "[", "'encoding'", "]", "===", "null", "&&", "function_exists", "(", "'mb_internal_encoding'", ")", ")", "{", "$", "this", "->", "options", "[", "'encoding'", "]", "=", "mb_internal_encoding", "(", ")", ";", "}", "return", "$", "this", "->", "options", "[", "'encoding'", "]", ";", "}" ]

[ "Returns", "the", "set", "encoding" ]

[ "public", "function", "json", "(", ")", "{", "$", "this", "->", "response", "->", "data", "=", "json_decode", "(", "$", "this", "->", "response", "->", "body", ")", ";", "return", "$", "this", "->", "response", ";", "}" ]

[ "Convert", "to", "JSON", "string" ]

[ "public", "static", "function", "detectBaseURL", "(", ")", "{", "if", "(", "PHP_SAPI", "==", "'cli'", ")", "return", "'http://php-cli.invalid/'", ";", "$", "protocol", "=", "'http://'", ";", "if", "(", "isset", "(", "$", "_SERVER", "[", "'HTTPS'", "]", ")", "&&", "filter_var", "(", "$", "_SERVER", "[", "'HTTPS'", "]", ",", "FILTER_VALIDATE_BOOLEAN", ")", ")", "{", "$", "protocol", "=", "'https://'", ";", "}", "/*\n\t\t * We use Apache's user-dir feature for our local development\n\t\t * environments (e.g. \"http://localhost/~Academic/\"). In order for\n\t\t * base URL detection to properly pick up on these URL's we use the\n\t\t * CONTEXT_PREFIX environment variable provided by recent (2.3.13+)\n\t\t * versions of Apache.\n\t\t */", "if", "(", "isset", "(", "$", "_SERVER", "[", "'CONTEXT_PREFIX'", "]", ")", ")", "{", "$", "path", "=", "trim", "(", "$", "_SERVER", "[", "'CONTEXT_PREFIX'", "]", ",", "'/\\\\'", ")", ".", "'/'", ";", "}", "else", "{", "$", "path", "=", "'./'", ";", "}", "return", "self", "::", "normaliseURL", "(", "\"{$protocol}{$_SERVER['HTTP_HOST']}/{$path}\"", ")", ";", "}" ]

[ "Detect", "the", "base", "URL", "for", "the", "current", "request", "." ]

[ "public", "static", "function", "status", "(", "$", "status", ",", "$", "suppress", "=", "false", ")", "{", "$", "message", "=", "self", "::", "getStatusMessage", "(", "$", "status", ")", ";", "if", "(", "$", "suppress", ")", "{", "@", "header", "(", "\"HTTP/1.1 $status $message\"", ")", ";", "}", "else", "{", "header", "(", "\"HTTP/1.1 $status $message\"", ")", ";", "}", "return", "$", "message", ";", "}" ]

[ "Set", "HTTP", "status", "-", "code", "." ]

[ "public", "static", "function", "message", "(", "$", "status", ",", "$", "message", ")", "{", "$", "title", "=", "self", "::", "status", "(", "$", "status", ")", ";", "?>\n\n\t\t\t<html>\n\t\t\t\t<head>\n\t\t\t\t\t<title><?=", "$", "title", ";", "?></title>\n\t\t\t\t</head>\n\t\t\t\t<body>\n\t\t\t\t\t<h1><?=", "$", "title", ";", "?></h1>\n\t\t\t\t\t<p>\n\t\t\t\t\t\t<?=", "htmlentities", "(", "$", "message", ",", "ENT_COMPAT", "|", "ENT_HTML401", ",", "'ISO-8859-1'", ")", ";", "?>.\n\t\t\t\t\t</p>\n\t\t\t\t</body>\n\t\t\t</html>\n\n\t\t<?php", "}" ]

[ "Set", "HTTP", "status", "-", "code", "and", "display", "a", "message", "." ]

[ "public", "static", "function", "redirect", "(", "$", "url", ",", "$", "status", "=", "307", ")", "{", "if", "(", "!", "in_array", "(", "$", "status", ",", "[", "300", ",", "301", ",", "302", ",", "303", ",", "307", "]", ")", ")", "{", "$", "status", "=", "307", ";", "}", "$", "url", "=", "trim", "(", "$", "url", ")", ";", "// Append base URL to a relative path", "if", "(", "strtolower", "(", "substr", "(", "$", "url", ",", "0", ",", "4", ")", ")", "!=", "'http'", ")", "{", "$", "base_url", "=", "self", "::", "detectBaseURL", "(", ")", ";", "// Unable to detect the base URL", "if", "(", "empty", "(", "$", "base_url", ")", ")", "{", "self", "::", "message", "(", "500", ",", "'Unable to detect base URL'", ")", ";", "return", ";", "}", "$", "url", "=", "$", "base_url", ".", "ltrim", "(", "$", "url", ",", "'/'", ")", ";", "}", "// Check target URL", "$", "url", "=", "self", "::", "normaliseURL", "(", "$", "url", ")", ";", "if", "(", "$", "url", "==", "''", ")", "{", "self", "::", "message", "(", "500", ",", "'Invalid URL provided for redirect operation'", ")", ";", "return", ";", "}", "// Automatic redirect", "if", "(", "$", "status", "!=", "HTTP", "::", "MULTIPLE_CHOICES", ")", "{", "self", "::", "status", "(", "$", "status", ")", ";", "header", "(", "\"Location: $url\"", ")", ";", "}", "// Manual redirect", "else", "{", "self", "::", "status", "(", "HTTP", "::", "MULTIPLE_CHOICES", ")", ";", "// Prevent the notification page from being cached", "header", "(", "'Cache-Control: no-cache, must-revalidate'", ")", ";", "header", "(", "'Expires: Sat, 26 Jul 1997 05:00:00 CEST'", ")", ";", "}", "?>\n\n\t\t\t<html>\n\t\t\t\t<head>\n\t\t\t\t\t<title>This Page has Moved</title>\n\t\t\t\t</head>\n\t\t\t\t<body>\n\t\t\t\t\t<h1>This Page has Moved</h1>\n\t\t\t\t\t<p>\n\t\t\t\t\t\tThe page you have requested has moved to another\n\t\t\t\t\t\tlocation.\n\t\t\t\t\t</p>\n\t\t\t\t\t<p>\n\t\t\t\t\t\tIf you are not automatically redirected to\n\t\t\t\t\t\t<a href=\"<?=", "$", "url", "?>\">the page's new location</a>,\n\t\t\t\t\t\tplease click <a href=\"<?=", "$", "url", "?>\">here</a> to do so\n\t\t\t\t\t\tmanually.<br>\n\t\t\t\t\t\tIf you keep seeing this message, or are otherwise unable\n\t\t\t\t\t\tto reach the new location, please return to\n\t\t\t\t\t\t<a href=\"/\">our homepage</a> and attempt to\n\t\t\t\t\t\treach the page from there.\n\t\t\t\t\t</p>\n\t\t\t\t</body>\n\t\t\t</html>\n\n\t\t<?php", "}" ]

[ "Redirect", "the", "browser", "to", "the", "provided", "path", "." ]

[ "public", "static", "function", "normaliseURL", "(", "$", "url", ",", "array", "&", "$", "components", "=", "[", "]", ")", "{", "$", "url", "=", "filter_var", "(", "trim", "(", "$", "url", ")", ",", "FILTER_SANITIZE_URL", ")", ";", "$", "components", "=", "@", "parse_url", "(", "$", "url", ")", ";", "if", "(", "!", "$", "components", "||", "!", "isset", "(", "$", "components", "[", "'host'", "]", ")", ")", "{", "return", "''", ";", "}", "// Scheme", "if", "(", "!", "preg_match", "(", "'/https*/i'", ",", "$", "components", "[", "'scheme'", "]", ")", ")", "{", "switch", "(", "$", "components", "[", "'port'", "]", ")", "{", "case", "443", ":", "$", "components", "[", "'scheme'", "]", "=", "'https'", ";", "break", ";", "case", "80", ":", "default", ":", "$", "components", "[", "'scheme'", "]", "=", "'http'", ";", "break", ";", "}", "}", "// Remove default ports", "if", "(", "!", "empty", "(", "$", "components", "[", "'port'", "]", ")", ")", "{", "if", "(", "$", "components", "[", "'scheme'", "]", "==", "'http'", "&&", "$", "components", "[", "'port'", "]", "==", "80", ")", "{", "unset", "(", "$", "components", "[", "'port'", "]", ")", ";", "}", "elseif", "(", "$", "components", "[", "'scheme'", "]", "==", "'https'", "&&", "$", "components", "[", "'port'", "]", "==", "443", ")", "{", "unset", "(", "$", "components", "[", "'port'", "]", ")", ";", "}", "}", "// Remove trailing dot from FQDN", "if", "(", "substr", "(", "$", "components", "[", "'host'", "]", ",", "-", "1", ")", "==", "'.'", ")", "{", "$", "components", "[", "'host'", "]", "=", "substr", "(", "$", "components", "[", "'host'", "]", ",", "0", ",", "-", "1", ")", ";", "}", "// Reconstruct URL", "$", "normalised", "=", "strtolower", "(", "\"{$components['scheme']}://{$components['host']}/\"", ")", ";", "if", "(", "isset", "(", "$", "components", "[", "'port'", "]", ")", ")", "{", "$", "normalised", "=", "substr", "(", "$", "normalised", ",", "0", ",", "-", "1", ")", ".", "\":{$components['port']}/\"", ";", "}", "if", "(", "isset", "(", "$", "components", "[", "'path'", "]", ")", ")", "{", "// Clean path", "$", "components", "[", "'path'", "]", "=", "str_replace", "(", "[", "'\\\\'", ",", "'/./'", "]", ",", "'/'", ",", "$", "components", "[", "'path'", "]", ")", ";", "$", "components", "[", "'path'", "]", "=", "preg_replace", "(", "'/[\\/]+/'", ",", "'/'", ",", "$", "components", "[", "'path'", "]", ")", ";", "$", "normalised", ".=", "ltrim", "(", "$", "components", "[", "'path'", "]", ",", "'/'", ")", ";", "}", "if", "(", "isset", "(", "$", "components", "[", "'query'", "]", ")", ")", "{", "$", "normalised", ".=", "\"?{$components['query']}\"", ";", "}", "if", "(", "isset", "(", "$", "components", "[", "'fragment'", "]", ")", ")", "{", "$", "normalised", ".=", "\"#{$components['fragment']}\"", ";", "}", "return", "$", "normalised", ";", "}" ]

[ "Normalise", "a", "URL", "." ]

[ "public", "static", "function", "getBaseURL", "(", "$", "url", ")", "{", "$", "parsed_url", "=", "parse_url", "(", "$", "url", ")", ";", "if", "(", "$", "parsed_url", "===", "false", ")", "{", "throw", "new", "ErrorException", "(", "'Malformed URL.'", ")", ";", "}", "$", "base_url", "=", "[", "]", ";", "if", "(", "empty", "(", "$", "parsed_url", "[", "'scheme'", "]", ")", ")", "{", "throw", "new", "ErrorException", "(", "'Malformed URL, no scheme.'", ")", ";", "}", "$", "base_url", "[", "]", "=", "$", "parsed_url", "[", "'scheme'", "]", ";", "$", "base_url", "[", "]", "=", "'://'", ";", "$", "base_url", "[", "]", "=", "$", "parsed_url", "[", "'host'", "]", ";", "// Check the path", "$", "path", "=", "$", "parsed_url", "[", "'path'", "]", ";", "$", "path_parts", "=", "explode", "(", "'/'", ",", "$", "path", ")", ";", "// Discard the first slash.", "array_shift", "(", "$", "path_parts", ")", ";", "$", "base", "=", "array_shift", "(", "$", "path_parts", ")", ";", "// Check if we're on localhost", "if", "(", "strpos", "(", "$", "base", ",", "'~'", ")", "!==", "false", ")", "{", "$", "base_url", "[", "]", "=", "'/'", ".", "$", "base", ";", "}", ";", "$", "base_url", "[", "]", "=", "'/'", ";", "return", "implode", "(", "''", ",", "$", "base_url", ")", ";", "}" ]

[ "Get", "the", "base", "URL", "for", "a", "given", "site", "URL", "." ]

[ "public", "static", "function", "parsedURLToString", "(", "$", "parsed_url", ")", "{", "$", "components", "=", "[", "]", ";", "if", "(", "!", "empty", "(", "$", "parsed_url", "[", "'scheme'", "]", ")", ")", "{", "$", "components", "[", "'scheme'", "]", "=", "$", "parsed_url", "[", "'scheme'", "]", ".", "'://'", ";", "}", "$", "components", "[", "'user'", "]", "=", "''", ";", "$", "components", "[", "'pass'", "]", "=", "''", ";", "if", "(", "!", "empty", "(", "$", "parsed_url", "[", "'user'", "]", ")", ")", "{", "$", "components", "[", "'user'", "]", "=", "$", "parsed_url", "[", "'user'", "]", ";", "}", "if", "(", "!", "empty", "(", "$", "parsed_url", "[", "'pass'", "]", ")", ")", "{", "$", "components", "[", "'pass'", "]", "=", "':'", ".", "$", "parsed_url", "[", "'pass'", "]", ";", "}", "if", "(", "$", "components", "[", "'user'", "]", "||", "$", "components", "[", "'pass'", "]", ")", "{", "$", "components", "[", "'pass'", "]", "=", "$", "components", "[", "'pass'", "]", ".", "'@'", ";", "}", "if", "(", "!", "empty", "(", "$", "parsed_url", "[", "'host'", "]", ")", ")", "{", "$", "components", "[", "'host'", "]", "=", "$", "parsed_url", "[", "'host'", "]", ";", "}", "if", "(", "!", "empty", "(", "$", "parsed_url", "[", "'port'", "]", ")", ")", "{", "$", "components", "[", "'port'", "]", "=", "':'", ".", "$", "parsed_url", "[", "'port'", "]", ";", "}", "if", "(", "!", "empty", "(", "$", "parsed_url", "[", "'path'", "]", ")", ")", "{", "$", "components", "[", "'path'", "]", "=", "$", "parsed_url", "[", "'path'", "]", ";", "}", "if", "(", "!", "empty", "(", "$", "parsed_url", "[", "'query'", "]", ")", ")", "{", "$", "components", "[", "'query'", "]", "=", "'?'", ".", "$", "parsed_url", "[", "'query'", "]", ";", "}", "if", "(", "!", "empty", "(", "$", "parsed_url", "[", "'fragment'", "]", ")", ")", "{", "$", "components", "[", "'fragment'", "]", "=", "'#'", ".", "$", "parsed_url", "[", "'fragment'", "]", ";", "}", "return", "implode", "(", "''", ",", "$", "components", ")", ";", "}" ]

[ "Convert", "a", "parsed", "URL", "back", "to", "a", "string", "." ]

[ "public", "static", "function", "cleanPath", "(", "$", "path", ")", "{", "$", "path", "=", "str_replace", "(", "[", "'\\\\'", ",", "'/./'", "]", ",", "'/'", ",", "$", "path", ")", ";", "$", "path", "=", "preg_replace", "(", "'/[\\/]+/'", ",", "'/'", ",", "$", "path", ")", ";", "$", "path", "=", "rtrim", "(", "$", "path", ",", "'/'", ")", ";", "$", "path", "=", "preg_replace", "(", "'/[^a-z0-9 \\-\\/]+/i'", ",", "''", ",", "$", "path", ")", ";", "$", "path", "=", "preg_replace", "(", "'/[ \\-]+/'", ",", "'-'", ",", "$", "path", ")", ";", "return", "$", "path", ";", "}" ]

[ "Strictly", "clean", "a", "URL", "-", "path", "from", "any", "unwanted", "characters", "." ]

[ "public", "function", "clear", "(", "$", "what", "=", "[", "]", ")", "{", "$", "defaults", "=", "[", "'criteria'", "=>", "[", "]", ",", "'offset'", "=>", "0", ",", "'limit'", "=>", "0", ",", "'orderby'", "=>", "[", "]", ",", "]", ";", "$", "what", "=", "(", "array", ")", "$", "what", ";", "if", "(", "empty", "(", "$", "what", ")", ")", "$", "what", "=", "array_keys", "(", "$", "defaults", ")", ";", "foreach", "(", "$", "what", "as", "$", "k", ")", "{", "$", "this", "->", "$", "k", "=", "$", "defaults", "[", "$", "k", "]", ";", "}", "return", "$", "this", ";", "}" ]

[ "Remove", "all", "existing", "criteria", "from", "the", "filter", "." ]

[ "public", "function", "orderBy", "(", "$", "field", ",", "$", "dir", "=", "Filter", "::", "SORT_ASC", ")", "{", "$", "field", "=", "trim", "(", "$", "field", ")", ";", "if", "(", "empty", "(", "$", "field", ")", ")", "throw", "new", "\\", "InvalidArgumentException", "(", "'No field specified'", ")", ";", "$", "modifier", "=", "substr", "(", "$", "field", ",", "0", ",", "1", ")", ";", "if", "(", "in_array", "(", "$", "modifier", ",", "[", "'+'", ",", "'-'", "]", ")", ")", "{", "$", "dir", "=", "(", "$", "modifier", "==", "'+'", ")", ";", "$", "field", "=", "substr", "(", "$", "field", ",", "1", ")", ";", "}", "$", "this", "->", "orderby", "[", "$", "field", "]", "=", "$", "dir", ";", "return", "$", "this", ";", "}" ]

[ "Specify", "a", "field", "to", "order", "the", "results", "by", ".", "Multiple", "levels", "of", "ordering", "can", "be", "specified", "by", "calling", "this", "method", "multiple", "times", "." ]

[ "public", "function", "toQuery", "(", "Query", "$", "query", ",", "array", "$", "columns", "=", "[", "]", ",", "$", "alias", "=", "''", ")", "{", "foreach", "(", "$", "this", "->", "criteria", "as", "$", "column", "=>", "$", "criteria", ")", "{", "if", "(", "!", "$", "column", "=", "$", "this", "->", "getColumnName", "(", "$", "columns", ",", "$", "column", ",", "$", "alias", ")", ")", "continue", ";", "foreach", "(", "$", "criteria", "as", "$", "operator", "=>", "$", "value", ")", "{", "$", "query", "->", "where", "(", "$", "column", ",", "$", "operator", ",", "$", "value", ")", ";", "}", "}", "foreach", "(", "$", "this", "->", "getOrder", "(", ")", "as", "$", "column", "=>", "$", "ascending", ")", "{", "$", "column", "=", "$", "this", "->", "getColumnName", "(", "$", "columns", ",", "$", "column", ",", "$", "alias", ")", ";", "if", "(", "!", "$", "column", ")", "continue", ";", "$", "query", "->", "orderBy", "(", "$", "column", ",", "$", "ascending", ")", ";", "}", "if", "(", "$", "this", "->", "offset", ")", "$", "query", "->", "offset", "(", "$", "this", "->", "offset", ")", ";", "if", "(", "$", "this", "->", "limit", ")", "$", "query", "->", "limit", "(", "$", "this", "->", "limit", ")", ";", "return", "$", "query", ";", "}" ]

[ "Apply", "the", "filter", "to", "a", "database", "Query" ]

[ "protected", "function", "addCriteria", "(", "$", "field", ",", "$", "operator", ",", "$", "value", ")", "{", "$", "field", "=", "trim", "(", "$", "field", ")", ";", "if", "(", "!", "isset", "(", "$", "this", "->", "criteria", "[", "$", "field", "]", ")", ")", "$", "this", "->", "criteria", "[", "$", "field", "]", "=", "[", "]", ";", "$", "this", "->", "criteria", "[", "$", "field", "]", "[", "$", "operator", "]", "=", "$", "value", ";", "return", "$", "this", ";", "}" ]

[ "Add", "a", "criteria", "item", "to", "the", "filter", "." ]

[ "public", "static", "function", "start", "(", "$", "skipConfiguration", "=", "false", ")", "{", "if", "(", "self", "::", "$", "instance", "!==", "null", ")", "{", "throw", "new", "LogException", "(", "\"Logger already started!\"", ")", ";", "}", "// Load the logger.", "self", "::", "$", "instance", "=", "new", "Writer", "(", ")", ";", "// Apply configuration.", "if", "(", "!", "$", "skipConfiguration", "&&", "Configuration", "::", "get", "(", "'app.log'", ",", "true", ")", ")", "{", "// Get configuration", "$", "logPath", "=", "Configuration", "::", "get", "(", "'app.logPath'", ")", ";", "if", "(", "$", "logPath", "===", "null", ")", "{", "// @codeCoverageIgnore", "throw", "new", "ConfigurationException", "(", "\"app.logPath is not valid!\"", ")", ";", "// @codeCoverageIgnore", "}", "// @codeCoverageIgnore", "if", "(", "!", "file_exists", "(", "$", "logPath", ")", ")", "{", "// @codeCoverageIgnore", "if", "(", "!", "mkdir", "(", "$", "logPath", ")", ")", "{", "// @codeCoverageIgnore", "throw", "new", "PermissionDeniedException", "(", "\"Could not create directory '\"", ".", "$", "logPath", ".", "\"'!\"", ")", ";", "// @codeCoverageIgnore", "}", "// @codeCoverageIgnore", "}", "// @codeCoverageIgnore", "// Get all level and log files.", "self", "::", "$", "files", "=", "Configuration", "::", "get", "(", "'app.logFile'", ",", "[", "'app.log'", "=>", "self", "::", "ERROR", "]", ")", ";", "self", "::", "$", "path", "=", "$", "logPath", ";", "// Load all handlers.", "foreach", "(", "self", "::", "$", "files", "as", "$", "file", "=>", "$", "minimumLevel", ")", "{", "self", "::", "$", "instance", "->", "addHandler", "(", "new", "StreamHandler", "(", "$", "logPath", ".", "$", "file", ",", "$", "minimumLevel", ")", ")", ";", "}", "}", "// Register exception/error handler", "ExceptionHandler", "::", "register", "(", ")", ";", "}" ]

[ "Start", "function", "will", "be", "called", "from", "the", "bootstrap", "file", "." ]

[ "public", "static", "function", "clearLog", "(", "$", "level", "=", "null", ")", "{", "foreach", "(", "self", "::", "$", "files", "as", "$", "fileName", "=>", "$", "fileLevel", ")", "{", "if", "(", "$", "level", "===", "null", "||", "$", "level", "===", "$", "fileLevel", ")", "{", "$", "fileName", "=", "self", "::", "$", "path", ".", "$", "fileName", ";", "if", "(", "file_exists", "(", "$", "fileName", ")", ")", "{", "@", "unlink", "(", "$", "fileName", ")", ";", "}", "continue", ";", "}", "}", "// Restart current logger instance.", "self", "::", "$", "instance", "=", "null", ";", "self", "::", "start", "(", ")", ";", "}" ]

[ "Clear", "and", "delete", "log", "files", "." ]

[ "public", "function", "setView", "(", "$", "view", ")", "{", "if", "(", "class_exists", "(", "$", "view", ")", ")", "{", "//if we already have a default view", "$", "values", "=", "[", "]", ";", "//grab all its parameters and store in parameters", "if", "(", "isset", "(", "$", "this", "->", "view", ")", "&&", "$", "this", "->", "view", "instanceof", "View", ")", "{", "$", "values", "=", "$", "this", "->", "view", "->", "getDataArray", "(", ")", ";", "$", "layout", "=", "$", "this", "->", "view", "->", "getLayout", "(", ")", ";", "//Load the newView;", "$", "this", "->", "view", "=", "$", "this", "->", "loadView", "(", "$", "view", ",", "$", "values", ")", ";", "if", "(", "!", "empty", "(", "$", "layout", ")", ")", "{", "$", "this", "->", "view", "->", "setLayout", "(", "$", "layout", ")", ";", "}", "}", "return", "$", "this", ";", "}", "else", "if", "(", "is_string", "(", "$", "view", ")", ")", "{", "$", "this", "->", "response", "->", "addContent", "(", "$", "view", ")", ";", "//so that $this->view(\"Hi There\"); will output Hi There;", "return", "$", "this", ";", "}", "return", "false", ";", "//no view set;", "}" ]

[ "Sets", "the", "view", "for", "this", "controller", "action" ]

[ "public", "function", "render", "(", "View", "$", "view", "=", "null", ")", "{", "if", "(", "$", "this", "->", "rendered", ")", "{", "return", "true", ";", "}", "//$this->reloadResponseVars( $this->response );", "$", "onRender", "=", "new", "Event", "(", "'Controller.beforeRender'", ",", "$", "this", ")", ";", "$", "this", "->", "observer", "->", "trigger", "(", "$", "onRender", ")", ";", "if", "(", "$", "onRender", "->", "isStopped", "(", ")", ")", "{", "$", "this", "->", "autoRender", "=", "false", ";", "return", "$", "this", "->", "response", ";", "}", "//controllers only know about one view.", "//Every action uses a single view;", "//views can be set with $this->setView(\"\") or $this->display(\"\"); //or can be set on render;", "//If we are setting a really late view;", "$", "view", "=", "!", "is_null", "(", "$", "view", ")", "?", "$", "view", ":", "$", "this", "->", "getView", "(", ")", ";", "$", "this", "->", "response", "->", "addContent", "(", "$", "view", "->", "render", "(", ")", ")", ";", "$", "this", "->", "rendered", "=", "true", ";", "return", "true", ";", "}" ]

[ "Renders", "the", "Controller", "-", ">", "Response", ";" ]

[ "public", "function", "invokeAction", "(", "$", "action", ",", "$", "params", "=", "[", "]", ")", "{", "//var_dump($this->request->getAttributes());", "//Will throw an exception if the method does not exists;", "$", "method", "=", "new", "ReflectionMethod", "(", "$", "this", ",", "$", "action", ")", ";", "if", "(", "!", "$", "method", "->", "isPublic", "(", ")", ")", "{", "throw", "new", "Exception", "(", "'Attempting to call a private method'", ")", ";", "}", "return", "$", "method", "->", "invokeArgs", "(", "$", "this", ",", "$", "params", ")", ";", "}" ]

[ "Checks", "that", "the", "method", "is", "callable", ";" ]

[ "protected", "function", "loadView", "(", "$", "view", ",", "$", "values", "=", "[", "]", ")", "{", "if", "(", "isset", "(", "$", "this", "->", "application", "[", "$", "view", "]", ")", ")", "{", "return", "$", "this", "->", "application", "[", "$", "view", "]", ";", "}", "$", "instance", "=", "$", "this", "->", "application", "->", "createInstance", "(", "$", "view", ",", "[", "$", "values", ",", "$", "this", "->", "response", ",", "$", "this", "->", "getHandler", "(", ")", "]", ")", ";", "//Otherwise return an instance of Controller;", "return", "$", "this", "->", "application", "->", "shareInstance", "(", "$", "instance", ",", "$", "view", ")", ";", "}" ]

[ "Loads", "a", "view", "from", "classname", ";" ]

[ "public", "function", "accountInformationAction", "(", ")", "{", "$", "databaseInfo", "=", "$", "this", "->", "checkDatabaseInformation", "(", ")", ";", "if", "(", "$", "databaseInfo", ")", "{", "return", "$", "databaseInfo", ";", "}", "$", "this", "->", "title", "(", "\"Admin Account\"", ")", ";", "return", "$", "this", "->", "render", "(", "\"steps/account_information.phtml\"", ")", ";", "}" ]

[ "Admin", "account", "information", "form", "." ]

[ "public", "static", "function", "fromXml", "(", "\\", "DOMElement", "$", "xml", ")", "{", "$", "static", "=", "new", "static", "(", ")", ";", "$", "static", "->", "libraryItemMetadata", "=", "LibraryItemMetadata", "::", "fromXml", "(", "$", "xml", ")", ";", "$", "static", "->", "renewable", "=", "Renewable", "::", "fromXml", "(", "$", "xml", ")", ";", "$", "loanDate", "=", "$", "xml", "->", "getElementsByTagName", "(", "'loanDate'", ")", ";", "$", "static", "->", "loanDate", "=", "DateTime", "::", "fromXml", "(", "$", "loanDate", ")", ";", "$", "dueDate", "=", "$", "xml", "->", "getElementsByTagName", "(", "'dueDate'", ")", ";", "$", "static", "->", "dueDate", "=", "DateTime", "::", "fromXml", "(", "$", "dueDate", ")", ";", "$", "returnedDate", "=", "$", "xml", "->", "getElementsByTagName", "(", "'returnedDate'", ")", ";", "$", "static", "->", "returnedDate", "=", "DateTime", "::", "fromXml", "(", "$", "returnedDate", ")", ";", "$", "stringLiterals", "=", "array", "(", "'pbsCode'", "=>", "$", "xml", "->", "getElementsByTagName", "(", "'pbsCode'", ")", ",", "'itemSequence'", "=>", "$", "xml", "->", "getElementsByTagName", "(", "'itemSequence'", ")", ",", "'material'", "=>", "$", "xml", "->", "getElementsByTagName", "(", "'material'", ")", ",", ")", ";", "foreach", "(", "$", "stringLiterals", "as", "$", "propertyName", "=>", "$", "xmlTag", ")", "{", "$", "static", "->", "$", "propertyName", "=", "StringLiteral", "::", "fromXml", "(", "$", "xmlTag", ")", ";", "}", "return", "$", "static", ";", "}" ]

[ "Builds", "a", "Loan", "object", "from", "XML", "." ]

[ "public", "function", "&", "get", "(", "$", "key", ")", "{", "if", "(", "$", "this", "->", "has", "(", "$", "key", ")", ")", "{", "$", "object", "=", "$", "this", "->", "_registered", "[", "$", "key", "]", ";", "if", "(", "$", "object", "instanceof", "Closure", ")", "{", "$", "object", "=", "$", "this", "->", "set", "(", "call_user_func", "(", "$", "object", ")", ",", "$", "key", ")", ";", "}", "return", "$", "object", ";", "}", "throw", "new", "MissingObjectException", "(", "sprintf", "(", "'Object %s does not exist in the container'", ",", "$", "key", ")", ")", ";", "}" ]

[ "Return", "the", "object", "assigned", "to", "the", "given", "key", "." ]

[ "public", "static", "function", "stringToUrl", "(", "$", "string", ",", "$", "separator", "=", "'_'", ",", "$", "encoding", "=", "'UTF-8'", ",", "$", "lower", "=", "false", ")", "{", "if", "(", "!", "Validate", "::", "isCharset", "(", "$", "encoding", ")", ")", "throw", "new", "\\", "Exception", "(", "'Encoding in\\'t a valid charset type'", ")", ";", "$", "string", "=", "htmlentities", "(", "html_entity_decode", "(", "$", "string", ",", "null", ",", "$", "encoding", ")", ",", "ENT_NOQUOTES", ",", "$", "encoding", ")", ";", "if", "(", "$", "lower", ")", "$", "string", "=", "strtolower", "(", "$", "string", ")", ";", "$", "search", "=", "array", "(", "'#\\&(.)(?:uml|circ|tilde|acute|grave|cedil|ring)\\;#'", ",", "'#\\&(.{2})(?:lig)\\;#'", ",", "'#\\&[a-z]+\\;#'", ",", "'#[^a-zA-Z0-9_]#'", ",", "'#'", ".", "$", "separator", ".", "'+#'", ")", ";", "$", "replace", "=", "array", "(", "'\\1'", ",", "'\\1'", ",", "''", ",", "$", "separator", ",", "$", "separator", ")", ";", "return", "trim", "(", "preg_replace", "(", "$", "search", ",", "$", "replace", ",", "$", "string", ")", ",", "$", "separator", ")", ";", "}" ]

[ "Convert", "a", "string", "to", "url", "format", "for", "url", "rewrite" ]

[ "public", "static", "function", "parseObjectToArray", "(", "$", "object", ")", "{", "$", "array", "=", "array", "(", ")", ";", "if", "(", "is_object", "(", "$", "object", ")", ")", "$", "array", "=", "get_object_vars", "(", "$", "object", ")", ";", "elseif", "(", "is_array", "(", "$", "object", ")", ")", "{", "foreach", "(", "$", "object", "as", "$", "k", "=>", "&", "$", "value", ")", "$", "array", "[", "$", "k", "]", "=", "self", "::", "parseObjectToArray", "(", "$", "value", ")", ";", "}", "else", "$", "array", "=", "$", "object", ";", "return", "$", "array", ";", "}" ]

[ "Transforme", "un", "object", "en", "array" ]

[ "public", "static", "function", "httpFileExistsWithCurl", "(", "$", "url", ")", "{", "if", "(", "!", "extension_loaded", "(", "'curl'", ")", ")", "throw", "new", "\\", "Exception", "(", "'Curl extension not loaded try change your PHP configuration'", ")", ";", "return", "(", "$", "ch", "=", "curl_init", "(", "$", "url", ")", ")", "?", "@", "curl_close", "(", "$", "ch", ")", "||", "true", ":", "false", ";", "}" ]

[ "Permet", "de", "regarder", "si", "un", "fichier", "existe", "depuis", "une", "url", "avec", "curl" ]

[ "public", "static", "function", "dirList", "(", "$", "dir", ")", "{", "if", "(", "!", "is_dir", "(", "$", "dir", ")", ")", "throw", "new", "\\", "Exception", "(", "'\"'", ".", "$", "dir", ".", "'\" is not a valid directory'", ")", ";", "$", "l", "=", "array", "(", ")", ";", "foreach", "(", "self", "::", "cleanScandir", "(", "$", "dir", ")", "as", "$", "f", ")", "{", "if", "(", "is_dir", "(", "$", "dir", ".", "$", "f", ")", ")", "{", "$", "l", "[", "]", "=", "$", "dir", ".", "$", "f", ".", "'/'", ";", "$", "l", "=", "array_merge", "(", "$", "l", ",", "self", "::", "dirList", "(", "$", "dir", ".", "$", "f", ".", "DIRECTORY_SEPARATOR", ")", ")", ";", "}", "}", "return", "$", "l", ";", "}" ]

[ "Permet", "de", "lister", "les", "repertoires", "d", "un", "dossier" ]

[ "public", "static", "function", "getIncludeContents", "(", "$", "filename", ",", "$", "param_contents", "=", "false", ")", "{", "//On verifie que le fichier existe, qu'il soit valid (lisible...) si ce n'est pas le cas, on genere une exception\r", "if", "(", "!", "is_file", "(", "$", "filename", ")", "&&", "!", "file_exists", "(", "$", "filename", ")", "&&", "!", "is_readable", "(", "$", "filename", ")", ")", "throw", "new", "\\", "Exception", "(", "'Le fichier \"'", ".", "$", "filename", ".", "'\" n\\'existe pas ou est invalid'", ")", ";", "//Attribution du nom et valeur de variables contenu dans le fichier à inclure\r", "if", "(", "$", "param_contents", ")", "{", "for", "(", "$", "i", "=", "0", ";", "$", "i", "<", "count", "(", "$", "param_contents", ")", ";", "$", "i", "++", ")", "{", "if", "(", "array_key_exists", "(", "'param_name'", ",", "$", "param_contents", ")", "&&", "array_key_exists", "(", "'param_value'", ",", "$", "param_contents", ")", ")", "$", "{", "$", "param_contents", "[", "$", "i", "]", "[", "'param_name'", "]", "}", "=", "$", "param_contents", "[", "$", "i", "]", "[", "'param_value'", "]", ";", "}", "}", "ob_start", "(", ")", ";", "include", "$", "filename", ";", "$", "contents", "=", "ob_get_contents", "(", ")", ";", "ob_end_clean", "(", ")", ";", "return", "$", "contents", ";", "}" ]

[ "Permet", "de", "retourner", "le", "contenu", "d", "un", "fichier", "inclut" ]

[ "public", "function", "addCallableHandle", "(", ")", "{", "if", "(", "$", "this", "->", "handler", ")", "{", "throw", "new", "AlreadyBuildedException", "(", "'The handler already builded.'", ")", ";", "}", "$", "loader", "=", "new", "CallableLoader", "(", ")", ";", "$", "resolver", "=", "new", "CallableResolver", "(", ")", ";", "$", "this", "->", "addCallableResolver", "(", "$", "resolver", ")", ";", "$", "this", "->", "addActionLoader", "(", "$", "loader", ")", ";", "return", "$", "loader", ";", "}" ]

[ "Add", "closure", "handle" ]

[ "public", "function", "addCallableResolver", "(", "CallableResolverInterface", "$", "callableResolver", ")", "{", "if", "(", "$", "this", "->", "handler", ")", "{", "throw", "new", "AlreadyBuildedException", "(", "'The handler already builded.'", ")", ";", "}", "$", "this", "->", "callableResolvers", "[", "spl_object_hash", "(", "$", "callableResolver", ")", "]", "=", "$", "callableResolver", ";", "return", "$", "this", ";", "}" ]

[ "Add", "callable", "resolver" ]

[ "public", "function", "addActionLoader", "(", "LoaderInterface", "$", "loader", ")", "{", "if", "(", "$", "this", "->", "handler", ")", "{", "throw", "new", "AlreadyBuildedException", "(", "'The handler already builded.'", ")", ";", "}", "$", "this", "->", "actionLoaders", "[", "spl_object_hash", "(", "$", "loader", ")", "]", "=", "$", "loader", ";", "return", "$", "this", ";", "}" ]

[ "Add", "action", "loader" ]

[ "public", "function", "setEventDispatcher", "(", "EventDispatcherInterface", "$", "eventDispatcher", ")", "{", "if", "(", "$", "this", "->", "handler", ")", "{", "throw", "new", "AlreadyBuildedException", "(", "'The handler already builded.'", ")", ";", "}", "$", "this", "->", "eventDispatcher", "=", "$", "eventDispatcher", ";", "return", "$", "this", ";", "}" ]

[ "Set", "event", "dispatcher" ]

[ "public", "function", "setParameterResolver", "(", "ParameterResolverInterface", "$", "resolver", ")", "{", "if", "(", "$", "this", "->", "handler", ")", "{", "throw", "new", "AlreadyBuildedException", "(", "'The handler already builded.'", ")", ";", "}", "$", "this", "->", "parameterResolver", "=", "$", "resolver", ";", "return", "$", "this", ";", "}" ]

[ "Set", "parameter", "resolver" ]

[ "public", "function", "setParameterExtractor", "(", "ParameterExtractorInterface", "$", "extractor", ")", "{", "if", "(", "$", "this", "->", "handler", ")", "{", "throw", "new", "AlreadyBuildedException", "(", "'The handler already builded.'", ")", ";", "}", "$", "this", "->", "parameterExtractor", "=", "$", "extractor", ";", "return", "$", "this", ";", "}" ]

[ "Set", "parameter", "extractor" ]

[ "public", "function", "with", "(", "callable", "$", "supplier", ",", "callable", "$", "accumulator", ",", "callable", "$", "finisher", "=", "null", ")", "{", "return", "$", "this", "->", "sequence", "->", "collect", "(", "new", "Collector", "(", "$", "supplier", ",", "$", "accumulator", ",", "$", "finisher", ")", ")", ";", "}" ]

[ "collects", "all", "elements", "into", "structure", "defined", "by", "supplier" ]

[ "public", "function", "inPartitions", "(", "callable", "$", "predicate", ",", "Collector", "$", "base", "=", "null", ")", ":", "array", "{", "$", "collector", "=", "(", "null", "===", "$", "base", ")", "?", "Collector", "::", "forList", "(", ")", ":", "$", "base", ";", "return", "$", "this", "->", "with", "(", "function", "(", ")", "use", "(", "$", "collector", ")", "{", "return", "[", "true", "=>", "$", "collector", "->", "fork", "(", ")", ",", "false", "=>", "$", "collector", "->", "fork", "(", ")", "]", ";", "}", ",", "function", "(", "&", "$", "partitions", ",", "$", "element", ",", "$", "key", ")", "use", "(", "$", "predicate", ")", "{", "$", "partitions", "[", "$", "predicate", "(", "$", "element", ")", "]", "->", "accumulate", "(", "$", "element", ",", "$", "key", ")", ";", "}", ",", "function", "(", "$", "partitions", ")", "{", "return", "[", "true", "=>", "$", "partitions", "[", "true", "]", "->", "finish", "(", ")", ",", "false", "=>", "$", "partitions", "[", "false", "]", "->", "finish", "(", ")", "]", ";", "}", ")", ";", "}" ]

[ "creates", "collector", "which", "groups", "the", "elements", "in", "two", "partitions", "according", "to", "given", "predicate" ]

[ "public", "function", "inGroups", "(", "callable", "$", "classifier", ",", "Collector", "$", "base", "=", "null", ")", ":", "array", "{", "$", "collector", "=", "(", "null", "===", "$", "base", ")", "?", "Collector", "::", "forList", "(", ")", ":", "$", "base", ";", "return", "$", "this", "->", "with", "(", "function", "(", ")", "{", "return", "[", "]", ";", "}", ",", "function", "(", "&", "$", "groups", ",", "$", "element", ")", "use", "(", "$", "classifier", ",", "$", "collector", ")", "{", "$", "key", "=", "$", "classifier", "(", "$", "element", ")", ";", "if", "(", "!", "isset", "(", "$", "groups", "[", "$", "key", "]", ")", ")", "{", "$", "groups", "[", "$", "key", "]", "=", "$", "collector", "->", "fork", "(", ")", ";", "}", "$", "groups", "[", "$", "key", "]", "->", "accumulate", "(", "$", "element", ",", "$", "key", ")", ";", "}", ",", "function", "(", "$", "groups", ")", "{", "foreach", "(", "$", "groups", "as", "$", "key", "=>", "$", "group", ")", "{", "$", "groups", "[", "$", "key", "]", "=", "$", "group", "->", "finish", "(", ")", ";", "}", "return", "$", "groups", ";", "}", ")", ";", "}" ]

[ "creates", "collector", "which", "groups", "the", "elements", "according", "to", "given", "classifier" ]

[ "public", "function", "byJoining", "(", "string", "$", "delimiter", "=", "', '", ",", "string", "$", "prefix", "=", "''", ",", "string", "$", "suffix", "=", "''", ",", "string", "$", "keySeparator", "=", "null", ")", ":", "string", "{", "return", "$", "this", "->", "with", "(", "function", "(", ")", "{", "return", "null", ";", "}", ",", "function", "(", "&", "$", "joinedElements", ",", "$", "element", ",", "$", "key", ")", "use", "(", "$", "prefix", ",", "$", "delimiter", ",", "$", "keySeparator", ")", "{", "if", "(", "null", "===", "$", "joinedElements", ")", "{", "$", "joinedElements", "=", "$", "prefix", ";", "}", "else", "{", "$", "joinedElements", ".=", "$", "delimiter", ";", "}", "$", "joinedElements", ".=", "(", "null", "!==", "$", "keySeparator", "?", "$", "key", ".", "$", "keySeparator", ":", "null", ")", ".", "$", "element", ";", "}", ",", "function", "(", "$", "joinedElements", ")", "use", "(", "$", "suffix", ")", "{", "return", "$", "joinedElements", ".", "$", "suffix", ";", "}", ")", ";", "}" ]

[ "creates", "collector", "which", "concatenates", "all", "elements", "into", "a", "single", "string" ]

[ "function", "bind", "(", "$", "orig", ",", "$", "b", ",", "$", "wanted", ")", "{", "$", "result", "=", "array", "(", "$", "b", ")", ";", "foreach", "(", "$", "wanted", "as", "$", "k", "=>", "$", "field", ")", "{", "if", "(", "isset", "(", "$", "orig", "[", "$", "field", "]", ")", "&&", "strlen", "(", "\"\"", ".", "$", "orig", "[", "$", "field", "]", ")", ")", "{", "$", "result", "[", "$", "field", "]", "=", "$", "orig", "[", "$", "field", "]", ";", "}", "else", "{", "$", "result", "[", "$", "field", "]", "=", "null", ";", "}", "}", "return", "$", "result", ";", "}" ]

[ "get", "the", "bound", "values", "using", "null", "if", "not", "defined", "in", "the", "orig" ]

[ "function", "id_insert", "(", "$", "table", ",", "$", "query", ",", "$", "bind_arr", "=", "null", ")", "{", "$", "stmt", "=", "$", "this", "->", "mysqli", "->", "prepare", "(", "$", "query", ")", ";", "if", "(", "!", "$", "stmt", ")", "{", "throw", "new", "Exception", "(", "\"can't prepare query:[$query] because [\"", ".", "$", "this", "->", "mysqli", "->", "error", ".", "\"]\"", ")", ";", "}", "if", "(", "isset", "(", "$", "bind_arr", ")", "&&", "$", "bind_arr", "!=", "null", ")", "{", "call_user_func_array", "(", "array", "(", "$", "stmt", ",", "'bind_param'", ")", ",", "$", "this", "->", "makeValuesReferenced", "(", "$", "bind_arr", ")", ")", ";", "}", "if", "(", "!", "$", "stmt", "->", "execute", "(", ")", ")", "{", "throw", "new", "Exception", "(", "$", "this", "->", "mysqli", "->", "error", ")", ";", "}", "if", "(", "!", "$", "id", "=", "$", "stmt", "->", "insert_id", ")", "{", "throw", "new", "Exception", "(", "\"no id returned for insert $query\"", ")", ";", "}", "/* close statement and connection */", "$", "stmt", "->", "close", "(", ")", ";", "$", "rows", "=", "$", "this", "->", "query", "(", "\"select * from $table where id = ?\"", ",", "array", "(", "\"i\"", ",", "$", "id", ")", ")", ";", "return", "$", "rows", "[", "0", "]", ";", "}" ]

[ "insert", "a", "row", "of", "data", "and", "return", "it", "back" ]

[ "function", "id_update", "(", "$", "table", ",", "$", "id", ",", "$", "query", ",", "$", "bind_arr", "=", "null", ")", "{", "$", "stmt", "=", "$", "this", "->", "mysqli", "->", "prepare", "(", "$", "query", ")", "or", "die", "(", "\"can't prepare query:[$query] because [\"", ".", "$", "this", "->", "mysqli", "->", "error", ".", "\"]\"", ")", ";", "if", "(", "isset", "(", "$", "bind_arr", ")", "&&", "$", "bind_arr", "!=", "null", ")", "{", "call_user_func_array", "(", "array", "(", "$", "stmt", ",", "'bind_param'", ")", ",", "$", "this", "->", "makeValuesReferenced", "(", "$", "bind_arr", ")", ")", ";", "}", "$", "stmt", "->", "execute", "(", ")", ";", "/* close statement and connection */", "$", "stmt", "->", "close", "(", ")", ";", "$", "rows", "=", "$", "this", "->", "query", "(", "\"select * from $table where id = ?\"", ",", "array", "(", "\"i\"", ",", "$", "id", ")", ")", ";", "return", "$", "rows", "[", "0", "]", ";", "}" ]

[ "update", "the", "row", "having", "the", "given", "id", "and", "return", "back", "the", "same", "row", "." ]

[ "public", "function", "editionMode", "(", ")", "{", "if", "(", "isset", "(", "$", "_SESSION", "[", "\"FINE_MESSAGE_EDITION_MODE\"", "]", ")", ")", "{", "$", "this", "->", "isMessageEditionMode", "=", "true", ";", "}", "$", "this", "->", "content", "->", "addFile", "(", "'../utils.i18n.fine/src/views/enableDisableEdition.php'", ",", "$", "this", ")", ";", "$", "this", "->", "template", "->", "toHtml", "(", ")", ";", "}" ]

[ "Admin", "page", "used", "to", "enable", "or", "disable", "label", "edition", "." ]

[ "public", "function", "setMode", "(", "$", "mode", ")", "{", "$", "editMode", "=", "(", "$", "mode", "==", "\"on\"", ")", "?", "true", ":", "false", ";", "//SessionUtils::setMessageEditionMode($editMode);", "if", "(", "$", "editMode", ")", "{", "$", "_SESSION", "[", "\"FINE_MESSAGE_EDITION_MODE\"", "]", "=", "true", ";", "$", "this", "->", "isMessageEditionMode", "=", "true", ";", "}", "else", "{", "unset", "(", "$", "_SESSION", "[", "\"FINE_MESSAGE_EDITION_MODE\"", "]", ")", ";", "}", "$", "this", "->", "content", "->", "addFile", "(", "'../utils.i18n.fine/src/views/enableDisableEdition.php'", ",", "$", "this", ")", ";", "$", "this", "->", "template", "->", "toHtml", "(", ")", ";", "}" ]

[ "Action", "used", "to", "set", "the", "mode", "of", "label", "edition", "." ]

[ "public", "function", "addSupportedLanguage", "(", "$", "language", ",", "$", "name", "=", "\"defaultTranslationService\"", ",", "$", "selfedit", "=", "\"false\"", ")", "{", "$", "this", "->", "addTranslationLanguageFromService", "(", "(", "$", "selfedit", "==", "\"true\"", ")", ",", "$", "name", ",", "$", "language", ")", ";", "// Once more to reaload languages list", "$", "this", "->", "supportedLanguages", "(", "$", "name", ",", "$", "selfedit", ")", ";", "}" ]

[ "Adds", "a", "language", "to", "the", "list", "of", "supported", "languages" ]

[ "public", "function", "searchLabel", "(", "$", "msginstancename", "=", "\"defaultTranslationService\"", ",", "$", "selfedit", "=", "\"false\"", ",", "$", "search", ",", "$", "language_search", "=", "null", ")", "{", "$", "this", "->", "msgInstanceName", "=", "$", "msginstancename", ";", "$", "this", "->", "selfedit", "=", "$", "selfedit", ";", "$", "array", "=", "$", "this", "->", "getAllMessagesFromService", "(", "(", "$", "selfedit", "==", "\"true\"", ")", ",", "$", "msginstancename", ",", "$", "language_search", ")", ";", "$", "this", "->", "languages", "=", "$", "array", "[", "\"languages\"", "]", ";", "$", "this", "->", "search", "=", "$", "search", ";", "$", "this", "->", "language_search", "=", "$", "language_search", ";", "if", "(", "$", "search", ")", "{", "$", "this", "->", "msgs", "=", "$", "array", "[", "\"msgs\"", "]", ";", "$", "regex", "=", "$", "this", "->", "stripRegexMetaChars", "(", "$", "this", "->", "stripAccents", "(", "$", "search", ")", ")", ";", "$", "this", "->", "results", "=", "$", "this", "->", "regex_search_array", "(", "$", "array", "[", "\"msgs\"", "]", ",", "$", "regex", ")", ";", "$", "this", "->", "error", "=", "false", ";", "}", "else", "$", "this", "->", "error", "=", "true", ";", "$", "webLibriary", "=", "new", "WebLibrary", "(", "array", "(", ")", ",", "array", "(", "'../utils.i18n.fine/src/views/css/style.css'", ")", ")", ";", "$", "this", "->", "template", "->", "getWebLibraryManager", "(", ")", "->", "addLibrary", "(", "$", "webLibriary", ")", ";", "$", "this", "->", "content", "->", "addFile", "(", "'../utils.i18n.fine/src/views/searchLabel.php'", ",", "$", "this", ")", ";", "$", "this", "->", "template", "->", "toHtml", "(", ")", ";", "}" ]

[ "Search", "All", "label", "with", "the", "value" ]

[ "protected", "static", "function", "setTranslationsForMessageFromService", "(", "$", "selfEdit", ",", "$", "msgInstanceName", ",", "$", "language", ",", "$", "translations", ")", "{", "$", "translationService", "=", "new", "InstanceProxy", "(", "$", "msgInstanceName", ",", "$", "selfEdit", ")", ";", "return", "$", "translationService", "->", "setMessages", "(", "$", "translations", ",", "$", "language", ")", ";", "}" ]

[ "Saves", "many", "translations", "for", "one", "key", "and", "one", "language", "using", "CURL", "." ]

[ "private", "function", "regex_search_array", "(", "$", "array", ",", "$", "regex", ")", "{", "$", "return", "=", "array", "(", ")", ";", "foreach", "(", "$", "array", "as", "$", "key", "=>", "$", "item", ")", "{", "if", "(", "is_array", "(", "$", "item", ")", ")", "{", "$", "tmp", "=", "$", "this", "->", "regex_search_array", "(", "$", "item", ",", "$", "regex", ")", ";", "if", "(", "$", "tmp", ")", "$", "return", "[", "$", "key", "]", "=", "$", "tmp", ";", "}", "elseif", "(", "!", "is_object", "(", "$", "item", ")", ")", "{", "//if (preg_match(\"/^.*\".$regex.\".*$/\", $this->stripAccents($item))) {", "if", "(", "preg_match", "(", "\"/\"", ".", "$", "regex", ".", "\"/i\"", ",", "$", "this", "->", "stripAccents", "(", "$", "item", ")", ")", ")", "{", "$", "return", "[", "$", "key", "]", "=", "$", "item", ";", "}", "}", "}", "return", "$", "return", ";", "}" ]

[ "Search", "the", "regex", "in", "all", "the", "array", ".", "Return", "an", "array", "with", "all", "result" ]

[ "public", "function", "toSum", "(", "callable", "$", "summer", "=", "null", ")", "{", "if", "(", "null", "===", "$", "summer", ")", "{", "$", "summer", "=", "function", "(", "$", "sum", ",", "$", "element", ")", "{", "return", "$", "sum", "+=", "$", "element", ";", "}", ";", "}", "return", "$", "this", "->", "with", "(", "$", "summer", ",", "0", ")", ";", "}" ]

[ "reduce", "to", "sum", "of", "all", "elements" ]

[ "public", "function", "toMin", "(", "callable", "$", "min", "=", "null", ")", "{", "if", "(", "null", "===", "$", "min", ")", "{", "// can't use min() as $smallest is initially null but actual", "// elements were not checked yet, and min() considers null to always", "// be the minimum value", "$", "min", "=", "function", "(", "$", "smallest", ",", "$", "element", ")", "{", "return", "(", "null", "===", "$", "smallest", "||", "$", "element", "<", "$", "smallest", ")", "?", "$", "element", ":", "$", "smallest", ";", "}", ";", "}", "return", "$", "this", "->", "with", "(", "$", "min", ")", ";", "}" ]

[ "reduce", "to", "smallest", "element" ]

[ "public", "function", "setWorkingDirectory", "(", "$", "workingDirectory", ")", "{", "if", "(", "(", "null", "!==", "$", "workingDirectory", ")", "&&", "!", "is_dir", "(", "$", "workingDirectory", ")", ")", "{", "throw", "new", "InvalidArgumentException", "(", "'The working directory must exist.'", ")", ";", "}", "$", "this", "->", "workingDirectory", "=", "$", "workingDirectory", ";", "return", "$", "this", ";", "}" ]

[ "Sets", "the", "working", "directory", "." ]

[ "public", "function", "generate", "(", ")", "{", "$", "options", "=", "$", "this", "->", "options", ";", "$", "arguments", "=", "array_merge", "(", "[", "$", "this", "->", "binary", "]", ",", "(", "array", ")", "$", "this", "->", "arguments", ")", ";", "$", "script", "=", "implode", "(", "' '", ",", "array_map", "(", "[", "ProcessUtils", "::", "class", ",", "'escapeArgument'", "]", ",", "$", "arguments", ")", ")", ";", "$", "process", "=", "new", "Process", "(", "$", "this", "->", "applyForceToBackground", "(", "$", "script", ")", ",", "$", "this", "->", "workingDirectory", ",", "$", "this", "->", "getEnvironmentVariables", "(", ")", ",", "$", "this", "->", "input", ",", "$", "this", "->", "timeout", ",", "$", "options", ")", ";", "if", "(", "$", "this", "->", "outputDisabled", ")", "{", "$", "process", "->", "disableOutput", "(", ")", ";", "}", "return", "$", "process", ";", "}" ]

[ "Generate", "the", "process", "." ]

[ "private", "function", "getEnvironmentVariables", "(", ")", "{", "// Initialize from globals, allow override of special keys via putenv calls.", "$", "variables", "=", "$", "this", "->", "inheritEnvironment", "?", "array_replace", "(", "$", "_ENV", ",", "$", "_SERVER", ",", "$", "this", "->", "environment", ")", ":", "$", "this", "->", "environment", ";", "foreach", "(", "array_keys", "(", "$", "variables", ")", "as", "$", "name", ")", "{", "if", "(", "false", "!==", "(", "$", "value", "=", "getenv", "(", "$", "name", ")", ")", ")", "{", "$", "variables", "[", "$", "name", "]", "=", "$", "value", ";", "}", "}", "return", "$", "variables", ";", "}" ]

[ "Retrieve", "the", "passed", "environment", "variables", "from", "the", "current", "session", "and", "return", "them", "." ]

[ "public", "function", "register", "(", ")", "{", "$", "app", "=", "$", "this", "->", "app", ";", "if", "(", "true", "===", "$", "this", "->", "app", "[", "'config'", "]", "->", "get", "(", "'database.autostart'", ")", ")", "{", "$", "configs", "=", "Config", "::", "get", "(", "'database'", ")", ";", "$", "connection", "=", "$", "configs", "[", "'connection'", "]", ";", "$", "connectionConfigs", "=", "Arr", "::", "get", "(", "$", "configs", "[", "'connections'", "]", ",", "$", "connection", ",", "[", "]", ")", ";", "Query", "::", "configs", "(", "$", "connectionConfigs", ")", ";", "$", "this", "->", "singleton", "(", "'database.base'", ",", "function", "(", ")", "{", "return", "new", "Database", "(", ")", ";", "}", ")", ";", "$", "this", "->", "singleton", "(", "Base", "::", "class", ",", "function", "(", ")", "{", "return", "App", "::", "make", "(", "'database.base'", ")", ";", "}", ")", ";", "}", "}" ]

[ "register", "the", "database", "base" ]

[ "public", "static", "function", "getQuery", "(", "string", "$", "p_type", "=", "\\", "FreeFW", "\\", "Model", "\\", "Query", "::", "QUERY_SELECT", ")", "{", "$", "cls", "=", "get_called_class", "(", ")", ";", "$", "cls", "=", "rtrim", "(", "ltrim", "(", "$", "cls", ",", "'\\\\'", ")", ",", "'\\\\'", ")", ";", "$", "query", "=", "\\", "FreeFW", "\\", "DI", "\\", "DI", "::", "get", "(", "'FreeFW::Model::Query'", ")", ";", "$", "query", "->", "setType", "(", "$", "p_type", ")", "->", "setMainModel", "(", "str_replace", "(", "'\\\\'", ",", "'::'", ",", "$", "cls", ")", ")", ";", "return", "$", "query", ";", "}" ]

[ "Get", "new", "Query", "Model" ]

[ "public", "function", "dispatchMatch", "(", "MatchContextInterface", "$", "match", ")", "{", "// store the previous request context.", "$", "request", "=", "$", "this", "->", "url", "->", "getRequestContext", "(", ")", ";", "$", "this", "->", "url", "->", "setRequestContext", "(", "$", "match", "->", "getRequest", "(", ")", ")", ";", "$", "this", "->", "routeStack", "->", "push", "(", "$", "match", "->", "getName", "(", ")", ")", ";", "$", "response", "=", "$", "this", "->", "mapper", "->", "mapResponse", "(", "$", "this", "->", "dispatcher", "->", "dispatch", "(", "$", "match", ")", ")", ";", "$", "this", "->", "routeStack", "->", "pop", "(", ")", ";", "// restore the previous request context.", "if", "(", "null", "!==", "$", "request", ")", "{", "$", "this", "->", "url", "->", "setRequestContext", "(", "$", "request", ")", ";", "}", "return", "$", "response", ";", "}" ]

[ "Dispatches", "a", "request", "." ]

[ "protected", "function", "registerComment", "(", ")", "{", "$", "this", "->", "app", "->", "singleton", "(", "'jlourenco.comments.comment'", ",", "function", "(", "$", "app", ")", "{", "$", "baseConfig", "=", "$", "app", "[", "'config'", "]", "->", "get", "(", "'jlourenco.base'", ")", ";", "$", "config", "=", "$", "app", "[", "'config'", "]", "->", "get", "(", "'jlourenco.comments'", ")", ";", "$", "model", "=", "array_get", "(", "$", "config", ",", "'models.comment'", ")", ";", "$", "users", "=", "array_get", "(", "$", "baseConfig", ",", "'models.User'", ")", ";", "if", "(", "class_exists", "(", "$", "model", ")", "&&", "method_exists", "(", "$", "model", ",", "'setUsersModel'", ")", ")", "forward_static_call_array", "(", "[", "$", "model", ",", "'setUsersModel'", "]", ",", "[", "$", "users", "]", ")", ";", "return", "new", "CommentRepository", "(", "$", "model", ")", ";", "}", ")", ";", "}" ]

[ "Registers", "the", "blog", "posts", "." ]

[ "protected", "function", "registerComments", "(", ")", "{", "$", "this", "->", "app", "->", "singleton", "(", "'comments'", ",", "function", "(", "$", "app", ")", "{", "$", "blog", "=", "new", "Comments", "(", "$", "app", "[", "'jlourenco.comments.comment'", "]", ")", ";", "return", "$", "blog", ";", "}", ")", ";", "$", "this", "->", "app", "->", "alias", "(", "'comments'", ",", "'jlourenco\\comments\\Comments'", ")", ";", "}" ]

[ "Registers", "log", "." ]