@@ -22,224 +22,224 @@  | 
                                                    ||
| 22 | 22 | * @author Mark Prins  | 
                                                        
| 23 | 23 | */  | 
                                                        
| 24 | 24 |  class helper_plugin_spatialhelper_sitemap extends DokuWiki_Plugin { | 
                                                        
| 25 | - /**  | 
                                                        |
| 26 | - * spatial index.  | 
                                                        |
| 27 | - */  | 
                                                        |
| 28 | - private $spatial_idx;  | 
                                                        |
| 29 | -  | 
                                                        |
| 30 | - /**  | 
                                                        |
| 31 | - * constructor, load spatial index.  | 
                                                        |
| 32 | - */  | 
                                                        |
| 33 | -    public function __construct() { | 
                                                        |
| 34 | - global $conf;  | 
                                                        |
| 35 | - $idx_dir = $conf['indexdir'];  | 
                                                        |
| 36 | -        if(!@file_exists($idx_dir . '/spatial.idx')) { | 
                                                        |
| 37 | -            $indexer = plugin_load('helper', 'spatialhelper_index'); | 
                                                        |
| 38 | -            if($indexer !== null) { | 
                                                        |
| 39 | - $indexer->generateSpatialIndex();  | 
                                                        |
| 40 | - }  | 
                                                        |
| 41 | - }  | 
                                                        |
| 42 | - $this->spatial_idx = unserialize(  | 
                                                        |
| 43 | - io_readFile($fn = $idx_dir . '/spatial.idx', false),  | 
                                                        |
| 44 | - ['allowed_classes' => false]  | 
                                                        |
| 45 | - );  | 
                                                        |
| 46 | - }  | 
                                                        |
| 47 | -  | 
                                                        |
| 48 | -    final public function getMethods(): array { | 
                                                        |
| 49 | - $result[] = array(  | 
                                                        |
| 50 | - 'name' => 'createGeoRSSSitemap',  | 
                                                        |
| 51 | - 'desc' => 'create a spatial sitemap in GeoRSS format.',  | 
                                                        |
| 52 | - 'params' => array(  | 
                                                        |
| 53 | - 'path' => 'string'  | 
                                                        |
| 54 | - ),  | 
                                                        |
| 55 | - 'return' => array(  | 
                                                        |
| 56 | - 'success' => 'boolean'  | 
                                                        |
| 57 | - )  | 
                                                        |
| 58 | - );  | 
                                                        |
| 59 | - $result[] = array(  | 
                                                        |
| 60 | - 'name' => 'createKMLSitemap',  | 
                                                        |
| 61 | - 'desc' => 'create a spatial sitemap in KML format.',  | 
                                                        |
| 62 | - 'params' => array(  | 
                                                        |
| 63 | - 'path' => 'string'  | 
                                                        |
| 64 | - ),  | 
                                                        |
| 65 | - 'return' => array(  | 
                                                        |
| 66 | - 'success' => 'boolean'  | 
                                                        |
| 67 | - )  | 
                                                        |
| 68 | - );  | 
                                                        |
| 69 | - return $result;  | 
                                                        |
| 70 | - }  | 
                                                        |
| 71 | -  | 
                                                        |
| 72 | - /**  | 
                                                        |
| 73 | - * Create a GeoRSS Simple sitemap (Atom).  | 
                                                        |
| 74 | - *  | 
                                                        |
| 75 | - * @param string $mediaID id  | 
                                                        |
| 76 | - * for the GeoRSS file  | 
                                                        |
| 77 | - */  | 
                                                        |
| 78 | -    final public function createGeoRSSSitemap(string $mediaID): bool { | 
                                                        |
| 79 | - global $conf;  | 
                                                        |
| 80 | - $namespace = getNS($mediaID);  | 
                                                        |
| 81 | -  | 
                                                        |
| 82 | - $idTag = 'tag:' . parse_url(DOKU_URL, PHP_URL_HOST) . ',';  | 
                                                        |
| 83 | -  | 
                                                        |
| 84 | - $RSSstart = '<?xml version="1.0" encoding="UTF-8"?>' . DOKU_LF;  | 
                                                        |
| 85 | - $RSSstart .= '<feed xmlns="http://www.w3.org/2005/Atom" xmlns:georss="http://www.georss.org/georss" ';  | 
                                                        |
| 86 | - $RSSstart .= 'xmlns:dc="http://purl.org/dc/elements/1.1/">' . DOKU_LF;  | 
                                                        |
| 87 | - $RSSstart .= '<title>' . $conf['title'] . ' spatial feed</title>' . DOKU_LF;  | 
                                                        |
| 88 | -        if(!empty($conf['tagline'])) { | 
                                                        |
| 89 | - $RSSstart .= '<subtitle>' . $conf['tagline'] . '</subtitle>' . DOKU_LF;  | 
                                                        |
| 90 | - }  | 
                                                        |
| 91 | - $RSSstart .= '<dc:publisher>' . $conf['title'] . '</dc:publisher>' . DOKU_LF;  | 
                                                        |
| 92 | - $RSSstart .= '<link href="' . DOKU_URL . '" />' . DOKU_LF;  | 
                                                        |
| 93 | - $RSSstart .= '<link href="' . ml($mediaID, '', true, '&', true) . '" rel="self" />' . DOKU_LF;  | 
                                                        |
| 94 | - $RSSstart .= '<updated>' . date(DATE_ATOM) . '</updated>' . DOKU_LF;  | 
                                                        |
| 95 | -        $RSSstart .= '<id>' . $idTag . date("Y-m-d") . ':' . parse_url(ml($mediaID), PHP_URL_PATH) | 
                                                        |
| 96 | - . '</id>' . DOKU_LF;  | 
                                                        |
| 97 | - $RSSstart .= '<rights>' . $conf['license'] . '</rights>' . DOKU_LF;  | 
                                                        |
| 98 | -  | 
                                                        |
| 99 | - $RSSend = '</feed>' . DOKU_LF;  | 
                                                        |
| 100 | -  | 
                                                        |
| 101 | - io_createNamespace($mediaID, 'media');  | 
                                                        |
| 102 | - @touch(mediaFN($mediaID));  | 
                                                        |
| 103 | - @chmod(mediaFN($mediaID), $conf['fmode']);  | 
                                                        |
| 104 | - $fh = fopen(mediaFN($mediaID), 'wb');  | 
                                                        |
| 105 | - fwrite($fh, $RSSstart);  | 
                                                        |
| 106 | -  | 
                                                        |
| 107 | -        foreach($this->spatial_idx as $idxEntry) { | 
                                                        |
| 108 | - // get list of id's  | 
                                                        |
| 109 | -            foreach($idxEntry as $id) { | 
                                                        |
| 110 | - // for document item in the index  | 
                                                        |
| 111 | -                if(strpos($id, 'media__', 0) !== 0) { | 
                                                        |
| 112 | -                    if($this->skipPage($id, $namespace)) { | 
                                                        |
| 113 | - continue;  | 
                                                        |
| 114 | - }  | 
                                                        |
| 115 | -  | 
                                                        |
| 116 | - $meta = p_get_metadata($id);  | 
                                                        |
| 117 | -  | 
                                                        |
| 118 | -                    // $desc = p_render('xhtmlsummary', p_get_instructions($meta['description']['abstract']), $info); | 
                                                        |
| 119 | - $desc = strip_tags($meta['description']['abstract']);  | 
                                                        |
| 120 | -  | 
                                                        |
| 121 | - $entry = '<entry>' . DOKU_LF;  | 
                                                        |
| 122 | - $entry .= ' <title>' . $meta['title'] . '</title>' . DOKU_LF;  | 
                                                        |
| 123 | - $entry .= ' <summary>' . $desc . '</summary>' . DOKU_LF;  | 
                                                        |
| 124 | - $entry .= ' <georss:point>' . $meta['geo']['lat'] . ' ' . $meta['geo']['lon']  | 
                                                        |
| 125 | - . '</georss:point>' . DOKU_LF;  | 
                                                        |
| 126 | -                    if(isset($meta['geo']['alt'])) { | 
                                                        |
| 127 | - $entry .= ' <georss:elev>' . $meta['geo']['alt'] . '</georss:elev>' . DOKU_LF;  | 
                                                        |
| 128 | - }  | 
                                                        |
| 129 | - $entry .= ' <link href="' . wl($id) . '" rel="alternate" type="text/html" />' . DOKU_LF;  | 
                                                        |
| 130 | -                    if(empty($meta['creator'])) { | 
                                                        |
| 131 | - $meta['creator'] = $conf['title'];  | 
                                                        |
| 132 | - }  | 
                                                        |
| 133 | - $entry .= ' <author><name>' . $meta['creator'] . '</name></author>' . DOKU_LF;  | 
                                                        |
| 134 | - $entry .= ' <updated>' . date_iso8601($meta['date']['modified']) . '</updated>' . DOKU_LF;  | 
                                                        |
| 135 | - $entry .= ' <published>' . date_iso8601($meta['date']['created']) . '</published>' . DOKU_LF;  | 
                                                        |
| 136 | -                    $entry .= '  <id>' . $idTag . date("Y-m-d", $meta['date']['modified']) . ':' | 
                                                        |
| 137 | - . parse_url(wl($id), PHP_URL_PATH) . '</id>' . DOKU_LF;  | 
                                                        |
| 138 | - $entry .= '</entry>' . DOKU_LF;  | 
                                                        |
| 139 | - fwrite($fh, $entry);  | 
                                                        |
| 140 | - }  | 
                                                        |
| 141 | - }  | 
                                                        |
| 142 | - }  | 
                                                        |
| 143 | -  | 
                                                        |
| 144 | - fwrite($fh, $RSSend);  | 
                                                        |
| 145 | - return fclose($fh);  | 
                                                        |
| 146 | - }  | 
                                                        |
| 147 | -  | 
                                                        |
| 148 | - /**  | 
                                                        |
| 149 | - * will return true for non-public or hidden pages or pages that are not below or in the namespace.  | 
                                                        |
| 150 | - */  | 
                                                        |
| 151 | -    private function skipPage(string $id, string $namespace): bool { | 
                                                        |
| 152 | -        dbglog("helper_plugin_spatialhelper_sitemap::skipPage, check for $id in $namespace"); | 
                                                        |
| 153 | -        if(isHiddenPage($id)) { | 
                                                        |
| 154 | - return true;  | 
                                                        |
| 155 | - }  | 
                                                        |
| 156 | -        if(auth_aclcheck($id, '', null) < AUTH_READ) { | 
                                                        |
| 157 | - return true;  | 
                                                        |
| 158 | - }  | 
                                                        |
| 159 | -  | 
                                                        |
| 160 | -        if(!empty($namespace)) { | 
                                                        |
| 161 | - // only if id is in or below namespace  | 
                                                        |
| 162 | -            if(0 !== strpos(getNS($id), $namespace)) { | 
                                                        |
| 163 | -                // dbglog("helper_plugin_spatialhelper_sitemap::skipPage, skipping $id, not in $namespace"); | 
                                                        |
| 164 | - return true;  | 
                                                        |
| 165 | - }  | 
                                                        |
| 166 | - }  | 
                                                        |
| 167 | - return false;  | 
                                                        |
| 168 | - }  | 
                                                        |
| 169 | -  | 
                                                        |
| 170 | - /**  | 
                                                        |
| 171 | - * Create a KML sitemap.  | 
                                                        |
| 172 | - *  | 
                                                        |
| 173 | - * @param string $mediaID id for the KML file  | 
                                                        |
| 174 | - */  | 
                                                        |
| 175 | -    final public function createKMLSitemap(string $mediaID): bool { | 
                                                        |
| 176 | - global $conf;  | 
                                                        |
| 177 | - $namespace = getNS($mediaID);  | 
                                                        |
| 178 | -  | 
                                                        |
| 179 | - $KMLstart = '<?xml version="1.0" encoding="UTF-8"?>' . DOKU_LF;  | 
                                                        |
| 180 | - $KMLstart .= '<kml xmlns="http://www.opengis.net/kml/2.2" ';  | 
                                                        |
| 181 | - $KMLstart .= 'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ';  | 
                                                        |
| 182 | - $KMLstart .= 'xmlns:atom="http://www.w3.org/2005/Atom"';  | 
                                                        |
| 183 | - $KMLstart .= ' xsi:schemaLocation="http://www.opengis.net/kml/2.2 ';  | 
                                                        |
| 184 | - $KMLstart .= 'http://schemas.opengis.net/kml/2.2.0/ogckml22.xsd">' . DOKU_LF;  | 
                                                        |
| 185 | - $KMLstart .= '<Document id="root_doc">' . DOKU_LF;  | 
                                                        |
| 186 | - $KMLstart .= '<name>' . $conf['title'] . ' spatial sitemap</name>' . DOKU_LF;  | 
                                                        |
| 187 | - $KMLstart .= '<atom:link href="' . DOKU_URL . '" rel="related" type="text/html" />' . DOKU_LF;  | 
                                                        |
| 188 | - $KMLstart .= '<!-- atom:updated>' . date(DATE_ATOM) . '</atom:updated -->' . DOKU_LF;  | 
                                                        |
| 189 | - $KMLstart .= '<Style id="icon"><IconStyle><color>ffffffff</color><scale>1</scale>';  | 
                                                        |
| 190 | - $KMLstart .= '<Icon><href>'  | 
                                                        |
| 191 | - . DOKU_BASE . 'lib/plugins/spatialhelper/wikiitem.png</href></Icon></IconStyle></Style>' . DOKU_LF;  | 
                                                        |
| 192 | -  | 
                                                        |
| 193 | - $KMLend = '</Document>' . DOKU_LF . '</kml>';  | 
                                                        |
| 194 | -  | 
                                                        |
| 195 | - io_createNamespace($mediaID, 'media');  | 
                                                        |
| 196 | - @touch(mediaFN($mediaID));  | 
                                                        |
| 197 | - @chmod(mediaFN($mediaID), $conf['fmode']);  | 
                                                        |
| 198 | -  | 
                                                        |
| 199 | - $fh = fopen(mediaFN($mediaID), 'wb');  | 
                                                        |
| 200 | - fwrite($fh, $KMLstart);  | 
                                                        |
| 201 | -  | 
                                                        |
| 202 | -        foreach($this->spatial_idx as $idxEntry) { | 
                                                        |
| 203 | - // get list of id's  | 
                                                        |
| 204 | -            foreach($idxEntry as $id) { | 
                                                        |
| 205 | - // for document item in the index  | 
                                                        |
| 206 | -                if(strpos($id, 'media__', 0) !== 0) { | 
                                                        |
| 207 | -                    if($this->skipPage($id, $namespace)) { | 
                                                        |
| 208 | - continue;  | 
                                                        |
| 209 | - }  | 
                                                        |
| 210 | -  | 
                                                        |
| 211 | - $meta = p_get_metadata($id);  | 
                                                        |
| 212 | -  | 
                                                        |
| 213 | -                    // $desc = p_render('xhtmlsummary', p_get_instructions($meta['description']['abstract']), $info); | 
                                                        |
| 214 | - $desc = '<p>' . strip_tags($meta['description']['abstract']) . '</p>';  | 
                                                        |
| 215 | - $desc .= '<p><a href="' . wl($id, '', true) . '">' . $meta['title'] . '</a></p>';  | 
                                                        |
| 216 | -  | 
                                                        |
| 217 | - // create an entry and store it  | 
                                                        |
| 218 | -                    $plcm = '<Placemark id="crc32-' . hash('crc32', $id) . '">' . DOKU_LF; | 
                                                        |
| 219 | - $plcm .= ' <name>' . $meta['title'] . '</name>' . DOKU_LF;  | 
                                                        |
| 220 | - // TODO escape quotes in: title="' . $meta['title'] . '"  | 
                                                        |
| 221 | - $plcm .= ' <atom:link href="' . wl($id, '' . true) . '" rel="alternate" type="text/html" />'  | 
                                                        |
| 222 | - . DOKU_LF;  | 
                                                        |
| 223 | -                    if(!empty($meta['creator'])) { | 
                                                        |
| 224 | - $plcm .= ' <atom:author><atom:name>' . $meta['creator'] . '</atom:name></atom:author>'  | 
                                                        |
| 225 | - . DOKU_LF;  | 
                                                        |
| 226 | - }  | 
                                                        |
| 227 | -  | 
                                                        |
| 228 | - $plcm .= ' <description><![CDATA[' . $desc . ']]></description>' . DOKU_LF;  | 
                                                        |
| 229 | - $plcm .= ' <styleUrl>#icon</styleUrl>' . DOKU_LF;  | 
                                                        |
| 230 | -  | 
                                                        |
| 231 | - $plcm .= ' <Point><coordinates>' . $meta['geo']['lon'] . ',' . $meta['geo']['lat'];  | 
                                                        |
| 232 | -                    if(isset($meta['geo']['alt'])) { | 
                                                        |
| 233 | - $plcm .= ',' . $meta['geo']['alt'];  | 
                                                        |
| 234 | - }  | 
                                                        |
| 235 | - $plcm .= '</coordinates></Point>' . DOKU_LF;  | 
                                                        |
| 236 | - $plcm .= '</Placemark>' . DOKU_LF;  | 
                                                        |
| 237 | -  | 
                                                        |
| 238 | - fwrite($fh, $plcm);  | 
                                                        |
| 239 | - }  | 
                                                        |
| 240 | - }  | 
                                                        |
| 241 | - }  | 
                                                        |
| 242 | - fwrite($fh, $KMLend);  | 
                                                        |
| 243 | - return fclose($fh);  | 
                                                        |
| 244 | - }  | 
                                                        |
| 25 | + /**  | 
                                                        |
| 26 | + * spatial index.  | 
                                                        |
| 27 | + */  | 
                                                        |
| 28 | + private $spatial_idx;  | 
                                                        |
| 29 | +  | 
                                                        |
| 30 | + /**  | 
                                                        |
| 31 | + * constructor, load spatial index.  | 
                                                        |
| 32 | + */  | 
                                                        |
| 33 | +	public function __construct() { | 
                                                        |
| 34 | + global $conf;  | 
                                                        |
| 35 | + $idx_dir = $conf['indexdir'];  | 
                                                        |
| 36 | +		if(!@file_exists($idx_dir . '/spatial.idx')) { | 
                                                        |
| 37 | +			$indexer = plugin_load('helper', 'spatialhelper_index'); | 
                                                        |
| 38 | +			if($indexer !== null) { | 
                                                        |
| 39 | + $indexer->generateSpatialIndex();  | 
                                                        |
| 40 | + }  | 
                                                        |
| 41 | + }  | 
                                                        |
| 42 | + $this->spatial_idx = unserialize(  | 
                                                        |
| 43 | + io_readFile($fn = $idx_dir . '/spatial.idx', false),  | 
                                                        |
| 44 | + ['allowed_classes' => false]  | 
                                                        |
| 45 | + );  | 
                                                        |
| 46 | + }  | 
                                                        |
| 47 | +  | 
                                                        |
| 48 | +	final public function getMethods(): array { | 
                                                        |
| 49 | + $result[] = array(  | 
                                                        |
| 50 | + 'name' => 'createGeoRSSSitemap',  | 
                                                        |
| 51 | + 'desc' => 'create a spatial sitemap in GeoRSS format.',  | 
                                                        |
| 52 | + 'params' => array(  | 
                                                        |
| 53 | + 'path' => 'string'  | 
                                                        |
| 54 | + ),  | 
                                                        |
| 55 | + 'return' => array(  | 
                                                        |
| 56 | + 'success' => 'boolean'  | 
                                                        |
| 57 | + )  | 
                                                        |
| 58 | + );  | 
                                                        |
| 59 | + $result[] = array(  | 
                                                        |
| 60 | + 'name' => 'createKMLSitemap',  | 
                                                        |
| 61 | + 'desc' => 'create a spatial sitemap in KML format.',  | 
                                                        |
| 62 | + 'params' => array(  | 
                                                        |
| 63 | + 'path' => 'string'  | 
                                                        |
| 64 | + ),  | 
                                                        |
| 65 | + 'return' => array(  | 
                                                        |
| 66 | + 'success' => 'boolean'  | 
                                                        |
| 67 | + )  | 
                                                        |
| 68 | + );  | 
                                                        |
| 69 | + return $result;  | 
                                                        |
| 70 | + }  | 
                                                        |
| 71 | +  | 
                                                        |
| 72 | + /**  | 
                                                        |
| 73 | + * Create a GeoRSS Simple sitemap (Atom).  | 
                                                        |
| 74 | + *  | 
                                                        |
| 75 | + * @param string $mediaID id  | 
                                                        |
| 76 | + * for the GeoRSS file  | 
                                                        |
| 77 | + */  | 
                                                        |
| 78 | +	final public function createGeoRSSSitemap(string $mediaID): bool { | 
                                                        |
| 79 | + global $conf;  | 
                                                        |
| 80 | + $namespace = getNS($mediaID);  | 
                                                        |
| 81 | +  | 
                                                        |
| 82 | + $idTag = 'tag:' . parse_url(DOKU_URL, PHP_URL_HOST) . ',';  | 
                                                        |
| 83 | +  | 
                                                        |
| 84 | + $RSSstart = '<?xml version="1.0" encoding="UTF-8"?>' . DOKU_LF;  | 
                                                        |
| 85 | + $RSSstart .= '<feed xmlns="http://www.w3.org/2005/Atom" xmlns:georss="http://www.georss.org/georss" ';  | 
                                                        |
| 86 | + $RSSstart .= 'xmlns:dc="http://purl.org/dc/elements/1.1/">' . DOKU_LF;  | 
                                                        |
| 87 | + $RSSstart .= '<title>' . $conf['title'] . ' spatial feed</title>' . DOKU_LF;  | 
                                                        |
| 88 | +		if(!empty($conf['tagline'])) { | 
                                                        |
| 89 | + $RSSstart .= '<subtitle>' . $conf['tagline'] . '</subtitle>' . DOKU_LF;  | 
                                                        |
| 90 | + }  | 
                                                        |
| 91 | + $RSSstart .= '<dc:publisher>' . $conf['title'] . '</dc:publisher>' . DOKU_LF;  | 
                                                        |
| 92 | + $RSSstart .= '<link href="' . DOKU_URL . '" />' . DOKU_LF;  | 
                                                        |
| 93 | + $RSSstart .= '<link href="' . ml($mediaID, '', true, '&', true) . '" rel="self" />' . DOKU_LF;  | 
                                                        |
| 94 | + $RSSstart .= '<updated>' . date(DATE_ATOM) . '</updated>' . DOKU_LF;  | 
                                                        |
| 95 | +		$RSSstart .= '<id>' . $idTag . date("Y-m-d") . ':' . parse_url(ml($mediaID), PHP_URL_PATH) | 
                                                        |
| 96 | + . '</id>' . DOKU_LF;  | 
                                                        |
| 97 | + $RSSstart .= '<rights>' . $conf['license'] . '</rights>' . DOKU_LF;  | 
                                                        |
| 98 | +  | 
                                                        |
| 99 | + $RSSend = '</feed>' . DOKU_LF;  | 
                                                        |
| 100 | +  | 
                                                        |
| 101 | + io_createNamespace($mediaID, 'media');  | 
                                                        |
| 102 | + @touch(mediaFN($mediaID));  | 
                                                        |
| 103 | + @chmod(mediaFN($mediaID), $conf['fmode']);  | 
                                                        |
| 104 | + $fh = fopen(mediaFN($mediaID), 'wb');  | 
                                                        |
| 105 | + fwrite($fh, $RSSstart);  | 
                                                        |
| 106 | +  | 
                                                        |
| 107 | +		foreach($this->spatial_idx as $idxEntry) { | 
                                                        |
| 108 | + // get list of id's  | 
                                                        |
| 109 | +			foreach($idxEntry as $id) { | 
                                                        |
| 110 | + // for document item in the index  | 
                                                        |
| 111 | +				if(strpos($id, 'media__', 0) !== 0) { | 
                                                        |
| 112 | +					if($this->skipPage($id, $namespace)) { | 
                                                        |
| 113 | + continue;  | 
                                                        |
| 114 | + }  | 
                                                        |
| 115 | +  | 
                                                        |
| 116 | + $meta = p_get_metadata($id);  | 
                                                        |
| 117 | +  | 
                                                        |
| 118 | +					// $desc = p_render('xhtmlsummary', p_get_instructions($meta['description']['abstract']), $info); | 
                                                        |
| 119 | + $desc = strip_tags($meta['description']['abstract']);  | 
                                                        |
| 120 | +  | 
                                                        |
| 121 | + $entry = '<entry>' . DOKU_LF;  | 
                                                        |
| 122 | + $entry .= ' <title>' . $meta['title'] . '</title>' . DOKU_LF;  | 
                                                        |
| 123 | + $entry .= ' <summary>' . $desc . '</summary>' . DOKU_LF;  | 
                                                        |
| 124 | + $entry .= ' <georss:point>' . $meta['geo']['lat'] . ' ' . $meta['geo']['lon']  | 
                                                        |
| 125 | + . '</georss:point>' . DOKU_LF;  | 
                                                        |
| 126 | +					if(isset($meta['geo']['alt'])) { | 
                                                        |
| 127 | + $entry .= ' <georss:elev>' . $meta['geo']['alt'] . '</georss:elev>' . DOKU_LF;  | 
                                                        |
| 128 | + }  | 
                                                        |
| 129 | + $entry .= ' <link href="' . wl($id) . '" rel="alternate" type="text/html" />' . DOKU_LF;  | 
                                                        |
| 130 | +					if(empty($meta['creator'])) { | 
                                                        |
| 131 | + $meta['creator'] = $conf['title'];  | 
                                                        |
| 132 | + }  | 
                                                        |
| 133 | + $entry .= ' <author><name>' . $meta['creator'] . '</name></author>' . DOKU_LF;  | 
                                                        |
| 134 | + $entry .= ' <updated>' . date_iso8601($meta['date']['modified']) . '</updated>' . DOKU_LF;  | 
                                                        |
| 135 | + $entry .= ' <published>' . date_iso8601($meta['date']['created']) . '</published>' . DOKU_LF;  | 
                                                        |
| 136 | +					$entry .= '  <id>' . $idTag . date("Y-m-d", $meta['date']['modified']) . ':' | 
                                                        |
| 137 | + . parse_url(wl($id), PHP_URL_PATH) . '</id>' . DOKU_LF;  | 
                                                        |
| 138 | + $entry .= '</entry>' . DOKU_LF;  | 
                                                        |
| 139 | + fwrite($fh, $entry);  | 
                                                        |
| 140 | + }  | 
                                                        |
| 141 | + }  | 
                                                        |
| 142 | + }  | 
                                                        |
| 143 | +  | 
                                                        |
| 144 | + fwrite($fh, $RSSend);  | 
                                                        |
| 145 | + return fclose($fh);  | 
                                                        |
| 146 | + }  | 
                                                        |
| 147 | +  | 
                                                        |
| 148 | + /**  | 
                                                        |
| 149 | + * will return true for non-public or hidden pages or pages that are not below or in the namespace.  | 
                                                        |
| 150 | + */  | 
                                                        |
| 151 | +	private function skipPage(string $id, string $namespace): bool { | 
                                                        |
| 152 | +		dbglog("helper_plugin_spatialhelper_sitemap::skipPage, check for $id in $namespace"); | 
                                                        |
| 153 | +		if(isHiddenPage($id)) { | 
                                                        |
| 154 | + return true;  | 
                                                        |
| 155 | + }  | 
                                                        |
| 156 | +		if(auth_aclcheck($id, '', null) < AUTH_READ) { | 
                                                        |
| 157 | + return true;  | 
                                                        |
| 158 | + }  | 
                                                        |
| 159 | +  | 
                                                        |
| 160 | +		if(!empty($namespace)) { | 
                                                        |
| 161 | + // only if id is in or below namespace  | 
                                                        |
| 162 | +			if(0 !== strpos(getNS($id), $namespace)) { | 
                                                        |
| 163 | +				// dbglog("helper_plugin_spatialhelper_sitemap::skipPage, skipping $id, not in $namespace"); | 
                                                        |
| 164 | + return true;  | 
                                                        |
| 165 | + }  | 
                                                        |
| 166 | + }  | 
                                                        |
| 167 | + return false;  | 
                                                        |
| 168 | + }  | 
                                                        |
| 169 | +  | 
                                                        |
| 170 | + /**  | 
                                                        |
| 171 | + * Create a KML sitemap.  | 
                                                        |
| 172 | + *  | 
                                                        |
| 173 | + * @param string $mediaID id for the KML file  | 
                                                        |
| 174 | + */  | 
                                                        |
| 175 | +	final public function createKMLSitemap(string $mediaID): bool { | 
                                                        |
| 176 | + global $conf;  | 
                                                        |
| 177 | + $namespace = getNS($mediaID);  | 
                                                        |
| 178 | +  | 
                                                        |
| 179 | + $KMLstart = '<?xml version="1.0" encoding="UTF-8"?>' . DOKU_LF;  | 
                                                        |
| 180 | + $KMLstart .= '<kml xmlns="http://www.opengis.net/kml/2.2" ';  | 
                                                        |
| 181 | + $KMLstart .= 'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ';  | 
                                                        |
| 182 | + $KMLstart .= 'xmlns:atom="http://www.w3.org/2005/Atom"';  | 
                                                        |
| 183 | + $KMLstart .= ' xsi:schemaLocation="http://www.opengis.net/kml/2.2 ';  | 
                                                        |
| 184 | + $KMLstart .= 'http://schemas.opengis.net/kml/2.2.0/ogckml22.xsd">' . DOKU_LF;  | 
                                                        |
| 185 | + $KMLstart .= '<Document id="root_doc">' . DOKU_LF;  | 
                                                        |
| 186 | + $KMLstart .= '<name>' . $conf['title'] . ' spatial sitemap</name>' . DOKU_LF;  | 
                                                        |
| 187 | + $KMLstart .= '<atom:link href="' . DOKU_URL . '" rel="related" type="text/html" />' . DOKU_LF;  | 
                                                        |
| 188 | + $KMLstart .= '<!-- atom:updated>' . date(DATE_ATOM) . '</atom:updated -->' . DOKU_LF;  | 
                                                        |
| 189 | + $KMLstart .= '<Style id="icon"><IconStyle><color>ffffffff</color><scale>1</scale>';  | 
                                                        |
| 190 | + $KMLstart .= '<Icon><href>'  | 
                                                        |
| 191 | + . DOKU_BASE . 'lib/plugins/spatialhelper/wikiitem.png</href></Icon></IconStyle></Style>' . DOKU_LF;  | 
                                                        |
| 192 | +  | 
                                                        |
| 193 | + $KMLend = '</Document>' . DOKU_LF . '</kml>';  | 
                                                        |
| 194 | +  | 
                                                        |
| 195 | + io_createNamespace($mediaID, 'media');  | 
                                                        |
| 196 | + @touch(mediaFN($mediaID));  | 
                                                        |
| 197 | + @chmod(mediaFN($mediaID), $conf['fmode']);  | 
                                                        |
| 198 | +  | 
                                                        |
| 199 | + $fh = fopen(mediaFN($mediaID), 'wb');  | 
                                                        |
| 200 | + fwrite($fh, $KMLstart);  | 
                                                        |
| 201 | +  | 
                                                        |
| 202 | +		foreach($this->spatial_idx as $idxEntry) { | 
                                                        |
| 203 | + // get list of id's  | 
                                                        |
| 204 | +			foreach($idxEntry as $id) { | 
                                                        |
| 205 | + // for document item in the index  | 
                                                        |
| 206 | +				if(strpos($id, 'media__', 0) !== 0) { | 
                                                        |
| 207 | +					if($this->skipPage($id, $namespace)) { | 
                                                        |
| 208 | + continue;  | 
                                                        |
| 209 | + }  | 
                                                        |
| 210 | +  | 
                                                        |
| 211 | + $meta = p_get_metadata($id);  | 
                                                        |
| 212 | +  | 
                                                        |
| 213 | +					// $desc = p_render('xhtmlsummary', p_get_instructions($meta['description']['abstract']), $info); | 
                                                        |
| 214 | + $desc = '<p>' . strip_tags($meta['description']['abstract']) . '</p>';  | 
                                                        |
| 215 | + $desc .= '<p><a href="' . wl($id, '', true) . '">' . $meta['title'] . '</a></p>';  | 
                                                        |
| 216 | +  | 
                                                        |
| 217 | + // create an entry and store it  | 
                                                        |
| 218 | +					$plcm = '<Placemark id="crc32-' . hash('crc32', $id) . '">' . DOKU_LF; | 
                                                        |
| 219 | + $plcm .= ' <name>' . $meta['title'] . '</name>' . DOKU_LF;  | 
                                                        |
| 220 | + // TODO escape quotes in: title="' . $meta['title'] . '"  | 
                                                        |
| 221 | + $plcm .= ' <atom:link href="' . wl($id, '' . true) . '" rel="alternate" type="text/html" />'  | 
                                                        |
| 222 | + . DOKU_LF;  | 
                                                        |
| 223 | +					if(!empty($meta['creator'])) { | 
                                                        |
| 224 | + $plcm .= ' <atom:author><atom:name>' . $meta['creator'] . '</atom:name></atom:author>'  | 
                                                        |
| 225 | + . DOKU_LF;  | 
                                                        |
| 226 | + }  | 
                                                        |
| 227 | +  | 
                                                        |
| 228 | + $plcm .= ' <description><![CDATA[' . $desc . ']]></description>' . DOKU_LF;  | 
                                                        |
| 229 | + $plcm .= ' <styleUrl>#icon</styleUrl>' . DOKU_LF;  | 
                                                        |
| 230 | +  | 
                                                        |
| 231 | + $plcm .= ' <Point><coordinates>' . $meta['geo']['lon'] . ',' . $meta['geo']['lat'];  | 
                                                        |
| 232 | +					if(isset($meta['geo']['alt'])) { | 
                                                        |
| 233 | + $plcm .= ',' . $meta['geo']['alt'];  | 
                                                        |
| 234 | + }  | 
                                                        |
| 235 | + $plcm .= '</coordinates></Point>' . DOKU_LF;  | 
                                                        |
| 236 | + $plcm .= '</Placemark>' . DOKU_LF;  | 
                                                        |
| 237 | +  | 
                                                        |
| 238 | + fwrite($fh, $plcm);  | 
                                                        |
| 239 | + }  | 
                                                        |
| 240 | + }  | 
                                                        |
| 241 | + }  | 
                                                        |
| 242 | + fwrite($fh, $KMLend);  | 
                                                        |
| 243 | + return fclose($fh);  | 
                                                        |
| 244 | + }  | 
                                                        |
| 245 | 245 | }  | 
                                                        
@@ -24,282 +24,282 @@  | 
                                                    ||
| 24 | 24 | * @author Mark Prins  | 
                                                        
| 25 | 25 | */  | 
                                                        
| 26 | 26 |  class helper_plugin_spatialhelper_index extends DokuWiki_Plugin { | 
                                                        
| 27 | - /**  | 
                                                        |
| 28 | - * directory for index files.  | 
                                                        |
| 29 | - *  | 
                                                        |
| 30 | - * @var string  | 
                                                        |
| 31 | - */  | 
                                                        |
| 32 | - protected $idx_dir = '';  | 
                                                        |
| 27 | + /**  | 
                                                        |
| 28 | + * directory for index files.  | 
                                                        |
| 29 | + *  | 
                                                        |
| 30 | + * @var string  | 
                                                        |
| 31 | + */  | 
                                                        |
| 32 | + protected $idx_dir = '';  | 
                                                        |
| 33 | 33 | |
| 34 | - /**  | 
                                                        |
| 35 | - * spatial index, well lookup list/array so we can do spatial queries.  | 
                                                        |
| 36 | -     * entries should be: array("geohash" => {"id1","id3",}) | 
                                                        |
| 37 | - *  | 
                                                        |
| 38 | - * @var array  | 
                                                        |
| 39 | - */  | 
                                                        |
| 40 | - protected $spatial_idx = array();  | 
                                                        |
| 34 | + /**  | 
                                                        |
| 35 | + * spatial index, well lookup list/array so we can do spatial queries.  | 
                                                        |
| 36 | +	 * entries should be: array("geohash" => {"id1","id3",}) | 
                                                        |
| 37 | + *  | 
                                                        |
| 38 | + * @var array  | 
                                                        |
| 39 | + */  | 
                                                        |
| 40 | + protected $spatial_idx = array();  | 
                                                        |
| 41 | 41 | |
| 42 | - /**  | 
                                                        |
| 43 | - * Constructor, initialises the spatial index.  | 
                                                        |
| 44 | - */  | 
                                                        |
| 45 | -    public function __construct() { | 
                                                        |
| 46 | -        if(!plugin_load('helper', 'geophp')) { | 
                                                        |
| 47 | - $message = 'helper_plugin_spatialhelper_index::spatialhelper_index: required geophp plugin is not available.';  | 
                                                        |
| 48 | - msg($message, -1);  | 
                                                        |
| 49 | - }  | 
                                                        |
| 42 | + /**  | 
                                                        |
| 43 | + * Constructor, initialises the spatial index.  | 
                                                        |
| 44 | + */  | 
                                                        |
| 45 | +	public function __construct() { | 
                                                        |
| 46 | +		if(!plugin_load('helper', 'geophp')) { | 
                                                        |
| 47 | + $message = 'helper_plugin_spatialhelper_index::spatialhelper_index: required geophp plugin is not available.';  | 
                                                        |
| 48 | + msg($message, -1);  | 
                                                        |
| 49 | + }  | 
                                                        |
| 50 | 50 | |
| 51 | - global $conf;  | 
                                                        |
| 52 | - $this->idx_dir = $conf ['indexdir'];  | 
                                                        |
| 53 | - // test if there is a spatialindex, if not build one for the wiki  | 
                                                        |
| 54 | -        if(!@file_exists($this->idx_dir . '/spatial.idx')) { | 
                                                        |
| 55 | - // creates and stores the index  | 
                                                        |
| 56 | - $this->generateSpatialIndex();  | 
                                                        |
| 57 | -        } else { | 
                                                        |
| 58 | - $this->spatial_idx = unserialize(  | 
                                                        |
| 59 | - io_readFile($this->idx_dir . '/spatial.idx', false),  | 
                                                        |
| 60 | - ['allowed_classes' => false]  | 
                                                        |
| 61 | - );  | 
                                                        |
| 62 | - dbglog($this->spatial_idx, 'done loading spatial index');  | 
                                                        |
| 63 | - }  | 
                                                        |
| 64 | - }  | 
                                                        |
| 51 | + global $conf;  | 
                                                        |
| 52 | + $this->idx_dir = $conf ['indexdir'];  | 
                                                        |
| 53 | + // test if there is a spatialindex, if not build one for the wiki  | 
                                                        |
| 54 | +		if(!@file_exists($this->idx_dir . '/spatial.idx')) { | 
                                                        |
| 55 | + // creates and stores the index  | 
                                                        |
| 56 | + $this->generateSpatialIndex();  | 
                                                        |
| 57 | +		} else { | 
                                                        |
| 58 | + $this->spatial_idx = unserialize(  | 
                                                        |
| 59 | + io_readFile($this->idx_dir . '/spatial.idx', false),  | 
                                                        |
| 60 | + ['allowed_classes' => false]  | 
                                                        |
| 61 | + );  | 
                                                        |
| 62 | + dbglog($this->spatial_idx, 'done loading spatial index');  | 
                                                        |
| 63 | + }  | 
                                                        |
| 64 | + }  | 
                                                        |
| 65 | 65 | |
| 66 | - /**  | 
                                                        |
| 67 | - * (re-)Generates the spatial index by running through all the pages in the wiki.  | 
                                                        |
| 68 | - *  | 
                                                        |
| 69 | - * @todo add an option to erase the old index  | 
                                                        |
| 70 | - */  | 
                                                        |
| 71 | -    public function generateSpatialIndex(): bool { | 
                                                        |
| 72 | - global $conf;  | 
                                                        |
| 73 | - require_once(DOKU_INC . 'inc/search.php');  | 
                                                        |
| 74 | - $pages = array();  | 
                                                        |
| 75 | - search($pages, $conf ['datadir'], 'search_allpages', array());  | 
                                                        |
| 76 | -        foreach($pages as $page) { | 
                                                        |
| 77 | - $this->updateSpatialIndex($page ['id']);  | 
                                                        |
| 78 | - }  | 
                                                        |
| 79 | - // media  | 
                                                        |
| 80 | - $media = array();  | 
                                                        |
| 81 | - search($media, $conf ['mediadir'], 'search_media', array());  | 
                                                        |
| 82 | -        foreach($media as $medium) { | 
                                                        |
| 83 | -            if($medium ['isimg']) { | 
                                                        |
| 84 | - $this->indexImage($medium);  | 
                                                        |
| 85 | - }  | 
                                                        |
| 86 | - }  | 
                                                        |
| 87 | - return true;  | 
                                                        |
| 88 | - }  | 
                                                        |
| 66 | + /**  | 
                                                        |
| 67 | + * (re-)Generates the spatial index by running through all the pages in the wiki.  | 
                                                        |
| 68 | + *  | 
                                                        |
| 69 | + * @todo add an option to erase the old index  | 
                                                        |
| 70 | + */  | 
                                                        |
| 71 | +	public function generateSpatialIndex(): bool { | 
                                                        |
| 72 | + global $conf;  | 
                                                        |
| 73 | + require_once(DOKU_INC . 'inc/search.php');  | 
                                                        |
| 74 | + $pages = array();  | 
                                                        |
| 75 | + search($pages, $conf ['datadir'], 'search_allpages', array());  | 
                                                        |
| 76 | +		foreach($pages as $page) { | 
                                                        |
| 77 | + $this->updateSpatialIndex($page ['id']);  | 
                                                        |
| 78 | + }  | 
                                                        |
| 79 | + // media  | 
                                                        |
| 80 | + $media = array();  | 
                                                        |
| 81 | + search($media, $conf ['mediadir'], 'search_media', array());  | 
                                                        |
| 82 | +		foreach($media as $medium) { | 
                                                        |
| 83 | +			if($medium ['isimg']) { | 
                                                        |
| 84 | + $this->indexImage($medium);  | 
                                                        |
| 85 | + }  | 
                                                        |
| 86 | + }  | 
                                                        |
| 87 | + return true;  | 
                                                        |
| 88 | + }  | 
                                                        |
| 89 | 89 | |
| 90 | - /**  | 
                                                        |
| 91 | - * Update the spatial index for the page.  | 
                                                        |
| 92 | - *  | 
                                                        |
| 93 | - * @param string $id  | 
                                                        |
| 94 | - * the document ID  | 
                                                        |
| 95 | - * @throws Exception  | 
                                                        |
| 96 | - */  | 
                                                        |
| 97 | -    public function updateSpatialIndex(string $id): bool { | 
                                                        |
| 98 | - $geotags = p_get_metadata($id, 'geo');  | 
                                                        |
| 99 | -        if(empty ($geotags)) { | 
                                                        |
| 100 | - return false;  | 
                                                        |
| 101 | - }  | 
                                                        |
| 102 | -        if(empty ($geotags ['lon']) || empty ($geotags ['lat'])) { | 
                                                        |
| 103 | - return false;  | 
                                                        |
| 104 | - }  | 
                                                        |
| 105 | - dbglog($geotags, "Geo metadata found for page $id");  | 
                                                        |
| 106 | - $geometry = new Point($geotags ['lon'], $geotags ['lat']);  | 
                                                        |
| 107 | -        $geohash  = $geometry->out('geohash'); | 
                                                        |
| 108 | -        dbglog('Update index for geohash: ' . $geohash); | 
                                                        |
| 109 | - return $this->addToIndex($geohash, $id);  | 
                                                        |
| 110 | - }  | 
                                                        |
| 90 | + /**  | 
                                                        |
| 91 | + * Update the spatial index for the page.  | 
                                                        |
| 92 | + *  | 
                                                        |
| 93 | + * @param string $id  | 
                                                        |
| 94 | + * the document ID  | 
                                                        |
| 95 | + * @throws Exception  | 
                                                        |
| 96 | + */  | 
                                                        |
| 97 | +	public function updateSpatialIndex(string $id): bool { | 
                                                        |
| 98 | + $geotags = p_get_metadata($id, 'geo');  | 
                                                        |
| 99 | +		if(empty ($geotags)) { | 
                                                        |
| 100 | + return false;  | 
                                                        |
| 101 | + }  | 
                                                        |
| 102 | +		if(empty ($geotags ['lon']) || empty ($geotags ['lat'])) { | 
                                                        |
| 103 | + return false;  | 
                                                        |
| 104 | + }  | 
                                                        |
| 105 | + dbglog($geotags, "Geo metadata found for page $id");  | 
                                                        |
| 106 | + $geometry = new Point($geotags ['lon'], $geotags ['lat']);  | 
                                                        |
| 107 | +		$geohash  = $geometry->out('geohash'); | 
                                                        |
| 108 | +		dbglog('Update index for geohash: ' . $geohash); | 
                                                        |
| 109 | + return $this->addToIndex($geohash, $id);  | 
                                                        |
| 110 | + }  | 
                                                        |
| 111 | 111 | |
| 112 | - /**  | 
                                                        |
| 113 | - * Store the hash/id entry in the index.  | 
                                                        |
| 114 | - *  | 
                                                        |
| 115 | - * @param string $geohash  | 
                                                        |
| 116 | - * @param string $id  | 
                                                        |
| 117 | - * page or media id  | 
                                                        |
| 118 | - * @return bool true when succesful  | 
                                                        |
| 119 | - */  | 
                                                        |
| 120 | -    private function addToIndex(string $geohash, string $id): bool { | 
                                                        |
| 121 | - $pageIds = array();  | 
                                                        |
| 122 | - // check index for key/geohash  | 
                                                        |
| 123 | -        if(!array_key_exists($geohash, $this->spatial_idx)) { | 
                                                        |
| 124 | -            dbglog("Geohash $geohash not in index, just add $id."); | 
                                                        |
| 125 | - $pageIds [] = $id;  | 
                                                        |
| 126 | -        } else { | 
                                                        |
| 127 | -            dbglog('Geohash for document is in index, find it.'); | 
                                                        |
| 128 | - // check the index for document  | 
                                                        |
| 129 | - $knownHashes = $this->findHashesForId($id, $this->spatial_idx);  | 
                                                        |
| 130 | -            if(empty ($knownHashes)) { | 
                                                        |
| 131 | -                dbglog("No index record found for document $id, just add"); | 
                                                        |
| 132 | - $pageIds = $this->spatial_idx [$geohash];  | 
                                                        |
| 133 | - $pageIds [] = $id;  | 
                                                        |
| 134 | - }  | 
                                                        |
| 135 | - // TODO shortcut, need to make sure there is only one element, if not the index is corrupt  | 
                                                        |
| 136 | - $knownHash = $knownHashes [0];  | 
                                                        |
| 112 | + /**  | 
                                                        |
| 113 | + * Store the hash/id entry in the index.  | 
                                                        |
| 114 | + *  | 
                                                        |
| 115 | + * @param string $geohash  | 
                                                        |
| 116 | + * @param string $id  | 
                                                        |
| 117 | + * page or media id  | 
                                                        |
| 118 | + * @return bool true when succesful  | 
                                                        |
| 119 | + */  | 
                                                        |
| 120 | +	private function addToIndex(string $geohash, string $id): bool { | 
                                                        |
| 121 | + $pageIds = array();  | 
                                                        |
| 122 | + // check index for key/geohash  | 
                                                        |
| 123 | +		if(!array_key_exists($geohash, $this->spatial_idx)) { | 
                                                        |
| 124 | +			dbglog("Geohash $geohash not in index, just add $id."); | 
                                                        |
| 125 | + $pageIds [] = $id;  | 
                                                        |
| 126 | +		} else { | 
                                                        |
| 127 | +			dbglog('Geohash for document is in index, find it.'); | 
                                                        |
| 128 | + // check the index for document  | 
                                                        |
| 129 | + $knownHashes = $this->findHashesForId($id, $this->spatial_idx);  | 
                                                        |
| 130 | +			if(empty ($knownHashes)) { | 
                                                        |
| 131 | +				dbglog("No index record found for document $id, just add"); | 
                                                        |
| 132 | + $pageIds = $this->spatial_idx [$geohash];  | 
                                                        |
| 133 | + $pageIds [] = $id;  | 
                                                        |
| 134 | + }  | 
                                                        |
| 135 | + // TODO shortcut, need to make sure there is only one element, if not the index is corrupt  | 
                                                        |
| 136 | + $knownHash = $knownHashes [0];  | 
                                                        |
| 137 | 137 | |
| 138 | -            if($knownHash === $geohash) { | 
                                                        |
| 139 | -                dbglog("Document $id was found in index and has the same geohash, nothing to do."); | 
                                                        |
| 140 | - return true;  | 
                                                        |
| 141 | - }  | 
                                                        |
| 138 | +			if($knownHash === $geohash) { | 
                                                        |
| 139 | +				dbglog("Document $id was found in index and has the same geohash, nothing to do."); | 
                                                        |
| 140 | + return true;  | 
                                                        |
| 141 | + }  | 
                                                        |
| 142 | 142 | |
| 143 | -            if(!empty ($knownHash)) { | 
                                                        |
| 144 | -                dbglog("Document/media $id was found in index but has different geohash (it moved)."); | 
                                                        |
| 145 | - $knownIds = $this->spatial_idx [$knownHash];  | 
                                                        |
| 146 | - dbglog($knownIds, "Known id's for this hash:");  | 
                                                        |
| 147 | - // remove it from the old geohash element  | 
                                                        |
| 148 | - $i = array_search($id, $knownIds);  | 
                                                        |
| 149 | -                dbglog('Unsetting:' . $knownIds [$i]); | 
                                                        |
| 150 | - unset ($knownIds [$i]);  | 
                                                        |
| 151 | - $this->spatial_idx [$knownHash] = $knownIds;  | 
                                                        |
| 152 | - // set on new geohash element  | 
                                                        |
| 153 | - $pageIds = $this->spatial_idx [$geohash];  | 
                                                        |
| 154 | - $pageIds [] = $id;  | 
                                                        |
| 155 | - }  | 
                                                        |
| 156 | - }  | 
                                                        |
| 157 | - // store and save  | 
                                                        |
| 158 | - $this->spatial_idx [$geohash] = $pageIds;  | 
                                                        |
| 159 | - return $this->saveIndex();  | 
                                                        |
| 160 | - }  | 
                                                        |
| 143 | +			if(!empty ($knownHash)) { | 
                                                        |
| 144 | +				dbglog("Document/media $id was found in index but has different geohash (it moved)."); | 
                                                        |
| 145 | + $knownIds = $this->spatial_idx [$knownHash];  | 
                                                        |
| 146 | + dbglog($knownIds, "Known id's for this hash:");  | 
                                                        |
| 147 | + // remove it from the old geohash element  | 
                                                        |
| 148 | + $i = array_search($id, $knownIds);  | 
                                                        |
| 149 | +				dbglog('Unsetting:' . $knownIds [$i]); | 
                                                        |
| 150 | + unset ($knownIds [$i]);  | 
                                                        |
| 151 | + $this->spatial_idx [$knownHash] = $knownIds;  | 
                                                        |
| 152 | + // set on new geohash element  | 
                                                        |
| 153 | + $pageIds = $this->spatial_idx [$geohash];  | 
                                                        |
| 154 | + $pageIds [] = $id;  | 
                                                        |
| 155 | + }  | 
                                                        |
| 156 | + }  | 
                                                        |
| 157 | + // store and save  | 
                                                        |
| 158 | + $this->spatial_idx [$geohash] = $pageIds;  | 
                                                        |
| 159 | + return $this->saveIndex();  | 
                                                        |
| 160 | + }  | 
                                                        |
| 161 | 161 | |
| 162 | - /**  | 
                                                        |
| 163 | - * Looks up the geohash(es) for the document in the index.  | 
                                                        |
| 164 | - *  | 
                                                        |
| 165 | - * @param String $id  | 
                                                        |
| 166 | - * document ID  | 
                                                        |
| 167 | - * @param array $index  | 
                                                        |
| 168 | - * spatial index  | 
                                                        |
| 169 | - */  | 
                                                        |
| 170 | -    public function findHashesForId(string $id, array $index): array { | 
                                                        |
| 171 | - $hashes = array();  | 
                                                        |
| 172 | -        foreach($index as $hash => $docIds) { | 
                                                        |
| 173 | -            if(in_array($id, $docIds, false)) { | 
                                                        |
| 174 | - $hashes [] = $hash;  | 
                                                        |
| 175 | - }  | 
                                                        |
| 176 | - }  | 
                                                        |
| 177 | - dbglog($hashes, "Found the following hashes for $id (should only be 1)");  | 
                                                        |
| 178 | - return $hashes;  | 
                                                        |
| 179 | - }  | 
                                                        |
| 162 | + /**  | 
                                                        |
| 163 | + * Looks up the geohash(es) for the document in the index.  | 
                                                        |
| 164 | + *  | 
                                                        |
| 165 | + * @param String $id  | 
                                                        |
| 166 | + * document ID  | 
                                                        |
| 167 | + * @param array $index  | 
                                                        |
| 168 | + * spatial index  | 
                                                        |
| 169 | + */  | 
                                                        |
| 170 | +	public function findHashesForId(string $id, array $index): array { | 
                                                        |
| 171 | + $hashes = array();  | 
                                                        |
| 172 | +		foreach($index as $hash => $docIds) { | 
                                                        |
| 173 | +			if(in_array($id, $docIds, false)) { | 
                                                        |
| 174 | + $hashes [] = $hash;  | 
                                                        |
| 175 | + }  | 
                                                        |
| 176 | + }  | 
                                                        |
| 177 | + dbglog($hashes, "Found the following hashes for $id (should only be 1)");  | 
                                                        |
| 178 | + return $hashes;  | 
                                                        |
| 179 | + }  | 
                                                        |
| 180 | 180 | |
| 181 | - /**  | 
                                                        |
| 182 | - * Save spatial index.  | 
                                                        |
| 183 | - */  | 
                                                        |
| 184 | -    private function saveIndex(): bool { | 
                                                        |
| 185 | - return io_saveFile($this->idx_dir . '/spatial.idx', serialize($this->spatial_idx));  | 
                                                        |
| 186 | - }  | 
                                                        |
| 181 | + /**  | 
                                                        |
| 182 | + * Save spatial index.  | 
                                                        |
| 183 | + */  | 
                                                        |
| 184 | +	private function saveIndex(): bool { | 
                                                        |
| 185 | + return io_saveFile($this->idx_dir . '/spatial.idx', serialize($this->spatial_idx));  | 
                                                        |
| 186 | + }  | 
                                                        |
| 187 | 187 | |
| 188 | - /**  | 
                                                        |
| 189 | - * Add an index entry for this file having EXIF / IPTC data.  | 
                                                        |
| 190 | - *  | 
                                                        |
| 191 | - * @param $img  | 
                                                        |
| 192 | - * a Dokuwiki image  | 
                                                        |
| 193 | - * @return bool true when image was succesfully added to the index.  | 
                                                        |
| 194 | - * @throws Exception  | 
                                                        |
| 195 | - * @see http://www.php.net/manual/en/function.iptcparse.php  | 
                                                        |
| 196 | - * @see http://php.net/manual/en/function.exif-read-data.php  | 
                                                        |
| 197 | - *  | 
                                                        |
| 198 | - */  | 
                                                        |
| 199 | -    public function indexImage($img): bool { | 
                                                        |
| 200 | - // test for supported files (jpeg only)  | 
                                                        |
| 201 | - if(  | 
                                                        |
| 202 | -            (substr($img ['file'], -strlen('.jpg')) !== '.jpg') && | 
                                                        |
| 203 | -            (substr($img ['file'], -strlen('.jpeg')) !== '.jpeg')) { | 
                                                        |
| 204 | - return false;  | 
                                                        |
| 205 | - }  | 
                                                        |
| 188 | + /**  | 
                                                        |
| 189 | + * Add an index entry for this file having EXIF / IPTC data.  | 
                                                        |
| 190 | + *  | 
                                                        |
| 191 | + * @param $img  | 
                                                        |
| 192 | + * a Dokuwiki image  | 
                                                        |
| 193 | + * @return bool true when image was succesfully added to the index.  | 
                                                        |
| 194 | + * @throws Exception  | 
                                                        |
| 195 | + * @see http://www.php.net/manual/en/function.iptcparse.php  | 
                                                        |
| 196 | + * @see http://php.net/manual/en/function.exif-read-data.php  | 
                                                        |
| 197 | + *  | 
                                                        |
| 198 | + */  | 
                                                        |
| 199 | +	public function indexImage($img): bool { | 
                                                        |
| 200 | + // test for supported files (jpeg only)  | 
                                                        |
| 201 | + if(  | 
                                                        |
| 202 | +			(substr($img ['file'], -strlen('.jpg')) !== '.jpg') && | 
                                                        |
| 203 | +			(substr($img ['file'], -strlen('.jpeg')) !== '.jpeg')) { | 
                                                        |
| 204 | + return false;  | 
                                                        |
| 205 | + }  | 
                                                        |
| 206 | 206 | |
| 207 | - $geometry = $this->getCoordsFromExif($img ['id']);  | 
                                                        |
| 208 | -        if(!$geometry) { | 
                                                        |
| 209 | - return false;  | 
                                                        |
| 210 | - }  | 
                                                        |
| 211 | -        $geohash = $geometry->out('geohash'); | 
                                                        |
| 212 | - // TODO truncate the geohash to something reasonable, otherwise they are  | 
                                                        |
| 213 | - // useless as an indexing mechanism eg. u1h73weckdrmskdqec3c9 is far too  | 
                                                        |
| 214 | - // precise, limit at ~9 as most GPS are not submeter accurate  | 
                                                        |
| 215 | - return $this->addToIndex($geohash, 'media__' . $img ['id']);  | 
                                                        |
| 216 | - }  | 
                                                        |
| 207 | + $geometry = $this->getCoordsFromExif($img ['id']);  | 
                                                        |
| 208 | +		if(!$geometry) { | 
                                                        |
| 209 | + return false;  | 
                                                        |
| 210 | + }  | 
                                                        |
| 211 | +		$geohash = $geometry->out('geohash'); | 
                                                        |
| 212 | + // TODO truncate the geohash to something reasonable, otherwise they are  | 
                                                        |
| 213 | + // useless as an indexing mechanism eg. u1h73weckdrmskdqec3c9 is far too  | 
                                                        |
| 214 | + // precise, limit at ~9 as most GPS are not submeter accurate  | 
                                                        |
| 215 | + return $this->addToIndex($geohash, 'media__' . $img ['id']);  | 
                                                        |
| 216 | + }  | 
                                                        |
| 217 | 217 | |
| 218 | - /**  | 
                                                        |
| 219 | - * retrieve GPS decimal coordinates from exif.  | 
                                                        |
| 220 | - *  | 
                                                        |
| 221 | - * @param string $id  | 
                                                        |
| 222 | - * @return Point|false  | 
                                                        |
| 223 | - * @throws Exception  | 
                                                        |
| 224 | - */  | 
                                                        |
| 225 | -    public function getCoordsFromExif(string $id) { | 
                                                        |
| 226 | - $exif = exif_read_data(mediaFN($id), 0, true);  | 
                                                        |
| 227 | -        if(empty ($exif ['GPS'])) { | 
                                                        |
| 228 | - return false;  | 
                                                        |
| 229 | - }  | 
                                                        |
| 218 | + /**  | 
                                                        |
| 219 | + * retrieve GPS decimal coordinates from exif.  | 
                                                        |
| 220 | + *  | 
                                                        |
| 221 | + * @param string $id  | 
                                                        |
| 222 | + * @return Point|false  | 
                                                        |
| 223 | + * @throws Exception  | 
                                                        |
| 224 | + */  | 
                                                        |
| 225 | +	public function getCoordsFromExif(string $id) { | 
                                                        |
| 226 | + $exif = exif_read_data(mediaFN($id), 0, true);  | 
                                                        |
| 227 | +		if(empty ($exif ['GPS'])) { | 
                                                        |
| 228 | + return false;  | 
                                                        |
| 229 | + }  | 
                                                        |
| 230 | 230 | |
| 231 | - $lat = $this->convertDMStoD(  | 
                                                        |
| 232 | - array(  | 
                                                        |
| 233 | - $exif ['GPS'] ['GPSLatitude'] [0],  | 
                                                        |
| 234 | - $exif ['GPS'] ['GPSLatitude'] [1],  | 
                                                        |
| 235 | - $exif ['GPS'] ['GPSLatitude'] [2],  | 
                                                        |
| 236 | - $exif ['GPS'] ['GPSLatitudeRef']  | 
                                                        |
| 237 | - )  | 
                                                        |
| 238 | - );  | 
                                                        |
| 231 | + $lat = $this->convertDMStoD(  | 
                                                        |
| 232 | + array(  | 
                                                        |
| 233 | + $exif ['GPS'] ['GPSLatitude'] [0],  | 
                                                        |
| 234 | + $exif ['GPS'] ['GPSLatitude'] [1],  | 
                                                        |
| 235 | + $exif ['GPS'] ['GPSLatitude'] [2],  | 
                                                        |
| 236 | + $exif ['GPS'] ['GPSLatitudeRef']  | 
                                                        |
| 237 | + )  | 
                                                        |
| 238 | + );  | 
                                                        |
| 239 | 239 | |
| 240 | - $lon = $this->convertDMStoD(  | 
                                                        |
| 241 | - array(  | 
                                                        |
| 242 | - $exif ['GPS'] ['GPSLongitude'] [0],  | 
                                                        |
| 243 | - $exif ['GPS'] ['GPSLongitude'] [1],  | 
                                                        |
| 244 | - $exif ['GPS'] ['GPSLongitude'] [2],  | 
                                                        |
| 245 | - $exif ['GPS'] ['GPSLongitudeRef']  | 
                                                        |
| 246 | - )  | 
                                                        |
| 247 | - );  | 
                                                        |
| 240 | + $lon = $this->convertDMStoD(  | 
                                                        |
| 241 | + array(  | 
                                                        |
| 242 | + $exif ['GPS'] ['GPSLongitude'] [0],  | 
                                                        |
| 243 | + $exif ['GPS'] ['GPSLongitude'] [1],  | 
                                                        |
| 244 | + $exif ['GPS'] ['GPSLongitude'] [2],  | 
                                                        |
| 245 | + $exif ['GPS'] ['GPSLongitudeRef']  | 
                                                        |
| 246 | + )  | 
                                                        |
| 247 | + );  | 
                                                        |
| 248 | 248 | |
| 249 | - return new Point($lon, $lat);  | 
                                                        |
| 250 | - }  | 
                                                        |
| 249 | + return new Point($lon, $lat);  | 
                                                        |
| 250 | + }  | 
                                                        |
| 251 | 251 | |
| 252 | - /**  | 
                                                        |
| 253 | - * convert DegreesMinutesSeconds to Decimal degrees.  | 
                                                        |
| 254 | - *  | 
                                                        |
| 255 | - * @param array $param array of rational DMS  | 
                                                        |
| 256 | - * @return float  | 
                                                        |
| 257 | - */  | 
                                                        |
| 258 | -    public function convertDMStoD(array $param): float { | 
                                                        |
| 259 | -        if(!is_array($param)) { | 
                                                        |
| 260 | - $param = array($param);  | 
                                                        |
| 261 | - }  | 
                                                        |
| 262 | - $deg = $this->convertRationaltoFloat($param [0]);  | 
                                                        |
| 263 | - $min = $this->convertRationaltoFloat($param [1]) / 60;  | 
                                                        |
| 264 | - $sec = $this->convertRationaltoFloat($param [2]) / 60 / 60;  | 
                                                        |
| 265 | - // Hemisphere (N, S, W or E)  | 
                                                        |
| 266 | - $hem = ($param [3] === 'N' || $param [3] === 'E') ? 1 : -1;  | 
                                                        |
| 267 | - return $hem * ($deg + $min + $sec);  | 
                                                        |
| 268 | - }  | 
                                                        |
| 252 | + /**  | 
                                                        |
| 253 | + * convert DegreesMinutesSeconds to Decimal degrees.  | 
                                                        |
| 254 | + *  | 
                                                        |
| 255 | + * @param array $param array of rational DMS  | 
                                                        |
| 256 | + * @return float  | 
                                                        |
| 257 | + */  | 
                                                        |
| 258 | +	public function convertDMStoD(array $param): float { | 
                                                        |
| 259 | +		if(!is_array($param)) { | 
                                                        |
| 260 | + $param = array($param);  | 
                                                        |
| 261 | + }  | 
                                                        |
| 262 | + $deg = $this->convertRationaltoFloat($param [0]);  | 
                                                        |
| 263 | + $min = $this->convertRationaltoFloat($param [1]) / 60;  | 
                                                        |
| 264 | + $sec = $this->convertRationaltoFloat($param [2]) / 60 / 60;  | 
                                                        |
| 265 | + // Hemisphere (N, S, W or E)  | 
                                                        |
| 266 | + $hem = ($param [3] === 'N' || $param [3] === 'E') ? 1 : -1;  | 
                                                        |
| 267 | + return $hem * ($deg + $min + $sec);  | 
                                                        |
| 268 | + }  | 
                                                        |
| 269 | 269 | |
| 270 | -    public function convertRationaltoFloat($param): float { | 
                                                        |
| 271 | - // rational64u  | 
                                                        |
| 272 | -        $nums = explode('/', $param); | 
                                                        |
| 273 | -        if((int) $nums[1] > 0) { | 
                                                        |
| 274 | - return (float) $nums[0] / (int) $nums[1];  | 
                                                        |
| 275 | -        } else { | 
                                                        |
| 276 | - return (float) $nums[0];  | 
                                                        |
| 277 | - }  | 
                                                        |
| 278 | - }  | 
                                                        |
| 270 | +	public function convertRationaltoFloat($param): float { | 
                                                        |
| 271 | + // rational64u  | 
                                                        |
| 272 | +		$nums = explode('/', $param); | 
                                                        |
| 273 | +		if((int) $nums[1] > 0) { | 
                                                        |
| 274 | + return (float) $nums[0] / (int) $nums[1];  | 
                                                        |
| 275 | +		} else { | 
                                                        |
| 276 | + return (float) $nums[0];  | 
                                                        |
| 277 | + }  | 
                                                        |
| 278 | + }  | 
                                                        |
| 279 | 279 | |
| 280 | - /**  | 
                                                        |
| 281 | - * Deletes the page from the index.  | 
                                                        |
| 282 | - *  | 
                                                        |
| 283 | - * @param string $id document ID  | 
                                                        |
| 284 | - */  | 
                                                        |
| 285 | -    public function deleteFromIndex(string $id): void { | 
                                                        |
| 286 | - // check the index for document  | 
                                                        |
| 287 | - $knownHashes = $this->findHashesForId($id, $this->spatial_idx);  | 
                                                        |
| 288 | -        if(empty ($knownHashes)) { | 
                                                        |
| 289 | - return;  | 
                                                        |
| 290 | - }  | 
                                                        |
| 280 | + /**  | 
                                                        |
| 281 | + * Deletes the page from the index.  | 
                                                        |
| 282 | + *  | 
                                                        |
| 283 | + * @param string $id document ID  | 
                                                        |
| 284 | + */  | 
                                                        |
| 285 | +	public function deleteFromIndex(string $id): void { | 
                                                        |
| 286 | + // check the index for document  | 
                                                        |
| 287 | + $knownHashes = $this->findHashesForId($id, $this->spatial_idx);  | 
                                                        |
| 288 | +		if(empty ($knownHashes)) { | 
                                                        |
| 289 | + return;  | 
                                                        |
| 290 | + }  | 
                                                        |
| 291 | 291 | |
| 292 | - // TODO shortcut, need to make sure there is only one element, if not the index is corrupt  | 
                                                        |
| 293 | - $knownHash = $knownHashes [0];  | 
                                                        |
| 294 | - $knownIds = $this->spatial_idx [$knownHash];  | 
                                                        |
| 295 | - $i = array_search($id, $knownIds);  | 
                                                        |
| 296 | -        dbglog("removing: $knownIds[$i] from the index."); | 
                                                        |
| 297 | - unset ($knownIds [$i]);  | 
                                                        |
| 298 | - $this->spatial_idx [$knownHash] = $knownIds;  | 
                                                        |
| 299 | -        if(empty ($this->spatial_idx [$knownHash])) { | 
                                                        |
| 300 | - // dbglog ( "removing key: $knownHash from the index." );  | 
                                                        |
| 301 | - unset ($this->spatial_idx [$knownHash]);  | 
                                                        |
| 302 | - }  | 
                                                        |
| 303 | - $this->saveIndex();  | 
                                                        |
| 304 | - }  | 
                                                        |
| 292 | + // TODO shortcut, need to make sure there is only one element, if not the index is corrupt  | 
                                                        |
| 293 | + $knownHash = $knownHashes [0];  | 
                                                        |
| 294 | + $knownIds = $this->spatial_idx [$knownHash];  | 
                                                        |
| 295 | + $i = array_search($id, $knownIds);  | 
                                                        |
| 296 | +		dbglog("removing: $knownIds[$i] from the index."); | 
                                                        |
| 297 | + unset ($knownIds [$i]);  | 
                                                        |
| 298 | + $this->spatial_idx [$knownHash] = $knownIds;  | 
                                                        |
| 299 | +		if(empty ($this->spatial_idx [$knownHash])) { | 
                                                        |
| 300 | + // dbglog ( "removing key: $knownHash from the index." );  | 
                                                        |
| 301 | + unset ($this->spatial_idx [$knownHash]);  | 
                                                        |
| 302 | + }  | 
                                                        |
| 303 | + $this->saveIndex();  | 
                                                        |
| 304 | + }  | 
                                                        |
| 305 | 305 | }  | 
                                                        
@@ -43,7 +43,7 @@ discard block  | 
                                                    ||
| 43 | 43 | * Constructor, initialises the spatial index.  | 
                                                        
| 44 | 44 | */  | 
                                                        
| 45 | 45 |      public function __construct() { | 
                                                        
| 46 | -        if(!plugin_load('helper', 'geophp')) { | 
                                                        |
| 46 | +        if (!plugin_load('helper', 'geophp')) { | 
                                                        |
| 47 | 47 | $message = 'helper_plugin_spatialhelper_index::spatialhelper_index: required geophp plugin is not available.';  | 
                                                        
| 48 | 48 | msg($message, -1);  | 
                                                        
| 49 | 49 | }  | 
                                                        
@@ -51,7 +51,7 @@ discard block  | 
                                                    ||
| 51 | 51 | global $conf;  | 
                                                        
| 52 | 52 | $this->idx_dir = $conf ['indexdir'];  | 
                                                        
| 53 | 53 | // test if there is a spatialindex, if not build one for the wiki  | 
                                                        
| 54 | -        if(!@file_exists($this->idx_dir . '/spatial.idx')) { | 
                                                        |
| 54 | +        if (!@file_exists($this->idx_dir . '/spatial.idx')) { | 
                                                        |
| 55 | 55 | // creates and stores the index  | 
                                                        
| 56 | 56 | $this->generateSpatialIndex();  | 
                                                        
| 57 | 57 |          } else { | 
                                                        
@@ -73,14 +73,14 @@ discard block  | 
                                                    ||
| 73 | 73 | require_once(DOKU_INC . 'inc/search.php');  | 
                                                        
| 74 | 74 | $pages = array();  | 
                                                        
| 75 | 75 | search($pages, $conf ['datadir'], 'search_allpages', array());  | 
                                                        
| 76 | -        foreach($pages as $page) { | 
                                                        |
| 76 | +        foreach ($pages as $page) { | 
                                                        |
| 77 | 77 | $this->updateSpatialIndex($page ['id']);  | 
                                                        
| 78 | 78 | }  | 
                                                        
| 79 | 79 | // media  | 
                                                        
| 80 | 80 | $media = array();  | 
                                                        
| 81 | 81 | search($media, $conf ['mediadir'], 'search_media', array());  | 
                                                        
| 82 | -        foreach($media as $medium) { | 
                                                        |
| 83 | -            if($medium ['isimg']) { | 
                                                        |
| 82 | +        foreach ($media as $medium) { | 
                                                        |
| 83 | +            if ($medium ['isimg']) { | 
                                                        |
| 84 | 84 | $this->indexImage($medium);  | 
                                                        
| 85 | 85 | }  | 
                                                        
| 86 | 86 | }  | 
                                                        
@@ -96,10 +96,10 @@ discard block  | 
                                                    ||
| 96 | 96 | */  | 
                                                        
| 97 | 97 |      public function updateSpatialIndex(string $id): bool { | 
                                                        
| 98 | 98 | $geotags = p_get_metadata($id, 'geo');  | 
                                                        
| 99 | -        if(empty ($geotags)) { | 
                                                        |
| 99 | +        if (empty ($geotags)) { | 
                                                        |
| 100 | 100 | return false;  | 
                                                        
| 101 | 101 | }  | 
                                                        
| 102 | -        if(empty ($geotags ['lon']) || empty ($geotags ['lat'])) { | 
                                                        |
| 102 | +        if (empty ($geotags ['lon']) || empty ($geotags ['lat'])) { | 
                                                        |
| 103 | 103 | return false;  | 
                                                        
| 104 | 104 | }  | 
                                                        
| 105 | 105 | dbglog($geotags, "Geo metadata found for page $id");  | 
                                                        
@@ -120,14 +120,14 @@ discard block  | 
                                                    ||
| 120 | 120 |      private function addToIndex(string $geohash, string $id): bool { | 
                                                        
| 121 | 121 | $pageIds = array();  | 
                                                        
| 122 | 122 | // check index for key/geohash  | 
                                                        
| 123 | -        if(!array_key_exists($geohash, $this->spatial_idx)) { | 
                                                        |
| 123 | +        if (!array_key_exists($geohash, $this->spatial_idx)) { | 
                                                        |
| 124 | 124 |              dbglog("Geohash $geohash not in index, just add $id."); | 
                                                        
| 125 | 125 | $pageIds [] = $id;  | 
                                                        
| 126 | 126 |          } else { | 
                                                        
| 127 | 127 |              dbglog('Geohash for document is in index, find it.'); | 
                                                        
| 128 | 128 | // check the index for document  | 
                                                        
| 129 | 129 | $knownHashes = $this->findHashesForId($id, $this->spatial_idx);  | 
                                                        
| 130 | -            if(empty ($knownHashes)) { | 
                                                        |
| 130 | +            if (empty ($knownHashes)) { | 
                                                        |
| 131 | 131 |                  dbglog("No index record found for document $id, just add"); | 
                                                        
| 132 | 132 | $pageIds = $this->spatial_idx [$geohash];  | 
                                                        
| 133 | 133 | $pageIds [] = $id;  | 
                                                        
@@ -135,12 +135,12 @@ discard block  | 
                                                    ||
| 135 | 135 | // TODO shortcut, need to make sure there is only one element, if not the index is corrupt  | 
                                                        
| 136 | 136 | $knownHash = $knownHashes [0];  | 
                                                        
| 137 | 137 | |
| 138 | -            if($knownHash === $geohash) { | 
                                                        |
| 138 | +            if ($knownHash === $geohash) { | 
                                                        |
| 139 | 139 |                  dbglog("Document $id was found in index and has the same geohash, nothing to do."); | 
                                                        
| 140 | 140 | return true;  | 
                                                        
| 141 | 141 | }  | 
                                                        
| 142 | 142 | |
| 143 | -            if(!empty ($knownHash)) { | 
                                                        |
| 143 | +            if (!empty ($knownHash)) { | 
                                                        |
| 144 | 144 |                  dbglog("Document/media $id was found in index but has different geohash (it moved)."); | 
                                                        
| 145 | 145 | $knownIds = $this->spatial_idx [$knownHash];  | 
                                                        
| 146 | 146 | dbglog($knownIds, "Known id's for this hash:");  | 
                                                        
@@ -169,8 +169,8 @@ discard block  | 
                                                    ||
| 169 | 169 | */  | 
                                                        
| 170 | 170 |      public function findHashesForId(string $id, array $index): array { | 
                                                        
| 171 | 171 | $hashes = array();  | 
                                                        
| 172 | -        foreach($index as $hash => $docIds) { | 
                                                        |
| 173 | -            if(in_array($id, $docIds, false)) { | 
                                                        |
| 172 | +        foreach ($index as $hash => $docIds) { | 
                                                        |
| 173 | +            if (in_array($id, $docIds, false)) { | 
                                                        |
| 174 | 174 | $hashes [] = $hash;  | 
                                                        
| 175 | 175 | }  | 
                                                        
| 176 | 176 | }  | 
                                                        
@@ -198,14 +198,14 @@ discard block  | 
                                                    ||
| 198 | 198 | */  | 
                                                        
| 199 | 199 |      public function indexImage($img): bool { | 
                                                        
| 200 | 200 | // test for supported files (jpeg only)  | 
                                                        
| 201 | - if(  | 
                                                        |
| 201 | + if (  | 
                                                        |
| 202 | 202 |              (substr($img ['file'], -strlen('.jpg')) !== '.jpg') && | 
                                                        
| 203 | 203 |              (substr($img ['file'], -strlen('.jpeg')) !== '.jpeg')) { | 
                                                        
| 204 | 204 | return false;  | 
                                                        
| 205 | 205 | }  | 
                                                        
| 206 | 206 | |
| 207 | 207 | $geometry = $this->getCoordsFromExif($img ['id']);  | 
                                                        
| 208 | -        if(!$geometry) { | 
                                                        |
| 208 | +        if (!$geometry) { | 
                                                        |
| 209 | 209 | return false;  | 
                                                        
| 210 | 210 | }  | 
                                                        
| 211 | 211 |          $geohash = $geometry->out('geohash'); | 
                                                        
@@ -224,7 +224,7 @@ discard block  | 
                                                    ||
| 224 | 224 | */  | 
                                                        
| 225 | 225 |      public function getCoordsFromExif(string $id) { | 
                                                        
| 226 | 226 | $exif = exif_read_data(mediaFN($id), 0, true);  | 
                                                        
| 227 | -        if(empty ($exif ['GPS'])) { | 
                                                        |
| 227 | +        if (empty ($exif ['GPS'])) { | 
                                                        |
| 228 | 228 | return false;  | 
                                                        
| 229 | 229 | }  | 
                                                        
| 230 | 230 | |
@@ -256,7 +256,7 @@ discard block  | 
                                                    ||
| 256 | 256 | * @return float  | 
                                                        
| 257 | 257 | */  | 
                                                        
| 258 | 258 |      public function convertDMStoD(array $param): float { | 
                                                        
| 259 | -        if(!is_array($param)) { | 
                                                        |
| 259 | +        if (!is_array($param)) { | 
                                                        |
| 260 | 260 | $param = array($param);  | 
                                                        
| 261 | 261 | }  | 
                                                        
| 262 | 262 | $deg = $this->convertRationaltoFloat($param [0]);  | 
                                                        
@@ -270,10 +270,10 @@ discard block  | 
                                                    ||
| 270 | 270 |      public function convertRationaltoFloat($param): float { | 
                                                        
| 271 | 271 | // rational64u  | 
                                                        
| 272 | 272 |          $nums = explode('/', $param); | 
                                                        
| 273 | -        if((int) $nums[1] > 0) { | 
                                                        |
| 274 | - return (float) $nums[0] / (int) $nums[1];  | 
                                                        |
| 273 | +        if (( int ) $nums[1] > 0) { | 
                                                        |
| 274 | + return ( float ) $nums[0] / ( int ) $nums[1];  | 
                                                        |
| 275 | 275 |          } else { | 
                                                        
| 276 | - return (float) $nums[0];  | 
                                                        |
| 276 | + return ( float ) $nums[0];  | 
                                                        |
| 277 | 277 | }  | 
                                                        
| 278 | 278 | }  | 
                                                        
| 279 | 279 | |
@@ -285,7 +285,7 @@ discard block  | 
                                                    ||
| 285 | 285 |      public function deleteFromIndex(string $id): void { | 
                                                        
| 286 | 286 | // check the index for document  | 
                                                        
| 287 | 287 | $knownHashes = $this->findHashesForId($id, $this->spatial_idx);  | 
                                                        
| 288 | -        if(empty ($knownHashes)) { | 
                                                        |
| 288 | +        if (empty ($knownHashes)) { | 
                                                        |
| 289 | 289 | return;  | 
                                                        
| 290 | 290 | }  | 
                                                        
| 291 | 291 | |
@@ -296,7 +296,7 @@ discard block  | 
                                                    ||
| 296 | 296 |          dbglog("removing: $knownIds[$i] from the index."); | 
                                                        
| 297 | 297 | unset ($knownIds [$i]);  | 
                                                        
| 298 | 298 | $this->spatial_idx [$knownHash] = $knownIds;  | 
                                                        
| 299 | -        if(empty ($this->spatial_idx [$knownHash])) { | 
                                                        |
| 299 | +        if (empty ($this->spatial_idx [$knownHash])) { | 
                                                        |
| 300 | 300 | // dbglog ( "removing key: $knownHash from the index." );  | 
                                                        
| 301 | 301 | unset ($this->spatial_idx [$knownHash]);  | 
                                                        
| 302 | 302 | }  | 
                                                        
@@ -26,178 +26,178 @@  | 
                                                    ||
| 26 | 26 | * @author Mark Prins  | 
                                                        
| 27 | 27 | */  | 
                                                        
| 28 | 28 |  class helper_plugin_spatialhelper_search extends DokuWiki_Plugin { | 
                                                        
| 29 | - /**  | 
                                                        |
| 30 | - * spatial index.  | 
                                                        |
| 31 | - *  | 
                                                        |
| 32 | - * @var array  | 
                                                        |
| 33 | - */  | 
                                                        |
| 34 | - protected $spatial_idx = array();  | 
                                                        |
| 35 | - /**  | 
                                                        |
| 36 | - * Precision, Distance of Adjacent Cell in Meters.  | 
                                                        |
| 37 | - *  | 
                                                        |
| 38 | - * @see https://stackoverflow.com/questions/13836416/geohash-and-max-distance  | 
                                                        |
| 39 | - *  | 
                                                        |
| 40 | - * @var float  | 
                                                        |
| 41 | - */  | 
                                                        |
| 42 | - private $precision = array(  | 
                                                        |
| 43 | - 5003530,  | 
                                                        |
| 44 | - 625441,  | 
                                                        |
| 45 | - 123264,  | 
                                                        |
| 46 | - 19545,  | 
                                                        |
| 47 | - 3803,  | 
                                                        |
| 48 | - 610,  | 
                                                        |
| 49 | - 118,  | 
                                                        |
| 50 | - 19,  | 
                                                        |
| 51 | - 3.7,  | 
                                                        |
| 52 | - 0.6  | 
                                                        |
| 53 | - );  | 
                                                        |
| 29 | + /**  | 
                                                        |
| 30 | + * spatial index.  | 
                                                        |
| 31 | + *  | 
                                                        |
| 32 | + * @var array  | 
                                                        |
| 33 | + */  | 
                                                        |
| 34 | + protected $spatial_idx = array();  | 
                                                        |
| 35 | + /**  | 
                                                        |
| 36 | + * Precision, Distance of Adjacent Cell in Meters.  | 
                                                        |
| 37 | + *  | 
                                                        |
| 38 | + * @see https://stackoverflow.com/questions/13836416/geohash-and-max-distance  | 
                                                        |
| 39 | + *  | 
                                                        |
| 40 | + * @var float  | 
                                                        |
| 41 | + */  | 
                                                        |
| 42 | + private $precision = array(  | 
                                                        |
| 43 | + 5003530,  | 
                                                        |
| 44 | + 625441,  | 
                                                        |
| 45 | + 123264,  | 
                                                        |
| 46 | + 19545,  | 
                                                        |
| 47 | + 3803,  | 
                                                        |
| 48 | + 610,  | 
                                                        |
| 49 | + 118,  | 
                                                        |
| 50 | + 19,  | 
                                                        |
| 51 | + 3.7,  | 
                                                        |
| 52 | + 0.6  | 
                                                        |
| 53 | + );  | 
                                                        |
| 54 | 54 | |
| 55 | - /**  | 
                                                        |
| 56 | - * constructor; initialize/load spatial index.  | 
                                                        |
| 57 | - */  | 
                                                        |
| 58 | -    public function __construct() { | 
                                                        |
| 59 | - // parent::__construct ();  | 
                                                        |
| 60 | - global $conf;  | 
                                                        |
| 55 | + /**  | 
                                                        |
| 56 | + * constructor; initialize/load spatial index.  | 
                                                        |
| 57 | + */  | 
                                                        |
| 58 | +	public function __construct() { | 
                                                        |
| 59 | + // parent::__construct ();  | 
                                                        |
| 60 | + global $conf;  | 
                                                        |
| 61 | 61 | |
| 62 | -        if(!plugin_load('helper', 'geophp', false, true)) { | 
                                                        |
| 63 | - $message =  | 
                                                        |
| 64 | - 'helper_plugin_spatialhelper_search::spatialhelper_search: required geophp plugin is not available.';  | 
                                                        |
| 65 | - msg($message, -1);  | 
                                                        |
| 66 | - }  | 
                                                        |
| 62 | +		if(!plugin_load('helper', 'geophp', false, true)) { | 
                                                        |
| 63 | + $message =  | 
                                                        |
| 64 | + 'helper_plugin_spatialhelper_search::spatialhelper_search: required geophp plugin is not available.';  | 
                                                        |
| 65 | + msg($message, -1);  | 
                                                        |
| 66 | + }  | 
                                                        |
| 67 | 67 | |
| 68 | - $idx_dir = $conf ['indexdir'];  | 
                                                        |
| 69 | -        if(!@file_exists($idx_dir . '/spatial.idx')) { | 
                                                        |
| 70 | -            plugin_load('helper', 'spatialhelper_index'); | 
                                                        |
| 71 | - }  | 
                                                        |
| 68 | + $idx_dir = $conf ['indexdir'];  | 
                                                        |
| 69 | +		if(!@file_exists($idx_dir . '/spatial.idx')) { | 
                                                        |
| 70 | +			plugin_load('helper', 'spatialhelper_index'); | 
                                                        |
| 71 | + }  | 
                                                        |
| 72 | 72 | |
| 73 | - $this->spatial_idx = unserialize(io_readFile($idx_dir . '/spatial.idx', false), ['allowed_classes' => false]);  | 
                                                        |
| 74 | - }  | 
                                                        |
| 73 | + $this->spatial_idx = unserialize(io_readFile($idx_dir . '/spatial.idx', false), ['allowed_classes' => false]);  | 
                                                        |
| 74 | + }  | 
                                                        |
| 75 | 75 | |
| 76 | - /**  | 
                                                        |
| 77 | - * Find locations based on the coordinate pair.  | 
                                                        |
| 78 | - *  | 
                                                        |
| 79 | - * @param float $lat  | 
                                                        |
| 80 | - * The y coordinate (or latitude)  | 
                                                        |
| 81 | - * @param float $lon  | 
                                                        |
| 82 | - * The x coordinate (or longitude)  | 
                                                        |
| 83 | - */  | 
                                                        |
| 84 | -    public function findNearbyLatLon(float $lat, float $lon): array { | 
                                                        |
| 85 | - $geometry = new Point($lon, $lat);  | 
                                                        |
| 86 | -        return $this->findNearby($geometry->out('geohash'), $geometry); | 
                                                        |
| 87 | - }  | 
                                                        |
| 76 | + /**  | 
                                                        |
| 77 | + * Find locations based on the coordinate pair.  | 
                                                        |
| 78 | + *  | 
                                                        |
| 79 | + * @param float $lat  | 
                                                        |
| 80 | + * The y coordinate (or latitude)  | 
                                                        |
| 81 | + * @param float $lon  | 
                                                        |
| 82 | + * The x coordinate (or longitude)  | 
                                                        |
| 83 | + */  | 
                                                        |
| 84 | +	public function findNearbyLatLon(float $lat, float $lon): array { | 
                                                        |
| 85 | + $geometry = new Point($lon, $lat);  | 
                                                        |
| 86 | +		return $this->findNearby($geometry->out('geohash'), $geometry); | 
                                                        |
| 87 | + }  | 
                                                        |
| 88 | 88 | |
| 89 | - /**  | 
                                                        |
| 90 | - * finds nearby elements in the index based on the geohash.  | 
                                                        |
| 91 | - * returns a list of documents and the bunding box.  | 
                                                        |
| 92 | - *  | 
                                                        |
| 93 | - * @param string $geohash  | 
                                                        |
| 94 | - * @param Point|null $p  | 
                                                        |
| 95 | - * optional point  | 
                                                        |
| 96 | - * @return array of ...  | 
                                                        |
| 97 | - * @throws Exception  | 
                                                        |
| 98 | - */  | 
                                                        |
| 99 | -    public function findNearby(string $geohash, Point $p = null): array { | 
                                                        |
| 100 | - $_geohashClass = new Geohash();  | 
                                                        |
| 101 | -        if(!$p) { | 
                                                        |
| 102 | - $decodedPoint = $_geohashClass->read($geohash);  | 
                                                        |
| 103 | -        } else { | 
                                                        |
| 104 | - $decodedPoint = $p;  | 
                                                        |
| 105 | - }  | 
                                                        |
| 89 | + /**  | 
                                                        |
| 90 | + * finds nearby elements in the index based on the geohash.  | 
                                                        |
| 91 | + * returns a list of documents and the bunding box.  | 
                                                        |
| 92 | + *  | 
                                                        |
| 93 | + * @param string $geohash  | 
                                                        |
| 94 | + * @param Point|null $p  | 
                                                        |
| 95 | + * optional point  | 
                                                        |
| 96 | + * @return array of ...  | 
                                                        |
| 97 | + * @throws Exception  | 
                                                        |
| 98 | + */  | 
                                                        |
| 99 | +	public function findNearby(string $geohash, Point $p = null): array { | 
                                                        |
| 100 | + $_geohashClass = new Geohash();  | 
                                                        |
| 101 | +		if(!$p) { | 
                                                        |
| 102 | + $decodedPoint = $_geohashClass->read($geohash);  | 
                                                        |
| 103 | +		} else { | 
                                                        |
| 104 | + $decodedPoint = $p;  | 
                                                        |
| 105 | + }  | 
                                                        |
| 106 | 106 | |
| 107 | - // find adjacent blocks  | 
                                                        |
| 108 | - $adjacent = array();  | 
                                                        |
| 109 | - $adjacent ['center'] = $geohash;  | 
                                                        |
| 110 | - $adjacent ['top'] = Geohash::adjacent($adjacent ['center'], 'top');  | 
                                                        |
| 111 | - $adjacent ['bottom'] = Geohash::adjacent($adjacent ['center'], 'bottom');  | 
                                                        |
| 112 | - $adjacent ['right'] = Geohash::adjacent($adjacent ['center'], 'right');  | 
                                                        |
| 113 | - $adjacent ['left'] = Geohash::adjacent($adjacent ['center'], 'left');  | 
                                                        |
| 114 | - $adjacent ['topleft'] = Geohash::adjacent($adjacent ['left'], 'top');  | 
                                                        |
| 115 | - $adjacent ['topright'] = Geohash::adjacent($adjacent ['right'], 'top');  | 
                                                        |
| 116 | - $adjacent ['bottomright'] = Geohash::adjacent($adjacent ['right'], 'bottom');  | 
                                                        |
| 117 | - $adjacent ['bottomleft'] = Geohash::adjacent($adjacent ['left'], 'bottom');  | 
                                                        |
| 118 | - dbglog($adjacent, "adjacent geo hashes:");  | 
                                                        |
| 107 | + // find adjacent blocks  | 
                                                        |
| 108 | + $adjacent = array();  | 
                                                        |
| 109 | + $adjacent ['center'] = $geohash;  | 
                                                        |
| 110 | + $adjacent ['top'] = Geohash::adjacent($adjacent ['center'], 'top');  | 
                                                        |
| 111 | + $adjacent ['bottom'] = Geohash::adjacent($adjacent ['center'], 'bottom');  | 
                                                        |
| 112 | + $adjacent ['right'] = Geohash::adjacent($adjacent ['center'], 'right');  | 
                                                        |
| 113 | + $adjacent ['left'] = Geohash::adjacent($adjacent ['center'], 'left');  | 
                                                        |
| 114 | + $adjacent ['topleft'] = Geohash::adjacent($adjacent ['left'], 'top');  | 
                                                        |
| 115 | + $adjacent ['topright'] = Geohash::adjacent($adjacent ['right'], 'top');  | 
                                                        |
| 116 | + $adjacent ['bottomright'] = Geohash::adjacent($adjacent ['right'], 'bottom');  | 
                                                        |
| 117 | + $adjacent ['bottomleft'] = Geohash::adjacent($adjacent ['left'], 'bottom');  | 
                                                        |
| 118 | + dbglog($adjacent, "adjacent geo hashes:");  | 
                                                        |
| 119 | 119 | |
| 120 | - // find all the pages in the index that overlap with the adjacent hashes  | 
                                                        |
| 121 | - $docIds = array();  | 
                                                        |
| 122 | -        foreach($adjacent as $adjHash) { | 
                                                        |
| 123 | -            if(is_array($this->spatial_idx)) { | 
                                                        |
| 124 | -                foreach($this->spatial_idx as $_geohash => $_docIds) { | 
                                                        |
| 125 | -                    if(strpos($_geohash, $adjHash) !== false) { | 
                                                        |
| 126 | - // dbglog ( "Found adjacent geo hash: $adjHash in $_geohash" );  | 
                                                        |
| 127 | - // if $adjHash similar to geohash  | 
                                                        |
| 128 | - $docIds = array_merge($docIds, $_docIds);  | 
                                                        |
| 129 | - }  | 
                                                        |
| 130 | - }  | 
                                                        |
| 131 | - }  | 
                                                        |
| 132 | - }  | 
                                                        |
| 133 | - $docIds = array_unique($docIds);  | 
                                                        |
| 134 | - dbglog($docIds, "found docIDs");  | 
                                                        |
| 120 | + // find all the pages in the index that overlap with the adjacent hashes  | 
                                                        |
| 121 | + $docIds = array();  | 
                                                        |
| 122 | +		foreach($adjacent as $adjHash) { | 
                                                        |
| 123 | +			if(is_array($this->spatial_idx)) { | 
                                                        |
| 124 | +				foreach($this->spatial_idx as $_geohash => $_docIds) { | 
                                                        |
| 125 | +					if(strpos($_geohash, $adjHash) !== false) { | 
                                                        |
| 126 | + // dbglog ( "Found adjacent geo hash: $adjHash in $_geohash" );  | 
                                                        |
| 127 | + // if $adjHash similar to geohash  | 
                                                        |
| 128 | + $docIds = array_merge($docIds, $_docIds);  | 
                                                        |
| 129 | + }  | 
                                                        |
| 130 | + }  | 
                                                        |
| 131 | + }  | 
                                                        |
| 132 | + }  | 
                                                        |
| 133 | + $docIds = array_unique($docIds);  | 
                                                        |
| 134 | + dbglog($docIds, "found docIDs");  | 
                                                        |
| 135 | 135 | |
| 136 | - // create associative array of pages + calculate distance  | 
                                                        |
| 137 | - $pages = array();  | 
                                                        |
| 138 | - $media = array();  | 
                                                        |
| 139 | -        $indexer = plugin_load('helper', 'spatialhelper_index'); | 
                                                        |
| 136 | + // create associative array of pages + calculate distance  | 
                                                        |
| 137 | + $pages = array();  | 
                                                        |
| 138 | + $media = array();  | 
                                                        |
| 139 | +		$indexer = plugin_load('helper', 'spatialhelper_index'); | 
                                                        |
| 140 | 140 | |
| 141 | -        foreach($docIds as $id) { | 
                                                        |
| 142 | -            if(strpos($id, 'media__', 0) === 0) { | 
                                                        |
| 143 | -                $id = substr($id, strlen('media__')); | 
                                                        |
| 144 | -                if(auth_quickaclcheck($id) >= /*AUTH_READ*/ 1) { | 
                                                        |
| 145 | - $point = $indexer->getCoordsFromExif($id);  | 
                                                        |
| 146 | - $line = new LineString(  | 
                                                        |
| 147 | - [  | 
                                                        |
| 148 | - $decodedPoint,  | 
                                                        |
| 149 | - $point  | 
                                                        |
| 150 | - ]  | 
                                                        |
| 151 | - );  | 
                                                        |
| 152 | - $media [] = array(  | 
                                                        |
| 153 | - 'id' => $id,  | 
                                                        |
| 154 | - 'distance' => (int) ($line->greatCircleLength()),  | 
                                                        |
| 155 | - 'lat' => $point->y(),  | 
                                                        |
| 156 | - 'lon' => $point->x()  | 
                                                        |
| 157 | - // optionally add other meta such as tag, description...  | 
                                                        |
| 158 | - );  | 
                                                        |
| 159 | - }  | 
                                                        |
| 160 | -            } else { | 
                                                        |
| 161 | -                if(auth_quickaclcheck($id) >= /*AUTH_READ*/ 1) { | 
                                                        |
| 162 | - $geotags = p_get_metadata($id, 'geo');  | 
                                                        |
| 163 | - $point = new Point($geotags ['lon'], $geotags ['lat']);  | 
                                                        |
| 164 | - $line = new LineString(  | 
                                                        |
| 165 | - [  | 
                                                        |
| 166 | - $decodedPoint,  | 
                                                        |
| 167 | - $point  | 
                                                        |
| 168 | - ]  | 
                                                        |
| 169 | - );  | 
                                                        |
| 170 | - $pages [] = array(  | 
                                                        |
| 171 | - 'id' => $id,  | 
                                                        |
| 172 | - 'distance' => (int) ($line->greatCircleLength()),  | 
                                                        |
| 173 | - 'description' => p_get_metadata($id, 'description')['abstract'],  | 
                                                        |
| 174 | - 'lat' => $geotags ['lat'],  | 
                                                        |
| 175 | - 'lon' => $geotags ['lon']  | 
                                                        |
| 176 | - // optionally add other meta such as tag...  | 
                                                        |
| 177 | - );  | 
                                                        |
| 178 | - }  | 
                                                        |
| 179 | - }  | 
                                                        |
| 180 | - }  | 
                                                        |
| 141 | +		foreach($docIds as $id) { | 
                                                        |
| 142 | +			if(strpos($id, 'media__', 0) === 0) { | 
                                                        |
| 143 | +				$id = substr($id, strlen('media__')); | 
                                                        |
| 144 | +				if(auth_quickaclcheck($id) >= /*AUTH_READ*/ 1) { | 
                                                        |
| 145 | + $point = $indexer->getCoordsFromExif($id);  | 
                                                        |
| 146 | + $line = new LineString(  | 
                                                        |
| 147 | + [  | 
                                                        |
| 148 | + $decodedPoint,  | 
                                                        |
| 149 | + $point  | 
                                                        |
| 150 | + ]  | 
                                                        |
| 151 | + );  | 
                                                        |
| 152 | + $media [] = array(  | 
                                                        |
| 153 | + 'id' => $id,  | 
                                                        |
| 154 | + 'distance' => (int) ($line->greatCircleLength()),  | 
                                                        |
| 155 | + 'lat' => $point->y(),  | 
                                                        |
| 156 | + 'lon' => $point->x()  | 
                                                        |
| 157 | + // optionally add other meta such as tag, description...  | 
                                                        |
| 158 | + );  | 
                                                        |
| 159 | + }  | 
                                                        |
| 160 | +			} else { | 
                                                        |
| 161 | +				if(auth_quickaclcheck($id) >= /*AUTH_READ*/ 1) { | 
                                                        |
| 162 | + $geotags = p_get_metadata($id, 'geo');  | 
                                                        |
| 163 | + $point = new Point($geotags ['lon'], $geotags ['lat']);  | 
                                                        |
| 164 | + $line = new LineString(  | 
                                                        |
| 165 | + [  | 
                                                        |
| 166 | + $decodedPoint,  | 
                                                        |
| 167 | + $point  | 
                                                        |
| 168 | + ]  | 
                                                        |
| 169 | + );  | 
                                                        |
| 170 | + $pages [] = array(  | 
                                                        |
| 171 | + 'id' => $id,  | 
                                                        |
| 172 | + 'distance' => (int) ($line->greatCircleLength()),  | 
                                                        |
| 173 | + 'description' => p_get_metadata($id, 'description')['abstract'],  | 
                                                        |
| 174 | + 'lat' => $geotags ['lat'],  | 
                                                        |
| 175 | + 'lon' => $geotags ['lon']  | 
                                                        |
| 176 | + // optionally add other meta such as tag...  | 
                                                        |
| 177 | + );  | 
                                                        |
| 178 | + }  | 
                                                        |
| 179 | + }  | 
                                                        |
| 180 | + }  | 
                                                        |
| 181 | 181 | |
| 182 | - // sort all the pages/media using distance  | 
                                                        |
| 183 | - usort(  | 
                                                        |
| 184 | -            $pages, static function ($a, $b) { | 
                                                        |
| 185 | - return strnatcmp($a ['distance'], $b ['distance']);  | 
                                                        |
| 186 | - }  | 
                                                        |
| 187 | - );  | 
                                                        |
| 188 | - usort(  | 
                                                        |
| 189 | -            $media, static function ($a, $b) { | 
                                                        |
| 190 | - return strnatcmp($a ['distance'], $b ['distance']);  | 
                                                        |
| 191 | - }  | 
                                                        |
| 192 | - );  | 
                                                        |
| 182 | + // sort all the pages/media using distance  | 
                                                        |
| 183 | + usort(  | 
                                                        |
| 184 | +			$pages, static function ($a, $b) { | 
                                                        |
| 185 | + return strnatcmp($a ['distance'], $b ['distance']);  | 
                                                        |
| 186 | + }  | 
                                                        |
| 187 | + );  | 
                                                        |
| 188 | + usort(  | 
                                                        |
| 189 | +			$media, static function ($a, $b) { | 
                                                        |
| 190 | + return strnatcmp($a ['distance'], $b ['distance']);  | 
                                                        |
| 191 | + }  | 
                                                        |
| 192 | + );  | 
                                                        |
| 193 | 193 | |
| 194 | - return array(  | 
                                                        |
| 195 | - 'pages' => $pages,  | 
                                                        |
| 196 | - 'media' => $media,  | 
                                                        |
| 197 | - 'lat' => $decodedPoint->y(),  | 
                                                        |
| 198 | - 'lon' => $decodedPoint->x(),  | 
                                                        |
| 199 | - 'geohash' => $geohash,  | 
                                                        |
| 200 | - 'precision' => $this->precision [strlen($geohash)]  | 
                                                        |
| 201 | - );  | 
                                                        |
| 202 | - }  | 
                                                        |
| 194 | + return array(  | 
                                                        |
| 195 | + 'pages' => $pages,  | 
                                                        |
| 196 | + 'media' => $media,  | 
                                                        |
| 197 | + 'lat' => $decodedPoint->y(),  | 
                                                        |
| 198 | + 'lon' => $decodedPoint->x(),  | 
                                                        |
| 199 | + 'geohash' => $geohash,  | 
                                                        |
| 200 | + 'precision' => $this->precision [strlen($geohash)]  | 
                                                        |
| 201 | + );  | 
                                                        |
| 202 | + }  | 
                                                        |
| 203 | 203 | }  | 
                                                        
@@ -59,14 +59,14 @@ discard block  | 
                                                    ||
| 59 | 59 | // parent::__construct ();  | 
                                                        
| 60 | 60 | global $conf;  | 
                                                        
| 61 | 61 | |
| 62 | -        if(!plugin_load('helper', 'geophp', false, true)) { | 
                                                        |
| 62 | +        if (!plugin_load('helper', 'geophp', false, true)) { | 
                                                        |
| 63 | 63 | $message =  | 
                                                        
| 64 | 64 | 'helper_plugin_spatialhelper_search::spatialhelper_search: required geophp plugin is not available.';  | 
                                                        
| 65 | 65 | msg($message, -1);  | 
                                                        
| 66 | 66 | }  | 
                                                        
| 67 | 67 | |
| 68 | 68 | $idx_dir = $conf ['indexdir'];  | 
                                                        
| 69 | -        if(!@file_exists($idx_dir . '/spatial.idx')) { | 
                                                        |
| 69 | +        if (!@file_exists($idx_dir . '/spatial.idx')) { | 
                                                        |
| 70 | 70 |              plugin_load('helper', 'spatialhelper_index'); | 
                                                        
| 71 | 71 | }  | 
                                                        
| 72 | 72 | |
@@ -98,7 +98,7 @@ discard block  | 
                                                    ||
| 98 | 98 | */  | 
                                                        
| 99 | 99 |      public function findNearby(string $geohash, Point $p = null): array { | 
                                                        
| 100 | 100 | $_geohashClass = new Geohash();  | 
                                                        
| 101 | -        if(!$p) { | 
                                                        |
| 101 | +        if (!$p) { | 
                                                        |
| 102 | 102 | $decodedPoint = $_geohashClass->read($geohash);  | 
                                                        
| 103 | 103 |          } else { | 
                                                        
| 104 | 104 | $decodedPoint = $p;  | 
                                                        
@@ -119,10 +119,10 @@ discard block  | 
                                                    ||
| 119 | 119 | |
| 120 | 120 | // find all the pages in the index that overlap with the adjacent hashes  | 
                                                        
| 121 | 121 | $docIds = array();  | 
                                                        
| 122 | -        foreach($adjacent as $adjHash) { | 
                                                        |
| 123 | -            if(is_array($this->spatial_idx)) { | 
                                                        |
| 124 | -                foreach($this->spatial_idx as $_geohash => $_docIds) { | 
                                                        |
| 125 | -                    if(strpos($_geohash, $adjHash) !== false) { | 
                                                        |
| 122 | +        foreach ($adjacent as $adjHash) { | 
                                                        |
| 123 | +            if (is_array($this->spatial_idx)) { | 
                                                        |
| 124 | +                foreach ($this->spatial_idx as $_geohash => $_docIds) { | 
                                                        |
| 125 | +                    if (strpos($_geohash, $adjHash) !== false) { | 
                                                        |
| 126 | 126 | // dbglog ( "Found adjacent geo hash: $adjHash in $_geohash" );  | 
                                                        
| 127 | 127 | // if $adjHash similar to geohash  | 
                                                        
| 128 | 128 | $docIds = array_merge($docIds, $_docIds);  | 
                                                        
@@ -138,10 +138,10 @@ discard block  | 
                                                    ||
| 138 | 138 | $media = array();  | 
                                                        
| 139 | 139 |          $indexer = plugin_load('helper', 'spatialhelper_index'); | 
                                                        
| 140 | 140 | |
| 141 | -        foreach($docIds as $id) { | 
                                                        |
| 142 | -            if(strpos($id, 'media__', 0) === 0) { | 
                                                        |
| 141 | +        foreach ($docIds as $id) { | 
                                                        |
| 142 | +            if (strpos($id, 'media__', 0) === 0) { | 
                                                        |
| 143 | 143 |                  $id = substr($id, strlen('media__')); | 
                                                        
| 144 | -                if(auth_quickaclcheck($id) >= /*AUTH_READ*/ 1) { | 
                                                        |
| 144 | +                if (auth_quickaclcheck($id) >= /*AUTH_READ*/ 1) { | 
                                                        |
| 145 | 145 | $point = $indexer->getCoordsFromExif($id);  | 
                                                        
| 146 | 146 | $line = new LineString(  | 
                                                        
| 147 | 147 | [  | 
                                                        
@@ -151,14 +151,14 @@ discard block  | 
                                                    ||
| 151 | 151 | );  | 
                                                        
| 152 | 152 | $media [] = array(  | 
                                                        
| 153 | 153 | 'id' => $id,  | 
                                                        
| 154 | - 'distance' => (int) ($line->greatCircleLength()),  | 
                                                        |
| 154 | + 'distance' => ( int ) ($line->greatCircleLength()),  | 
                                                        |
| 155 | 155 | 'lat' => $point->y(),  | 
                                                        
| 156 | 156 | 'lon' => $point->x()  | 
                                                        
| 157 | 157 | // optionally add other meta such as tag, description...  | 
                                                        
| 158 | 158 | );  | 
                                                        
| 159 | 159 | }  | 
                                                        
| 160 | 160 |              } else { | 
                                                        
| 161 | -                if(auth_quickaclcheck($id) >= /*AUTH_READ*/ 1) { | 
                                                        |
| 161 | +                if (auth_quickaclcheck($id) >= /*AUTH_READ*/ 1) { | 
                                                        |
| 162 | 162 | $geotags = p_get_metadata($id, 'geo');  | 
                                                        
| 163 | 163 | $point = new Point($geotags ['lon'], $geotags ['lat']);  | 
                                                        
| 164 | 164 | $line = new LineString(  | 
                                                        
@@ -169,7 +169,7 @@ discard block  | 
                                                    ||
| 169 | 169 | );  | 
                                                        
| 170 | 170 | $pages [] = array(  | 
                                                        
| 171 | 171 | 'id' => $id,  | 
                                                        
| 172 | - 'distance' => (int) ($line->greatCircleLength()),  | 
                                                        |
| 172 | + 'distance' => ( int ) ($line->greatCircleLength()),  | 
                                                        |
| 173 | 173 | 'description' => p_get_metadata($id, 'description')['abstract'],  | 
                                                        
| 174 | 174 | 'lat' => $geotags ['lat'],  | 
                                                        
| 175 | 175 | 'lon' => $geotags ['lon']  | 
                                                        
@@ -181,12 +181,12 @@ discard block  | 
                                                    ||
| 181 | 181 | |
| 182 | 182 | // sort all the pages/media using distance  | 
                                                        
| 183 | 183 | usort(  | 
                                                        
| 184 | -            $pages, static function ($a, $b) { | 
                                                        |
| 184 | +            $pages, static function($a, $b) { | 
                                                        |
| 185 | 185 | return strnatcmp($a ['distance'], $b ['distance']);  | 
                                                        
| 186 | 186 | }  | 
                                                        
| 187 | 187 | );  | 
                                                        
| 188 | 188 | usort(  | 
                                                        
| 189 | -            $media, static function ($a, $b) { | 
                                                        |
| 189 | +            $media, static function($a, $b) { | 
                                                        |
| 190 | 190 | return strnatcmp($a ['distance'], $b ['distance']);  | 
                                                        
| 191 | 191 | }  | 
                                                        
| 192 | 192 | );  |