idx int64 0 241k | question stringlengths 64 6.21k | target stringlengths 5 803 |
|---|---|---|
4,300 | protected function buildSelectQuery ( SQLSelect $ query , array & $ parameters ) { $ sql = $ this -> buildSelectFragment ( $ query , $ parameters ) ; $ sql .= $ this -> buildFromFragment ( $ query , $ parameters ) ; $ sql .= $ this -> buildWhereFragment ( $ query , $ parameters ) ; $ sql .= $ this -> buildGroupByFragment ( $ query , $ parameters ) ; $ sql .= $ this -> buildHavingFragment ( $ query , $ parameters ) ; $ sql .= $ this -> buildOrderByFragment ( $ query , $ parameters ) ; $ sql .= $ this -> buildLimitFragment ( $ query , $ parameters ) ; return $ sql ; } | Builds a query from a SQLSelect expression |
4,301 | protected function buildDeleteQuery ( SQLDelete $ query , array & $ parameters ) { $ sql = $ this -> buildDeleteFragment ( $ query , $ parameters ) ; $ sql .= $ this -> buildFromFragment ( $ query , $ parameters ) ; $ sql .= $ this -> buildWhereFragment ( $ query , $ parameters ) ; return $ sql ; } | Builds a query from a SQLDelete expression |
4,302 | protected function buildInsertQuery ( SQLInsert $ query , array & $ parameters ) { $ nl = $ this -> getSeparator ( ) ; $ into = $ query -> getInto ( ) ; $ columns = $ query -> getColumns ( ) ; $ sql = "INSERT INTO {$into}{$nl}(" . implode ( ', ' , $ columns ) . ")" ; $ sql .= "{$nl}VALUES" ; $ rowParts = array ( ) ; foreach ( $ query -> getRows ( ) as $ row ) { $ assignments = $ row -> getAssignments ( ) ; $ parts = array ( ) ; foreach ( $ columns as $ column ) { if ( isset ( $ assignments [ $ column ] ) ) { foreach ( $ assignments [ $ column ] as $ assignmentSQL => $ assignmentParameters ) { $ parts [ ] = $ assignmentSQL ; $ parameters = array_merge ( $ parameters , $ assignmentParameters ) ; break ; } } else { $ parts [ ] = '?' ; $ parameters [ ] = null ; } } $ rowParts [ ] = '(' . implode ( ', ' , $ parts ) . ')' ; } $ sql .= $ nl . implode ( ",$nl" , $ rowParts ) ; return $ sql ; } | Builds a query from a SQLInsert expression |
4,303 | protected function buildUpdateQuery ( SQLUpdate $ query , array & $ parameters ) { $ sql = $ this -> buildUpdateFragment ( $ query , $ parameters ) ; $ sql .= $ this -> buildWhereFragment ( $ query , $ parameters ) ; return $ sql ; } | Builds a query from a SQLUpdate expression |
4,304 | protected function buildSelectFragment ( SQLSelect $ query , array & $ parameters ) { $ distinct = $ query -> getDistinct ( ) ; $ select = $ query -> getSelect ( ) ; $ clauses = array ( ) ; foreach ( $ select as $ alias => $ field ) { $ fieldAlias = "\"{$alias}\"" ; if ( $ alias === $ field || substr ( $ field , - strlen ( $ fieldAlias ) ) === $ fieldAlias ) { $ clauses [ ] = $ field ; } else { $ clauses [ ] = "$field AS $fieldAlias" ; } } $ text = 'SELECT ' ; if ( $ distinct ) { $ text .= 'DISTINCT ' ; } return $ text . implode ( ', ' , $ clauses ) ; } | Returns the SELECT clauses ready for inserting into a query . |
4,305 | public function buildDeleteFragment ( SQLDelete $ query , array & $ parameters ) { $ text = 'DELETE' ; $ delete = $ query -> getDelete ( ) ; if ( ! empty ( $ delete ) ) { $ text .= ' ' . implode ( ', ' , $ delete ) ; } return $ text ; } | Return the DELETE clause ready for inserting into a query . |
4,306 | public function buildUpdateFragment ( SQLUpdate $ query , array & $ parameters ) { $ table = $ query -> getTable ( ) ; $ text = "UPDATE $table" ; $ parts = array ( ) ; foreach ( $ query -> getAssignments ( ) as $ column => $ assignment ) { foreach ( $ assignment as $ assignmentSQL => $ assignmentParameters ) { $ parts [ ] = "$column = $assignmentSQL" ; $ parameters = array_merge ( $ parameters , $ assignmentParameters ) ; break ; } } $ nl = $ this -> getSeparator ( ) ; $ text .= "{$nl}SET " . implode ( ', ' , $ parts ) ; return $ text ; } | Return the UPDATE clause ready for inserting into a query . |
4,307 | public function buildFromFragment ( SQLConditionalExpression $ query , array & $ parameters ) { $ from = $ query -> getJoins ( $ joinParameters ) ; $ parameters = array_merge ( $ parameters , $ joinParameters ) ; $ nl = $ this -> getSeparator ( ) ; return "{$nl}FROM " . implode ( ' ' , $ from ) ; } | Return the FROM clause ready for inserting into a query . |
4,308 | public function buildWhereFragment ( SQLConditionalExpression $ query , array & $ parameters ) { $ where = $ query -> getWhereParameterised ( $ whereParameters ) ; if ( empty ( $ where ) ) { return '' ; } $ connective = $ query -> getConnective ( ) ; $ parameters = array_merge ( $ parameters , $ whereParameters ) ; $ nl = $ this -> getSeparator ( ) ; return "{$nl}WHERE (" . implode ( "){$nl}{$connective} (" , $ where ) . ")" ; } | Returns the WHERE clauses ready for inserting into a query . |
4,309 | public function buildOrderByFragment ( SQLSelect $ query , array & $ parameters ) { $ orderBy = $ query -> getOrderBy ( ) ; if ( empty ( $ orderBy ) ) { return '' ; } $ statements = array ( ) ; foreach ( $ orderBy as $ clause => $ dir ) { $ statements [ ] = trim ( "$clause $dir" ) ; } $ nl = $ this -> getSeparator ( ) ; return "{$nl}ORDER BY " . implode ( ', ' , $ statements ) ; } | Returns the ORDER BY clauses ready for inserting into a query . |
4,310 | public function buildGroupByFragment ( SQLSelect $ query , array & $ parameters ) { $ groupBy = $ query -> getGroupBy ( ) ; if ( empty ( $ groupBy ) ) { return '' ; } $ nl = $ this -> getSeparator ( ) ; return "{$nl}GROUP BY " . implode ( ', ' , $ groupBy ) ; } | Returns the GROUP BY clauses ready for inserting into a query . |
4,311 | public function buildHavingFragment ( SQLSelect $ query , array & $ parameters ) { $ having = $ query -> getHavingParameterised ( $ havingParameters ) ; if ( empty ( $ having ) ) { return '' ; } $ connective = $ query -> getConnective ( ) ; $ parameters = array_merge ( $ parameters , $ havingParameters ) ; $ nl = $ this -> getSeparator ( ) ; return "{$nl}HAVING (" . implode ( "){$nl}{$connective} (" , $ having ) . ")" ; } | Returns the HAVING clauses ready for inserting into a query . |
4,312 | public function buildLimitFragment ( SQLSelect $ query , array & $ parameters ) { $ nl = $ this -> getSeparator ( ) ; $ limit = $ query -> getLimit ( ) ; if ( empty ( $ limit ) ) { return '' ; } if ( ! is_array ( $ limit ) ) { return "{$nl}LIMIT $limit" ; } if ( ! isset ( $ limit [ 'limit' ] ) || ! is_numeric ( $ limit [ 'limit' ] ) ) { throw new InvalidArgumentException ( 'DBQueryBuilder::buildLimitSQL(): Wrong format for $limit: ' . var_export ( $ limit , true ) ) ; } $ clause = "{$nl}LIMIT {$limit['limit']}" ; if ( isset ( $ limit [ 'start' ] ) && is_numeric ( $ limit [ 'start' ] ) && $ limit [ 'start' ] !== 0 ) { $ clause .= " OFFSET {$limit['start']}" ; } return $ clause ; } | Return the LIMIT clause ready for inserting into a query . |
4,313 | public function logIn ( Member $ member , $ persistent = false , HTTPRequest $ request = null ) { $ member -> beforeMemberLoggedIn ( ) ; foreach ( $ this -> getHandlers ( ) as $ handler ) { $ handler -> logIn ( $ member , $ persistent , $ request ) ; } Security :: setCurrentUser ( $ member ) ; $ member -> afterMemberLoggedIn ( ) ; } | Log into the identity - store handlers attached to this request filter |
4,314 | public function logOut ( HTTPRequest $ request = null ) { $ member = Security :: getCurrentUser ( ) ; if ( $ member ) { $ member -> beforeMemberLoggedOut ( $ request ) ; } foreach ( $ this -> getHandlers ( ) as $ handler ) { $ handler -> logOut ( $ request ) ; } Security :: setCurrentUser ( null ) ; if ( $ member ) { $ member -> afterMemberLoggedOut ( $ request ) ; } } | Log out of all the identity - store handlers attached to this request filter |
4,315 | public function renderError ( $ httpRequest , $ errno , $ errstr , $ errfile , $ errline ) { if ( ! isset ( self :: $ error_types [ $ errno ] ) ) { $ errorTypeTitle = "UNKNOWN TYPE, ERRNO $errno" ; } else { $ errorTypeTitle = self :: $ error_types [ $ errno ] [ 'title' ] ; } $ output = CLI :: text ( "ERROR [" . $ errorTypeTitle . "]: $errstr\nIN $httpRequest\n" , "red" , null , true ) ; $ output .= CLI :: text ( "Line $errline in $errfile\n\n" , "red" ) ; return $ output ; } | Write information about the error to the screen |
4,316 | public function renderSourceFragment ( $ lines , $ errline ) { $ output = "Source\n======\n" ; foreach ( $ lines as $ offset => $ line ) { $ output .= ( $ offset == $ errline ) ? "* " : " " ; $ output .= str_pad ( "$offset:" , 5 ) ; $ output .= wordwrap ( $ line , self :: config ( ) -> columns , "\n " ) ; } $ output .= "\n" ; return $ output ; } | Write a fragment of the a source file |
4,317 | public function renderTrace ( $ trace = null ) { $ output = "Trace\n=====\n" ; $ output .= Backtrace :: get_rendered_backtrace ( $ trace ? $ trace : debug_backtrace ( ) , true ) ; return $ output ; } | Write a backtrace |
4,318 | public function getVersion ( ) { $ modules = $ this -> getModules ( ) ; $ lockModules = $ this -> getModuleVersionFromComposer ( array_keys ( $ modules ) ) ; $ output = [ ] ; foreach ( $ modules as $ module => $ title ) { $ version = isset ( $ lockModules [ $ module ] ) ? $ lockModules [ $ module ] : _t ( __CLASS__ . '.VERSIONUNKNOWN' , 'Unknown' ) ; $ output [ ] = $ title . ': ' . $ version ; } return implode ( ', ' , $ output ) ; } | Gets a comma delimited string of package titles and versions |
4,319 | public function getModuleVersionFromComposer ( $ modules = [ ] ) { $ versions = [ ] ; $ lockData = $ this -> getComposerLock ( ) ; if ( $ lockData && ! empty ( $ lockData [ 'packages' ] ) ) { foreach ( $ lockData [ 'packages' ] as $ package ) { if ( in_array ( $ package [ 'name' ] , $ modules ) && isset ( $ package [ 'version' ] ) ) { $ versions [ $ package [ 'name' ] ] = $ package [ 'version' ] ; } } } return $ versions ; } | Tries to obtain version number from composer . lock if it exists |
4,320 | protected function getComposerLock ( $ cache = true ) { $ composerLockPath = BASE_PATH . '/composer.lock' ; if ( ! file_exists ( $ composerLockPath ) ) { return [ ] ; } $ lockData = [ ] ; $ jsonData = file_get_contents ( $ composerLockPath ) ; if ( $ cache ) { $ cache = Injector :: inst ( ) -> get ( CacheInterface :: class . '.VersionProvider_composerlock' ) ; $ cacheKey = md5 ( $ jsonData ) ; if ( $ versions = $ cache -> get ( $ cacheKey ) ) { $ lockData = json_decode ( $ versions , true ) ; } } if ( empty ( $ lockData ) && $ jsonData ) { $ lockData = json_decode ( $ jsonData , true ) ; if ( $ cache ) { $ cache -> set ( $ cacheKey , $ jsonData ) ; } } return $ lockData ; } | Load composer . lock s contents and return it |
4,321 | public function toASCII ( $ source ) { if ( function_exists ( 'iconv' ) && $ this -> config ( ) -> use_iconv ) { return $ this -> useIconv ( $ source ) ; } else { return $ this -> useStrTr ( $ source ) ; } } | Convert the given utf8 string to a safe ASCII source |
4,322 | public function getRelationAutosetClass ( $ default = File :: class ) { if ( ! $ this -> getRelationAutoSetting ( ) ) { return $ default ; } $ name = $ this -> getName ( ) ; $ record = $ this -> getRecord ( ) ; if ( empty ( $ name ) || empty ( $ record ) ) { return $ default ; } else { $ class = $ record -> getRelationClass ( $ name ) ; return empty ( $ class ) ? $ default : $ class ; } } | Gets the foreign class that needs to be created or File as default if there is no relationship or it cannot be determined . |
4,323 | protected function extractUploadedFileData ( $ postVars ) { $ tmpFiles = array ( ) ; if ( ! empty ( $ postVars [ 'tmp_name' ] ) && is_array ( $ postVars [ 'tmp_name' ] ) && ! empty ( $ postVars [ 'tmp_name' ] [ 'Uploads' ] ) ) { for ( $ i = 0 ; $ i < count ( $ postVars [ 'tmp_name' ] [ 'Uploads' ] ) ; $ i ++ ) { if ( empty ( $ postVars [ 'tmp_name' ] [ 'Uploads' ] [ $ i ] ) ) { continue ; } $ tmpFile = array ( ) ; foreach ( array ( 'name' , 'type' , 'tmp_name' , 'error' , 'size' ) as $ field ) { $ tmpFile [ $ field ] = $ postVars [ $ field ] [ 'Uploads' ] [ $ i ] ; } $ tmpFiles [ ] = $ tmpFile ; } } elseif ( ! empty ( $ postVars [ 'tmp_name' ] ) ) { $ tmpFiles [ ] = $ postVars ; } return $ tmpFiles ; } | Given an array of post variables extract all temporary file data into an array |
4,324 | protected function prepareColumns ( $ columns ) { $ prefix = DataQuery :: applyRelationPrefix ( $ this -> relation ) ; $ table = DataObject :: getSchema ( ) -> tableForField ( $ this -> model , current ( $ columns ) ) ; $ fullTable = $ prefix . $ table ; $ columns = array_map ( function ( $ col ) use ( $ fullTable ) { return "\"{$fullTable}\".\"{$col}\"" ; } , $ columns ) ; return implode ( ',' , $ columns ) ; } | Adds table identifier to the every column . Columns must have table identifier to prevent duplicate column name error . |
4,325 | public function getItems ( ) { $ items = new ArrayList ( ) ; if ( $ this -> value != 'unchanged' ) { $ sourceObject = $ this -> getSourceObject ( ) ; if ( is_array ( $ sourceObject ) ) { $ values = is_array ( $ this -> value ) ? $ this -> value : preg_split ( '/ *, */' , trim ( $ this -> value ) ) ; foreach ( $ values as $ value ) { $ item = new stdClass ; $ item -> ID = $ value ; $ item -> Title = $ sourceObject [ $ value ] ; $ items -> push ( $ item ) ; } return $ items ; } if ( is_string ( $ this -> value ) ) { $ ids = explode ( ',' , $ this -> value ) ; foreach ( $ ids as $ id ) { if ( ! is_numeric ( $ id ) ) { continue ; } $ item = DataObject :: get_by_id ( $ sourceObject , $ id ) ; if ( $ item ) { $ items -> push ( $ item ) ; } } return $ items ; } } if ( $ this -> form ) { $ fieldName = $ this -> name ; $ record = $ this -> form -> getRecord ( ) ; if ( is_object ( $ record ) && $ record -> hasMethod ( $ fieldName ) ) { return $ record -> $ fieldName ( ) ; } } return $ items ; } | Return this field s linked items |
4,326 | public function Field ( $ properties = array ( ) ) { $ value = '' ; $ titleArray = array ( ) ; $ idArray = array ( ) ; $ items = $ this -> getItems ( ) ; $ emptyTitle = _t ( 'SilverStripe\\Forms\\DropdownField.CHOOSE' , '(Choose)' , 'start value of a dropdown' ) ; if ( $ items && count ( $ items ) ) { foreach ( $ items as $ item ) { $ idArray [ ] = $ item -> ID ; $ titleArray [ ] = ( $ item instanceof ViewableData ) ? $ item -> obj ( $ this -> getLabelField ( ) ) -> forTemplate ( ) : Convert :: raw2xml ( $ item -> { $ this -> getLabelField ( ) } ) ; } $ title = implode ( ", " , $ titleArray ) ; sort ( $ idArray ) ; $ value = implode ( "," , $ idArray ) ; } else { $ title = $ emptyTitle ; } $ dataUrlTree = '' ; if ( $ this -> form ) { $ dataUrlTree = $ this -> Link ( 'tree' ) ; if ( ! empty ( $ idArray ) ) { $ dataUrlTree = Controller :: join_links ( $ dataUrlTree , '?forceValue=' . implode ( ',' , $ idArray ) ) ; } } $ properties = array_merge ( $ properties , array ( 'Title' => $ title , 'EmptyTitle' => $ emptyTitle , 'Link' => $ dataUrlTree , 'Value' => $ value ) ) ; return FormField :: Field ( $ properties ) ; } | We overwrite the field attribute to add our hidden fields as this formfield can contain multiple values . |
4,327 | public function performReadonlyTransformation ( ) { $ copy = $ this -> castedCopy ( TreeMultiselectField_Readonly :: class ) ; $ copy -> setKeyField ( $ this -> getKeyField ( ) ) ; $ copy -> setLabelField ( $ this -> getLabelField ( ) ) ; $ copy -> setSourceObject ( $ this -> getSourceObject ( ) ) ; $ copy -> setTitleField ( $ this -> getTitleField ( ) ) ; return $ copy ; } | Changes this field to the readonly field . |
4,328 | public function setList ( $ list ) { $ this -> list = $ list ; $ this -> failover = $ this -> list ; return $ this ; } | Set the list this decorator wraps around . |
4,329 | public function getFormatter ( ) { $ locale = $ this -> getLocale ( ) ; $ currency = $ this -> getCurrency ( ) ; if ( $ currency ) { $ locale .= '@currency=' . $ currency ; } return NumberFormatter :: create ( $ locale , NumberFormatter :: CURRENCY ) ; } | Get currency formatter |
4,330 | public function getQuery ( $ searchParams , $ sort = false , $ limit = false , $ existingQuery = null ) { $ query = null ; if ( $ existingQuery ) { if ( ! ( $ existingQuery instanceof DataList ) ) { throw new InvalidArgumentException ( "existingQuery must be DataList" ) ; } if ( $ existingQuery -> dataClass ( ) != $ this -> modelClass ) { throw new InvalidArgumentException ( "existingQuery's dataClass is " . $ existingQuery -> dataClass ( ) . ", $this->modelClass expected." ) ; } $ query = $ existingQuery ; } else { $ query = DataList :: create ( $ this -> modelClass ) ; } if ( is_array ( $ limit ) ) { $ query = $ query -> limit ( isset ( $ limit [ 'limit' ] ) ? $ limit [ 'limit' ] : null , isset ( $ limit [ 'start' ] ) ? $ limit [ 'start' ] : null ) ; } else { $ query = $ query -> limit ( $ limit ) ; } $ query = $ query -> sort ( $ sort ) ; $ this -> setSearchParams ( $ searchParams ) ; foreach ( $ this -> searchParams as $ key => $ value ) { $ key = str_replace ( '__' , '.' , $ key ) ; if ( $ filter = $ this -> getFilter ( $ key ) ) { $ filter -> setModel ( $ this -> modelClass ) ; $ filter -> setValue ( $ value ) ; if ( ! $ filter -> isEmpty ( ) ) { $ query = $ query -> alterDataQuery ( array ( $ filter , 'apply' ) ) ; } } } if ( $ this -> connective != "AND" ) { throw new Exception ( "SearchContext connective '$this->connective' not supported after ORM-rewrite." ) ; } return $ query ; } | Returns a SQL object representing the search context for the given list of query parameters . |
4,331 | public function getResults ( $ searchParams , $ sort = false , $ limit = false ) { $ searchParams = array_filter ( ( array ) $ searchParams , array ( $ this , 'clearEmptySearchFields' ) ) ; return $ this -> getQuery ( $ searchParams , $ sort , $ limit ) ; } | Returns a result set from the given search parameters . |
4,332 | public function getFilter ( $ name ) { if ( isset ( $ this -> filters [ $ name ] ) ) { return $ this -> filters [ $ name ] ; } else { return null ; } } | Accessor for the filter attached to a named field . |
4,333 | public function setSearchParams ( $ searchParams ) { if ( $ searchParams instanceof HTTPRequest ) { $ this -> searchParams = $ searchParams -> getVars ( ) ; } else { $ this -> searchParams = $ searchParams ; } return $ this ; } | Set search param values |
4,334 | public function getSummary ( ) { $ list = ArrayList :: create ( ) ; foreach ( $ this -> searchParams as $ searchField => $ searchValue ) { if ( empty ( $ searchValue ) ) { continue ; } $ filter = $ this -> getFilter ( $ searchField ) ; if ( ! $ filter ) { continue ; } $ field = $ this -> fields -> fieldByName ( $ filter -> getFullName ( ) ) ; if ( ! $ field ) { continue ; } if ( $ field instanceof SelectField ) { $ source = $ field -> getSource ( ) ; if ( isset ( $ source [ $ searchValue ] ) ) { $ searchValue = $ source [ $ searchValue ] ; } } else { if ( $ field instanceof CheckboxField ) { $ searchValue = null ; } } $ list -> push ( ArrayData :: create ( [ 'Field' => $ field -> Title ( ) , 'Value' => $ searchValue , ] ) ) ; } return $ list ; } | Gets a list of what fields were searched and the values provided for each field . Returns an ArrayList of ArrayData suitable for rendering on a template . |
4,335 | public static function requireLogin ( HTTPRequest $ request , $ realm , $ permissionCode = null , $ tryUsingSessionLogin = true ) { if ( ( Director :: is_cli ( ) && static :: config ( ) -> get ( 'ignore_cli' ) ) ) { return true ; } $ member = null ; try { if ( $ request -> getHeader ( 'PHP_AUTH_USER' ) && $ request -> getHeader ( 'PHP_AUTH_PW' ) ) { $ authenticators = Security :: singleton ( ) -> getApplicableAuthenticators ( Authenticator :: LOGIN ) ; foreach ( $ authenticators as $ name => $ authenticator ) { $ member = $ authenticator -> authenticate ( [ 'Email' => $ request -> getHeader ( 'PHP_AUTH_USER' ) , 'Password' => $ request -> getHeader ( 'PHP_AUTH_PW' ) , ] , $ request ) ; if ( $ member instanceof Member ) { break ; } } } } catch ( DatabaseException $ e ) { return true ; } if ( ! $ member && $ tryUsingSessionLogin ) { $ member = Security :: getCurrentUser ( ) ; } if ( ! $ member ) { $ response = new HTTPResponse ( null , 401 ) ; $ response -> addHeader ( 'WWW-Authenticate' , "Basic realm=\"$realm\"" ) ; if ( $ request -> getHeader ( 'PHP_AUTH_USER' ) ) { $ response -> setBody ( _t ( 'SilverStripe\\Security\\BasicAuth.ERRORNOTREC' , "That username / password isn't recognised" ) ) ; } else { $ response -> setBody ( _t ( 'SilverStripe\\Security\\BasicAuth.ENTERINFO' , 'Please enter a username and password.' ) ) ; } $ e = new HTTPResponse_Exception ( null , 401 ) ; $ e -> setResponse ( $ response ) ; throw $ e ; } if ( $ permissionCode && ! Permission :: checkMember ( $ member -> ID , $ permissionCode ) ) { $ response = new HTTPResponse ( null , 401 ) ; $ response -> addHeader ( 'WWW-Authenticate' , "Basic realm=\"$realm\"" ) ; if ( $ request -> getHeader ( 'PHP_AUTH_USER' ) ) { $ response -> setBody ( _t ( 'SilverStripe\\Security\\BasicAuth.ERRORNOTADMIN' , 'That user is not an administrator.' ) ) ; } $ e = new HTTPResponse_Exception ( null , 401 ) ; $ e -> setResponse ( $ response ) ; throw $ e ; } return $ member ; } | Require basic authentication . Will request a username and password if none is given . |
4,336 | public static function protect_entire_site ( $ protect = true , $ code = self :: AUTH_PERMISSION , $ message = null ) { static :: config ( ) -> set ( 'entire_site_protected' , $ protect ) -> set ( 'entire_site_protected_code' , $ code ) ; if ( $ message ) { static :: config ( ) -> set ( 'entire_site_protected_message' , $ message ) ; } } | Enable protection of the entire site with basic authentication . |
4,337 | public function setWhitelist ( $ whitelist ) { if ( ! is_array ( $ whitelist ) ) { $ whitelist = preg_split ( '/\s*,\s*/' , $ whitelist ) ; } $ this -> whitelist = $ whitelist ; return $ this ; } | Set list of html properties to whitelist |
4,338 | public function Plain ( ) { $ text = preg_replace ( '/\<br(\s*)?\/?\>/i' , "\n" , $ this -> RAW ( ) ) ; $ text = preg_replace ( '/\<\/p\>/i' , "\n\n" , $ text ) ; $ text = strip_tags ( $ text ) ; $ text = preg_replace ( '~(\R){2,}~' , "\n\n" , $ text ) ; return trim ( Convert :: xml2raw ( $ text ) ) ; } | Get plain - text version |
4,339 | protected function getTransactionManager ( ) { if ( ! $ this -> transactionManager ) { if ( $ this -> connector instanceof TransactionManager ) { $ this -> transactionManager = new NestedTransactionManager ( $ this -> connector ) ; } else { $ this -> transactionManager = new NestedTransactionManager ( new MySQLTransactionManager ( $ this ) ) ; } } return $ this -> transactionManager ; } | Returns the TransactionManager to handle transactions for this database . |
4,340 | protected function resetTransactionNesting ( ) { if ( $ this -> connector instanceof TransactionalDBConnector ) { if ( $ this -> transactionNesting > 0 ) { $ this -> connector -> transactionRollback ( ) ; } } $ this -> transactionNesting = 0 ; } | In error condition set transactionNesting to zero |
4,341 | protected function inspectQuery ( $ sql ) { $ isDDL = $ this -> getConnector ( ) -> isQueryDDL ( $ sql ) ; if ( $ isDDL ) { $ this -> resetTransactionNesting ( ) ; } } | Inspect a SQL query prior to execution |
4,342 | public function clearTable ( $ table ) { $ this -> query ( "DELETE FROM \"$table\"" ) ; $ autoIncrement = $ this -> preparedQuery ( 'SELECT "AUTO_INCREMENT" FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ?' , [ $ this -> getSelectedDatabase ( ) , $ table ] ) -> value ( ) ; if ( $ autoIncrement > 1 ) { $ this -> query ( "ALTER TABLE \"$table\" AUTO_INCREMENT = 1" ) ; } } | Clear all data in a given table |
4,343 | public function resolveURL ( $ resource ) { if ( empty ( $ resource ) ) { return null ; } $ resource = $ this -> resolveResource ( $ resource ) ; $ generator = Injector :: inst ( ) -> get ( ResourceURLGenerator :: class ) ; return $ generator -> urlForResource ( $ resource ) ; } | Resolves resource specifier to the given url . |
4,344 | public function resolveResource ( $ resource ) { if ( ! preg_match ( '#^ *(?<module>[^/: ]+/[^/: ]+) *: *(?<resource>[^ ]*)$#' , $ resource , $ matches ) ) { return $ resource ; } $ module = $ matches [ 'module' ] ; $ resource = $ matches [ 'resource' ] ; $ moduleObj = ModuleLoader :: getModule ( $ module ) ; if ( ! $ moduleObj ) { throw new InvalidArgumentException ( "Can't find module '$module', the composer.json file may be missing from the modules installation directory" ) ; } $ resourceObj = $ moduleObj -> getResource ( $ resource ) ; return $ resourceObj ; } | Return module resource for the given path if specified as one . Returns the original resource otherwise . |
4,345 | public static function create ( $ select = "*" , $ from = array ( ) , $ where = array ( ) , $ orderby = array ( ) , $ groupby = array ( ) , $ having = array ( ) , $ limit = array ( ) ) { return Injector :: inst ( ) -> createWithArgs ( __CLASS__ , func_get_args ( ) ) ; } | Construct a new SQLSelect . |
4,346 | public function setSelect ( $ fields ) { $ this -> select = array ( ) ; if ( func_num_args ( ) > 1 ) { $ fields = func_get_args ( ) ; } elseif ( ! is_array ( $ fields ) ) { $ fields = array ( $ fields ) ; } return $ this -> addSelect ( $ fields ) ; } | Set the list of columns to be selected by the query . |
4,347 | public function addSelect ( $ fields ) { if ( func_num_args ( ) > 1 ) { $ fields = func_get_args ( ) ; } elseif ( ! is_array ( $ fields ) ) { $ fields = array ( $ fields ) ; } foreach ( $ fields as $ idx => $ field ) { $ this -> selectField ( $ field , is_numeric ( $ idx ) ? null : $ idx ) ; } return $ this ; } | Add to the list of columns to be selected by the query . |
4,348 | public function selectField ( $ field , $ alias = null ) { if ( ! $ alias ) { if ( preg_match ( '/"([^"]+)"$/' , $ field , $ matches ) ) { $ alias = $ matches [ 1 ] ; } else { $ alias = $ field ; } } $ this -> select [ $ alias ] = $ field ; return $ this ; } | Select an additional field . |
4,349 | public function setLimit ( $ limit , $ offset = 0 ) { if ( ( is_numeric ( $ limit ) && $ limit < 0 ) || ( is_numeric ( $ offset ) && $ offset < 0 ) ) { throw new InvalidArgumentException ( "SQLSelect::setLimit() only takes positive values" ) ; } if ( $ limit === 0 ) { Deprecation :: notice ( '4.3' , "setLimit(0) is deprecated in SS4. To clear limit, call setLimit(null). " . "In SS5 a limit of 0 will instead return no records." ) ; } if ( is_numeric ( $ limit ) && ( $ limit || $ offset ) ) { $ this -> limit = array ( 'start' => ( int ) $ offset , 'limit' => ( int ) $ limit , ) ; } elseif ( $ limit && is_string ( $ limit ) ) { if ( strpos ( $ limit , ',' ) !== false ) { list ( $ start , $ innerLimit ) = explode ( ',' , $ limit , 2 ) ; } else { list ( $ innerLimit , $ start ) = explode ( ' OFFSET ' , strtoupper ( $ limit ) , 2 ) ; } $ this -> limit = array ( 'start' => ( int ) $ start , 'limit' => ( int ) $ innerLimit , ) ; } elseif ( $ limit === null && $ offset ) { $ this -> limit = array ( 'start' => ( int ) $ offset , 'limit' => $ limit ) ; } else { $ this -> limit = $ limit ; } return $ this ; } | Pass LIMIT clause either as SQL snippet or in array format . Internally limit will always be stored as a map containing the keys start and limit |
4,350 | public function setOrderBy ( $ clauses = null , $ direction = null ) { $ this -> orderby = array ( ) ; return $ this -> addOrderBy ( $ clauses , $ direction ) ; } | Set ORDER BY clause either as SQL snippet or in array format . |
4,351 | public function addOrderBy ( $ clauses = null , $ direction = null ) { if ( empty ( $ clauses ) ) { return $ this ; } if ( is_string ( $ clauses ) ) { if ( strpos ( $ clauses , "(" ) !== false ) { $ sort = preg_split ( "/,(?![^()]*+\\))/" , $ clauses ) ; } else { $ sort = explode ( "," , $ clauses ) ; } $ clauses = array ( ) ; foreach ( $ sort as $ clause ) { list ( $ column , $ direction ) = $ this -> getDirectionFromString ( $ clause , $ direction ) ; $ clauses [ $ column ] = $ direction ; } } if ( is_array ( $ clauses ) ) { foreach ( $ clauses as $ key => $ value ) { if ( ! is_numeric ( $ key ) ) { $ column = trim ( $ key ) ; $ columnDir = strtoupper ( trim ( $ value ) ) ; } else { list ( $ column , $ columnDir ) = $ this -> getDirectionFromString ( $ value ) ; } $ this -> orderby [ $ column ] = $ columnDir ; } } else { user_error ( 'SQLSelect::orderby() incorrect format for $orderby' , E_USER_WARNING ) ; } if ( $ this -> orderby ) { $ i = 0 ; $ orderby = array ( ) ; foreach ( $ this -> orderby as $ clause => $ dir ) { if ( strpos ( $ clause , '(' ) !== false || strpos ( $ clause , " " ) !== false ) { $ clause = trim ( $ clause ) ; do { $ column = "_SortColumn{$i}" ; ++ $ i ; } while ( array_key_exists ( '"' . $ column . '"' , $ this -> orderby ) ) ; $ this -> selectField ( $ clause , $ column ) ; $ clause = '"' . $ column . '"' ; } $ orderby [ $ clause ] = $ dir ; } $ this -> orderby = $ orderby ; } return $ this ; } | Add ORDER BY clause either as SQL snippet or in array format . |
4,352 | private function getDirectionFromString ( $ value , $ defaultDirection = null ) { if ( preg_match ( '/^(.*)(asc|desc)$/i' , $ value , $ matches ) ) { $ column = trim ( $ matches [ 1 ] ) ; $ direction = strtoupper ( $ matches [ 2 ] ) ; } else { $ column = $ value ; $ direction = $ defaultDirection ? $ defaultDirection : "ASC" ; } return array ( $ column , $ direction ) ; } | Extract the direction part of a single - column order by clause . |
4,353 | public function getOrderBy ( ) { $ orderby = $ this -> orderby ; if ( ! $ orderby ) { $ orderby = array ( ) ; } if ( ! is_array ( $ orderby ) ) { $ orderby = preg_split ( '/,(?![^()]*+\\))/' , $ orderby ) ; } foreach ( $ orderby as $ k => $ v ) { if ( strpos ( $ v , ' ' ) !== false ) { unset ( $ orderby [ $ k ] ) ; $ rule = explode ( ' ' , trim ( $ v ) ) ; $ clause = $ rule [ 0 ] ; $ dir = ( isset ( $ rule [ 1 ] ) ) ? $ rule [ 1 ] : 'ASC' ; $ orderby [ $ clause ] = $ dir ; } } return $ orderby ; } | Returns the current order by as array if not already . To handle legacy statements which are stored as strings . Without clauses and directions convert the orderby clause to something readable . |
4,354 | public function reverseOrderBy ( ) { $ order = $ this -> getOrderBy ( ) ; $ this -> orderby = array ( ) ; foreach ( $ order as $ clause => $ dir ) { $ dir = ( strtoupper ( $ dir ) == 'DESC' ) ? 'ASC' : 'DESC' ; $ this -> addOrderBy ( $ clause , $ dir ) ; } return $ this ; } | Reverses the order by clause by replacing ASC or DESC references in the current order by with it s corollary . |
4,355 | public function addGroupBy ( $ groupby ) { if ( is_array ( $ groupby ) ) { $ this -> groupby = array_merge ( $ this -> groupby , $ groupby ) ; } elseif ( ! empty ( $ groupby ) ) { $ this -> groupby [ ] = $ groupby ; } return $ this ; } | Add a GROUP BY clause . |
4,356 | public function setHaving ( $ having ) { $ having = func_num_args ( ) > 1 ? func_get_args ( ) : $ having ; $ this -> having = array ( ) ; return $ this -> addHaving ( $ having ) ; } | Set a HAVING clause . |
4,357 | public function addHaving ( $ having ) { $ having = $ this -> normalisePredicates ( func_get_args ( ) ) ; $ this -> having = array_merge ( $ this -> having , $ having ) ; return $ this ; } | Add a HAVING clause |
4,358 | public function unlimitedRowCount ( $ column = null ) { if ( count ( $ this -> having ) ) { $ records = $ this -> execute ( ) ; return $ records -> numRecords ( ) ; } $ clone = clone $ this ; $ clone -> limit = null ; $ clone -> orderby = null ; if ( $ column == null ) { if ( $ this -> groupby ) { $ countQuery = new SQLSelect ( ) ; $ countQuery -> setSelect ( "count(*)" ) ; $ countQuery -> setFrom ( array ( '(' . $ clone -> sql ( $ innerParameters ) . ') all_distinct' ) ) ; $ sql = $ countQuery -> sql ( $ parameters ) ; $ result = DB :: prepared_query ( $ sql , $ innerParameters ) ; return ( int ) $ result -> value ( ) ; } else { $ clone -> setSelect ( array ( "count(*)" ) ) ; } } else { $ clone -> setSelect ( array ( "count($column)" ) ) ; } $ clone -> setGroupBy ( array ( ) ) ; return ( int ) $ clone -> execute ( ) -> value ( ) ; } | Return the number of rows in this query if the limit were removed . Useful in paged data sets . |
4,359 | public function count ( $ column = null ) { if ( ! empty ( $ this -> having ) ) { $ records = $ this -> execute ( ) ; return $ records -> numRecords ( ) ; } elseif ( $ column == null ) { if ( $ this -> groupby ) { $ column = 'DISTINCT ' . implode ( ", " , $ this -> groupby ) ; } else { $ column = '*' ; } } $ clone = clone $ this ; $ clone -> select = array ( 'Count' => "count($column)" ) ; $ clone -> limit = null ; $ clone -> orderby = null ; $ clone -> groupby = null ; $ count = ( int ) $ clone -> execute ( ) -> value ( ) ; if ( $ this -> limit ) { if ( $ this -> limit [ 'limit' ] !== null && $ count >= ( $ this -> limit [ 'start' ] + $ this -> limit [ 'limit' ] ) ) { return $ this -> limit [ 'limit' ] ; } else { return max ( 0 , $ count - $ this -> limit [ 'start' ] ) ; } } else { return $ count ; } } | Return the number of rows in this query respecting limit and offset . |
4,360 | public function aggregate ( $ column , $ alias = null ) { $ clone = clone $ this ; if ( $ this -> limit ) { $ clone -> setLimit ( $ this -> limit ) ; $ clone -> setOrderBy ( $ this -> orderby ) ; } else { $ clone -> setOrderBy ( array ( ) ) ; } $ clone -> setGroupBy ( $ this -> groupby ) ; if ( $ alias ) { $ clone -> setSelect ( array ( ) ) ; $ clone -> selectField ( $ column , $ alias ) ; } else { $ clone -> setSelect ( $ column ) ; } return $ clone ; } | Return a new SQLSelect that calls the given aggregate functions on this data . |
4,361 | public function firstRow ( ) { $ query = clone $ this ; $ offset = $ this -> limit ? $ this -> limit [ 'start' ] : 0 ; $ query -> setLimit ( 1 , $ offset ) ; return $ query ; } | Returns a query that returns only the first row of this query |
4,362 | public function lastRow ( ) { $ query = clone $ this ; $ offset = $ this -> limit ? $ this -> limit [ 'start' ] : 0 ; $ index = max ( $ this -> count ( ) + $ offset - 1 , 0 ) ; $ query -> setLimit ( 1 , $ index ) ; return $ query ; } | Returns a query that returns only the last row of this query |
4,363 | public function groupedDataClasses ( ) { $ allClasses = get_declared_classes ( ) ; $ rootClasses = [ ] ; foreach ( $ allClasses as $ class ) { if ( get_parent_class ( $ class ) == DataObject :: class ) { $ rootClasses [ $ class ] = array ( ) ; } } foreach ( $ allClasses as $ class ) { if ( ! isset ( $ rootClasses [ $ class ] ) && is_subclass_of ( $ class , DataObject :: class ) ) { foreach ( $ rootClasses as $ rootClass => $ dummy ) { if ( is_subclass_of ( $ class , $ rootClass ) ) { $ rootClasses [ $ rootClass ] [ ] = $ class ; break ; } } } } return $ rootClasses ; } | Get the data classes grouped by their root class |
4,364 | protected function getReturnURL ( ) { $ url = $ this -> request -> getVar ( 'returnURL' ) ; if ( empty ( $ url ) || ! Director :: is_site_url ( $ url ) ) { return null ; } return Director :: absoluteURL ( $ url , true ) ; } | Gets the url to return to after build |
4,365 | public function buildDefaults ( ) { $ dataClasses = ClassInfo :: subclassesFor ( DataObject :: class ) ; array_shift ( $ dataClasses ) ; if ( ! Director :: is_cli ( ) ) { echo "<ul>" ; } foreach ( $ dataClasses as $ dataClass ) { singleton ( $ dataClass ) -> requireDefaultRecords ( ) ; if ( Director :: is_cli ( ) ) { echo "Defaults loaded for $dataClass\n" ; } else { echo "<li>Defaults loaded for $dataClass</li>\n" ; } } if ( ! Director :: is_cli ( ) ) { echo "</ul>" ; } } | Build the default data calling requireDefaultRecords on all DataObject classes |
4,366 | public static function lastBuilt ( ) { $ file = TEMP_PATH . DIRECTORY_SEPARATOR . 'database-last-generated-' . str_replace ( array ( '\\' , '/' , ':' ) , '.' , Director :: baseFolder ( ) ) ; if ( file_exists ( $ file ) ) { return filemtime ( $ file ) ; } return null ; } | Returns the timestamp of the time that the database was last built |
4,367 | protected function getClassNameRemappingFields ( ) { $ dataClasses = ClassInfo :: getValidSubClasses ( DataObject :: class ) ; $ schema = DataObject :: getSchema ( ) ; $ remapping = [ ] ; foreach ( $ dataClasses as $ className ) { $ fieldSpecs = $ schema -> fieldSpecs ( $ className ) ; foreach ( $ fieldSpecs as $ fieldName => $ fieldSpec ) { if ( Injector :: inst ( ) -> create ( $ fieldSpec , 'Dummy' ) instanceof DBClassName ) { $ remapping [ $ className ] [ ] = $ fieldName ; } } } return $ remapping ; } | Find all DBClassName fields on valid subclasses of DataObject that should be remapped . This includes ClassName fields as well as polymorphic class name fields . |
4,368 | public function cleanup ( ) { $ baseClasses = [ ] ; foreach ( ClassInfo :: subclassesFor ( DataObject :: class ) as $ class ) { if ( get_parent_class ( $ class ) == DataObject :: class ) { $ baseClasses [ ] = $ class ; } } $ schema = DataObject :: getSchema ( ) ; foreach ( $ baseClasses as $ baseClass ) { $ baseTable = $ schema -> baseDataTable ( $ baseClass ) ; $ subclasses = ClassInfo :: subclassesFor ( $ baseClass ) ; unset ( $ subclasses [ 0 ] ) ; foreach ( $ subclasses as $ k => $ subclass ) { if ( ! DataObject :: getSchema ( ) -> classHasTable ( $ subclass ) ) { unset ( $ subclasses [ $ k ] ) ; } } if ( $ subclasses ) { $ records = DB :: query ( "SELECT * FROM \"$baseTable\"" ) ; foreach ( $ subclasses as $ subclass ) { $ subclassTable = $ schema -> tableName ( $ subclass ) ; $ recordExists [ $ subclass ] = DB :: query ( "SELECT \"ID\" FROM \"$subclassTable\"" ) -> keyedColumn ( ) ; } foreach ( $ records as $ record ) { foreach ( $ subclasses as $ subclass ) { $ subclassTable = $ schema -> tableName ( $ subclass ) ; $ id = $ record [ 'ID' ] ; if ( ( $ record [ 'ClassName' ] != $ subclass ) && ( ! is_subclass_of ( $ record [ 'ClassName' ] , $ subclass ) ) && isset ( $ recordExists [ $ subclass ] [ $ id ] ) ) { $ sql = "DELETE FROM \"$subclassTable\" WHERE \"ID\" = ?" ; echo "<li>$sql [{$id}]</li>" ; DB :: prepared_query ( $ sql , [ $ id ] ) ; } } } } } } | Remove invalid records from tables - that is records that don t have corresponding records in their parent class tables . |
4,369 | protected function getFormFields ( ) { $ request = $ this -> getRequest ( ) ; if ( $ request -> getVar ( 'BackURL' ) ) { $ backURL = $ request -> getVar ( 'BackURL' ) ; } else { $ backURL = $ request -> getSession ( ) -> get ( 'BackURL' ) ; } $ label = Member :: singleton ( ) -> fieldLabel ( Member :: config ( ) -> get ( 'unique_identifier_field' ) ) ; $ fields = FieldList :: create ( HiddenField :: create ( "AuthenticationMethod" , null , $ this -> getAuthenticatorClass ( ) , $ this ) , $ emailField = TextField :: create ( "Email" , $ label , null , null , $ this ) , PasswordField :: create ( "Password" , _t ( 'SilverStripe\\Security\\Member.PASSWORD' , 'Password' ) ) ) ; $ emailField -> setAttribute ( 'autofocus' , 'true' ) ; if ( Security :: config ( ) -> get ( 'remember_username' ) ) { $ emailField -> setValue ( $ this -> getSession ( ) -> get ( 'SessionForms.MemberLoginForm.Email' ) ) ; } else { $ this -> setAttribute ( 'autocomplete' , 'off' ) ; $ emailField -> setAttribute ( 'autocomplete' , 'off' ) ; } if ( Security :: config ( ) -> get ( 'autologin_enabled' ) ) { $ fields -> push ( CheckboxField :: create ( "Remember" , _t ( 'SilverStripe\\Security\\Member.KEEPMESIGNEDIN' , "Keep me signed in" ) ) -> setAttribute ( 'title' , _t ( 'SilverStripe\\Security\\Member.REMEMBERME' , "Remember me next time? (for {count} days on this device)" , [ 'count' => RememberLoginHash :: config ( ) -> uninherited ( 'token_expiry_days' ) ] ) ) ) ; } if ( isset ( $ backURL ) ) { $ fields -> push ( HiddenField :: create ( 'BackURL' , 'BackURL' , $ backURL ) ) ; } return $ fields ; } | Build the FieldList for the login form |
4,370 | protected function getFormActions ( ) { $ actions = FieldList :: create ( FormAction :: create ( 'doLogin' , _t ( 'SilverStripe\\Security\\Member.BUTTONLOGIN' , "Log in" ) ) , LiteralField :: create ( 'forgotPassword' , '<p id="ForgotPassword"><a href="' . Security :: lost_password_url ( ) . '">' . _t ( 'SilverStripe\\Security\\Member.BUTTONLOSTPASSWORD' , "I've lost my password" ) . '</a></p>' ) ) ; return $ actions ; } | Build default login form action FieldList |
4,371 | public function getName ( ) { if ( $ this -> getEmbed ( ) -> title ) { return $ this -> getEmbed ( ) -> title ; } return preg_replace ( '/\?.*/' , '' , basename ( $ this -> getEmbed ( ) -> getUrl ( ) ) ) ; } | Get human readable name for this resource |
4,372 | public function getEmbed ( ) { if ( ! $ this -> embed ) { $ this -> embed = Embed :: create ( $ this -> url , $ this -> getOptions ( ) , $ this -> getDispatcher ( ) ) ; } return $ this -> embed ; } | Returns a bootstrapped Embed object |
4,373 | public function runTask ( $ request ) { $ name = $ request -> param ( 'TaskName' ) ; $ tasks = $ this -> getTasks ( ) ; $ title = function ( $ content ) { printf ( Director :: is_cli ( ) ? "%s\n\n" : '<h1>%s</h1>' , $ content ) ; } ; $ message = function ( $ content ) { printf ( Director :: is_cli ( ) ? "%s\n" : '<p>%s</p>' , $ content ) ; } ; foreach ( $ tasks as $ task ) { if ( $ task [ 'segment' ] == $ name ) { $ inst = Injector :: inst ( ) -> create ( $ task [ 'class' ] ) ; $ title ( sprintf ( 'Running Task %s' , $ inst -> getTitle ( ) ) ) ; if ( ! $ inst -> isEnabled ( ) ) { $ message ( 'The task is disabled' ) ; return ; } $ inst -> run ( $ request ) ; return ; } } $ message ( sprintf ( 'The build task "%s" could not be found' , Convert :: raw2xml ( $ name ) ) ) ; } | Runs a BuildTask |
4,374 | public function setDataQueryParam ( $ keyOrArray , $ val = null ) { $ clone = clone $ this ; if ( is_array ( $ keyOrArray ) ) { foreach ( $ keyOrArray as $ key => $ value ) { $ clone -> dataQuery -> setQueryParam ( $ key , $ value ) ; } } else { $ clone -> dataQuery -> setQueryParam ( $ keyOrArray , $ val ) ; } return $ clone ; } | Returns a new DataList instance with the specified query parameter assigned |
4,375 | public function where ( $ filter ) { return $ this -> alterDataQuery ( function ( DataQuery $ query ) use ( $ filter ) { $ query -> where ( $ filter ) ; } ) ; } | Return a new DataList instance with a WHERE clause added to this list s query . |
4,376 | public function whereAny ( $ filter ) { return $ this -> alterDataQuery ( function ( DataQuery $ query ) use ( $ filter ) { $ query -> whereAny ( $ filter ) ; } ) ; } | Return a new DataList instance with a WHERE clause added to this list s query . All conditions provided in the filter will be joined with an OR |
4,377 | public function canFilterBy ( $ fieldName ) { $ model = singleton ( $ this -> dataClass ) ; $ relations = explode ( "." , $ fieldName ) ; $ fieldName = array_pop ( $ relations ) ; foreach ( $ relations as $ r ) { $ relationClass = $ model -> getRelationClass ( $ r ) ; if ( ! $ relationClass ) { return false ; } $ model = singleton ( $ relationClass ) ; if ( ! $ model ) { return false ; } } if ( $ model -> hasDatabaseField ( $ fieldName ) ) { return true ; } return false ; } | Returns true if this DataList can be filtered by the given field . |
4,378 | public function limit ( $ limit , $ offset = 0 ) { return $ this -> alterDataQuery ( function ( DataQuery $ query ) use ( $ limit , $ offset ) { $ query -> limit ( $ limit , $ offset ) ; } ) ; } | Return a new DataList instance with the records returned in this query restricted by a limit clause . |
4,379 | public function distinct ( $ value ) { return $ this -> alterDataQuery ( function ( DataQuery $ query ) use ( $ value ) { $ query -> distinct ( $ value ) ; } ) ; } | Return a new DataList instance with distinct records or not |
4,380 | public function sort ( ) { $ count = func_num_args ( ) ; if ( $ count == 0 ) { return $ this ; } if ( $ count > 2 ) { throw new InvalidArgumentException ( 'This method takes zero, one or two arguments' ) ; } if ( $ count == 2 ) { $ col = null ; $ dir = null ; list ( $ col , $ dir ) = func_get_args ( ) ; if ( ! in_array ( strtolower ( $ dir ) , [ 'desc' , 'asc' ] ) ) { user_error ( 'Second argument to sort must be either ASC or DESC' ) ; } $ sort = [ $ col => $ dir ] ; } else { $ sort = func_get_arg ( 0 ) ; } return $ this -> alterDataQuery ( function ( DataQuery $ query , DataList $ list ) use ( $ sort ) { if ( is_string ( $ sort ) && $ sort ) { if ( false !== stripos ( $ sort , ' asc' ) || false !== stripos ( $ sort , ' desc' ) ) { $ query -> sort ( $ sort ) ; } else { $ list -> applyRelation ( $ sort , $ column , true ) ; $ query -> sort ( $ column , 'ASC' ) ; } } elseif ( is_array ( $ sort ) ) { $ query -> sort ( null , null ) ; foreach ( $ sort as $ column => $ direction ) { $ list -> applyRelation ( $ column , $ relationColumn , true ) ; $ query -> sort ( $ relationColumn , $ direction , false ) ; } } } ) ; } | Return a new DataList instance as a copy of this data list with the sort order set . |
4,381 | public function filter ( ) { $ arguments = func_get_args ( ) ; switch ( sizeof ( $ arguments ) ) { case 1 : $ filters = $ arguments [ 0 ] ; break ; case 2 : $ filters = [ $ arguments [ 0 ] => $ arguments [ 1 ] ] ; break ; default : throw new InvalidArgumentException ( 'Incorrect number of arguments passed to filter()' ) ; } return $ this -> addFilter ( $ filters ) ; } | Return a copy of this list which only includes items with these charactaristics |
4,382 | public function addFilter ( $ filterArray ) { $ list = $ this ; foreach ( $ filterArray as $ expression => $ value ) { $ filter = $ this -> createSearchFilter ( $ expression , $ value ) ; $ list = $ list -> alterDataQuery ( [ $ filter , 'apply' ] ) ; } return $ list ; } | Return a new instance of the list with an added filter |
4,383 | public function applyRelation ( $ field , & $ columnName = null , $ linearOnly = false ) { if ( ! $ this -> isValidRelationName ( $ field ) ) { $ columnName = $ field ; return $ this ; } if ( strpos ( $ field , '.' ) === false ) { $ columnName = '"' . $ field . '"' ; return $ this ; } return $ this -> alterDataQuery ( function ( DataQuery $ query ) use ( $ field , & $ columnName , $ linearOnly ) { $ relations = explode ( '.' , $ field ) ; $ fieldName = array_pop ( $ relations ) ; $ relationModelName = $ query -> applyRelation ( $ relations , $ linearOnly ) ; $ relationPrefix = $ query -> applyRelationPrefix ( $ relations ) ; $ columnName = DataObject :: getSchema ( ) -> sqlColumnForField ( $ relationModelName , $ fieldName , $ relationPrefix ) ; } ) ; } | Given a field or relation name apply it safely to this datalist . |
4,384 | public function exclude ( ) { $ numberFuncArgs = count ( func_get_args ( ) ) ; $ whereArguments = [ ] ; if ( $ numberFuncArgs == 1 && is_array ( func_get_arg ( 0 ) ) ) { $ whereArguments = func_get_arg ( 0 ) ; } elseif ( $ numberFuncArgs == 2 ) { $ whereArguments [ func_get_arg ( 0 ) ] = func_get_arg ( 1 ) ; } else { throw new InvalidArgumentException ( 'Incorrect number of arguments passed to exclude()' ) ; } return $ this -> alterDataQuery ( function ( DataQuery $ query ) use ( $ whereArguments ) { $ subquery = $ query -> disjunctiveGroup ( ) ; foreach ( $ whereArguments as $ field => $ value ) { $ filter = $ this -> createSearchFilter ( $ field , $ value ) ; $ filter -> exclude ( $ subquery ) ; } } ) ; } | Return a copy of this list which does not contain any items that match all params |
4,385 | public function excludeAny ( ) { $ numberFuncArgs = count ( func_get_args ( ) ) ; $ whereArguments = [ ] ; if ( $ numberFuncArgs == 1 && is_array ( func_get_arg ( 0 ) ) ) { $ whereArguments = func_get_arg ( 0 ) ; } elseif ( $ numberFuncArgs == 2 ) { $ whereArguments [ func_get_arg ( 0 ) ] = func_get_arg ( 1 ) ; } else { throw new InvalidArgumentException ( 'Incorrect number of arguments passed to excludeAny()' ) ; } return $ this -> alterDataQuery ( function ( DataQuery $ dataQuery ) use ( $ whereArguments ) { foreach ( $ whereArguments as $ field => $ value ) { $ filter = $ this -> createSearchFilter ( $ field , $ value ) ; $ filter -> exclude ( $ dataQuery ) ; } return $ dataQuery ; } ) ; } | Return a copy of this list which does not contain any items with any of these params |
4,386 | public function innerJoin ( $ table , $ onClause , $ alias = null , $ order = 20 , $ parameters = [ ] ) { return $ this -> alterDataQuery ( function ( DataQuery $ query ) use ( $ table , $ onClause , $ alias , $ order , $ parameters ) { $ query -> innerJoin ( $ table , $ onClause , $ alias , $ order , $ parameters ) ; } ) ; } | Return a new DataList instance with an inner join clause added to this list s query . |
4,387 | public function toArray ( ) { $ query = $ this -> dataQuery -> query ( ) ; $ rows = $ query -> execute ( ) ; $ results = [ ] ; foreach ( $ rows as $ row ) { $ results [ ] = $ this -> createDataObject ( $ row ) ; } return $ results ; } | Return an array of the actual items that this DataList contains at this stage . This is when the query is actually executed . |
4,388 | public function getGenerator ( ) { $ query = $ this -> dataQuery -> query ( ) -> execute ( ) ; while ( $ row = $ query -> record ( ) ) { yield $ this -> createDataObject ( $ row ) ; } } | Returns a generator for this DataList |
4,389 | public function createDataObject ( $ row ) { $ class = $ this -> dataClass ; if ( empty ( $ row [ 'ClassName' ] ) ) { $ row [ 'ClassName' ] = $ class ; } if ( empty ( $ row [ 'RecordClassName' ] ) ) { $ row [ 'RecordClassName' ] = $ row [ 'ClassName' ] ; } if ( class_exists ( $ row [ 'RecordClassName' ] ) ) { $ class = $ row [ 'RecordClassName' ] ; } $ item = Injector :: inst ( ) -> create ( $ class , $ row , false , $ this -> getQueryParams ( ) ) ; return $ item ; } | Create a DataObject from the given SQL row |
4,390 | public function first ( ) { foreach ( $ this -> dataQuery -> firstRow ( ) -> execute ( ) as $ row ) { return $ this -> createDataObject ( $ row ) ; } return null ; } | Returns the first item in this DataList |
4,391 | public function last ( ) { foreach ( $ this -> dataQuery -> lastRow ( ) -> execute ( ) as $ row ) { return $ this -> createDataObject ( $ row ) ; } return null ; } | Returns the last item in this DataList |
4,392 | public function setQueriedColumns ( $ queriedColumns ) { return $ this -> alterDataQuery ( function ( DataQuery $ query ) use ( $ queriedColumns ) { $ query -> setQueriedColumns ( $ queriedColumns ) ; } ) ; } | Restrict the columns to fetch into this DataList |
4,393 | public function setByIDList ( $ idList ) { $ has = [ ] ; foreach ( $ this -> column ( ) as $ id ) { $ has [ $ id ] = true ; } $ itemsToDelete = $ has ; if ( $ idList ) { foreach ( $ idList as $ id ) { unset ( $ itemsToDelete [ $ id ] ) ; if ( $ id && ! isset ( $ has [ $ id ] ) ) { $ this -> add ( $ id ) ; } } } $ this -> removeMany ( array_keys ( $ itemsToDelete ) ) ; } | Sets the ComponentSet to be the given ID list . Records will be added and deleted as appropriate . |
4,394 | public function newObject ( $ initialFields = null ) { $ class = $ this -> dataClass ; return Injector :: inst ( ) -> create ( $ class , $ initialFields , false ) ; } | Return a new item to add to this DataList . |
4,395 | protected function configFor ( $ name ) { if ( array_key_exists ( $ name , $ this -> configs ) ) { return $ this -> configs [ $ name ] ; } $ config = Config :: inst ( ) -> get ( Injector :: class , $ name ) ; $ this -> configs [ $ name ] = $ config ; return $ config ; } | Retrieves the config for a named service without performing a hierarchy walk |
4,396 | public static function fromString ( $ content , $ cacheTemplate = null ) { $ viewer = SSViewer_FromString :: create ( $ content ) ; if ( $ cacheTemplate !== null ) { $ viewer -> setCacheTemplate ( $ cacheTemplate ) ; } return $ viewer ; } | Create a template from a string instead of a . ss file |
4,397 | public static function add_themes ( $ themes = [ ] ) { $ currentThemes = SSViewer :: get_themes ( ) ; $ finalThemes = array_merge ( $ themes , $ currentThemes ) ; static :: set_themes ( array_values ( array_unique ( $ finalThemes ) ) ) ; } | Add to the list of active themes to apply |
4,398 | public static function get_themes ( ) { $ default = [ self :: PUBLIC_THEME , self :: DEFAULT_THEME ] ; if ( ! SSViewer :: config ( ) -> uninherited ( 'theme_enabled' ) ) { return $ default ; } $ themes = static :: $ current_themes ; if ( ! isset ( $ themes ) ) { $ themes = SSViewer :: config ( ) -> uninherited ( 'themes' ) ; } if ( $ themes ) { return $ themes ; } if ( $ theme = SSViewer :: config ( ) -> uninherited ( 'theme' ) ) { return [ self :: PUBLIC_THEME , $ theme , self :: DEFAULT_THEME ] ; } return $ default ; } | Get the list of active themes |
4,399 | public function getParser ( ) { if ( ! $ this -> parser ) { $ this -> setParser ( Injector :: inst ( ) -> get ( 'SilverStripe\\View\\SSTemplateParser' ) ) ; } return $ this -> parser ; } | Returns the parser that is set for template generation |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.