idx int64 0 241k | question stringlengths 64 6.21k | target stringlengths 5 803 |
|---|---|---|
6,600 | public function setTermsLookup ( string $ key , array $ termsLookup ) : self { $ this -> _key = $ key ; $ this -> _terms = $ termsLookup ; return $ this ; } | Sets key and terms lookup for the query . |
6,601 | public function match ( string $ field = null , $ values = null ) : Match { return new Match ( $ field , $ values ) ; } | match query . |
6,602 | public function common_terms ( string $ field , string $ query , float $ cutoffFrequency ) : Common { return new Common ( $ field , $ query , $ cutoffFrequency ) ; } | common terms query . |
6,603 | public function fuzzy ( string $ fieldName = null , string $ value = null ) : Fuzzy { return new Fuzzy ( $ fieldName , $ value ) ; } | fuzzy query . |
6,604 | public function regexp ( string $ key = '' , string $ value = null , float $ boost = 1.0 ) : Regexp { return new Regexp ( $ key , $ value , $ boost ) ; } | regexp query . |
6,605 | public function span_first ( $ match = null , int $ end = null ) : SpanFirst { return new SpanFirst ( $ match , $ end ) ; } | span first query . |
6,606 | public function span_near ( array $ clauses = [ ] , int $ slop = 1 , bool $ inOrder = false ) : SpanNear { return new SpanNear ( $ clauses , $ slop , $ inOrder ) ; } | span near query . |
6,607 | public function span_containing ( AbstractSpanQuery $ little = null , AbstractSpanQuery $ big = null ) : SpanContaining { return new SpanContaining ( $ little , $ big ) ; } | span_containing query . |
6,608 | public function span_within ( AbstractSpanQuery $ little = null , AbstractSpanQuery $ big = null ) : SpanWithin { return new SpanWithin ( $ little , $ big ) ; } | span_within query . |
6,609 | public function wildcard ( string $ key = '' , string $ value = null , float $ boost = 1.0 ) : Wildcard { return new Wildcard ( $ key , $ value , $ boost ) ; } | wildcard query . |
6,610 | public function geo_distance ( string $ key , $ location , string $ distance ) : GeoDistance { return new GeoDistance ( $ key , $ location , $ distance ) ; } | geo distance query . |
6,611 | public function generateDefaultResponse ( array $ params ) : Response { $ response = [ 'took' => 0 , 'timed_out' => false , '_shards' => [ 'total' => 0 , 'successful' => 0 , 'failed' => 0 , ] , 'hits' => [ 'total' => 0 , 'max_score' => null , 'hits' => [ ] , ] , 'params' => $ params , ] ; return new Response ( JSON :: stringify ( $ response ) ) ; } | Generate an example response object . |
6,612 | protected function _convertArrayable ( array $ array ) { $ arr = [ ] ; foreach ( $ array as $ key => $ value ) { if ( $ value instanceof ArrayableInterface ) { $ arr [ $ value instanceof NameableInterface ? $ value -> getName ( ) : $ key ] = $ value -> toArray ( ) ; } elseif ( \ is_array ( $ value ) ) { $ arr [ $ key ] = $ this -> _convertArrayable ( $ value ) ; } else { $ arr [ $ key ] = $ value ; } } return $ arr ; } | Cast objects to arrays . |
6,613 | public function getParam ( $ key ) { if ( ! $ this -> hasParam ( $ key ) ) { throw new InvalidException ( 'Param ' . $ key . ' does not exist' ) ; } return $ this -> _params [ $ key ] ; } | Returns a specific param . |
6,614 | public function setParam ( string $ key , $ value ) : Mapping { $ this -> _mapping [ $ key ] = $ value ; return $ this ; } | Sets raw parameters . |
6,615 | public function toArray ( ) : array { $ type = $ this -> getType ( ) ; if ( empty ( $ type ) ) { throw new InvalidException ( 'Type has to be set' ) ; } return [ $ type -> getName ( ) => $ this -> _mapping ] ; } | Converts the mapping to an array . |
6,616 | public function send ( array $ query = [ ] ) : Response { $ endpoint = new Put ( ) ; $ endpoint -> setBody ( $ this -> toArray ( ) ) ; $ endpoint -> setParams ( $ query ) ; return $ this -> getType ( ) -> requestEndpoint ( $ endpoint ) ; } | Submits the mapping and sends it to the server . |
6,617 | public static function create ( $ mapping ) : Mapping { if ( \ is_array ( $ mapping ) ) { $ mappingObject = new self ( ) ; $ mappingObject -> setProperties ( $ mapping ) ; return $ mappingObject ; } if ( $ mapping instanceof self ) { return $ mapping ; } throw new InvalidException ( 'Invalid object type' ) ; } | Creates a mapping object . |
6,618 | public function buildResultSet ( Response $ response , Query $ query ) : ResultSet { $ resultSet = $ this -> builder -> buildResultSet ( $ response , $ query ) ; $ this -> processor -> process ( $ resultSet ) ; return $ resultSet ; } | Runs any registered transformers on the ResultSet before returning it allowing the transformers to inject additional data into each Result . |
6,619 | public function addRange ( string $ fromValue = null , string $ toValue = null ) : self { if ( null === $ fromValue && null === $ toValue ) { throw new InvalidException ( 'Either fromValue or toValue must be set. Both cannot be null.' ) ; } $ range = [ ] ; if ( null !== $ fromValue ) { $ range [ 'from' ] = $ fromValue ; } if ( null !== $ toValue ) { $ range [ 'to' ] = $ toValue ; } return $ this -> addParam ( 'ranges' , $ range ) ; } | Add an ip range to this aggregation . |
6,620 | public function addAggregation ( AbstractAggregation $ aggregation ) : self { if ( $ aggregation instanceof GlobalAggregation ) { throw new InvalidException ( 'Global aggregators can only be placed as top level aggregators' ) ; } $ this -> _aggs [ ] = $ aggregation ; return $ this ; } | Add a sub - aggregation . |
6,621 | public function getError ( ) : string { foreach ( $ this -> getBulkResponses ( ) as $ bulkResponse ) { if ( $ bulkResponse -> hasError ( ) ) { return $ bulkResponse -> getError ( ) ; } } return '' ; } | Returns first found error . |
6,622 | public function addCoordinates ( string $ key , array $ coordinates ) : self { if ( ! isset ( $ coordinates [ 0 ] ) || ! isset ( $ coordinates [ 1 ] ) ) { throw new InvalidException ( 'expected $coordinates to be an array with two elements' ) ; } $ this -> setParam ( $ key , [ 'top_left' => $ coordinates [ 0 ] , 'bottom_right' => $ coordinates [ 1 ] , ] ) ; return $ this ; } | Add coordinates . |
6,623 | public function addDSL ( DSL $ dsl ) { $ this -> _facades [ $ dsl -> getType ( ) ] = new Facade ( $ dsl , $ this -> _version ) ; } | Adds a new DSL object . |
6,624 | public function updateByQuery ( $ query , AbstractScript $ script , array $ options = [ ] ) { $ query = Query :: create ( $ query ) -> getQuery ( ) ; $ endpoint = new UpdateByQuery ( ) ; $ body = [ 'query' => \ is_array ( $ query ) ? $ query : $ query -> toArray ( ) , ] ; $ body [ 'script' ] = $ script -> toArray ( ) [ 'script' ] ; $ endpoint -> setBody ( $ body ) ; $ endpoint -> setParams ( $ options ) ; return $ this -> requestEndpoint ( $ endpoint ) ; } | Update entries in the db based on a query . |
6,625 | public function forcemerge ( $ args = [ ] ) { $ endpoint = new ForceMerge ( ) ; $ endpoint -> setParams ( $ args ) ; return $ this -> requestEndpoint ( $ endpoint ) ; } | Force merges index . |
6,626 | public function create ( array $ args = [ ] , $ options = null ) { if ( \ is_bool ( $ options ) && $ options ) { try { $ this -> delete ( ) ; } catch ( ResponseException $ e ) { } } elseif ( \ is_array ( $ options ) ) { foreach ( $ options as $ key => $ value ) { switch ( $ key ) { case 'recreate' : try { $ this -> delete ( ) ; } catch ( ResponseException $ e ) { } break ; default : throw new InvalidException ( 'Invalid option ' . $ key ) ; break ; } } } $ endpoint = new Create ( ) ; $ endpoint -> setBody ( $ args ) ; return $ this -> requestEndpoint ( $ endpoint ) ; } | Creates a new index with the given arguments . |
6,627 | public function addAlias ( $ name , $ replace = false ) { $ data = [ 'actions' => [ ] ] ; if ( $ replace ) { $ status = new Status ( $ this -> getClient ( ) ) ; foreach ( $ status -> getIndicesWithAlias ( $ name ) as $ index ) { $ data [ 'actions' ] [ ] = [ 'remove' => [ 'index' => $ index -> getName ( ) , 'alias' => $ name ] ] ; } } $ data [ 'actions' ] [ ] = [ 'add' => [ 'index' => $ this -> getName ( ) , 'alias' => $ name ] ] ; $ endpoint = new Update ( ) ; $ endpoint -> setBody ( $ data ) ; return $ this -> getClient ( ) -> requestEndpoint ( $ endpoint ) ; } | Adds an alias to the current index . |
6,628 | public function removeAlias ( $ name ) { $ endpoint = new \ Elasticsearch \ Endpoints \ Indices \ Alias \ Delete ( ) ; $ endpoint -> setName ( $ name ) ; return $ this -> requestEndpoint ( $ endpoint ) ; } | Removes an alias pointing to the current index . |
6,629 | public function getAliases ( ) { $ endpoint = new \ Elasticsearch \ Endpoints \ Indices \ Alias \ Get ( ) ; $ endpoint -> setName ( '*' ) ; $ responseData = $ this -> requestEndpoint ( $ endpoint ) -> getData ( ) ; if ( ! isset ( $ responseData [ $ this -> getName ( ) ] ) ) { return [ ] ; } $ data = $ responseData [ $ this -> getName ( ) ] ; if ( ! empty ( $ data [ 'aliases' ] ) ) { return \ array_keys ( $ data [ 'aliases' ] ) ; } return [ ] ; } | Returns all index aliases . |
6,630 | public function flush ( array $ options = [ ] ) { $ endpoint = new Flush ( ) ; $ endpoint -> setParams ( $ options ) ; return $ this -> requestEndpoint ( $ endpoint ) ; } | Flushes the index to storage . |
6,631 | public function setSettings ( array $ data ) { $ endpoint = new Put ( ) ; $ endpoint -> setBody ( $ data ) ; return $ this -> requestEndpoint ( $ endpoint ) ; } | Can be used to change settings during runtime . One example is to use it for bulk updating . |
6,632 | public function requestEndpoint ( AbstractEndpoint $ endpoint ) { $ cloned = clone $ endpoint ; $ cloned -> setIndex ( $ this -> getName ( ) ) ; return $ this -> getClient ( ) -> requestEndpoint ( $ cloned ) ; } | Makes calls to the elasticsearch server with usage official client Endpoint based on this index . |
6,633 | public function analyze ( array $ body , $ args = [ ] ) { $ endpoint = new Analyze ( ) ; $ endpoint -> setBody ( $ body ) ; $ endpoint -> setParams ( $ args ) ; $ data = $ this -> requestEndpoint ( $ endpoint ) -> getData ( ) ; if ( isset ( $ body [ 'explain' ] ) && $ body [ 'explain' ] ) { return $ data [ 'detail' ] ; } return $ data [ 'tokens' ] ; } | Analyzes a string . |
6,634 | public function buildResultSet ( Response $ response , Query $ query ) : ResultSet { $ results = $ this -> buildResults ( $ response ) ; $ resultSet = new ResultSet ( $ response , $ query , $ results ) ; return $ resultSet ; } | Builds a ResultSet for a given Response . |
6,635 | private function buildResults ( Response $ response ) : array { $ data = $ response -> getData ( ) ; $ results = [ ] ; if ( ! isset ( $ data [ 'hits' ] [ 'hits' ] ) ) { return $ results ; } foreach ( $ data [ 'hits' ] [ 'hits' ] as $ hit ) { $ results [ ] = new Result ( $ hit ) ; } return $ results ; } | Builds individual result objects . |
6,636 | public function setQueryParam ( string $ key , $ value ) : self { $ this -> _queryParams [ $ key ] = $ value ; return $ this ; } | Set a parameter in the body of this query . |
6,637 | public function setInclude ( string $ pattern , string $ flags = null ) : self { if ( null === $ flags ) { return $ this -> setParam ( 'include' , $ pattern ) ; } return $ this -> setParam ( 'include' , [ 'pattern' => $ pattern , 'flags' => $ flags , ] ) ; } | Filter documents to include based on a regular expression . |
6,638 | public function setExclude ( string $ pattern , string $ flags = null ) : self { if ( null === $ flags ) { return $ this -> setParam ( 'exclude' , $ pattern ) ; } return $ this -> setParam ( 'exclude' , [ 'pattern' => $ pattern , 'flags' => $ flags , ] ) ; } | Filter documents to exclude based on a regular expression . |
6,639 | protected function createCacheFile ( ) { $ this -> createCacheDir ( ) ; $ cacheFilePath = $ this -> getCacheFile ( ) ; if ( ! file_exists ( $ cacheFilePath ) ) { touch ( $ cacheFilePath ) ; } } | Create a cache file . |
6,640 | public function put ( string $ path , string $ contents ) : int { return file_put_contents ( $ path , $ contents , LOCK_EX ) ; } | Write the contents of a file with exclusive lock . |
6,641 | public function isValid ( string $ key ) : bool { $ key = $ this -> getActualCacheKey ( $ key ) ; $ meta = $ this -> getCacheContents ( ) [ $ key ] ?? [ ] ; if ( empty ( $ meta [ 'expires_at' ] ) ) { return false ; } return Carbon :: now ( ) < Carbon :: createFromFormat ( self :: RFC_7231 , $ meta [ 'expires_at' ] ) ; } | Check if cache is still valid . |
6,642 | public function getCacheContents ( ) { $ cacheFile = $ this -> getCacheFile ( ) ; if ( ! file_exists ( $ cacheFile ) ) { return false ; } return json_decode ( $ this -> sharedGet ( $ cacheFile ) , true ) ?? [ ] ; } | Get cache contents . |
6,643 | public function getActualCacheKey ( string $ key ) : string { $ prefix = $ this -> getPrefix ( ) ; if ( false === strpos ( $ key , $ prefix ) ) { $ key = $ prefix . $ key ; } return $ key ; } | Get actual cache key with prefix . |
6,644 | public function send ( $ content , int $ status = HttpResponse :: HTTP_OK , array $ headers = [ ] ) : HttpResponse { $ headers = array_merge ( $ this -> headers , $ headers ) ; if ( is_array ( $ content ) ) { $ content = json_encode ( $ content ) ; } $ response = $ this -> response -> create ( $ content , $ status , $ headers ) ; return $ this -> createOnly ? $ response : $ response -> send ( ) ; } | Create and send a response . |
6,645 | public function file ( string $ file , string $ name = null ) : self { $ this -> filePath = $ file ; if ( ! file_exists ( $ file ) || ! is_readable ( $ file ) ) { throw new FileException ( 'Cannot read file: ' . $ file ) ; } $ this -> fileName = $ name ?? basename ( $ this -> filePath ) ; $ this -> fileSize = filesize ( $ file ) ; return $ this ; } | Set file properties . |
6,646 | public function getChecksum ( ) : string { if ( empty ( $ this -> checksum ) ) { $ this -> setChecksum ( hash_file ( $ this -> getChecksumAlgorithm ( ) , $ this -> getFilePath ( ) ) ) ; } return $ this -> checksum ; } | Get checksum . |
6,647 | public function isExpired ( ) : bool { $ expiresAt = $ this -> getCache ( ) -> get ( $ this -> getKey ( ) ) [ 'expires_at' ] ?? null ; return empty ( $ expiresAt ) || Carbon :: parse ( $ expiresAt ) -> lt ( Carbon :: now ( ) ) ; } | Check if current upload is expired . |
6,648 | public function seek ( int $ offset ) : self { $ this -> partialOffset = $ offset ; $ this -> partial ( ) ; return $ this ; } | Set offset and force this to be a partial upload request . |
6,649 | public function create ( string $ key ) : string { $ headers = [ 'Upload-Length' => $ this -> fileSize , 'Upload-Key' => $ key , 'Upload-Checksum' => $ this -> getUploadChecksumHeader ( ) , 'Upload-Metadata' => 'filename ' . base64_encode ( $ this -> fileName ) , ] ; if ( $ this -> isPartial ( ) ) { $ headers += [ 'Upload-Concat' => 'partial' ] ; } $ response = $ this -> getClient ( ) -> post ( $ this -> apiPath , [ 'headers' => $ headers , ] ) ; $ statusCode = $ response -> getStatusCode ( ) ; if ( HttpResponse :: HTTP_CREATED !== $ statusCode ) { throw new FileException ( 'Unable to create resource.' ) ; } $ uploadLocation = current ( $ response -> getHeader ( 'location' ) ) ; $ this -> getCache ( ) -> set ( $ this -> getKey ( ) , [ 'location' => $ uploadLocation , 'expires_at' => Carbon :: now ( ) -> addSeconds ( $ this -> getCache ( ) -> getTtl ( ) ) -> format ( $ this -> getCache ( ) :: RFC_7231 ) , ] ) ; return $ uploadLocation ; } | Create resource with POST request . |
6,650 | public function concat ( string $ key , ... $ partials ) : string { $ response = $ this -> getClient ( ) -> post ( $ this -> apiPath , [ 'headers' => [ 'Upload-Length' => $ this -> fileSize , 'Upload-Key' => $ key , 'Upload-Checksum' => $ this -> getUploadChecksumHeader ( ) , 'Upload-Metadata' => 'filename ' . base64_encode ( $ this -> fileName ) , 'Upload-Concat' => self :: UPLOAD_TYPE_FINAL . ';' . implode ( ' ' , $ partials ) , ] , ] ) ; $ data = json_decode ( $ response -> getBody ( ) , true ) ; $ checksum = $ data [ 'data' ] [ 'checksum' ] ?? null ; $ statusCode = $ response -> getStatusCode ( ) ; if ( HttpResponse :: HTTP_CREATED !== $ statusCode || ! $ checksum ) { throw new FileException ( 'Unable to create resource.' ) ; } return $ checksum ; } | Concatenate 2 or more partial uploads . |
6,651 | public function delete ( ) { try { $ this -> getClient ( ) -> delete ( $ this -> getUrl ( ) ) ; } catch ( ClientException $ e ) { $ statusCode = $ e -> getResponse ( ) -> getStatusCode ( ) ; if ( HttpResponse :: HTTP_NOT_FOUND === $ statusCode || HttpResponse :: HTTP_GONE === $ statusCode ) { throw new FileException ( 'File not found.' ) ; } } } | Send DELETE request . |
6,652 | protected function partial ( bool $ state = true ) { $ this -> partial = $ state ; if ( ! $ this -> partial ) { return ; } $ key = $ this -> getKey ( ) ; if ( false !== strpos ( $ key , self :: PARTIAL_UPLOAD_NAME_SEPARATOR ) ) { list ( $ key , ) = explode ( self :: PARTIAL_UPLOAD_NAME_SEPARATOR , $ key ) ; } $ this -> key = $ key . uniqid ( self :: PARTIAL_UPLOAD_NAME_SEPARATOR ) ; } | Set as partial request . |
6,653 | protected function handleClientException ( ClientException $ e ) { $ statusCode = $ e -> getResponse ( ) -> getStatusCode ( ) ; if ( HttpResponse :: HTTP_REQUESTED_RANGE_NOT_SATISFIABLE === $ statusCode ) { return new FileException ( 'The uploaded file is corrupt.' ) ; } if ( HttpResponse :: HTTP_CONTINUE === $ statusCode ) { return new ConnectionException ( 'Connection aborted by user.' ) ; } if ( HttpResponse :: HTTP_UNSUPPORTED_MEDIA_TYPE === $ statusCode ) { return new TusException ( 'Unsupported media types.' ) ; } return new TusException ( $ e -> getResponse ( ) -> getBody ( ) , $ statusCode ) ; } | Handle client exception during patch request . |
6,654 | protected function getData ( int $ offset , int $ bytes ) : string { $ file = new File ; $ handle = $ file -> open ( $ this -> getFilePath ( ) , $ file :: READ_BINARY ) ; $ file -> seek ( $ handle , $ offset ) ; $ data = $ file -> read ( $ handle , $ bytes ) ; $ file -> close ( $ handle ) ; return ( string ) $ data ; } | Get X bytes of data from file . |
6,655 | public function setMeta ( int $ offset , int $ fileSize , string $ filePath , string $ location = null ) : self { $ this -> offset = $ offset ; $ this -> fileSize = $ fileSize ; $ this -> filePath = $ filePath ; $ this -> location = $ location ; return $ this ; } | Set file meta . |
6,656 | public function details ( ) : array { $ now = Carbon :: now ( ) ; return [ 'name' => $ this -> name , 'size' => $ this -> fileSize , 'offset' => $ this -> offset , 'checksum' => $ this -> checksum , 'location' => $ this -> location , 'file_path' => $ this -> filePath , 'created_at' => $ now -> format ( $ this -> cache :: RFC_7231 ) , 'expires_at' => $ now -> addSeconds ( $ this -> cache -> getTtl ( ) ) -> format ( $ this -> cache :: RFC_7231 ) , ] ; } | Get file meta . |
6,657 | public function upload ( int $ totalBytes ) : int { if ( $ this -> offset === $ totalBytes ) { return $ this -> offset ; } $ input = $ this -> open ( $ this -> getInputStream ( ) , self :: READ_BINARY ) ; $ output = $ this -> open ( $ this -> getFilePath ( ) , self :: APPEND_BINARY ) ; $ key = $ this -> getKey ( ) ; try { $ this -> seek ( $ output , $ this -> offset ) ; while ( ! feof ( $ input ) ) { if ( CONNECTION_NORMAL !== connection_status ( ) ) { throw new ConnectionException ( 'Connection aborted by user.' ) ; } $ data = $ this -> read ( $ input , self :: CHUNK_SIZE ) ; $ bytes = $ this -> write ( $ output , $ data , self :: CHUNK_SIZE ) ; $ this -> offset += $ bytes ; $ this -> cache -> set ( $ key , [ 'offset' => $ this -> offset ] ) ; if ( $ this -> offset > $ totalBytes ) { throw new OutOfRangeException ( 'The uploaded file is corrupt.' ) ; } if ( $ this -> offset === $ totalBytes ) { break ; } } } finally { $ this -> close ( $ input ) ; $ this -> close ( $ output ) ; } return $ this -> offset ; } | Upload file to server . |
6,658 | public function open ( string $ filePath , string $ mode ) { $ this -> exists ( $ filePath , $ mode ) ; $ ptr = @ fopen ( $ filePath , $ mode ) ; if ( false === $ ptr ) { throw new FileException ( "Unable to open $filePath." ) ; } return $ ptr ; } | Open file in given mode . |
6,659 | public function exists ( string $ filePath , string $ mode = self :: READ_BINARY ) : bool { if ( self :: INPUT_STREAM === $ filePath ) { return true ; } if ( self :: READ_BINARY === $ mode && ! file_exists ( $ filePath ) ) { throw new FileException ( 'File not found.' ) ; } return true ; } | Check if file to read exists . |
6,660 | public function seek ( $ handle , int $ offset , int $ whence = SEEK_SET ) : int { $ position = fseek ( $ handle , $ offset , $ whence ) ; if ( - 1 === $ position ) { throw new FileException ( 'Cannot move pointer to desired position.' ) ; } return $ position ; } | Move file pointer to given offset . |
6,661 | public function read ( $ handle , int $ chunkSize ) : string { $ data = fread ( $ handle , $ chunkSize ) ; if ( false === $ data ) { throw new FileException ( 'Cannot read file.' ) ; } return ( string ) $ data ; } | Read data from file . |
6,662 | public function write ( $ handle , string $ data , $ length = null ) : int { $ bytesWritten = is_int ( $ length ) ? fwrite ( $ handle , $ data , $ length ) : fwrite ( $ handle , $ data ) ; if ( false === $ bytesWritten ) { throw new FileException ( 'Cannot write to a file.' ) ; } return $ bytesWritten ; } | Write data to file . |
6,663 | public function merge ( array $ files ) : int { $ destination = $ this -> getFilePath ( ) ; $ firstFile = array_shift ( $ files ) ; $ this -> copy ( $ firstFile [ 'file_path' ] , $ destination ) ; $ this -> offset = $ firstFile [ 'offset' ] ; $ this -> fileSize = filesize ( $ firstFile [ 'file_path' ] ) ; $ handle = $ this -> open ( $ destination , self :: APPEND_BINARY ) ; foreach ( $ files as $ file ) { if ( ! file_exists ( $ file [ 'file_path' ] ) ) { throw new FileException ( 'File to be merged not found.' ) ; } $ this -> fileSize += $ this -> write ( $ handle , file_get_contents ( $ file [ 'file_path' ] ) ) ; $ this -> offset += $ file [ 'offset' ] ; } $ this -> close ( $ handle ) ; return $ this -> fileSize ; } | Merge 2 or more files . |
6,664 | public function copy ( string $ source , string $ destination ) : bool { $ status = @ copy ( $ source , $ destination ) ; if ( false === $ status ) { throw new FileException ( 'Cannot copy source to destination.' ) ; } return $ status ; } | Copy file from source to destination . |
6,665 | public function deleteFiles ( array $ files ) : bool { if ( empty ( $ files ) ) { return false ; } $ status = true ; foreach ( $ files as $ file ) { if ( file_exists ( $ file ) ) { $ status = $ status && unlink ( $ file ) ; } } return $ status ; } | Delete multiple files . |
6,666 | public function allowedHttpVerbs ( ) : array { return [ HttpRequest :: METHOD_GET , HttpRequest :: METHOD_POST , HttpRequest :: METHOD_PATCH , HttpRequest :: METHOD_DELETE , HttpRequest :: METHOD_HEAD , HttpRequest :: METHOD_OPTIONS , ] ; } | Supported http requests . |
6,667 | public function extractFromHeader ( string $ key , string $ value ) : array { $ meta = $ this -> header ( $ key ) ; if ( false !== strpos ( $ meta , $ value ) ) { $ meta = trim ( str_replace ( $ value , '' , $ meta ) ) ; return explode ( ' ' , $ meta ) ?? [ ] ; } return [ ] ; } | Extract metadata from header . |
6,668 | public function extractMeta ( string $ requestedKey ) : string { $ uploadMetaData = $ this -> request -> headers -> get ( 'Upload-Metadata' ) ; if ( empty ( $ uploadMetaData ) ) { return '' ; } $ uploadMetaDataChunks = explode ( ',' , $ uploadMetaData ) ; foreach ( $ uploadMetaDataChunks as $ chunk ) { list ( $ key , $ value ) = explode ( ' ' , $ chunk ) ; if ( $ key === $ requestedKey ) { return base64_decode ( $ value ) ; } } return '' ; } | Extracts the meta data from the request header . |
6,669 | public function deleteAll ( array $ keys ) : bool { if ( empty ( $ keys ) ) { return false ; } $ status = true ; foreach ( $ keys as $ key ) { $ status = $ status && $ this -> delete ( $ key ) ; } return $ status ; } | Delete all keys . |
6,670 | public function add ( ... $ middleware ) : self { foreach ( $ middleware as $ m ) { if ( $ m instanceof TusMiddleware ) { $ this -> globalMiddleware [ get_class ( $ m ) ] = $ m ; } elseif ( is_string ( $ m ) ) { $ this -> globalMiddleware [ $ m ] = new $ m ; } } return $ this ; } | Set middleware . |
6,671 | public function skip ( ... $ middleware ) : self { foreach ( $ middleware as $ m ) { unset ( $ this -> globalMiddleware [ $ m ] ) ; } return $ this ; } | Skip middleware . |
6,672 | public function getChecksumAlgorithm ( ) : ? string { $ checksumHeader = $ this -> getRequest ( ) -> header ( 'Upload-Checksum' ) ; if ( empty ( $ checksumHeader ) ) { return self :: DEFAULT_CHECKSUM_ALGORITHM ; } list ( $ checksumAlgorithm , ) = explode ( ' ' , $ checksumHeader ) ; return $ checksumAlgorithm ; } | Get checksum algorithm . |
6,673 | public function getUploadKey ( ) { if ( ! empty ( $ this -> uploadKey ) ) { return $ this -> uploadKey ; } $ key = $ this -> getRequest ( ) -> header ( 'Upload-Key' ) ?? Uuid :: uuid4 ( ) -> toString ( ) ; if ( empty ( $ key ) ) { return $ this -> response -> send ( null , HttpResponse :: HTTP_BAD_REQUEST ) ; } $ this -> uploadKey = $ key ; return $ this -> uploadKey ; } | Get upload key from header . |
6,674 | public function serve ( ) { $ this -> applyMiddleware ( ) ; $ requestMethod = $ this -> getRequest ( ) -> method ( ) ; if ( ! in_array ( $ requestMethod , $ this -> getRequest ( ) -> allowedHttpVerbs ( ) ) ) { return $ this -> response -> send ( null , HttpResponse :: HTTP_METHOD_NOT_ALLOWED ) ; } $ clientVersion = $ this -> getRequest ( ) -> header ( 'Tus-Resumable' ) ; if ( $ clientVersion && $ clientVersion !== self :: TUS_PROTOCOL_VERSION ) { return $ this -> response -> send ( null , HttpResponse :: HTTP_PRECONDITION_FAILED , [ 'Tus-Version' => self :: TUS_PROTOCOL_VERSION , ] ) ; } $ method = 'handle' . ucfirst ( strtolower ( $ requestMethod ) ) ; return $ this -> { $ method } ( ) ; } | Handle all HTTP request . |
6,675 | protected function applyMiddleware ( ) { $ middleware = $ this -> middleware ( ) -> list ( ) ; foreach ( $ middleware as $ m ) { $ m -> handle ( $ this -> getRequest ( ) , $ this -> getResponse ( ) ) ; } } | Apply middleware . |
6,676 | protected function handleOptions ( ) : HttpResponse { $ headers = [ 'Allow' => implode ( ',' , $ this -> request -> allowedHttpVerbs ( ) ) , 'Tus-Version' => self :: TUS_PROTOCOL_VERSION , 'Tus-Extension' => implode ( ',' , self :: TUS_EXTENSIONS ) , 'Tus-Checksum-Algorithm' => $ this -> getSupportedHashAlgorithms ( ) , ] ; $ maxUploadSize = $ this -> getMaxUploadSize ( ) ; if ( $ maxUploadSize > 0 ) { $ headers [ 'Tus-Max-Size' ] = $ maxUploadSize ; } return $ this -> response -> send ( null , HttpResponse :: HTTP_OK , $ headers ) ; } | Handle OPTIONS request . |
6,677 | protected function handleHead ( ) : HttpResponse { $ key = $ this -> request -> key ( ) ; if ( ! $ fileMeta = $ this -> cache -> get ( $ key ) ) { return $ this -> response -> send ( null , HttpResponse :: HTTP_NOT_FOUND ) ; } $ offset = $ fileMeta [ 'offset' ] ?? false ; if ( false === $ offset ) { return $ this -> response -> send ( null , HttpResponse :: HTTP_GONE ) ; } return $ this -> response -> send ( null , HttpResponse :: HTTP_OK , $ this -> getHeadersForHeadRequest ( $ fileMeta ) ) ; } | Handle HEAD request . |
6,678 | protected function handlePost ( ) : HttpResponse { $ fileName = $ this -> getRequest ( ) -> extractFileName ( ) ; $ uploadType = self :: UPLOAD_TYPE_NORMAL ; if ( empty ( $ fileName ) ) { return $ this -> response -> send ( null , HttpResponse :: HTTP_BAD_REQUEST ) ; } if ( ! $ this -> verifyUploadSize ( ) ) { return $ this -> response -> send ( null , HttpResponse :: HTTP_REQUEST_ENTITY_TOO_LARGE ) ; } $ uploadKey = $ this -> getUploadKey ( ) ; $ filePath = $ this -> uploadDir . DIRECTORY_SEPARATOR . $ fileName ; if ( $ this -> getRequest ( ) -> isFinal ( ) ) { return $ this -> handleConcatenation ( $ fileName , $ filePath ) ; } if ( $ this -> getRequest ( ) -> isPartial ( ) ) { $ filePath = $ this -> getPathForPartialUpload ( $ uploadKey ) . $ fileName ; $ uploadType = self :: UPLOAD_TYPE_PARTIAL ; } $ checksum = $ this -> getClientChecksum ( ) ; $ location = $ this -> getRequest ( ) -> url ( ) . $ this -> getApiPath ( ) . '/' . $ uploadKey ; $ file = $ this -> buildFile ( [ 'name' => $ fileName , 'offset' => 0 , 'size' => $ this -> getRequest ( ) -> header ( 'Upload-Length' ) , 'file_path' => $ filePath , 'location' => $ location , ] ) -> setKey ( $ uploadKey ) -> setChecksum ( $ checksum ) ; $ this -> cache -> set ( $ uploadKey , $ file -> details ( ) + [ 'upload_type' => $ uploadType ] ) ; $ this -> event ( ) -> dispatch ( UploadCreated :: NAME , new UploadCreated ( $ file , $ this -> getRequest ( ) , $ this -> getResponse ( ) ) ) ; return $ this -> response -> send ( null , HttpResponse :: HTTP_CREATED , [ 'Location' => $ location , 'Upload-Expires' => $ this -> cache -> get ( $ uploadKey ) [ 'expires_at' ] , ] ) ; } | Handle POST request . |
6,679 | protected function handleConcatenation ( string $ fileName , string $ filePath ) : HttpResponse { $ partials = $ this -> getRequest ( ) -> extractPartials ( ) ; $ uploadKey = $ this -> getUploadKey ( ) ; $ files = $ this -> getPartialsMeta ( $ partials ) ; $ filePaths = array_column ( $ files , 'file_path' ) ; $ location = $ this -> getRequest ( ) -> url ( ) . $ this -> getApiPath ( ) . '/' . $ uploadKey ; $ file = $ this -> buildFile ( [ 'name' => $ fileName , 'offset' => 0 , 'size' => 0 , 'file_path' => $ filePath , 'location' => $ location , ] ) -> setFilePath ( $ filePath ) -> setKey ( $ uploadKey ) ; $ file -> setOffset ( $ file -> merge ( $ files ) ) ; $ checksum = $ this -> getServerChecksum ( $ filePath ) ; if ( $ checksum !== $ this -> getClientChecksum ( ) ) { return $ this -> response -> send ( null , self :: HTTP_CHECKSUM_MISMATCH ) ; } $ file -> setChecksum ( $ checksum ) ; $ this -> cache -> set ( $ uploadKey , $ file -> details ( ) + [ 'upload_type' => self :: UPLOAD_TYPE_FINAL ] ) ; if ( $ file -> delete ( $ filePaths , true ) ) { $ this -> cache -> deleteAll ( $ partials ) ; } $ this -> event ( ) -> dispatch ( UploadMerged :: NAME , new UploadMerged ( $ file , $ this -> getRequest ( ) , $ this -> getResponse ( ) ) ) ; return $ this -> response -> send ( [ 'data' => [ 'checksum' => $ checksum ] ] , HttpResponse :: HTTP_CREATED , [ 'Location' => $ location , ] ) ; } | Handle file concatenation . |
6,680 | protected function handlePatch ( ) : HttpResponse { $ uploadKey = $ this -> request -> key ( ) ; if ( ! $ meta = $ this -> cache -> get ( $ uploadKey ) ) { return $ this -> response -> send ( null , HttpResponse :: HTTP_GONE ) ; } $ status = $ this -> verifyPatchRequest ( $ meta ) ; if ( HttpResponse :: HTTP_OK !== $ status ) { return $ this -> response -> send ( null , $ status ) ; } $ file = $ this -> buildFile ( $ meta ) ; $ checksum = $ meta [ 'checksum' ] ; try { $ fileSize = $ file -> getFileSize ( ) ; $ offset = $ file -> setKey ( $ uploadKey ) -> setChecksum ( $ checksum ) -> upload ( $ fileSize ) ; if ( $ offset === $ fileSize ) { if ( ! $ this -> verifyChecksum ( $ checksum , $ meta [ 'file_path' ] ) ) { return $ this -> response -> send ( null , self :: HTTP_CHECKSUM_MISMATCH ) ; } $ this -> event ( ) -> dispatch ( UploadComplete :: NAME , new UploadComplete ( $ file , $ this -> getRequest ( ) , $ this -> getResponse ( ) ) ) ; } else { $ this -> event ( ) -> dispatch ( UploadProgress :: NAME , new UploadProgress ( $ file , $ this -> getRequest ( ) , $ this -> getResponse ( ) ) ) ; } } catch ( FileException $ e ) { return $ this -> response -> send ( $ e -> getMessage ( ) , HttpResponse :: HTTP_UNPROCESSABLE_ENTITY ) ; } catch ( OutOfRangeException $ e ) { return $ this -> response -> send ( null , HttpResponse :: HTTP_REQUESTED_RANGE_NOT_SATISFIABLE ) ; } catch ( ConnectionException $ e ) { return $ this -> response -> send ( null , HttpResponse :: HTTP_CONTINUE ) ; } return $ this -> response -> send ( null , HttpResponse :: HTTP_NO_CONTENT , [ 'Content-Type' => self :: HEADER_CONTENT_TYPE , 'Upload-Expires' => $ this -> cache -> get ( $ uploadKey ) [ 'expires_at' ] , 'Upload-Offset' => $ offset , ] ) ; } | Handle PATCH request . |
6,681 | protected function verifyPatchRequest ( array $ meta ) : int { if ( self :: UPLOAD_TYPE_FINAL === $ meta [ 'upload_type' ] ) { return HttpResponse :: HTTP_FORBIDDEN ; } $ uploadOffset = $ this -> request -> header ( 'upload-offset' ) ; if ( $ uploadOffset && $ uploadOffset !== ( string ) $ meta [ 'offset' ] ) { return HttpResponse :: HTTP_CONFLICT ; } $ contentType = $ this -> request -> header ( 'Content-Type' ) ; if ( $ contentType !== self :: HEADER_CONTENT_TYPE ) { return HTTPRESPONSE :: HTTP_UNSUPPORTED_MEDIA_TYPE ; } return HttpResponse :: HTTP_OK ; } | Verify PATCH request . |
6,682 | protected function handleDownload ( ) { $ path = explode ( '/' , str_replace ( '/get' , '' , $ this -> request -> path ( ) ) ) ; $ key = end ( $ path ) ; if ( ! $ fileMeta = $ this -> cache -> get ( $ key ) ) { return $ this -> response -> send ( '404 upload not found.' , HttpResponse :: HTTP_NOT_FOUND ) ; } $ resource = $ fileMeta [ 'file_path' ] ?? null ; $ fileName = $ fileMeta [ 'name' ] ?? null ; if ( ! $ resource || ! file_exists ( $ resource ) ) { return $ this -> response -> send ( '404 upload not found.' , HttpResponse :: HTTP_NOT_FOUND ) ; } return $ this -> response -> download ( $ resource , $ fileName ) ; } | Handle Download request . |
6,683 | protected function handleDelete ( ) : HttpResponse { $ key = $ this -> request -> key ( ) ; $ fileMeta = $ this -> cache -> get ( $ key ) ; $ resource = $ fileMeta [ 'file_path' ] ?? null ; if ( ! $ resource ) { return $ this -> response -> send ( null , HttpResponse :: HTTP_NOT_FOUND ) ; } $ isDeleted = $ this -> cache -> delete ( $ key ) ; if ( ! $ isDeleted || ! file_exists ( $ resource ) ) { return $ this -> response -> send ( null , HttpResponse :: HTTP_GONE ) ; } unlink ( $ resource ) ; return $ this -> response -> send ( null , HttpResponse :: HTTP_NO_CONTENT , [ 'Tus-Extension' => self :: TUS_EXTENSION_TERMINATION , ] ) ; } | Handle DELETE request . |
6,684 | protected function getHeadersForHeadRequest ( array $ fileMeta ) : array { $ headers = [ 'Upload-Length' => ( int ) $ fileMeta [ 'size' ] , 'Upload-Offset' => ( int ) $ fileMeta [ 'offset' ] , 'Cache-Control' => 'no-store' , ] ; if ( self :: UPLOAD_TYPE_FINAL === $ fileMeta [ 'upload_type' ] && $ fileMeta [ 'size' ] !== $ fileMeta [ 'offset' ] ) { unset ( $ headers [ 'Upload-Offset' ] ) ; } if ( self :: UPLOAD_TYPE_NORMAL !== $ fileMeta [ 'upload_type' ] ) { $ headers += [ 'Upload-Concat' => $ fileMeta [ 'upload_type' ] ] ; } return $ headers ; } | Get required headers for head request . |
6,685 | protected function buildFile ( array $ meta ) : File { $ file = new File ( $ meta [ 'name' ] , $ this -> cache ) ; if ( array_key_exists ( 'offset' , $ meta ) ) { $ file -> setMeta ( $ meta [ 'offset' ] , $ meta [ 'size' ] , $ meta [ 'file_path' ] , $ meta [ 'location' ] ) ; } return $ file ; } | Build file object . |
6,686 | protected function getSupportedHashAlgorithms ( ) : string { $ supportedAlgorithms = hash_algos ( ) ; $ algorithms = [ ] ; foreach ( $ supportedAlgorithms as $ hashAlgo ) { if ( false !== strpos ( $ hashAlgo , ',' ) ) { $ algorithms [ ] = "'{$hashAlgo}'" ; } else { $ algorithms [ ] = $ hashAlgo ; } } return implode ( ',' , $ algorithms ) ; } | Get list of supported hash algorithms . |
6,687 | protected function getClientChecksum ( ) { $ checksumHeader = $ this -> getRequest ( ) -> header ( 'Upload-Checksum' ) ; if ( empty ( $ checksumHeader ) ) { return '' ; } list ( $ checksumAlgorithm , $ checksum ) = explode ( ' ' , $ checksumHeader ) ; $ checksum = base64_decode ( $ checksum ) ; if ( ! in_array ( $ checksumAlgorithm , hash_algos ( ) ) || false === $ checksum ) { return $ this -> response -> send ( null , HttpResponse :: HTTP_BAD_REQUEST ) ; } return $ checksum ; } | Verify and get upload checksum from header . |
6,688 | protected function isExpired ( $ contents ) : bool { $ isExpired = empty ( $ contents [ 'expires_at' ] ) || Carbon :: parse ( $ contents [ 'expires_at' ] ) -> lt ( Carbon :: now ( ) ) ; if ( $ isExpired && $ contents [ 'offset' ] !== $ contents [ 'size' ] ) { return true ; } return false ; } | Get expired but incomplete uploads . |
6,689 | protected function getPathForPartialUpload ( string $ key ) : string { list ( $ actualKey , ) = explode ( self :: PARTIAL_UPLOAD_NAME_SEPARATOR , $ key ) ; $ path = $ this -> uploadDir . DIRECTORY_SEPARATOR . $ actualKey . DIRECTORY_SEPARATOR ; if ( ! file_exists ( $ path ) ) { mkdir ( $ path ) ; } return $ path ; } | Get path for partial upload . |
6,690 | protected function getPartialsMeta ( array $ partials ) : array { $ files = [ ] ; foreach ( $ partials as $ partial ) { $ fileMeta = $ this -> getCache ( ) -> get ( $ partial ) ; $ files [ ] = $ fileMeta ; } return $ files ; } | Get metadata of partials . |
6,691 | public function handleExpiration ( ) : array { $ deleted = [ ] ; $ cacheKeys = $ this -> cache -> keys ( ) ; foreach ( $ cacheKeys as $ key ) { $ fileMeta = $ this -> cache -> get ( $ key , true ) ; if ( ! $ this -> isExpired ( $ fileMeta ) ) { continue ; } if ( ! $ this -> cache -> delete ( $ key ) ) { continue ; } if ( is_writable ( $ fileMeta [ 'file_path' ] ) ) { unlink ( $ fileMeta [ 'file_path' ] ) ; } $ deleted [ ] = $ fileMeta ; } return $ deleted ; } | Delete expired resources . |
6,692 | protected function verifyUploadSize ( ) : bool { $ maxUploadSize = $ this -> getMaxUploadSize ( ) ; if ( $ maxUploadSize > 0 && $ this -> getRequest ( ) -> header ( 'Upload-Length' ) > $ maxUploadSize ) { return false ; } return true ; } | Verify max upload size . |
6,693 | protected function verifyChecksum ( string $ checksum , string $ filePath ) : bool { if ( empty ( $ checksum ) ) { return true ; } return $ checksum === $ this -> getServerChecksum ( $ filePath ) ; } | Verify checksum if available . |
6,694 | public static function set ( $ config = null , bool $ force = false ) { if ( ! $ force && ! empty ( self :: $ config ) ) { return ; } if ( is_array ( $ config ) ) { self :: $ config = $ config ; } else { self :: $ config = require $ config ?? self :: DEFAULT_CONFIG_PATH ; } } | Load default application configs . |
6,695 | public static function get ( string $ key = null ) { self :: set ( ) ; if ( empty ( $ key ) ) { return self :: $ config ; } $ keys = explode ( '.' , $ key ) ; $ value = self :: $ config ; foreach ( $ keys as $ key ) { if ( ! isset ( $ value [ $ key ] ) ) { return null ; } $ value = $ value [ $ key ] ; } return $ value ; } | Get config . |
6,696 | protected function stripComments ( ) { $ minifier = $ this ; $ callback = function ( $ match ) use ( $ minifier ) { $ count = count ( $ minifier -> extracted ) ; $ placeholder = '/*' . $ count . '*/' ; $ minifier -> extracted [ $ placeholder ] = $ match [ 0 ] ; return $ placeholder ; } ; $ this -> registerPattern ( '/\n?\/\*(!|.*?@license|.*?@preserve).*?\*\/\n?/s' , $ callback ) ; $ this -> registerPattern ( '/\/\*.*?\*\//s' , '' ) ; $ this -> registerPattern ( '/\/\/.*$/m' , '' ) ; } | Strip comments from source code . |
6,697 | protected function canImportFile ( $ path ) { $ parsed = parse_url ( $ path ) ; if ( isset ( $ parsed [ 'host' ] ) || isset ( $ parsed [ 'query' ] ) ) { return false ; } return strlen ( $ path ) < PHP_MAXPATHLEN && @ is_file ( $ path ) && is_readable ( $ path ) ; } | Check if the path is a regular file and can be read . |
6,698 | public function makeClassName ( ) { $ parts = array_map ( 'studly_case' , explode ( '\\' , $ this -> argument ( 'name' ) ) ) ; $ className = array_pop ( $ parts ) ; $ ns = count ( $ parts ) > 0 ? implode ( '\\' , $ parts ) . '\\' : '' ; $ fqClass = config ( 'eloquentfilter.namespace' , 'App\\ModelFilters\\' ) . $ ns . $ className ; if ( substr ( $ fqClass , - 6 , 6 ) !== 'Filter' ) { $ fqClass .= 'Filter' ; } if ( class_exists ( $ fqClass ) ) { $ this -> error ( "\n\n\t$fqClass Already Exists!\n" ) ; die ; } $ this -> setClassName ( $ fqClass ) ; return $ this ; } | Create Filter Class Name . |
6,699 | public function removeEmptyInput ( $ input ) { $ filterableInput = [ ] ; foreach ( $ input as $ key => $ val ) { if ( $ val !== '' && $ val !== null ) { $ filterableInput [ $ key ] = $ val ; } } return $ filterableInput ; } | Remove empty strings from the input array . |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.