1: <?php
  2: 
  3: /*
  4:   
  5:  *
  6:  * NOTICE OF LICENSE
  7:  *
  8:  * This source file is subject to the Open Software License (OSL 3.0)
  9:  * or OpenGPL v3 license (GNU Public License V3.0)
 10:  * that is bundled with this package in the file LICENSE.txt.
 11:  * It is also available through the world-wide-web at this URL:
 12:  * http://opensource.org/licenses/osl-3.0.php
 13:  * or
 14:  * http://www.gnu.org/licenses/gpl-3.0.txt
 15:  * If you did not receive a copy of the license and are unable to
 16:  * obtain it through the world-wide-web, please send an email
 17:  * to info@e-abi.ee so we can send you a copy immediately.
 18:  *
 19:  * DISCLAIMER
 20:  *
 21:  * Do not edit or add to this file if you wish to upgrade this module to newer
 22:  * versions in the future.
 23:  *
 24:  * @category   Eabi
 25:  * @package    Eabi_Dpd
 26:  * @copyright  Copyright (c) 2014 Aktsiamaailm LLC (http://en.e-abi.ee/)
 27:  * @license    http://opensource.org/licenses/osl-3.0.php  Open Software License (OSL 3.0)
 28:  * @license    http://www.gnu.org/licenses/gpl-3.0.txt  GNU Public License V3.0
 29:  * @author     Matis Halmann
 30:  * 
 31: 
 32:  */
 33: 
 34: /**
 35:  * <p>Replaces Varien_Directory_Collection for PHP5.3+ compatibility</p>
 36:  *
 37:  * @author Matis
 38:  */
 39: class Eabi_Livehandler_Model_Directory_Collection implements IteratorAggregate, Countable {
 40:     protected $_path='';
 41:     protected $_dirName='';
 42:     protected $_recursionLevel=0;
 43:     protected $_isRecursion;
 44:     protected $_filters = array();
 45:     
 46:     /**
 47:      * Constructor
 48:      *
 49:      * @param   string $path - path to directory
 50:      * @param   bool $is_recursion - use or not recursion
 51:      * @return  none
 52:      */
 53:     public function __construct($path,$isRecursion=true,$recursionLevel = 0) {
 54:         $this->setPath($path);
 55:         $this->_dirName = $this->lastDir();
 56:         $this->setRecursion($isRecursion);
 57:         $this->setRecursionLevel($recursionLevel);
 58:         if($this->getRecursion() || $this->getRecursionLevel()==0){
 59:             $this->parseDir();
 60:         }
 61:     }
 62:     /**
 63:      * Get name of this directory
 64:      *
 65:      * @return  string - name of this directory
 66:      */
 67:     public function getDirName() {
 68:         return $this->_dirName;
 69:     }
 70:     /**
 71:      * Get recursion
 72:      *
 73:      * @return  bool - is or not recursion
 74:      */
 75:     public function getRecursion() {
 76:         return $this->_isRecursion;
 77:     }
 78:     /**
 79:      * Get recursion level
 80:      *
 81:      * @return  int - recursion level
 82:      */
 83:     public function getRecursionLevel() {
 84:         return $this->_recursionLevel;
 85:     }
 86:     /**
 87:      * Get path
 88:      *
 89:      * @return  string - path to this directory
 90:      */
 91:     public function getPath() {
 92:         return $this->_path;
 93:     }
 94:     /**
 95:      * Set path to this directory
 96:      * @param   string $path - path to this directory
 97:      * @param   bool $isRecursion - use or not recursion
 98:      * @return  none
 99:      */
100:     public function setPath($path, $isRecursion='') {
101:         if(is_dir($path)){
102:             if(isset($this->_path) && $this->_path!=$path && $this->_path!=''){
103:                 $this->_path = $path;
104:                 if($isRecursion!='')$this->_isRecursion = $isRecursion;
105:                 $this->parseDir();
106:             } else {
107:                 $this->_path = $path;
108:             }
109:         } else {
110:             throw new Exception($path. 'is not dir.');
111:         }
112:     }
113:     /**
114:      * Set recursion
115:      *
116:      * @param   bool $isRecursion - use or not recursion
117:      * @return  none
118:      */
119:     public function setRecursion($isRecursion) {
120:         $this->_isRecursion = $isRecursion;
121:     }
122:     /**
123:      * Set level of recursion
124:      *
125:      * @param   int $recursionLevel - level of recursion
126:      * @return  none
127:      */
128:     public function setRecursionLevel($recursionLevel) {
129:         $this->_recursionLevel = $recursionLevel;
130:     }
131:     /**
132:      * get latest dir in the path
133:      *
134:      * @param   string $path - path to directory
135:      * @return  string - latest dir in the path
136:      */
137:     public function lastDir() {
138:         return self::getLastDir($this->getPath());
139:     }
140:     /**
141:      * get latest dir in the path
142:      *
143:      * @param   string $path - path to directory
144:      * @return  string - latest dir in the path
145:      */
146:     static public function getLastDir($path) {
147:         if($path=='') $path = $this->getPath();
148:         $last = strrpos($path, "/");
149:         return substr($path,$last+1);
150:     }
151:     /**
152:      * add item to collection
153:      *
154:      * @param   IFactory $item - item of collection
155:      * @return  none
156:      */
157:     public function addItem($item) {
158:         $this->_items[] = $item;
159:     }
160:     /**
161:      * parse this directory
162:      *
163:      * @return  none
164:      */
165:     protected function parseDir() {
166:         $this->clear();
167:         $iter = new RecursiveDirectoryIterator($this->getPath());
168:         while ($iter->valid()) {
169:             $curr = (string)$iter->getSubPathname();
170:             if (!$iter->isDot() && $curr[0]!='.'){
171:                 $this->addItem(self::getFactory($iter->current(),$this->getRecursion(),$this->getRecursionLevel()));
172:             }
173:             $iter->next();
174:         }
175:     }
176:     
177:     static public function getFactory($path,$is_recursion = true,$recurse_level=0) {
178:         if(is_dir($path)){
179:             $obj = new Eabi_Livehandler_Model_Directory_Collection($path,$is_recursion,$recurse_level+1);
180:             return $obj;
181:         } else {
182:             return new Eabi_Livehandler_Model_File_Object($path);
183:         }
184:     }
185:     
186:     
187:     /**
188:      * set filter using
189:      *
190:      * @param   bool $useFilter - filter using
191:      * @return  none
192:      */
193:     public function useFilter($useFilter) {
194:         $this->_renderFilters();
195:         $this->walk('useFilter', array($useFilter));
196:     }
197:     /**
198:      * get files names of current collection
199:      *
200:      * @return  array - files names of current collection
201:      */
202:     public function filesName() {
203:         $files = array();
204:         $this->getFilesName($files);
205:         return $files;
206: 
207:     }
208:     /**
209:      * get files names of current collection
210:      *
211:      * @param   array $files - array of files names
212:      * @return  none
213:      */
214:     public function getFilesName(&$files) {
215:         $this->walk('getFilesName', array(&$files));
216:     }
217:     /**
218:      * get files paths of current collection
219:      *
220:      * @return  array - files paths of current collection
221:      */
222:     public function filesPaths() {
223:         $paths = array();
224:         $this->getFilesPaths($paths);
225:         return $paths;
226:     }
227:     /**
228:      * get files paths of current collection
229:      *
230:      * @param   array $files - array of files paths
231:      * @return  none
232:      */
233:     public function getFilesPaths(&$paths) {
234:         $this->walk('getFilesPaths', array(&$paths));
235:     }
236:     /**
237:      * get SplFileObject objects of files of current collection
238:      *
239:      * @return  array - array of SplFileObject objects
240:      */
241:     public function filesObj() {
242:         $objs = array();
243:         $this->getFilesObj($objs);
244:         return $objs;
245:     }
246:     /**
247:      * get SplFileObject objects of files of current collection
248:      *
249:      * @param   array $objs - array of SplFileObject objects
250:      * @return  none
251:      */
252:     public function getFilesObj(&$objs) {
253:         $this->walk('getFilesObj', array(&$objs));
254:     }
255:     /**
256:      * get names of dirs of current collection
257:      *
258:      * @return  array - array of names of dirs
259:      */
260:     public function dirsName() {
261:         $dir = array();
262:         $this->getDirsName($dir);
263:         return $dir;
264:     }
265:     /**
266:      * get names of dirs of current collection
267:      *
268:      * @param   array $dirs - array of names of dirs
269:      * @return  none
270:      */
271:     public function getDirsName(&$dirs) {
272:         $this->walk('getDirsName', array(&$dirs));
273:         if($this->getRecursionLevel()>0)
274:         $dirs[] = $this->getDirName();
275:     }
276:     /**
277:      * set filters for files
278:      *
279:      * @param   array $filter - array of filters
280:      * @return  none
281:      */
282:     protected function setFilesFilter($filter) {
283:         $this->walk('setFilesFilter', array($filter));
284:     }
285:     /**
286:      * display this collection as array
287:      *
288:      * @return  array
289:      */
290:     public function __toArray() {
291:         $arr = array();
292:         $this->toArray($arr);
293:         return $arr;
294:     }
295:     /**
296:      * display this collection as array
297:      * @param   array &$arr - this collection array
298:      * @return  none
299:      */
300:     public function toArray($arrRequiredFields = array()) {
301:         return array();
302:     }
303:     /**
304:      * get this collection as xml
305:      * @param   bool $addOpenTag - add or not header of xml
306:      * @param   string $rootName - root element name
307:      * @return  none
308:      */
309:     public function __toXml($addOpenTag=true,$rootName='Struct') {
310:         $xml='';
311:         $this->toXml($xml,$addOpenTag,$rootName);
312:         return $xml;
313:     }
314:     /**
315:      * get this collection as xml
316:      * @param   string &$xml - xml
317:      * @param   bool $addOpenTag - add or not header of xml
318:      * @param   string $rootName - root element name
319:      * @return  none
320:      */
321:     public function toXml() {
322:         return '';
323:     }
324:     /**
325:      * apply filters
326:      * @return  none
327:      */
328:     protected function _renderFilters() {
329:         $exts = array();
330:         $names = array();
331:         $regName = array();
332:         foreach ($this->_filters as $filter){
333:             switch ($filter['field']){
334:                 case 'extension':
335:                     if(is_array($filter['value'])){
336:                         foreach ($filter['value'] as $value){
337:                             $exts[] = $value;
338:                         }
339:                     } else {
340:                         $exts[] = $filter['value'];
341:                     }
342:                     break;
343:                 case 'name':
344:                     if(is_array($filter['value'])){
345:                         foreach ($filter['value'] as $value){
346:                             $names[] = $filter['value'];
347:                         }
348:                     } else {
349:                         $names[] = $filter['value'];
350:                     }
351:                     break;
352:                 case 'regName':
353:                     if(is_array($filter['value'])){
354:                         foreach ($filter['value'] as $value){
355:                             $regName[] = $filter['value'];
356:                         }
357:                     } else {
358:                         $regName[] = $filter['value'];
359:                     }
360:                     break;
361:             }
362:         }
363:         $filter = array();
364:         if(count($exts)>0) {
365:             $filter['extension'] = $exts;
366:         } else {
367:             $filter['extension'] = null;
368:         }
369:         if(count($names)>0) {
370:             $filter['name']=$names;
371:         } else {
372:             $filter['name']=null;
373:         }
374:         if(count($regName)>0) {
375: 
376:             $filter['regName']=$regName;
377:         } else {
378:             $filter['regName']=null;
379:         }
380:         $this->setFilesFilter($filter);
381:     }
382:     /**
383:      * add filter
384:      * @return  none
385:      */
386:     public function addFilter($field, $value, $type = 'and') {
387:         $filter = array();
388:         $filter['field']   = $field;
389:         $filter['value']   = $value;
390:         $this->_filters[] = $filter;
391:         $this->_isFiltersRendered = false;
392:         $this->walk('addFilter',array($field, $value));
393:         return $this;
394:     }
395: 
396:     public function count() {
397:         $this->load();
398:         return count($this->_items);
399:         
400:     }
401: 
402:     public function getIterator() {
403:         $this->load();
404:         return new ArrayIterator($this->_items);
405:         
406:     }
407:     /**
408:      * Load data
409:      *
410:      * @return  Varien_Data_Collection
411:      */
412:     public function loadData($printQuery = false, $logQuery = false) {
413:         return $this;
414:     }
415: 
416:     /**
417:      * Load data
418:      *
419:      * @return  Varien_Data_Collection
420:      */
421:     public function load($printQuery = false, $logQuery = false) {
422:         return $this->loadData($printQuery, $logQuery);
423:     }
424:     /**
425:      * Clear collection
426:      *
427:      * @return Varien_Data_Collection
428:      */
429:     public function clear() {
430:         $this->_setIsLoaded(false);
431:         $this->_items = array();
432:         return $this;
433:     }
434:     /**
435:      * Retrieve collection loading status
436:      *
437:      * @return bool
438:      */
439:     public function isLoaded() {
440:         return $this->_isCollectionLoaded;
441:     }
442: 
443:     /**
444:      * Set collection loading status flag
445:      *
446:      * @param unknown_type $flag
447:      * @return unknown
448:      */
449:     protected function _setIsLoaded($flag = true) {
450:         $this->_isCollectionLoaded = $flag;
451:         return $this;
452:     }
453:     /**
454:      * Walk through the collection and run model method or external callback
455:      * with optional arguments
456:      *
457:      * Returns array with results of callback for each item
458:      *
459:      * @param string $method
460:      * @param array $args
461:      * @return array
462:      */
463:     public function walk($callback, array $args=array()) {
464:         $results = array();
465:         $useItemCallback = is_string($callback) && strpos($callback, '::')===false;
466:         foreach ($this->getItems() as $id=>$item) {
467:             if ($useItemCallback) {
468:                 $cb = array($item, $callback);
469:             } else {
470:                 $cb = $callback;
471:                 array_unshift($args, $item);
472:             }
473:             $results[$id] = call_user_func_array($cb, $args);
474:         }
475:         return $results;
476:     }
477:     
478:     /**
479:      * Retrieve collection items
480:      *
481:      * @return array
482:      */
483:     public function getItems() {
484:         $this->load();
485:         return $this->_items;
486:     }
487:     
488: 
489:     
490: }
491: 
492: